1. บทนำ
อัปเดตล่าสุด 11-04-2022
ใน Codelab นี้ คุณจะได้เรียนรู้วิธีฝึกโมเดลการจัดประเภทรูปภาพโดยใช้ Teachable Machine และเรียกใช้ด้วยการเร่งฮาร์ดแวร์ Corral โดยใช้ TensorFlow.js ซึ่งเป็นไลบรารีแมชชีนเลิร์นนิงที่ทรงพลังและยืดหยุ่นสำหรับ JavaScript คุณสร้างแอป Electron ที่แสดงรูปภาพจากเว็บแคมและจัดประเภทรูปภาพโดยใช้ Coral EDGE TPU Codelab เวอร์ชันที่ทำงานได้อย่างสมบูรณ์มีอยู่ในที่เก็บ GitHub ของ sig-tfjs
ฉันต้องมีอุปกรณ์ Coral ไหม
ไม่ คุณลองใช้ Codelab นี้ได้โดยไม่ต้องใช้อุปกรณ์ Coral แต่ยังคงทำงานได้ดีในเครื่องเดสก์ท็อปโดยใช้ Accelerator WebNN แทน
สิ่งที่คุณจะสร้าง
ใน Codelab นี้ คุณจะได้สร้างแอป Electron ที่จัดหมวดหมู่รูปภาพ แอปของคุณ:
- จัดประเภทรูปภาพจากเว็บแคมลงในหมวดหมู่ที่กำหนดไว้ในโมเดลที่คุณฝึกใช้งาน
- ใช้โปรแกรมเร่งสีปะการังเพื่อเพิ่มประสิทธิภาพ หากมี
- ใช้ WebNN เพื่อเพิ่มประสิทธิภาพหากแพลตฟอร์มของคุณรองรับ
สิ่งที่คุณจะได้เรียนรู้
- วิธีติดตั้งและตั้งค่าแพ็กเกจ NPM tfjs-tflite-node เพื่อเรียกใช้โมเดล TFLite ใน Node.js
- วิธีติดตั้งไลบรารีรันไทม์ Edge TPU เพื่อเรียกใช้โมเดลในอุปกรณ์ Coral
- วิธีเร่งการอนุมานโมเดลโดยใช้ Coral EDGE TPU
- วิธีเร่งการอนุมานโมเดลด้วย WebNN
Codelab นี้มุ่งเน้นไปที่ TFLite ใน Node.js แนวคิดที่ไม่เกี่ยวข้องและโค้ดบล็อกจะปกปิดไว้เพื่อให้คุณคัดลอกและวางได้อย่างง่ายดาย
สิ่งที่คุณต้องมี
คุณต้องมีสิ่งต่อไปนี้เพื่อดำเนินการ Codelab นี้ให้เสร็จสมบูรณ์
- คอมพิวเตอร์ที่มีเว็บแคม
- สำหรับ Coral เราขอแนะนำให้ใช้ Raspberry Pi ที่ใช้ Raspberry Pi OS (64 บิต) กับเดสก์ท็อป
- สำหรับ WebNN เราขอแนะนำให้ใช้เครื่อง Intel x86-64 ที่ใช้ Ubuntu 20.04 หรือ Windows 10
- Node.js เวอร์ชัน >= 12
- ความรู้เกี่ยวกับ JavaScript
- (แนะนำ) Coral USB Accelerator เพื่อช่วยเร่งความเร็วของโมเดล
2. ตั้งค่า
รับโค้ด
เราได้ใส่โค้ดทั้งหมดที่คุณต้องการสำหรับโปรเจ็กต์นี้ไว้ในที่เก็บ Git แล้ว ในการเริ่มต้นใช้งาน ให้ดึงโค้ดมาและเปิดในสภาพแวดล้อมในการพัฒนาซอฟต์แวร์ที่คุณชื่นชอบ สำหรับ Codelab นี้ เราขอแนะนำให้ใช้ Raspberry Pi ที่ใช้ Raspberry Pi OS (64 บิต) กับเดสก์ท็อป วิธีนี้ช่วยให้คุณเชื่อมต่อ Coral Accelerator ได้โดยง่าย
แนะนำอย่างยิ่ง: ใช้ Git เพื่อโคลนที่เก็บใน Raspberry Pi
หากต้องการรับโค้ด ให้เปิดหน้าต่างเทอร์มินัลใหม่และโคลนที่เก็บ โดยทำดังนี้
git clone https://github.com/tensorflow/sig-tfjs.git
ไฟล์ทั้งหมดที่ต้องการแก้ไขสำหรับ Codelab จะอยู่ในไดเรกทอรี tfjs-tflite-node-codelab (ภายใน sig-tfjs) ในไดเรกทอรีนี้ คุณจะเห็นไดเรกทอรีย่อยชื่อ starter_code, cpu_inference_working, coral_inference_working และ webnn_inference_working จุดตรวจเหล่านี้คือจุดตรวจสำหรับขั้นตอนต่างๆ ของ Codelab นี้
ไฟล์อื่นๆ ในที่เก็บคือแพ็กเกจ NPM ที่ tfjs-tflite-node-codelab ใช้อยู่ คุณไม่จำเป็นต้องแก้ไขไฟล์เหล่านี้เลย แต่จะต้องเรียกใช้การทดสอบบางอย่างเพื่อให้มั่นใจว่าสภาพแวดล้อมของคุณมีการตั้งค่าอย่างถูกต้อง
ติดตั้งไลบรารีรันไทม์ Edge TPU
อุปกรณ์ Coral กำหนดให้คุณต้องติดตั้งไลบรารีรันไทม์ Edge TPU ก่อนใช้งาน ติดตั้งโดยทำตามวิธีการสำหรับแพลตฟอร์มของคุณ
ใน Linux / Rspberry Pi
ใน Linux ไลบรารีนี้มีอยู่ใน PPA ของ Google เป็นแพ็กเกจ Debian, libedgetpu1-std สำหรับสถาปัตยกรรม x86-64 และ Armv8 (64 บิต) หากโปรเซสเซอร์ใช้สถาปัตยกรรมอื่น คุณจะต้องคอมไพล์จากต้นทาง
เรียกใช้คำสั่งนี้เพื่อเพิ่ม Coral PPA ของ Google และติดตั้งไลบรารีรันไทม์ Edge TPU
# None of this is needed on Coral boards
# This repo is needed for almost all packages below
echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
# This repo is needed for only python3-coral-cloudiot and python3-coral-enviro
echo "deb https://packages.cloud.google.com/apt coral-cloud-stable main" | sudo tee /etc/apt/sources.list.d/coral-cloud.list
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
sudo apt-get update
sudo apt-get install libedgetpu1-std
ใน Windows / ระบบปฏิบัติการอื่นๆ
ไบนารีที่คอมไพล์ไว้ล่วงหน้าแล้วสำหรับ MacOS และ Windows เวอร์ชัน x86-64 และติดตั้งได้ด้วยการเรียกใช้สคริปต์ install.sh หรือ install.bat ในที่เก็บถาวรเมื่อดาวน์โหลดแล้ว
รีสตาร์ทอุปกรณ์
เมื่อติดตั้งรันไทม์ Edge TPU แล้ว ให้รีสตาร์ทอุปกรณ์เพื่อเปิดใช้งานกฎ Coral Udev ใหม่ที่โปรแกรมติดตั้งเพิ่ม
ยืนยันว่าตรวจพบอุปกรณ์ Coral
หากต้องการยืนยันว่าตรวจพบอุปกรณ์ Coral แล้วและกำลังทำงาน ให้ทดสอบการผสานรวมสำหรับแพ็กเกจ coral-tflite-delegate แพ็กเกจนี้จะอยู่ในไดเรกทอรีรูทของที่เก็บ หากต้องการเรียกใช้การทดสอบการผสานรวม ให้เสียบปลั๊ก Coral Accelerator และเรียกใช้คำสั่งต่อไปนี้ในไดเรกทอรีของแพ็กเกจ
npx yarn
npx yarn build-deps
npx yarn test-integration
คุณควรจะเห็นเอาต์พุตดังนี้
yarn run v1.22.17
$ yarn build && yarn test-integration-dev
$ tsc
$ jasmine --config=jasmine-integration.json
Platform node has already been set. Overwriting the platform with node.
Randomized with seed 78904
Started
============================
Hi there 👋. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================
WARNING: converting 'int32' to 'uint8'
.
1 spec, 0 failures
Finished in 2.777 seconds
Randomized with seed 78904 (jasmine --random=true --seed=78904)
Done in 6.36s.
ไม่ต้องกังวลกับการติดตั้ง @tensorflow/tfjs-node, ตามที่ระบุไว้ในบันทึก เนื่องจากคุณจะเรียกใช้โมเดลใน TFLite
หากเอาต์พุตมี Encountered unresolved custom op: edgetpu-custom-op แทน แสดงว่าระบบไม่พบอุปกรณ์ Coral ของคุณ ตรวจสอบว่าคุณได้ติดตั้งไลบรารีรันไทม์ EDGE TPU และเสียบอุปกรณ์ Coral เข้ากับคอมพิวเตอร์แล้ว นอกจากนี้ คุณยังทำตามคู่มือเริ่มต้นใช้งานของ Coral เพื่อทดสอบการเชื่อมโยงปะการังเวอร์ชัน Python ได้ด้วย หากเวอร์ชัน Python ใช้งานได้ แต่การทดสอบเหล่านี้ยังคงล้มเหลว โปรดแจ้งให้เราทราบโดยยื่นรายงานข้อบกพร่อง
เรียกใช้โค้ดเริ่มต้น
ตอนนี้คุณก็พร้อมที่จะเรียกใช้โค้ดเริ่มต้นแล้ว ทำตามขั้นตอนต่อไปนี้เพื่อเริ่มต้น
- ย้ายไปที่ไดเรกทอรี
starter_codeภายใต้ไดเรกทอรีtfjs-tflite-node-codelab - เรียกใช้
npm installเพื่อติดตั้งทรัพยากร Dependency - เรียกใช้
npm startเพื่อเปิดใช้โปรเจ็กต์ แอปที่แสดงฟีดวิดีโอจากเว็บแคมของคอมพิวเตอร์ควรเปิดขึ้น
จุดเริ่มต้นของเราคืออะไร
จุดเริ่มต้นของเราคือแอปกล้อง Electron พื้นฐานที่ออกแบบมาสำหรับ Codelab นี้ โดยได้รับการปรับให้โค้ดง่ายขึ้นเพื่อแสดงแนวคิดใน Codelab และมีการจัดการข้อผิดพลาดเพียงเล็กน้อย หากคุณเลือกที่จะนำโค้ดใดๆ มาใช้ซ้ำในแอปเวอร์ชันที่ใช้งานจริง โปรดตรวจสอบให้แน่ใจว่าคุณได้จัดการกับข้อผิดพลาดและทดสอบโค้ดทั้งหมดอย่างสมบูรณ์แล้ว
สำรวจโค้ดเริ่มต้น
มีไฟล์จำนวนมากในโค้ดเริ่มต้นนี้ แต่ไฟล์เดียวที่คุณต้องแก้ไขคือ renderer.js โดยจะควบคุมสิ่งที่แสดงในหน้าเว็บ รวมถึงฟีดวิดีโอและองค์ประกอบ HTML ทั้งยังเป็นที่ที่คุณเพิ่มโมเดลแมชชีนเลิร์นนิงลงในแอป ส่วนไฟล์อื่นๆ จะเป็นไฟล์ index.html แต่มีเพียงโหลดไฟล์ renderer.js นอกจากนี้ยังมีไฟล์ main.js ซึ่งเป็นจุดแรกเข้าของอิเล็กตรอน โดยจะควบคุมวงจรของแอป ซึ่งรวมถึงสิ่งที่จะแสดงเมื่อเปิดแอป และสิ่งที่ต้องทำเมื่อปิดแล้ว โดยคุณไม่จำเป็นต้องทำการเปลี่ยนแปลงใดๆ
เปิดโปรแกรมแก้ไขข้อบกพร่อง
คุณอาจต้องแก้ไขข้อบกพร่องของแอปเมื่อทำตาม Codelab นี้ เนื่องจากแอปนี้ใช้ Electron จึงมีโปรแกรมแก้ไขข้อบกพร่องของ Chrome ในตัว ในแพลตฟอร์มส่วนใหญ่ คุณสามารถเปิดได้ด้วยปุ่ม Ctrl + Shift + i คลิกแท็บคอนโซลเพื่อดูบันทึกและข้อความแสดงข้อผิดพลาดจากแอป
ที่นี่ไม่มีอะไรให้สำรวจอีก ดังนั้นมาเริ่มฝึกตัวแยกประเภทรูปภาพกันเลย
3. ฝึกตัวแยกประเภทรูปภาพ
ในส่วนนี้ คุณจะได้ฝึกเวอร์ชัน TFLite และ Coral ของโมเดลการจัดประเภทรูปภาพที่กำหนดเอง
ฝึกอบรมตัวแยกประเภท
ตัวแยกประเภทรูปภาพจะเลือกรูปภาพที่ป้อนและกำหนดป้ายกำกับให้กับรูปภาพดังกล่าว สำหรับ Codelab นี้ คุณใช้ Teachable Machine เพื่อฝึกโมเดลในเบราว์เซอร์ หากต้องการเร่งการฝึกในส่วนนี้ คุณสามารถใช้คอมพิวเตอร์เดสก์ท็อปหรือแล็ปท็อปแทน Raspberry Pi แต่คุณจะต้องคัดลอกไฟล์ที่ได้ไปยัง Pi
ตอนนี้คุณก็พร้อมฝึกโมเดลแล้ว หากคุณไม่แน่ใจว่าจะฝึกโมเดลประเภทใด โมเดลง่ายๆ ในการฝึกคือตัวตรวจจับบุคคล ซึ่งจะตรวจจับว่าบุคคลอยู่ในเฟรมหรือไม่
- เปิดหน้าการฝึกของ Teachable Machine ในแท็บใหม่
- เลือกโปรเจ็กต์รูปภาพ แล้วเลือกโมเดลรูปภาพมาตรฐาน
- เพิ่มตัวอย่างรูปภาพสำหรับแต่ละชั้นเรียน การใช้อินพุตเว็บแคมเป็นวิธีที่ง่ายที่สุดในการดำเนินการ หรือจะเปลี่ยนชื่อชั้นเรียนก็ได้
- เมื่อรวบรวมข้อมูลสำหรับแต่ละคลาสเพียงพอแล้ว (โดยปกติ 50 ตัวอย่างก็เพียงพอแล้ว) ให้กดฝึกโมเดล
เมื่อการฝึกโมเดลเสร็จสิ้น คุณควรเห็นตัวอย่างเอาต์พุตของโมเดล
ลองป้อนข้อมูลที่แตกต่างกันให้กับโมเดล หากคุณพบอินพุตที่มีการจัดประเภทไม่ถูกต้อง ให้เพิ่มอินพุตนั้นในข้อมูลการฝึกและฝึกโมเดลอีกครั้ง
- เมื่อพอใจกับความถูกต้องของโมเดลแล้ว ให้คลิกส่งออกโมเดล คุณจะต้องดาวน์โหลดโมเดล 2 เวอร์ชันแยกกัน
- ส่งออกโมเดลเป็นโมเดลจุดลอยตัว Tensorflow Lite การดำเนินการนี้จะดาวน์โหลดไฟล์ชื่อ
converted_tflite.zipที่ทำงานบน CPU - ส่งออกโมเดลเป็นโมเดล Tensorflow Lite EdgeTPU การดำเนินการนี้จะดาวน์โหลดไฟล์ชื่อ
converted_edgetpu.zipซึ่งทำงานบน Coral Edge TPU
4. เรียกใช้รุ่น CPU ในแอป
เมื่อฝึกโมเดลแล้ว ก็ถึงเวลาเพิ่มลงในแอป ในตอนท้ายของส่วนนี้ แอปจะสามารถเรียกใช้โมเดลโดยใช้ CPU ของอุปกรณ์ได้
เพิ่มไฟล์โมเดลลงในแอป
แตกไฟล์โมเดล converted_tflite.zip ที่ดาวน์โหลดมาเมื่อฝึกตัวแยกประเภท ที่เก็บถาวรมี 2 ไฟล์ model_uquant.tflite คือโมเดล TFLite ที่บันทึกไว้ รวมถึงกราฟโมเดลและน้ำหนัก labels.txt มีป้ายกำกับที่มนุษย์อ่านได้สำหรับคลาสที่โมเดลคาดการณ์ วางทั้ง 2 ไฟล์ไว้ใน modeldirectory
ติดตั้งทรัพยากร Dependency
การโหลดอินพุตโมเดลและการประมวลผลล่วงหน้าจำเป็นต้องมีทรัพยากร Dependency บางรายการจาก TensorFlow.js ดังนี้
tfjs-tflite-node: แพ็กเกจของ TensorFlow.js สำหรับการเรียกใช้โมเดล TFLite ใน Node.js@tensorflow/tfjs: แพ็กเกจหลักของ TensorFlow.js
ติดตั้ง @tensorflow/tfjs ไว้แล้ว แต่คุณต้องติดตั้ง tfjs-tflite-node ด้วยคำสั่งต่อไปนี้
npm install --save tfjs-tflite-node
เมื่อติดตั้งแล้ว ให้เพิ่มไปยังแอปที่ด้านบนของ renderer.js ดังนี้
CODELAB ส่วนที่ 1: นำเข้าโหนด tfjs-tflite-node
const {loadTFLiteModel} = require('tfjs-tflite-node');
โหลดโมเดล
ขณะนี้คุณพร้อมที่จะโหลดโมเดล tfjs-tflite-node มีฟังก์ชัน loadTFLiteModel ในการดำเนินการนี้ โดยสามารถโหลดโมเดลจากเส้นทางไฟล์, ArrayBuffer หรือ TFHub URL ได้ หากต้องการโหลดโมเดลและน้ำหนัก ให้เพิ่มข้อมูลนี้ลงในฟังก์ชัน main
CODELAB ส่วนที่ 1: โหลดโมเดลที่นี่
const modelPath = './model/model_unquant.tflite';
const model = await loadTFLiteModel(modelPath);
const labels = fs.readFileSync('./model/labels.txt', 'utf8')
.split('\n');
เรียกใช้โมเดล
การเรียกใช้โมเดลมี 3 ขั้นตอน ก่อนอื่นให้ดึงและประมวลผลเฟรมอินพุตล่วงหน้าจากเว็บแคม จากนั้นจึงเรียกใช้โมเดลในเฟรมนั้นและรับการคาดการณ์ หลังจากนั้น คุณจะแสดงการคาดคะเนในหน้าเว็บ
ประมวลผลอินพุตเว็บแคมล่วงหน้า
ขณะนี้เว็บแคมเป็นเพียงองค์ประกอบ HTML เท่านั้น และเฟรมที่แสดงไม่สามารถใช้กับไฟล์ JavaScriptrenderer.js ในการดึงเฟรมจากเว็บแคม TensorFlow.js จะให้ tf.data.webcam ซึ่งมีเมธอด capture() ที่ใช้งานง่ายสำหรับการจับภาพเฟรมจากกล้อง
หากต้องการใช้งาน ให้เพิ่มรหัสการตั้งค่านี้ไปยัง main():
CODELAB ส่วนที่ 1: ตั้งค่า tf.data.webcam ที่นี่
const tensorCam = await tf.data.webcam(webcam);
จากนั้นหากต้องการจับภาพทุกเฟรม ให้เพิ่มข้อมูลต่อไปนี้ลงใน run()
CODELAB ส่วนที่ 1: จับภาพเฟรมเว็บแคมที่นี่
const image = await tensorCam.capture();
นอกจากนี้คุณต้องประมวลผลแต่ละเฟรมล่วงหน้าเพื่อให้เข้ากันได้กับโมเดลนี้ โมเดลที่ Codelab นี้ใช้มีรูปร่างอินพุต [1, 224, 224, 3] ดังนั้นจึงควรมีรูปภาพ RGB ขนาด 224 x 224 พิกเซล tensorCam.capture()ให้รูปร่างเป็น [224, 224, 3] คุณจึงต้องเพิ่มมิติข้อมูลอีกที่ด้านหน้าของ Tensor ด้วย tf.expandDims นอกจากนี้ โมเดล CPU คาดว่าอินพุต Float32 จะอยู่ระหว่าง -1 ถึง 1 แต่เว็บแคมจะบันทึกค่าได้ตั้งแต่ 0 ถึง 255 คุณสามารถหาร Tensor อินพุตด้วย 127 เพื่อเปลี่ยนช่วงจาก [0, 255] เป็น [0, ~2] แล้วลบ 1 เพื่อให้ได้ช่วงที่ต้องการ [-1, ~1] เพิ่มบรรทัดต่อไปนี้ไปยัง tf.tidy() ในฟังก์ชัน run() เพื่อดำเนินการนี้
CODELAB ส่วนที่ 1: ประมวลผลเฟรมเว็บแคมล่วงหน้าที่นี่
const expanded = tf.expandDims(image, 0);
const divided = tf.div(expanded, tf.scalar(127));
const normalized = tf.sub(divided, tf.scalar(1));
ควรกำจัด Tensor ออกหลังจากใช้งานแล้ว tf.tidy() จะดําเนินการเช่นนี้โดยอัตโนมัติสําหรับโค้ดที่อยู่ใน Callback แต่ไม่รองรับฟังก์ชันอะซิงโครนัส คุณจะต้องกำจัด Tensor รูปภาพที่สร้างขึ้นก่อนหน้านี้ด้วยตนเองโดยเรียกใช้เมธอด dispose()
CODELAB ส่วนที่ 1: กำจัดเฟรมเว็บแคมที่นี่
image.dispose();
เรียกใช้โมเดลและแสดงผลลัพธ์
หากต้องการเรียกใช้โมเดลบนอินพุตที่ประมวลผลล่วงหน้า ให้เรียกใช้ model.predict() ใน Tensor มาตรฐาน ซึ่งจะแสดงผล Tensor หนึ่งมิติข้อมูลที่มีข้อมูลความน่าจะเป็นที่คาดการณ์ไว้ของแต่ละป้ายกำกับ คูณความน่าจะเป็นนี้ด้วย 100 เพื่อหาค่าเปอร์เซ็นต์ของป้ายกำกับแต่ละป้าย และใช้ฟังก์ชัน showPrediction ที่มาพร้อมกับโค้ดเริ่มต้นเพื่อแสดงการคาดการณ์ของโมเดลบนหน้าจอ
โค้ดนี้ยังใช้ stats.js เพื่อระบุระยะเวลาที่ใช้ในการคาดการณ์ด้วยการโทรหา stats.begin และ stats.end ประมาณ model.predict
CODELAB ส่วนที่ 1: เรียกใช้โมเดลและแสดงผลลัพธ์ที่นี่
stats.begin();
const prediction = model.predict(normalized);
stats.end();
const percentage = tf.mul(prediction, tf.scalar(100));
showPrediction(percentage.dataSync(), labels);
เรียกใช้แอปอีกครั้งด้วย yarn start จากนั้นคุณจะเห็นการแยกประเภทจากโมเดลของคุณ
ประสิทธิภาพ
โมเดลจะทำงานบน CPU เนื่องจากมีการตั้งค่าอยู่ในขณะนี้ วิธีนี้เหมาะสำหรับคอมพิวเตอร์เดสก์ท็อปและแล็ปท็อปส่วนใหญ่ แต่อาจไม่ต้องการหากเรียกใช้บน Raspberry Pi หรืออุปกรณ์พลังงานต่ำชนิดอื่น ใน Raspberry Pi 4 คุณอาจจะเห็นประมาณ 10 FPS ซึ่งอาจเร็วพอสำหรับแอปพลิเคชันบางรายการ หากต้องการประสิทธิภาพที่ดีขึ้นโดยไม่ต้องใช้เครื่องที่ทำงานได้เร็วขึ้น คุณสามารถใช้ซิลิคอนเฉพาะแอปพลิเคชันในรูปแบบ Coral Edge TPU
5. เรียกใช้โมเดล Coral ในแอป
หากไม่มีอุปกรณ์ Coral ให้ข้ามส่วนนี้
ขั้นตอนของ Codelab นี้จะสร้างขึ้นจากโค้ดที่คุณเขียนไว้ในส่วนสุดท้าย แต่คุณสามารถใช้จุดตรวจสอบ cpu_inference_working แทนหากต้องการเริ่มต้นด้วยสเลทใหม่
ขั้นตอนสำหรับการเรียกใช้โมเดล Coral จะเกือบเหมือนกับขั้นตอนการเรียกใช้โมเดล CPU ความแตกต่างหลักๆ คือรูปแบบโมเดล เนื่องจาก Coral รองรับเฉพาะ uint8 tensor ทำให้โมเดลนี้เล็กลง ซึ่งจะส่งผลต่อ Tensor อินพุตที่ส่งไปยังโมเดลและ Tensor เอาต์พุตที่ส่งกลับ ข้อแตกต่างอีกประการก็คือโมเดลจะต้องคอมไพเลอร์โดยใช้คอมไพเลอร์ Edge TPU เพื่อเรียกใช้บน Coral TPU TeachableMachine ได้ทำตามขั้นตอนนี้แล้ว แต่คุณดูวิธีการสำหรับโมเดลอื่นๆ ได้โดยไปที่เอกสารประกอบของ Coral
เพิ่มไฟล์โมเดล Coral ลงในแอป
แตกไฟล์โมเดล converted_edgetpu.zip ที่ดาวน์โหลดมาเมื่อฝึกตัวแยกประเภท ที่เก็บถาวรมี 2 ไฟล์ model_edgetpu.tflite คือโมเดล TFLite ที่บันทึกไว้ รวมถึงกราฟโมเดลและน้ำหนัก labels.txt มีป้ายกำกับที่มนุษย์อ่านได้สำหรับคลาสที่โมเดลคาดการณ์ วางไฟล์โมเดลในไดเรกทอรี coral_model
ติดตั้งทรัพยากร Dependency
การเรียกใช้โมเดล Coral ต้องใช้ไลบรารีรันไทม์ของ Edge TPU ตรวจสอบว่าคุณได้ติดตั้งแอปแล้วโดยทำตามวิธีการตั้งค่าก่อนดำเนินการต่อ
อุปกรณ์ Coral จะเข้าถึงในฐานะผู้ที่ได้รับมอบสิทธิ์ TFLite หากต้องการเข้าถึงจาก JavaScript ให้ติดตั้งแพ็กเกจ coral-tflite-delegate ดังนี้
npm install --save coral-tflite-delegate
จากนั้นนำเข้าผู้รับมอบสิทธิ์โดยเพิ่มบรรทัดนี้ลงในด้านบนสุดของไฟล์ renderer.js
CODELAB ส่วนที่ 2: นำเข้าผู้รับมอบสิทธิ์ที่นี่
const {CoralDelegate} = require('coral-tflite-delegate');
โหลดโมเดล
ตอนนี้คุณพร้อมที่จะโหลดโมเดล Coral แล้ว คุณทำในลักษณะเดียวกันกับรุ่น CPU ยกเว้นตอนนี้ที่คุณส่งตัวเลือกไปยังฟังก์ชัน loadTFLiteModel เพื่อโหลดผู้รับมอบสิทธิ์ Coral
CODELAB ส่วนที่ 2: โหลดโมเดลผู้รับมอบสิทธิ์ที่นี่
const coralModelPath = './coral_model/model_edgetpu.tflite';
const options = {delegates: [new CoralDelegate()]};
const coralModel = await loadTFLiteModel(coralModelPath, options);
คุณไม่จำเป็นต้องโหลดป้ายกำกับ เนื่องจากป้ายกำกับจะเหมือนกันสำหรับรุ่น CPU
เพิ่มปุ่มเพื่อสลับระหว่าง CPU กับ Coral
คุณเพิ่มรุ่น Coral ควบคู่ไปกับรุ่น CPU ที่เพิ่มไว้ในส่วนสุดท้าย การเรียกใช้ทั้งคู่พร้อมกันทำให้เห็นความแตกต่างของประสิทธิภาพได้ยาก ดังนั้นปุ่มเปิด/ปิดจะสลับระหว่างการทำงานของ Coral กับ CPU
เพิ่มปุ่มด้วยโค้ดนี้:
CODELAB ส่วนที่ 2: สร้างปุ่มมอบสิทธิ์ที่นี่
let useCoralDelegate = false;
const toggleCoralButton = document.createElement('button');
function toggleCoral() {
useCoralDelegate = !useCoralDelegate;
toggleCoralButton.innerText = useCoralDelegate
? 'Using Coral. Press to switch to CPU.'
: 'Using CPU. Press to switch to Coral.';
}
toggleCoralButton.addEventListener('click', toggleCoral);
toggleCoral();
document.body.appendChild(toggleCoralButton);
มาผสานรวมเงื่อนไขนี้ในฟังก์ชัน run() กัน เมื่อ useCoralDelegate เป็น "เท็จ" แอปควรเรียกใช้เวอร์ชัน CPU หรือไม่เช่นนั้นก็จะเรียกใช้เวอร์ชัน Coral (แต่ตอนนี้ยังไม่ทำงาน) ตัดโค้ดจากการเรียกใช้รุ่น CPU ในคำสั่ง if โปรดทราบว่า tensor ของ expanded จะไม่อยู่ในคำสั่ง if เนื่องจากโมเดล Coral ใช้พารามิเตอร์นี้
CODELAB ส่วนที่ 2: ตรวจสอบว่าจะใช้ผู้ได้รับมอบสิทธิ์หรือไม่
// NOTE: Don't just copy-paste this code into the app.
// You'll need to edit the code from the CPU section.
const expanded = tf.expandDims(image, 0);
if (useCoralDelegate) {
// CODELAB part 2: Run Coral prediction here.
} else {
const divided = tf.div(expanded, tf.scalar(127));
const normalized = tf.sub(divided, tf.scalar(1));
stats.begin();
const prediction = model.predict(normalized);
stats.end();
const percentage = tf.mul(prediction, tf.scalar(100));
showPrediction(percentage.dataSync(), labels);
}
เรียกใช้โมเดล
เวอร์ชัน Coral ของโมเดลคาดว่า uint8 จะเป็น 0 ถึง 255 ดังนั้นอินพุตของโมเดลจึงไม่ต้องปรับให้เป็นมาตรฐาน อย่างไรก็ตาม เอาต์พุตจะเป็น Tensor 8 ในช่วง 0 ถึง 255 ด้วย โดยต้องแปลงเป็นจำนวนลอยตัวจาก 0 ถึง 100 ก่อน จึงจะแสดงค่าได้
CODELAB ส่วนที่ 2: เรียกใช้การคาดการณ์ Coral ที่นี่ (นี่คือส่วนหนึ่งของข้อมูลโค้ดด้านบน)
stats.begin();
const prediction = coralModel.predict(expanded);
stats.end();
const percentage = tf.div(tf.mul(prediction, tf.scalar(100)), tf.scalar(255));
showPrediction(percentage.dataSync(), labels);
เรียกใช้แอปอีกครั้งด้วย yarn start และแอปควรแสดงการแยกประเภทจาก Coral Accelerator
คุณสลับระหว่างการอนุมานของ Coral และ CPU ได้โดยกดปุ่ม คุณอาจสังเกตเห็นว่าอันดับความเชื่อมั่นของโมเดล Coral มีความแม่นยำน้อยกว่าของรุ่น CPU และมักจะลงท้ายด้วยทศนิยมที่เท่ากัน การสูญเสียความแม่นยํานี้เกิดจากข้อดีข้อเสียของการเรียกใช้โมเดลเชิงปริมาณกับ Coral ซึ่งมักไม่ใช่ประเด็นสำคัญในทางปฏิบัติ แต่เป็นสิ่งที่ควรคำนึงถึง
หมายเหตุเกี่ยวกับประสิทธิภาพ
อัตราเฟรมที่คุณเห็นรวมการประมวลผลล่วงหน้าและหลังการประมวลผล จึงไม่ได้แสดงถึงประสิทธิภาพของฮาร์ดแวร์ Coral คุณสามารถดูประสิทธิภาพที่แม่นยำมากขึ้นได้โดยคลิกที่ตัววัด FPS จนกว่าเครื่องจะแสดงเวลาในการตอบสนอง (เป็นมิลลิวินาที) ซึ่งวัดเฉพาะการเรียกไปยัง model.predict อย่างไรก็ตาม ยังรวมถึงเวลาที่ใช้ในการย้าย Tensor ไปยังการเชื่อมโยง C แบบ TFLite แบบเนทีฟแล้วไปยังอุปกรณ์ Coral ด้วย ดังนั้นจึงไม่ใช่การวัดผลที่สมบูรณ์แบบ สำหรับการเปรียบเทียบประสิทธิภาพที่เขียนด้วย C++ ที่แม่นยำยิ่งขึ้น โปรดดูหน้าการเปรียบเทียบ EdgeTPU
โปรดทราบด้วยว่า วิดีโอบันทึกในแล็ปท็อปแทนที่จะเป็น Raspberry Pi ดังนั้นคุณอาจเห็น FPS ที่แตกต่างกัน
เพิ่มความเร็วในการประมวลผล Coral ล่วงหน้า
ในบางกรณี คุณสามารถเร่งการประมวลผลล่วงหน้าได้โดยการเปลี่ยนแบ็กเอนด์ของ TFJS แบ็กเอนด์เริ่มต้นคือ WebGL ซึ่งเหมาะสำหรับการดำเนินการขนาดใหญ่และขนานกัน แต่แอปนี้ไม่ได้ทำสิ่งต่อไปนี้ในช่วงก่อนการประมวลผล (ตัวเลือกเดียวที่ใช้คือ expandDims ซึ่งไม่พร้อมกัน) คุณสามารถเปลี่ยนไปใช้แบ็กเอนด์ของ CPU เพื่อหลีกเลี่ยงเวลาในการตอบสนองเพิ่มเติมของการย้าย Tensor ไปยังและจาก GPU ได้โดยการเพิ่มบรรทัดนี้หลังจากการนำเข้าที่ด้านบนของไฟล์
tf.setBackend(‘cpu');
นอกจากนี้ยังส่งผลต่อการประมวลผลล่วงหน้าสำหรับ CPU รุ่น TFLite ที่เป็นแบบขนานด้วย ดังนั้นรุ่นดังกล่าวจะทำงานช้าลงมากเมื่อมีการเปลี่ยนแปลงนี้
6. เร่งความเร็วให้โมเดล CPU ด้วย WebNN
หากไม่มี Coral Accelerator หรือเพียงต้องการลองใช้วิธีอื่นเพื่อเร่งความเร็วโมเดล คุณสามารถใช้ผู้รับมอบสิทธิ์ WebNN TFLite ผู้รับมอบสิทธิ์รายนี้ใช้ฮาร์ดแวร์แมชชีนเลิร์นนิงในตัวประมวลผลของ Intel เพื่อเร่งการอนุมานโมเดลด้วยชุดเครื่องมือ OpenVINO ดังนั้นจึงมีข้อกำหนดเพิ่มเติมที่ไม่ได้กล่าวถึงในส่วนการตั้งค่าของ Codelab นี้ และคุณจะต้องติดตั้งชุดเครื่องมือ OpenVINO โปรดตรวจสอบการตั้งค่ากับแพลตฟอร์มระบบเป้าหมายที่รองรับก่อนดำเนินการต่อ แต่โปรดทราบว่าผู้รับมอบสิทธิ์ WebNN ยังไม่รองรับ macOS
ติดตั้งชุดเครื่องมือ OpenVINO
ชุดเครื่องมือ OpenVINO ใช้ฮาร์ดแวร์แมชชีนเลิร์นนิงในตัวโปรเซสเซอร์ของ Intel เพื่อเพิ่มความเร็วให้กับโมเดล คุณสามารถดาวน์โหลดเวอร์ชันแบบคอมไพล์จาก Intel หรือสร้างจากต้นทางก็ได้ การติดตั้ง OpenVINO มีอยู่หลายวิธี แต่ขอแนะนำให้ใช้สคริปต์โปรแกรมติดตั้งสำหรับ Windows หรือ Linux ตามวัตถุประสงค์ของ Codelab นี้ โปรดติดตั้งรันไทม์ LTS เวอร์ชัน 2021.4.2 เนื่องจากเวอร์ชันอื่นๆ อาจใช้งานร่วมกันไม่ได้ หลังจากเรียกใช้โปรแกรมติดตั้งแล้ว โปรดตรวจสอบว่าได้กำหนดค่าตัวแปรสภาพแวดล้อมของ Shell ตามที่อธิบายไว้ในคำแนะนำในการติดตั้งสำหรับ Linux หรือ Windows ( โซลูชันถาวร) หรือเรียกใช้คำสั่ง setupvars.sh (Linux) หรือ setupvars.bat (Windows) ในไดเรกทอรี webnn-tflite-delegate
ยืนยันว่าผู้รับมอบสิทธิ์ WebNN ใช้งานได้
หากต้องการยืนยันว่าผู้รับมอบสิทธิ์ WebNN ทำงานได้อย่างถูกต้อง ให้เรียกใช้การทดสอบการผสานรวมสำหรับแพ็กเกจ webnn-tflite-delegate ที่พบในไดเรกทอรีรากของที่เก็บ หากต้องการเรียกใช้การทดสอบการผสานรวม ให้เรียกใช้คำสั่งเหล่านี้ในไดเรกทอรีของแพ็กเกจ
# In webnn-tflite-delegate/
npx yarn
npx yarn test-integration
คุณควรจะเห็นเอาต์พุตดังนี้
WebNN delegate: WebNN device set to 0.
INFO: Created TensorFlow Lite WebNN delegate for device Default and power Default.
============================
Hi there 👋. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================
label: wine bottle
score: 0.934505045413971
.
1 spec, 0 failures
Finished in 0.446 seconds
Randomized with seed 58441 (jasmine --random=true --seed=58441)
Done in 8.07s.
หากคุณเห็นเอาต์พุตแบบนี้ แสดงว่าเกิดข้อผิดพลาดในการกำหนดค่า
Platform node has already been set. Overwriting the platform with node.
Randomized with seed 05938
Started
error Command failed with exit code 3221225477.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.
เอาต์พุตนี้อาจหมายความว่าคุณไม่ได้ตั้งค่าตัวแปรสภาพแวดล้อมของ OpenVINO ไว้ ในตอนนี้คุณสามารถตั้งค่าได้โดยเรียกใช้คำสั่ง setupvars.sh (Linux) หรือ setupvars.bat (Windows) แต่คุณอาจต้องการตั้งค่าอย่างถาวรโดยทำตามคำแนะนำ Linux หรือ Windows ( โซลูชันถาวร) หากคุณใช้ Windows the
setupvars.bat
command ไม่รองรับ Git bash ดังนั้นตรวจสอบให้แน่ใจว่าคุณได้เรียกใช้และคำสั่งอื่นๆ จาก Codelab นี้จากพรอมต์คำสั่งของ Windows แล้ว
ติดตั้งการมอบสิทธิ์ WebNN
เมื่อติดตั้ง OpenVINO แล้ว คุณก็พร้อมที่จะเร่งความเร็วโมเดล CPU ด้วย WebNN แล้ว ส่วนของ Codelab นี้จะสร้างขึ้นจากโค้ดที่คุณเขียนไว้ในส่วน "เรียกใช้โมเดล CPU ในแอปของคุณ" คุณสามารถใช้โค้ดที่เขียนในขั้นตอนนี้ได้ แต่หากคุณดำเนินการส่วน Coral เสร็จสมบูรณ์แล้ว ให้ใช้จุดตรวจสอบ cpu_inference_working แทนเพื่อให้เริ่มต้นด้วยแถบสเลทใหม่
ส่วน Node.js ของการมอบสิทธิ์ WebNN จะกระจายอยู่บน npmjs หากต้องการติดตั้ง ให้เรียกใช้คำสั่งนี้
npm install --save webnn-tflite-delegate
จากนั้นนำเข้าผู้รับมอบสิทธิ์โดยเพิ่มบรรทัดนี้ลงในด้านบนสุดของไฟล์ renderer.js
CODELAB ส่วนที่ 2: นำเข้าผู้รับมอบสิทธิ์ที่นี่
const {WebNNDelegate, WebNNDevice} = require('webnn-tflite-delegate');
ผู้รับมอบสิทธิ์ WebNN รองรับการทำงานบน CPU หรือ GPU WebNNDevice ให้คุณเลือกอุปกรณ์ที่จะใช้
โหลดโมเดล
ตอนนี้คุณพร้อมที่จะโหลดโมเดลเมื่อเปิดใช้การมอบสิทธิ์ WebNN สำหรับ Coral คุณต้องโหลดไฟล์โมเดลอื่น แต่ WebNN รองรับรูปแบบโมเดลเดียวกันกับ TFLite เพิ่ม WebNNDelegate ไปยังรายชื่อผู้รับมอบสิทธิ์ที่จะส่งไปยังโมเดลเพื่อเปิดใช้:
CODELAB ส่วนที่ 2: โหลดโมเดลผู้รับมอบสิทธิ์ที่นี่
let webnnModel = await loadTFLiteModel(modelPath, {
delegates: [new WebNNDelegate({webnnDevice: WebNNDevice.DEFAULT})],
});
คุณไม่จำเป็นต้องโหลดป้ายกำกับอีกครั้ง เนื่องจากเป็นรูปแบบเดียวกัน
เพิ่มปุ่มเพื่อสลับระหว่าง CPU ของ TfLite กับ WebNN
ตอนนี้โมเดลเวอร์ชัน WebNN พร้อมใช้งานแล้ว ให้เพิ่มปุ่มเพื่อสลับระหว่างการอนุมาน CPU ของ WebNN และ TfLite การเรียกใช้ทั้ง 2 ฟีเจอร์พร้อมกันจะทำให้เห็นความแตกต่างด้านประสิทธิภาพได้ยาก
เพิ่มปุ่มด้วยโค้ดนี้ (โปรดทราบว่าปุ่มนี้จะยังไม่เปลี่ยนรูปแบบ):
CODELAB ส่วนที่ 2: สร้างปุ่มมอบสิทธิ์ที่นี่
let useWebNNDelegate = false;
const divElem = document.createElement('div');
const toggleWebNNButton = document.createElement('button');
function toggleWebNN() {
useWebNNDelegate = !useWebNNDelegate;
toggleWebNNButton.innerHTML = useWebNNDelegate
? 'Using WebNN. Press to switch to TFLite CPU.'
: 'Using TFLite CPU. Press to switch to WebNN.';
divElem.hidden = useWebNNDelegate ? false : true;
}
toggleWebNNButton.addEventListener('click', toggleWebNN);
toggleWebNN();
document.body.appendChild(toggleWebNNButton);
document.body.appendChild(divElem);
โค้ดนี้จะเพิ่มเอลิเมนต์ div ที่คุณใช้กําหนดการตั้งค่า WebNN ในส่วนถัดไปด้วย
เพิ่มเมนูแบบเลื่อนลงเพื่อสลับระหว่างอุปกรณ์ WebNN
WebNN รองรับการทำงานบน CPU และ GPU ดังนั้นให้เพิ่มเมนูแบบเลื่อนลงเพื่อสลับระหว่างองค์ประกอบเหล่านั้น เพิ่มโค้ดนี้หลังโค้ดที่สร้างปุ่ม
// Create elements for WebNN device selection
divElem.innerHTML = '<br/>WebNN Device: ';
const selectElem = document.createElement('select');
divElem.appendChild(selectElem);
const webnnDevices = ['Default', 'GPU', 'CPU'];
// append the options
for (let i = 0; i < webnnDevices.length; i++) {
var optionElem = document.createElement('option');
optionElem.value = i;
optionElem.text = webnnDevices[i];
selectElem.appendChild(optionElem);
}
หากเรียกใช้แอป คุณจะเห็นเมนูแบบเลื่อนลง "ค่าเริ่มต้น", GPU และ CPU การเลือกรายการใดรายการหนึ่งจะไม่มีผลใดๆ เนื่องจากเมนูแบบเลื่อนลงยังไม่ได้รับการเชื่อมต่อ 
ทำให้เมนูแบบเลื่อนลงเปลี่ยนอุปกรณ์
หากต้องการเชื่อมต่อเมนูแบบเลื่อนลงเพื่อเปลี่ยนอุปกรณ์ WebNN ที่ใช้ ให้เพิ่ม Listener ลงในเหตุการณ์ change ขององค์ประกอบตัวเลือกเมนูแบบเลื่อนลง เมื่อค่าที่เลือกมีการเปลี่ยนแปลง ให้สร้างโมเดล WebNN ใหม่ด้วยอุปกรณ์ WebNN ที่เกี่ยวข้องซึ่งเลือกไว้ในตัวเลือกการมอบสิทธิ์
เพิ่มโค้ดต่อไปนี้หลังโค้ดที่เพิ่มเมนูแบบเลื่อนลง
selectElem.addEventListener('change', async () => {
let webnnDevice;
switch(selectElem.value) {
case '1':
webnnDevice = WebNNDevice.GPU;
break;
case '2':
webnnDevice = WebNNDevice.CPU;
break;
default:
webnnDevice = WebNNDevice.DEFAULT;
break;
}
webnnModel = await loadTFLiteModel(modelPath, {
delegates: [new WebNNDelegate({webnnDevice})],
});
});
เมื่อใช้การเปลี่ยนแปลงนี้ เมนูแบบเลื่อนลงจะสร้างโมเดลใหม่ที่มีการตั้งค่าที่ถูกต้องทุกครั้งที่มีการเปลี่ยนแปลง ถึงเวลาเชื่อมต่อโมเดล WebNN แล้วใช้เพื่ออนุมาน
เรียกใช้โมเดล WebNN
โมเดล WebNN พร้อมใช้งานแล้ว แต่ปุ่มสำหรับสลับระหว่าง CPU WebNN และ TfLite ยังไม่เปลี่ยนไปใช้โมเดล หากต้องการเปลี่ยนรูปแบบ คุณต้องเปลี่ยนชื่อตัวแปร model จากตอนที่โหลดโมเดล CPU ของ TfLite ในส่วนแรกของ Codelab ก่อน
เปลี่ยนบรรทัดต่อไปนี้...
const model = await loadTFLiteModel(modelPath);
...เพื่อให้ตรงกับบรรทัดนี้
const cpuModel = await loadTFLiteModel(modelPath);
เมื่อเปลี่ยนชื่อตัวแปร model เป็น cpuModel แล้ว ให้เพิ่มค่านี้ลงในฟังก์ชัน run เพื่อเลือกโมเดลที่ถูกต้องตามสถานะของปุ่ม ดังนี้
CODELAB ส่วนที่ 2: ตรวจสอบว่าจะใช้ผู้ได้รับมอบสิทธิ์หรือไม่
let model;
if (useWebNNDelegate) {
model = webnnModel;
} else {
model = cpuModel;
}
ตอนนี้ เมื่อเรียกใช้แอป ปุ่มจะสลับระหว่าง CPU ของ TfLite และ WebNN 
คุณยังสลับระหว่างการอนุมาน CPU และ GPU ของ WebNN ได้ด้วยหากมี Intel GPU ในตัว
หมายเหตุเกี่ยวกับประสิทธิภาพ
อัตราเฟรมที่คุณเห็นรวมการประมวลผลล่วงหน้าและหลังการประมวลผล ดังนั้นจึงไม่ได้แสดงถึงความสามารถของ WebNN คุณสามารถดูประสิทธิภาพที่แม่นยำมากขึ้นได้โดยคลิกที่ตัววัด FPS จนกว่าเครื่องจะแสดงเวลาในการตอบสนอง (เป็นมิลลิวินาที) ซึ่งวัดเฉพาะการเรียกไปยัง model.predict อย่างไรก็ตาม ยังรวมถึงเวลาที่ใช้ในการย้าย Tensor ไปยังการเชื่อมโยง C แบบ TFLite แบบเนทีฟด้วย ดังนั้นวิธีนี้จึงไม่ใช่การวัดผลที่สมบูรณ์แบบ
7. ขอแสดงความยินดี
ยินดีด้วย คุณเพิ่งทำโปรเจ็กต์ Coral / WebNN เสร็จเป็นครั้งแรกโดยใช้ tfjs-tflite-node ใน Electron
ลองใช้งาน และทดสอบกับรูปภาพต่างๆ นอกจากนี้คุณยังฝึกโมเดลใหม่ใน TeachableMachine เพื่อจัดประเภทสิ่งที่แตกต่างไปโดยสิ้นเชิงได้
สรุป
คุณได้เรียนรู้สิ่งต่อไปนี้ใน Codelab แล้ว
- วิธีติดตั้งและตั้งค่าแพ็กเกจ tfjs-tflite-node npm เพื่อเรียกใช้โมเดล TFLite ใน Node.js
- วิธีติดตั้งไลบรารีรันไทม์ Edge TPU เพื่อเรียกใช้โมเดลในอุปกรณ์ Coral
- วิธีเร่งการอนุมานโมเดลโดยใช้ Coral EDGE TPU
- วิธีเร่งการอนุมานโมเดลด้วย WebNN
สิ่งที่ต้องทำต่อไป
ตอนนี้คุณมีฐานการทำงานที่จะเริ่มต้นแล้ว ลองคิดหาไอเดียสร้างสรรค์ใหม่ๆ เพื่อขยายการใช้งานโมเดลแมชชีนเลิร์นนิงนี้ไปยังกรณีการใช้งานจริงที่คุณอาจกำลังทำอยู่ บางทีคุณอาจปฏิวัติอุตสาหกรรมที่คุณทำงานอยู่โดยใช้การอนุมานที่รวดเร็วและราคาประหยัด หรือบางทีคุณอาจสามารถดัดแปลงเครื่องปิ้งขนมปังเพื่อให้ขนมปังหยุดปิ้งเมื่อขนมปังดูพอดี ทุกอย่างเป็นไปได้
หากต้องการข้อมูลเพิ่มเติมและข้อมูลเพิ่มเติมเกี่ยวกับวิธีที่ TeachableMachine ฝึกโมเดลที่คุณใช้ โปรดดู Codelab ในการโอนการเรียนรู้ หากกำลังมองหารุ่นอื่นๆ ที่ใช้งานร่วมกับ Coral ได้ เช่น การจดจำคำพูดและการคาดคะเนท่าทาง โปรดดูที่ coral.ai/models นอกจากนี้คุณยังค้นหาเวอร์ชัน CPU ของรุ่นดังกล่าวและรุ่นอื่นๆ ได้ใน TensorFlow Hub
แชร์สิ่งที่คุณทำกับเรา
คุณสามารถต่อยอดสิ่งที่คุณทำในวันนี้ไปยังกรณีการใช้งานที่สร้างสรรค์อื่นๆ ได้ง่ายๆ เช่นกัน และเราขอแนะนำให้คุณคิดนอกกรอบและแฮ็กไปเรื่อยๆ
อย่าลืมแท็กเราบนโซเชียลมีเดียโดยใช้แฮชแท็ก #MadeWithTFJS เพื่อลุ้นโอกาสให้โปรเจ็กต์ของคุณปรากฏบนบล็อก TensorFlow หรือแม้แต่กิจกรรมในอนาคต เราอยากเห็นสิ่งที่คุณสร้าง