1. บทนำ
อัปเดตล่าสุด: 2022-04-11
ใน Codelab นี้ คุณจะได้เรียนรู้วิธีฝึกโมเดลการจัดประเภทรูปภาพโดยใช้ Teachable Machine และดำเนินการด้วยการเร่งฮาร์ดแวร์ของ Coral โดยใช้ TensorFlow.js ซึ่งเป็นไลบรารีแมชชีนเลิร์นนิงที่มีประสิทธิภาพและยืดหยุ่นสำหรับ JavaScript คุณสร้างแอป Electron ที่แสดงรูปภาพจากเว็บแคมและจัดประเภทรูปภาพโดยใช้ Coral Edge TPU เวอร์ชันที่ใช้งานได้เต็มรูปแบบของ Codelab นี้มีอยู่ในที่เก็บ sig-tfjs GitHub
ฉันต้องใช้อุปกรณ์ Coral ไหม
ไม่ได้ คุณลองทำ Codelab นี้โดยไม่ต้องใช้อุปกรณ์ Coral และยังคงได้รับประสิทธิภาพที่ดีบนเครื่องเดสก์ท็อปได้โดยใช้ตัวเร่ง WebNN แทน
สิ่งที่คุณจะสร้าง
ใน Codelab นี้ คุณจะได้สร้างแอป Electron ที่จัดประเภทรูปภาพ แอปของคุณ
- จัดประเภทรูปภาพจากเว็บแคมเป็นหมวดหมู่ที่กำหนดไว้ในโมเดลที่คุณฝึก
- ใช้ตัวเร่งความเร็ว Coral เพื่อเพิ่มประสิทธิภาพ หากมี
- ใช้ 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 ได้ง่าย
ขอแนะนำอย่างยิ่ง: ใช้ 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 / Raspberry Pi
ใน Linux ไลบรารีนี้พร้อมให้บริการจาก PPA ของ Google ในรูปแบบแพ็กเกจ Debian, libedgetpu1-std สำหรับสถาปัตยกรรม x86-64 และ Armv8 (64 บิต) หากโปรเซสเซอร์ใช้สถาปัตยกรรมอื่น คุณจะต้องคอมไพล์จากแหล่งที่มา
เรียกใช้คำสั่งนี้เพื่อเพิ่ม PPA ของ Coral ของ Google และติดตั้งไลบรารี Edge TPU Runtime
# 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 Runtime แล้ว ให้รีสตาร์ทอุปกรณ์เพื่อเปิดใช้งานกฎ Udev ใหม่ของ Coral ที่โปรแกรมติดตั้งเพิ่ม
ตรวจสอบว่าตรวจพบอุปกรณ์ Coral
หากต้องการยืนยันว่าระบบตรวจพบอุปกรณ์ Coral และอุปกรณ์ทำงานได้ ให้เรียกใช้การทดสอบการผสานรวมสำหรับแพ็กเกจ coral-tflite-delegate แพ็กเกจนี้อยู่ในไดเรกทอรีรากของที่เก็บ หากต้องการเรียกใช้การทดสอบการผสานรวม ให้เสียบตัวเร่งความเร็ว Coral แล้วเรียกใช้คำสั่งเหล่านี้ในไดเรกทอรีของแพ็กเกจ
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 ของ Coral ได้ด้วย หากเวอร์ชัน Python ใช้งานได้ แต่การทดสอบเหล่านี้ยังคงล้มเหลว โปรดแจ้งให้เราทราบโดยยื่นรายงานข้อบกพร่อง
เรียกใช้โค้ดเริ่มต้น
ตอนนี้คุณก็พร้อมที่จะเรียกใช้โค้ดเริ่มต้นแล้ว ทำตามขั้นตอนต่อไปนี้เพื่อเริ่มต้นใช้งาน
- ย้ายไปที่ไดเรกทอรี
starter_codeภายใต้ไดเรกทอรีtfjs-tflite-node-codelab - เรียกใช้
npm installเพื่อติดตั้งการอ้างอิง - เรียกใช้
npm startเพื่อเปิดโปรเจ็กต์ แอปที่แสดงฟีดวิดีโอจากเว็บแคมของคอมพิวเตอร์ควรเปิดขึ้น
จุดเริ่มต้นของเราคืออะไร
จุดเริ่มต้นของเราคือแอปกล้อง Electron พื้นฐานที่ออกแบบมาสำหรับ Codelab นี้ เราได้ลดความซับซ้อนของโค้ดเพื่อแสดงแนวคิดใน Codelab และโค้ดนี้มีการจัดการข้อผิดพลาดเพียงเล็กน้อย หากเลือกที่จะนำโค้ดใดๆ ไปใช้ซ้ำในแอปเวอร์ชันที่ใช้งานจริง โปรดตรวจสอบว่าคุณได้จัดการข้อผิดพลาดและทดสอบโค้ดทั้งหมดอย่างละเอียดแล้ว
สำรวจโค้ดเริ่มต้น
โค้ดเริ่มต้นนี้มีไฟล์จำนวนมาก แต่ไฟล์เดียวที่คุณต้องแก้ไขคือ renderer.js ซึ่งจะควบคุมสิ่งที่แสดงในหน้าเว็บ รวมถึงฟีดวิดีโอและองค์ประกอบ HTML และเป็นที่ที่คุณเพิ่มโมเดลแมชชีนเลิร์นนิงลงในแอป ในบรรดาไฟล์อื่นๆ จะมีไฟล์ index.html แต่ไฟล์นี้จะโหลดไฟล์ renderer.js เท่านั้น นอกจากนี้ยังมีไฟล์ main.js ซึ่งเป็นจุดแรกเข้าสำหรับ Electron ซึ่งจะควบคุมวงจรของแอป รวมถึงสิ่งที่ต้องแสดงเมื่อเปิดแอปและสิ่งที่ต้องทำเมื่อปิดแอป แต่คุณไม่จำเป็นต้องทำการเปลี่ยนแปลงใดๆ
เปิดดีบักเกอร์
คุณอาจต้องแก้ไขข้อบกพร่องของแอปขณะทำตาม 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
ติดตั้งการอ้างอิง
การโหลดโมเดลและการประมวลผลอินพุตล่วงหน้าต้องมีการอ้างอิงบางอย่างจาก 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 หรือ URL ของ TFHub ก็ได้ หากต้องการโหลดโมเดลและน้ำหนักของโมเดล ให้เพิ่มสิ่งนี้ลงในฟังก์ชัน 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 และเฟรมที่แสดงจะไม่มีให้ไฟล์ JavaScript renderer.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] ดังนั้นคุณจึงต้องเพิ่มมิติข้อมูลพิเศษที่ด้านหน้าของเทนเซอร์ด้วย tf.expandDims นอกจากนี้ โมเดล CPU คาดหวังอินพุต Float32 ระหว่าง -1 ถึง 1 แต่เว็บแคมจะบันทึกค่าจาก 0 ถึง 255 คุณสามารถหารเทนเซอร์อินพุตด้วย 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));
คุณควรทิ้งเทนเซอร์หลังจากใช้งานแล้ว tf.tidy() จะดำเนินการนี้โดยอัตโนมัติสำหรับโค้ดที่มีอยู่ใน Callback แต่ไม่รองรับฟังก์ชันแบบไม่พร้อมกัน คุณจะต้องทิ้งอิมเมจเทนเซอร์ที่สร้างไว้ก่อนหน้านี้ด้วยตนเองโดยเรียกใช้เมธอด dispose()
CODELAB ส่วนที่ 1: ทิ้งเฟรมเว็บแคมที่นี่
image.dispose();
เรียกใช้โมเดลและแสดงผลลัพธ์
หากต้องการเรียกใช้โมเดลในอินพุตที่ประมวลผลล่วงหน้า ให้เรียกใช้ model.predict() ในเทนเซอร์ที่ทำให้เป็นมาตรฐาน ซึ่งจะแสดงผลเทนเซอร์แบบ 1 มิติที่มีความน่าจะเป็นที่คาดการณ์ของแต่ละป้ายกำกับ คูณความน่าจะเป็นนี้ด้วย 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 จึงต้องมีการวัดปริมาณโมเดล ซึ่งจะส่งผลต่อเทนเซอร์อินพุตที่ส่งไปยังโมเดลและเทนเซอร์เอาต์พุตที่โมเดลส่งคืน ความแตกต่างอีกอย่างคือต้องคอมไพล์โมเดลโดยใช้คอมไพเลอร์ Edge TPU เพื่อเรียกใช้ใน Coral TPU TeachableMachine ได้ดำเนินการขั้นตอนนี้แล้ว แต่คุณสามารถดูวิธีดำเนินการสำหรับโมเดลอื่นๆ ได้โดยไปที่เอกสารประกอบของ Coral
เพิ่มไฟล์โมเดล Coral ลงในแอป
แตกไฟล์โมเดล converted_edgetpu.zip ที่ดาวน์โหลดเมื่อฝึกตัวแยกประเภท โดยในไฟล์เก็บถาวรจะมีไฟล์ 2 ไฟล์ model_edgetpu.tflite คือโมเดล TFLite ที่บันทึกไว้ ซึ่งรวมถึงกราฟโมเดลและน้ำหนัก labels.txt มีป้ายกำกับที่มนุษย์อ่านได้สำหรับคลาสที่โมเดลคาดการณ์ วางไฟล์โมเดลในไดเรกทอรี coral_model
ติดตั้งการอ้างอิง
การเรียกใช้โมเดล Coral ต้องใช้ไลบรารีรันไทม์ของ Edge TPU โปรดตรวจสอบว่าคุณได้ติดตั้งโดยทำตามวิธีการตั้งค่าก่อนดำเนินการต่อ
ระบบจะเข้าถึงอุปกรณ์ Coral ในฐานะ TFLite delegates หากต้องการเข้าถึงจาก JavaScript ให้ติดตั้งแพ็กเกจ coral-tflite-delegate โดยทำดังนี้
npm install --save coral-tflite-delegate
จากนั้นนำเข้าผู้รับมอบสิทธิ์โดยเพิ่มบรรทัดนี้ที่ด้านบนของไฟล์ renderer.js
CODELAB part 2: Import the delegate here.
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 ที่เพิ่มในส่วนที่แล้ว การเรียกใช้ทั้ง 2 อย่างพร้อมกันจะทำให้ดูความแตกต่างของประสิทธิภาพได้ยาก ดังนั้นปุ่มสลับจึงจะสลับระหว่างการดำเนินการของ 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 โปรดทราบว่าเราไม่ได้ใส่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 uint8 ในช่วง 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
คุณสามารถสลับระหว่างการอนุมานของ Coral กับ CPU ได้โดยกดปุ่ม คุณอาจสังเกตเห็นว่าการจัดอันดับความน่าเชื่อถือของโมเดล Coral มีความแม่นยำน้อยกว่าโมเดล CPU และมักจะลงท้ายด้วยทศนิยมคู่ ความแม่นยำที่ลดลงนี้เป็นผลมาจากการแลกเปลี่ยนกับการเรียกใช้โมเดลที่แปลงเป็นจำนวนเต็มบน Coral โดยปกติแล้วในทางปฏิบัติจะไม่เป็นปัญหา แต่ก็เป็นสิ่งที่ควรคำนึงถึง
หมายเหตุเกี่ยวกับประสิทธิภาพ
อัตราเฟรมที่คุณเห็นรวมการประมวลผลเบื้องต้นและการประมวลผลภายหลัง จึงไม่ได้แสดงถึงความสามารถของฮาร์ดแวร์ Coral คุณจะเห็นภาพประสิทธิภาพได้ดียิ่งขึ้นโดยคลิกมิเตอร์ FPS จนกว่าจะแสดงเวลาในการตอบสนอง (เป็นมิลลิวินาที) ซึ่งจะวัดเฉพาะการเรียกไปยัง model.predict อย่างไรก็ตาม เวลาดังกล่าวจะยังรวมเวลาที่ใช้ในการย้าย Tensor ไปยังการเชื่อมโยง C แบบเนทีฟของ TFLite แล้วจึงย้ายไปยังอุปกรณ์ Coral ด้วย จึงไม่ใช่การวัดที่สมบูรณ์แบบ ดูเกณฑ์เปรียบเทียบประสิทธิภาพที่แม่นยำยิ่งขึ้นซึ่งเขียนด้วย C++ ได้ที่หน้าเกณฑ์เปรียบเทียบ EdgeTPU
นอกจากนี้ โปรดทราบว่าวิดีโอนี้บันทึกบนแล็ปท็อปแทนที่จะเป็น Raspberry Pi คุณจึงอาจเห็น FPS ที่แตกต่างกัน
การเร่งการประมวลผลล่วงหน้าของ Coral
ในบางกรณี คุณสามารถเร่งการประมวลผลล่วงหน้าได้โดยการเปลี่ยนแบ็กเอนด์ของ TFJS แบ็กเอนด์เริ่มต้นคือ WebGL ซึ่งเหมาะสำหรับการดำเนินการขนาดใหญ่ที่สามารถขนานกันได้ แต่แอปนี้ไม่ได้ดำเนินการดังกล่าวมากนักในระยะการประมวลผลเบื้องต้น (การดำเนินการเดียวที่ใช้คือ expandDims ซึ่งไม่ขนานกัน) คุณสามารถเปลี่ยนไปใช้แบ็กเอนด์ CPU เพื่อหลีกเลี่ยงเวลาในการตอบสนองเพิ่มเติมในการย้ายเทนเซอร์ไปยังและจาก GPU ได้โดยเพิ่มบรรทัดนี้หลังการนำเข้าที่ด้านบนของไฟล์
tf.setBackend(‘cpu');
การเปลี่ยนแปลงนี้ยังส่งผลต่อการประมวลผลล่วงหน้าสำหรับโมเดล TFLite CPU ซึ่งเป็นแบบขนานด้วย ดังนั้นโมเดลจึงทำงานช้าลงมากเมื่อมีการเปลี่ยนแปลงนี้
6. เร่งความเร็วโมเดล CPU ด้วย WebNN
หากไม่มีตัวเร่ง Coral หรือเพียงต้องการลองวิธีอื่นในการเพิ่มความเร็วโมเดล คุณสามารถใช้ WebNN TFLite delegate ได้ Delegate นี้ใช้ฮาร์ดแวร์แมชชีนเลิร์นนิงที่สร้างขึ้นในโปรเซสเซอร์ Intel เพื่อเร่งการอนุมานโมเดลด้วย OpenVINO Toolkit ด้วยเหตุนี้ จึงมีข้อกำหนดเพิ่มเติมที่ไม่ได้กล่าวถึงในส่วนการตั้งค่าของ Codelab นี้ และคุณจะต้องติดตั้งชุดเครื่องมือ OpenVINO โปรดตรวจสอบการตั้งค่ากับ Target System Platforms ที่รองรับก่อนดำเนินการต่อ แต่โปรดทราบว่าตัวแทน WebNN ยังไม่รองรับ macOS
ติดตั้งชุดเครื่องมือ OpenVINO
ชุดเครื่องมือ OpenVINO ใช้ฮาร์ดแวร์แมชชีนเลิร์นนิงที่สร้างขึ้นในโปรเซสเซอร์ Intel เพื่อเร่งความเร็วโมเดล คุณสามารถดาวน์โหลดเวอร์ชันที่คอมไพล์ไว้ล่วงหน้าจาก Intel หรือสร้างจากแหล่งที่มา การติดตั้ง OpenVINO ทำได้หลายวิธี แต่เพื่อวัตถุประสงค์ของ Codelab นี้ เราขอแนะนำให้คุณใช้สคริปต์โปรแกรมติดตั้งสำหรับ Windows หรือ Linux โปรดติดตั้งรันไทม์เวอร์ชัน 2021.4.2 LTS เนื่องจากเวอร์ชันอื่นๆ อาจใช้ร่วมกันไม่ได้ หลังจากเรียกใช้โปรแกรมติดตั้งแล้ว ให้ตรวจสอบว่าคุณได้กำหนดค่าตัวแปรสภาพแวดล้อมของ Shell ตามที่อธิบายไว้ในวิธีการติดตั้งสำหรับ Linux หรือ Windows ( โซลูชันถาวร) หรือโดยการเรียกใช้คำสั่ง setupvars.sh (Linux) หรือ setupvars.bat (Windows) ที่อยู่ในไดเรกทอรี webnn-tflite-delegate
ยืนยันว่า WebNN Delegate ทำงานอยู่
หากต้องการยืนยันว่าตัวแทน 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 ให้ทำดังนี้
setupvars.bat
คำสั่งไม่รองรับ Git Bash ดังนั้นโปรดตรวจสอบว่าคุณดำเนินการและคำสั่งอื่นๆ จาก Codelab นี้จาก Command Prompt ของ Windows
ติดตั้งโปรแกรมมอบสิทธิ์ WebNN
เมื่อติดตั้ง OpenVINO แล้ว คุณก็พร้อมที่จะเร่งความเร็วโมเดล CPU ด้วย WebNN แล้ว ส่วนนี้ของ Codelab จะสร้างขึ้นจากโค้ดที่คุณเขียนในส่วน "เรียกใช้โมเดล CPU ในแอป" คุณสามารถใช้โค้ดที่เขียนในขั้นตอนนี้ได้ แต่หากทำส่วน Coral เสร็จแล้ว ให้ใช้เช็คพอยต์ cpu_inference_working แทนเพื่อให้เริ่มต้นด้วยสถานะที่สะอาด
ส่วน Node.js ของตัวแทน WebNN จะเผยแพร่ใน npmjs หากต้องการติดตั้ง ให้เรียกใช้คำสั่งต่อไปนี้
npm install --save webnn-tflite-delegate
จากนั้นนำเข้าผู้รับมอบสิทธิ์โดยเพิ่มบรรทัดนี้ที่ด้านบนของไฟล์ renderer.js
CODELAB part 2: Import the delegate here.
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})],
});
คุณไม่จำเป็นต้องโหลดป้ายกำกับอีกครั้งเนื่องจากเป็นโมเดลเดียวกัน
เพิ่มปุ่มเพื่อสลับระหว่าง TfLite CPU กับ 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 ดังนั้นให้เพิ่มเมนูแบบเลื่อนลงเพื่อสลับระหว่าง 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 ที่เกี่ยวข้องในตัวเลือก Delegate
เพิ่มโค้ดต่อไปนี้หลังโค้ดที่เพิ่มเมนูแบบเลื่อนลง
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 พร้อมใช้งานแล้ว แต่ปุ่มสลับระหว่าง WebNN กับ TfLite CPU ยังไม่สลับโมเดลจริงๆ หากต้องการเปลี่ยนโมเดล คุณต้องเปลี่ยนชื่อตัวแปร model จากตอนที่คุณโหลดโมเดล TfLite CPU ในส่วนแรกของ 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;
}
ตอนนี้เมื่อคุณเรียกใช้แอป ปุ่มจะสลับระหว่าง TfLite CPU กับ WebNN 
นอกจากนี้ คุณยังสลับระหว่างการอนุมาน CPU และ GPU ของ WebNN ได้หากมี GPU ของ Intel แบบออนบอร์ด
หมายเหตุเกี่ยวกับประสิทธิภาพ
อัตราเฟรมที่คุณเห็นรวมการประมวลผลเบื้องต้นและการประมวลผลภายหลัง ดังนั้นจึงไม่ได้แสดงถึงความสามารถของ WebNN คุณจะเห็นภาพประสิทธิภาพได้ดียิ่งขึ้นโดยคลิกมิเตอร์ FPS จนกว่าจะแสดงเวลาในการตอบสนอง (เป็นมิลลิวินาที) ซึ่งจะวัดเฉพาะการเรียกไปยัง model.predict อย่างไรก็ตาม เวลาดังกล่าวจะยังรวมเวลาที่ใช้ในการย้าย Tensor ไปยังการเชื่อมโยง C แบบเนทีฟของ TFLite ด้วย จึงไม่ใช่การวัดที่สมบูรณ์แบบ
7. ขอแสดงความยินดี
ยินดีด้วย คุณเพิ่งทำโปรเจ็กต์ Coral / WebNN เป็นครั้งแรกโดยใช้ tfjs-tflite-node ใน Electron
ลองใช้ฟีเจอร์นี้และทดสอบกับรูปภาพต่างๆ นอกจากนี้ คุณยังฝึกโมเดลใหม่ใน Teachable Machine เพื่อแยกประเภทสิ่งอื่นๆ ที่แตกต่างออกไปโดยสิ้นเชิงได้ด้วย
สรุป
ใน Codelab นี้ คุณได้เรียนรู้สิ่งต่อไปนี้
- วิธีติดตั้งและตั้งค่าแพ็กเกจ npm tfjs-tflite-node เพื่อเรียกใช้โมเดล TFLite ใน Node.js
- วิธีติดตั้งไลบรารีรันไทม์ของ Edge TPU เพื่อเรียกใช้โมเดลในอุปกรณ์ Coral
- วิธีเร่งการอนุมานโมเดลโดยใช้ Coral Edge TPU
- วิธีเร่งการอนุมานโมเดลด้วย WebNN
สิ่งต่อไปที่ควรทำ
ตอนนี้คุณมีฐานที่ใช้งานได้เพื่อเริ่มต้นแล้ว คุณจะคิดไอเดียสร้างสรรค์อะไรได้บ้างเพื่อขยายโปรแกรมเรียกใช้โมเดลแมชชีนเลิร์นนิงนี้ไปยัง Use Case จริงที่คุณอาจกำลังดำเนินการอยู่ คุณอาจปฏิวัติอุตสาหกรรมที่คุณทำงานด้วยการอนุมานที่รวดเร็วและราคาไม่แพง หรืออาจดัดแปลงเครื่องปิ้งขนมปังให้หยุดปิ้งเมื่อขนมปังดูสุกกำลังดี ทุกอย่างเป็นไปได้
หากต้องการดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีที่ Teachable Machine ฝึกโมเดลที่คุณใช้ โปรดดู Codelab เกี่ยวกับการถ่ายโอนการเรียนรู้ หากกำลังมองหารุ่นอื่นๆ ที่ใช้ได้กับ Coral เช่น การจดจำเสียงและการประมาณท่าทาง โปรดดูที่ coral.ai/models นอกจากนี้ คุณยังดูโมเดลเหล่านั้นและโมเดลอื่นๆ อีกมากมายในเวอร์ชัน CPU ได้ที่ TensorFlow Hub
แชร์ผลงานของคุณกับเรา
คุณสามารถขยายผลงานที่สร้างในวันนี้ไปใช้ในกรณีการใช้งานอื่นๆ ที่สร้างสรรค์ได้ด้วย และเราขอแนะนำให้คุณคิดนอกกรอบและสร้างสรรค์ต่อไป
อย่าลืมแท็กเราบนโซเชียลมีเดียโดยใช้แฮชแท็ก #MadeWithTFJS เพื่อให้โปรเจ็กต์ของคุณมีโอกาสได้แสดงในบล็อก TensorFlow หรือแม้แต่กิจกรรมในอนาคต เราอยากเห็นผลงานของคุณ