1. บทนำ
สิ่งที่คุณจะสร้าง
ใน Codelab นี้ เราจะเรียนรู้วิธีใช้ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์เพื่อเรียกใช้โมเดลการเรียนรู้เชิงลึกในSparkFun Edge Development Board เราจะทำงานร่วมกับโมเดลการตรวจจับคำพูดที่ติดตั้งมาในตัวของกระดานซึ่งใช้โครงข่ายระบบประสาทเทียมแบบ Convolutional เพื่อตรวจจับคำว่า "ใช่" และ "ไม่" กำลังพูดผ่านไมโครโฟน 2 ตัวของกระดาน
แมชชีนเลิร์นนิงในไมโครคอนโทรลเลอร์
การเรียนรู้ของเครื่องสามารถใช้เพื่อสร้างเครื่องมือ อัจฉริยะที่ทำให้ผู้ใช้ ชีวิตง่ายขึ้น เช่น Google Assistant แต่บ่อยครั้งที่ประสบการณ์เหล่านี้ต้องการการประมวลผลหรือทรัพยากรจำนวนมาก ซึ่งอาจรวมไปถึงเซิร์ฟเวอร์ระบบคลาวด์ที่มีประสิทธิภาพหรือเดสก์ท็อป แต่ปัจจุบันคุณสามารถเรียกใช้การอนุมานของแมชชีนเลิร์นนิงบนฮาร์ดแวร์ขนาดเล็กแต่ใช้พลังงานต่ำ เช่น ไมโครคอนโทรลเลอร์
ไมโครคอนโทรลเลอร์ใช้กันทั่วไป มีราคาถูก ใช้พลังงานน้อยมาก และเสถียรมาก โดยเป็นส่วนหนึ่งของอุปกรณ์ในครัวเรือนทุกประเภท ได้แก่ เครื่องใช้ รถยนต์ และของเล่น ในความเป็นจริงมีการผลิตอุปกรณ์ที่ใช้ไมโครคอนโทรลเลอร์ประมาณ 3 หมื่นล้านเครื่องต่อปี
การนำแมชชีนเลิร์นนิงเข้ามาสู่ไมโครคอนโทรลเลอร์ขนาดจิ๋ว ช่วยให้เราเพิ่มความชาญฉลาดของอุปกรณ์หลายพันล้านเครื่องที่เราใช้ในชีวิตได้โดยไม่ต้องอาศัยฮาร์ดแวร์ราคาแพงหรือการเชื่อมต่ออินเทอร์เน็ตที่เสถียร ลองจินตนาการถึงเครื่องใช้ไฟฟ้าอัจฉริยะที่สามารถปรับให้เข้ากับกิจวัตรประจำวันของคุณได้ เซ็นเซอร์อัจฉริยะในอุตสาหกรรมที่เข้าใจความแตกต่างระหว่างปัญหาและการทำงานตามปกติ และยังมีของเล่นวิเศษที่ช่วยให้เด็กๆ เรียนรู้ได้ด้วยวิธีที่สนุกและน่าประทับใจ
TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ (ซอฟต์แวร์)
TensorFlow คือเฟรมเวิร์กแมชชีนเลิร์นนิงโอเพนซอร์สของ Google สำหรับการฝึกและการเรียกใช้โมเดล TensorFlow Lite เป็นเฟรมเวิร์กซอฟต์แวร์ซึ่งเป็น TensorFlow เวอร์ชันที่ได้รับการเพิ่มประสิทธิภาพซึ่งกำหนดเป้าหมายเพื่อเรียกใช้โมเดล tensorflow ในอุปกรณ์ขนาดเล็กที่ใช้พลังงานต่ำ เช่น โทรศัพท์มือถือ
TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์คือเฟรมเวิร์กซอฟต์แวร์ซึ่งเป็น TensorFlow เวอร์ชันที่เพิ่มประสิทธิภาพซึ่งกำหนดเป้าหมายเพื่อเรียกใช้โมเดล tensorflow บนฮาร์ดแวร์ขนาดจิ๋วที่ใช้พลังงานต่ำ เช่น ไมโครคอนโทรลเลอร์ และเป็นไปตามข้อจำกัดที่จำเป็นในสภาพแวดล้อมแบบฝังเหล่านี้ กล่าวคือมีไบนารีขนาดเล็ก ไม่จำเป็นต้องมีการรองรับระบบปฏิบัติการ ไลบรารี C หรือ C++ มาตรฐานใดๆ หรือการจัดสรรหน่วยความจำแบบไดนามิก ฯลฯ
SparkFun Edge (ฮาร์ดแวร์)
SparkFun Edge เป็นแพลตฟอร์มจากไมโครคอนโทรลเลอร์ ซึ่งก็คือคอมพิวเตอร์ขนาดเล็กบนแผงวงจรเดียว โดยมีโปรเซสเซอร์ หน่วยความจำ และฮาร์ดแวร์ I/O ที่ช่วยให้อุปกรณ์รับส่งสัญญาณดิจิทัลไปยังอุปกรณ์อื่นๆ ได้ มาพร้อมไฟ LED 4 ดวงในสีโปรดจาก Google
ไมโครคอนโทรลเลอร์ต่างจากคอมพิวเตอร์ตรงที่ไม่ได้ใช้ระบบปฏิบัติการ แต่โปรแกรมที่คุณเขียนจะทำงานบนฮาร์ดแวร์โดยตรง คุณเขียนโค้ดบนคอมพิวเตอร์และดาวน์โหลดลงในไมโครคอนโทรลเลอร์ผ่านอุปกรณ์ที่เรียกว่าโปรแกรมเมอร์
ไมโครคอนโทรลเลอร์ไม่ใช่คอมพิวเตอร์ที่มีประสิทธิภาพ โดยมีโปรเซสเซอร์ขนาดเล็กและมีหน่วยความจำไม่มากนัก แต่เนื่องจากไมโครคอนโทรลเลอร์ออกแบบมาให้เรียบง่ายที่สุด ทำให้ไมโครคอนโทรลเลอร์ใช้พลังงานน้อยมาก SparkFun Edge จะทำงานได้หลายสัปดาห์โดยใช้แบตเตอรี่เซลล์แบบเหรียญเดียว ทั้งนี้ขึ้นอยู่กับว่าโปรแกรมของคุณทำอะไร
สิ่งที่คุณจะได้เรียนรู้
- คอมไพล์โปรแกรมตัวอย่างสำหรับ SparkFun Edge ในคอมพิวเตอร์
- ทำให้โปรแกรมใช้งานได้ในอุปกรณ์ของคุณ
- ทำการเปลี่ยนแปลงโปรแกรมแล้วทำให้ใช้งานได้อีกครั้ง
สิ่งที่คุณต้องมี
คุณจะต้องมีฮาร์ดแวร์ดังต่อไปนี้
- คอมพิวเตอร์ Linux หรือ MacOS
- กระดาน SparkFun Edge
- โปรแกรมเมอร์ SparkFun USB-C Serial Basic
- สาย USB-C กับ USB-A (หากคุณใช้คอมพิวเตอร์ USB-C ให้ใช้สาย USB-C กับ USB-C แทน)
- (ไม่บังคับ) แบตเตอรี่ลิเธียมเซลล์แบบเหรียญขนาด 3V 20 มม. (CR2032) สำหรับเรียกใช้การอนุมานโดยไม่ใช้โปรแกรมเมอร์และสายเคเบิล
คุณจะต้องมีซอฟต์แวร์ต่อไปนี้
- Git (ตรวจสอบว่าติดตั้งแล้วหรือไม่โดยเรียกใช้
gitในบรรทัดคำสั่ง) - Python 3 (ตรวจสอบว่าติดตั้งแล้วหรือไม่โดยเรียกใช้
python3หรือpython --versionในบรรทัดคำสั่ง) - Pip สำหรับ Python 3 ( คำตอบ StackOverflow ที่เป็นประโยชน์)
- สร้างเวอร์ชัน 4.2.1 ขึ้นไป (ตรวจสอบว่าติดตั้งแล้วหรือไม่โดยเรียกใช้
make --versionในบรรทัดคำสั่ง) - ไดรเวอร์ SparkFun Serial Basic
2. ตั้งค่าฮาร์ดแวร์
ไมโครคอนโทรลเลอร์ SparkFun Edge มาพร้อมกับไบนารีที่ติดตั้งไว้ล่วงหน้าซึ่งเรียกใช้โมเดลเสียงพูดได้ ก่อนที่เราจะเขียนทับสิ่งนี้ด้วยเวอร์ชันของเราเอง ให้เรียกใช้โมเดลนี้ก่อน
เพิ่มประสิทธิภาพกระดานของคุณโดย:
- ใส่แบตเตอรี่เซลล์แบบเหรียญเข้ากับขั้วต่อแบตเตอรี่ที่ด้านหลังของแผง (โดยหงายด้าน "+" ของแบตเตอรี่ขึ้น หากบอร์ดของคุณใส่แบตเตอรี่ไว้แล้ว ให้ดึงแท็บพลาสติกออก แล้วดันแบตเตอรี่เข้าไปเพื่อให้เสียบเข้าไปจนสุด)
- หากไม่มีแบตเตอรี่ คุณสามารถใช้อุปกรณ์โปรแกรมเมอร์ SparkFun USB-C Serial Basic เพื่อจ่ายไฟให้กระดานได้ หากต้องการติดอุปกรณ์นี้กับกระดาน ให้ทำตามขั้นตอนต่อไปนี้
- มองหาส่วนหัว 6 หมุดที่ด้านข้างของ SparkFun Edge
- เสียบ SparkFun USB-C Serial Basic กับพินเหล่านี้โดยให้พินที่มีป้ายกำกับว่า "BLK" และ "GRN" บนอุปกรณ์แต่ละเครื่องจัดเรียงอย่างถูกต้อง
- เชื่อมต่อสาย USB-C ระหว่าง SparkFun USB-C Serial Basic กับคอมพิวเตอร์
เมื่อคุณเปิดเครื่องบอร์ดโดยใส่แบตเตอรี่หรือเชื่อมต่อโปรแกรมเมอร์แบบ USB แล้ว กระดานจะปลุกระบบและเริ่มฟังด้วยไมโครโฟน แสงสีฟ้าควรเริ่มกะพริบ
โมเดลแมชชีนเลิร์นนิงบนกระดานได้รับการฝึกให้รู้จักคำว่า "ใช่" "ไม่" และเพื่อตรวจจับการมีอยู่และไม่มีเสียงพูด สื่อสารผลลัพธ์ด้วยไฟ LED ที่มีสีสว่าง ตารางต่อไปนี้แสดงความหมายของไฟ LED แต่ละสี
ผลการตรวจหา | สี LED |
"ใช่" | เหลือง |
"ไม่" | แดง |
คำพูดที่ไม่รู้จัก | เขียว |
ไม่พบคำพูด | ไฟ LED ไม่สว่าง |
ลองใช้เลย
ยกกระดานขึ้นปากแล้วพูดว่า "ใช่" 2-3 ครั้ง คุณจะเห็นแฟลช LED สีเหลือง หากไม่มีอะไรเกิดขึ้นเมื่อคุณพูดว่า "ใช่" ให้ลองดำเนินการต่อไปนี้
- ถือกระดานไว้ประมาณ 10 นิ้ว จากปากของเธอ
- หลีกเลี่ยงเสียงรบกวนรอบข้างมากเกินไป
- พูดตามเดิมว่า "ใช่" ติดต่อกันเร็วๆ หลายครั้ง (ลองพูดว่า "ใช่ ใช่ ใช่")
3. ตั้งค่าซอฟต์แวร์
เรากำลังจะดาวน์โหลด ติดตั้ง และเรียกใช้โมเดลเสียงพูดบนไมโครคอนโทรลเลอร์เอง สำหรับกรณีนี้ ก่อนอื่นเราจะต้องดาวน์โหลดซอร์สโค้ดสำหรับโปรแกรมนี้และทรัพยากร Dependency ที่จำเป็นเพื่อสร้าง โปรแกรมดังกล่าวเขียนด้วย C++ ซึ่งต้องคอมไพล์ไว้ในไบนารีก่อนที่จะดาวน์โหลดลงบนกระดาน ไบนารีคือไฟล์ที่มีโปรแกรมอยู่ในรูปแบบที่ฮาร์ดแวร์ SparkFun Edge เรียกใช้ได้โดยตรง
วิธีการต่อไปนี้เขียนขึ้นสำหรับ Linux หรือ MacOS
ดาวน์โหลดที่เก็บ TensorFlow
โค้ดจะอยู่ในที่เก็บ TensorFlow บน GitHub ในตำแหน่งต่อไปนี้
https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/micro
เปิดเทอร์มินัลในคอมพิวเตอร์ เปลี่ยนเป็นไดเรกทอรีที่คุณมักจะจัดเก็บโปรเจ็กต์การเขียนโค้ด ดาวน์โหลดที่เก็บ TensorFlow และป้อนไดเรกทอรีที่สร้างขึ้นดังที่แสดงด้านล่าง
cd ~ # change into your home (or any other) directory git clone --depth 1 https://github.com/tensorflow/tensorflow.git cd tensorflow
ดาวน์โหลดทรัพยากร Dependency ของ Python
เราจะใช้ Python 3 ในการเตรียมไบนารีของเราและแฟลชไปยังอุปกรณ์ สคริปต์ Python ขึ้นอยู่กับไลบรารีบางตัวที่มีอยู่ เรียกใช้คำสั่งต่อไปนี้เพื่อติดตั้งการอ้างอิงเหล่านี้
pip3 install pycrypto pyserial --user
4. สร้างและเตรียมไบนารี
เราจะสร้างไบนารีและเรียกใช้คำสั่งที่เตรียมความพร้อมสำหรับการดาวน์โหลดลงในอุปกรณ์
สร้างไบนารี
หากต้องการดาวน์โหลดทรัพยากร Dependency ที่จำเป็นทั้งหมดและสร้างไบนารี ให้เรียกใช้คำสั่งต่อไปนี้
make -f tensorflow/lite/micro/tools/make/Makefile TARGET=sparkfun_edge micro_speech_bin
หากบิลด์ทำงานสำเร็จ บรรทัดสุดท้ายของเอาต์พุตควรปรากฏดังนี้
arm-none-eabi-objcopy tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin -O binary
หากต้องการยืนยันว่าสร้างไบนารีเรียบร้อยแล้ว ให้เรียกใช้คำสั่งต่อไปนี้
test -f \ tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin && \ echo "Binary was successfully created" || echo "Binary is missing"
คุณควรเห็น Binary was successfully created พิมพ์ไปยังคอนโซล หากคุณเห็น Binary is missing แสดงว่าเกิดปัญหากับกระบวนการบิลด์ที่ต้องมีการแก้ไขข้อบกพร่อง
เตรียมไบนารี
ไบนารีนั้นต้องลงชื่อด้วยคีย์การเข้ารหัสเพื่อให้ใช้งานได้กับอุปกรณ์ ตอนนี้เราจะเรียกใช้คำสั่งบางอย่างที่จะลงนามไบนารีของเราเพื่อให้สามารถดาวน์โหลดไปยัง SparkFun Edge ได้
ป้อนคำสั่งต่อไปนี้เพื่อตั้งค่าคีย์การเข้ารหัสจำลองที่เราใช้ในการพัฒนาได้
cp tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/keys_info0.py tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/keys_info.py
จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไบนารีที่มีการลงนาม
python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/create_cust_image_blob.py \ --bin tensorflow/lite/micro/tools/make/gen/sparkfun_edge_cortex-m4/bin/micro_speech.bin \ --load-address 0xC000 \ --magic-num 0xCB \ -o main_nonsecure_ota \ --version 0x0
การดำเนินการนี้จะสร้างไฟล์ main_nonsecure_ota.bin ตอนนี้เราจะเรียกใช้คำสั่งอื่นเพื่อสร้างไฟล์เวอร์ชันสุดท้ายที่สามารถใช้แฟลชอุปกรณ์ของเราด้วยสคริปต์ Bootloader ที่เราจะใช้ในขั้นตอนถัดไป
python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/create_cust_wireupdate_blob.py \ --load-address 0x20000 \ --bin main_nonsecure_ota.bin \ -i 6 \ -o main_nonsecure_wire \ --options 0x1
ตอนนี้คุณควรมีไฟล์ชื่อ main_nonsecure_wire.bin ในไดเรกทอรีที่เรียกใช้คำสั่ง ซึ่งเป็นไฟล์ที่เราจะแฟลชไปยังอุปกรณ์
5. เตรียมพร้อมที่จะแฟลชไบนารี
การกะพริบคืออะไร
SparkFun Edge จัดเก็บโปรแกรมที่กำลังใช้งานอยู่ในหน่วยความจำแฟลช 512 กิโลไบต์ ถ้าเราต้องการให้กระดานเรียกใช้โปรแกรมใหม่ เราต้องส่งกระดานนั้นไปยังกระดาน ซึ่งจะจัดเก็บไว้ในหน่วยความจำแฟลช โดยเขียนทับโปรแกรมใดๆ ที่บันทึกไว้ก่อนหน้านี้
กระบวนการนี้เรียกว่า "การกะพริบ" โดยเราจะใช้เพื่อส่งโปรแกรมของเราไปยังกระดาน
ติดโปรแกรมเมอร์กับกระดาน
เราจะใช้โปรแกรมเมอร์อนุกรม SparkFun USB-C Serial Basic เพื่อดาวน์โหลดโปรแกรมใหม่ๆ มาไว้ในกระดาน อุปกรณ์นี้ช่วยให้คอมพิวเตอร์สื่อสารกับไมโครคอนโทรลเลอร์ผ่าน USB ได้
หากต้องการติดอุปกรณ์นี้กับกระดาน ให้ทำตามขั้นตอนต่อไปนี้
- มองหาส่วนหัว 6 หมุดที่ด้านข้างของ SparkFun Edge
- เสียบ SparkFun USB-C Serial Basic เข้ากับพินเหล่านี้โดยให้พินที่มีป้ายกำกับว่า "BLK" และ "GRN" บนอุปกรณ์แต่ละเครื่องจัดเรียงอย่างถูกต้อง
ต่อโปรแกรมเมอร์กับคอมพิวเตอร์
เราจะเชื่อมต่อกระดานกับคอมพิวเตอร์ผ่าน USB ในการเขียนโปรแกรมกระดาน เราจำเป็นต้องทราบชื่อที่คอมพิวเตอร์ของคุณมอบอุปกรณ์ให้ วิธีที่ดีที่สุดคือการแสดงอุปกรณ์คอมพิวเตอร์ทั้งหมดก่อนและหลังการต่อเชื่อม และดูว่าอุปกรณ์เครื่องใดเป็นเครื่องใหม่
ก่อนต่ออุปกรณ์ผ่าน USB ให้เรียกใช้คำสั่งต่อไปนี้
If you are using Linux: ls /dev/tty* If you are using MacOS: ls /dev/cu*
การดำเนินการนี้ควรแสดงรายการอุปกรณ์ที่แนบซึ่งมีลักษณะดังต่อไปนี้
/dev/cu.Bluetooth-Incoming-Port /dev/cu.MALS /dev/cu.SOC
จากนั้นให้เชื่อมต่อโปรแกรมเมอร์กับพอร์ต USB ของคอมพิวเตอร์ ป้อนคำสั่งต่อไปนี้อีกครั้ง
If you are using Linux: ls /dev/tty* If you are using MacOS: ls /dev/cu*
คุณควรเห็นรายการเพิ่มเติมในเอาต์พุตตามตัวอย่างด้านล่าง รายการใหม่อาจมีชื่ออื่น รายการใหม่นี้คือชื่อของอุปกรณ์
/dev/cu.Bluetooth-Incoming-Port /dev/cu.MALS /dev/cu.SOC /dev/cu.wchusbserial-1450
ก่อนอื่น เราจะสร้างตัวแปรสภาพแวดล้อมเพื่อระบุชื่ออุปกรณ์
export DEVICENAME=put your device name here
ถัดไป เราจะสร้างตัวแปรสภาพแวดล้อมเพื่อระบุอัตรารับส่งข้อมูล ซึ่งก็คือความเร็วในการส่งข้อมูลไปยังอุปกรณ์
export BAUD_RATE=921600
6. แฟลชไบนารี
เรียกใช้สคริปต์เพื่อแฟลชกระดานของคุณ
ถ้าต้องการแฟลชบอร์ด เราต้องใส่ลงใน "bootloader" พิเศษ ที่เตรียมพร้อมในการรับไบนารีใหม่ จากนั้นเราจะเรียกใช้สคริปต์เพื่อส่งไบนารีไปยังกระดาน
มาทำความคุ้นเคยกับปุ่มต่อไปนี้บนกระดานกัน
ทำตามขั้นตอนต่อไปนี้เพื่อรีเซ็ตและแฟลชกระดาน:
- ตรวจสอบว่าบอร์ดของคุณเชื่อมต่อกับโปรแกรมเมอร์ และการตั้งค่าทั้งหมดเชื่อมต่อกับคอมพิวเตอร์ผ่าน USB
- เริ่มกดปุ่ม
14บนกระดานค้างไว้ ถือสายรอจนถึงขั้นตอนที่ 6 - หากยังกดปุ่ม
14ค้างไว้ หากต้องการรีเซ็ตกระดานให้อยู่ในสถานะ Bootloader ให้คลิกปุ่มRSTเพื่อรีเซ็ตกระดาน - หากยังคงกดปุ่ม
14ค้างไว้ ให้วางคำสั่งต่อไปนี้ลงในเทอร์มินัลและกด Enter เพื่อเรียกใช้ (เพื่อความสะดวก คุณสามารถวางคำสั่งนี้ลงในเทอร์มินัลก่อนที่จะเริ่มกดปุ่มค้างไว้ แต่อย่ากด Enter จนกว่าจะถึงขั้นตอนนี้)
python3 tensorflow/lite/micro/tools/make/downloads/AmbiqSuite-Rel2.2.0/tools/apollo3_scripts/uart_wired_update.py -b ${BAUD_RATE} ${DEVICENAME} -r 1 -f main_nonsecure_wire.bin -i 6
- หากยังคงกดปุ่ม
14ค้างไว้ คุณควรเห็นสิ่งต่อไปนี้ปรากฏบนหน้าจอ
Connecting with Corvette over serial port /dev/cu.usbserial-1440... Sending Hello. Received response for Hello Received Status length = 0x58 version = 0x3 Max Storage = 0x4ffa0 Status = 0x2 State = 0x7 AMInfo = 0x1 0xff2da3ff 0x55fff 0x1 0x49f40003 0xffffffff [...lots more 0xffffffff...] Sending OTA Descriptor = 0xfe000 Sending Update Command. number of updates needed = 1 Sending block of size 0x158b0 from 0x0 to 0x158b0 Sending Data Packet of length 8180 Sending Data Packet of length 8180 [...lots more Sending Data Packet of length 8180...]
- หยุดกดปุ่มที่มีเครื่องหมาย
14บนกระดานค้างไว้หลังจากเห็นSending Data Packet of length 8180(แต่ถ้ากดค้างไว้ก็ไม่เป็นไร) โปรแกรมจะยังคงพิมพ์บรรทัดบนเครื่องอ่านต่อไป ซึ่งในที่สุดจะมีหน้าตาดังนี้
[...lots more Sending Data Packet of length 8180...] Sending Data Packet of length 8180 Sending Data Packet of length 6440 Sending Reset Command. Done.
หากคุณเห็น Done แสดงว่ากะพริบสำเร็จแล้ว หากเอาต์พุตของโปรแกรมสิ้นสุดลงโดยมีข้อผิดพลาด ให้ตรวจสอบว่ามีการพิมพ์ Sending Reset Command หรือไม่ หากใช่ การกะพริบอาจสำเร็จแม้จะเกิดข้อผิดพลาดก็ตาม
คุณอาจพบ NoResponse Error ในเครื่อง Linux ปัญหานี้เกิดจากการมีการติดตั้งไดรเวอร์อนุกรม ch34x คู่กับไดรเวอร์ซีเรียลที่มีอยู่ ซึ่งจะแก้ไขได้ดังนี้
ขั้นตอนที่ 1: ติดตั้งไลบรารี ch34x เวอร์ชันที่ถูกต้องอีกครั้ง ตรวจสอบว่าไม่ได้เสียบปลั๊กอุปกรณ์ออกจากคอมพิวเตอร์ในระหว่างการติดตั้ง
git clone https://github.com/juliagoda/CH341SER.git cd CH341SER/ make sudo insmod ch34x.ko sudo rmmod ch341
ขั้นตอนที่ 2: เสียบ USB ของบอร์ดแล้วเรียกใช้
dmesg | grep "ch34x"
คุณควรเห็นข้อความดังนี้
[ 1299.444724] ch34x_attach+0x1af/0x280 [ch34x] [ 1299.445386] usb 2-13.1: ch34x converter now attached to ttyUSB0
หากไดรเวอร์ที่ใช้ไม่ใช่ "ch34x" (เช่น ch341) ให้ลองปิดใช้ไดรเวอร์ตัวอื่นๆ โดยเรียกใช้
rmmod <non-ch34x driver name>
ถอดปลั๊กอุปกรณ์และเสียบกลับเข้าไปใหม่ และตรวจสอบว่าไดรเวอร์ที่ใช้คือ "ch34x"
7. สาธิต
ลองใช้โปรแกรม
เมื่อแฟลชบอร์ดของคุณสว่างขึ้นแล้ว ให้กดปุ่มที่มีเครื่องหมาย
RST เพื่อรีสตาร์ทกระดานและเริ่มโปรแกรม หากไฟ LED สีน้ำเงินเริ่มกะพริบ แสดงว่าไฟกะพริบสําเร็จ หากยังไม่ได้ผล ให้เลื่อนลงไปที่ส่วน "จะเกิดอะไรขึ้นหากไม่ได้ผล" ด้านล่าง
โมเดลแมชชีนเลิร์นนิงบนกระดานได้รับการฝึกให้รู้จักคำว่า "ใช่" "ไม่" และเพื่อตรวจจับการมีอยู่และไม่มีเสียงพูด สื่อสารผลลัพธ์ด้วยไฟ LED ที่มีสีสว่าง ตารางต่อไปนี้แสดงความหมายของไฟ LED แต่ละสี
ผลการตรวจหา | สี LED |
"ใช่" | เหลือง |
"ไม่" | แดง |
คำพูดที่ไม่รู้จัก | เขียว |
ไม่พบคำพูด | ไฟ LED ไม่สว่าง |
ลองใช้เลย
ยกกระดานขึ้นปากแล้วพูดว่า "ใช่" 2-3 ครั้ง คุณจะเห็นแฟลช LED สีเหลือง หากไม่มีอะไรเกิดขึ้นเมื่อคุณพูดว่า "ใช่" ให้ลองดำเนินการต่อไปนี้
- ถือกระดานไว้ประมาณ 10 นิ้ว จากปากของเธอ
- หลีกเลี่ยงเสียงรบกวนรอบข้างมากเกินไป
- พูดตามเดิมว่า "ใช่" ติดต่อกันเร็วๆ หลายครั้ง (ลองพูดว่า "ใช่ ใช่ ใช่")
จะเกิดอะไรขึ้นหากไม่ได้ผล
ปัญหาที่เป็นไปได้และวิธีแก้ไขข้อบกพร่องมีดังนี้
ปัญหา: หลังจากกะพริบแล้ว ไฟ LED ไม่สว่างขึ้นเลย
วิธีแก้ปัญหา: ลองกดปุ่ม RST หรือยกเลิกการเชื่อมต่อและเชื่อมต่อบอร์ดจากโปรแกรมเมอร์อีกครั้ง หากวิธีเหล่านี้ไม่ได้ผล ให้ลองแฟลชบอร์ดอีกครั้ง
ปัญหา: ไฟ LED สีน้ำเงินสว่างขึ้น แต่มืดมาก
วิธีแก้ไข: เปลี่ยนแบตเตอรี่เมื่อแบตเตอรี่เหลือน้อย หรืออีกวิธีคือเปิดบอร์ดด้วยคอมพิวเตอร์โดยใช้โปรแกรมเมอร์และสาย
8. อ่านผลลัพธ์การแก้ไขข้อบกพร่อง (ไม่บังคับ)
อ่านส่วนนี้หากพบปัญหาและต้องการแก้ไขข้อบกพร่องของโค้ดโดยละเอียด เพื่อให้คุณเข้าใจสิ่งที่เกิดขึ้นในไมโครคอนโทรลเลอร์เมื่อโค้ดทำงาน คุณสามารถพิมพ์ข้อมูลการดีบักผ่านการเชื่อมต่อแบบอนุกรมของบอร์ด โดยใช้คอมพิวเตอร์ในการเชื่อมต่อและแสดงข้อมูลที่กระดานกำลังส่ง
เปิดการเชื่อมต่อแบบอนุกรม
โดยค่าเริ่มต้น โค้ดตัวอย่าง SparkFun Edge ของเราจะบันทึกคำสั่งเสียงทั้งหมด พร้อมกับความมั่นใจ หากต้องการดูเอาต์พุตของบอร์ด ให้เรียกใช้คำสั่งต่อไปนี้
screen ${DEVICENAME} 115200
ในตอนแรกคุณอาจเห็นเอาต์พุตดังนี้ (ซึ่งจะปรากฏขึ้นเฉพาะในกรณีที่มีการรีเซ็ตกระดานเมื่อเชื่อมต่อแล้ว ไม่เช่นนั้นอาจเริ่มเห็นข้อมูลการแก้ไขข้อบกพร่อง)
Apollo3 Burst Mode is Available
Apollo3 operating in Burst Mode (96MHz)
ลองออกคำสั่งด้วยการพูดว่า "ใช่" หรือ "ไม่" คุณควรเห็นข้อมูลการแก้ไขข้อบกพร่องของการพิมพ์บอร์ดสำหรับแต่ละคำสั่ง ดังนี้
Heard yes (202) @65536ms
ในบันทึกด้านบน yes จะหมายถึงคำสั่ง ตัวเลข 202 หมายถึงระดับความเชื่อมั่นว่าได้ยินคำสั่ง (โดยต่ำสุดคือ 200) สุดท้าย 65536ms หมายถึงระยะเวลาที่ผ่านไปนับตั้งแต่การรีเซ็ตไมโครคอนโทรลเลอร์ครั้งล่าสุด
หากต้องการหยุดดูเอาต์พุตการแก้ไขข้อบกพร่อง ให้กด Ctrl+A ตามด้วยคีย์ K ทันที จากนั้นกดคีย์ Y
เขียนบันทึกการแก้ไขข้อบกพร่อง
คุณดูโค้ดที่บันทึกข้อมูลนี้ในไฟล์ command_responder.cc ที่เพิ่งทำงานด้วยได้
tensorflow/lite/micro/examples/micro_speech/sparkfun_edge/command_responder.cc
หากต้องการบันทึกข้อมูล คุณสามารถเรียกใช้เมธอด error_reporter->Report() โดยรองรับโทเค็น printf มาตรฐานสำหรับการประมาณค่าสตริง ซึ่งคุณจะใช้เพื่อรวมข้อมูลสำคัญในบันทึกได้ ดังนี้
error_reporter->Report("Heard %s (%d) @%dms", found_command, score, current_time);
วิธีการนี้จะเป็นประโยชน์เมื่อคุณกำลังทำการเปลี่ยนแปลงโค้ดด้วยตนเองในส่วนถัดไป
9. ขยายรหัส (ไม่บังคับ)
ตอนนี้คุณรู้วิธีสร้างและแฟลช SparkFun Edge แล้ว คุณสามารถเริ่มเล่นเกมด้วยโค้ดและปรับใช้กับอุปกรณ์เพื่อดูผลลัพธ์ได้
อ่านโค้ด
ที่ที่ควรเริ่มอ่านโค้ดคือไฟล์ต่อไปนี้ command_responder.cc.
tensorflow/lite/micro/examples/micro_speech/sparkfun_edge/command_responder.cc
คุณดูไฟล์ใน GitHub ได้ที่นี่
ระบบจะเรียกเมธอด RespondToCommand ในไฟล์นี้เมื่อตรวจพบคำสั่งเสียง รหัสเดิมจะเปิดไฟ LED ที่แตกต่างกันโดยขึ้นอยู่กับว่าได้ยินเสียง "ใช่" "ไม่" หรือได้ยินคำสั่งที่ไม่รู้จัก ข้อมูลโค้ดต่อไปนี้แสดงวิธีการทำงาน
if (found_command[0] == 'y') {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_YELLOW);
}
if (found_command[0] == 'n') {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_RED);
}
if (found_command[0] == 'u') {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_GREEN);
}
อาร์กิวเมนต์ found_command มีชื่อคำสั่งที่ตรวจพบ เมื่อตรวจสอบอักขระตัวแรก คำสั่ง if ชุดนี้จะกำหนดว่าไฟ LED ดวงใดที่จะสว่าง
มีการเรียกเมธอด ResponseToCommand ด้วยอาร์กิวเมนต์หลายตัว ดังนี้
void RespondToCommand(tflite::ErrorReporter* error_reporter,
int32_t current_time, const char* found_command,
uint8_t score, bool is_new_command) {
error_reporterใช้เพื่อบันทึกข้อมูลการแก้ไขข้อบกพร่อง (รายละเอียดเพิ่มเติมในภายหลัง)current_timeแสดงเวลาที่ตรวจพบคำสั่งfound_commandแจ้งให้เราทราบว่าตรวจพบคำสั่งใดscoreบอกให้เรารู้ว่าตรวจพบคำสั่งได้อย่างมั่นใจเพียงใดis_new_commandแจ้งให้เราทราบหากได้ยินคำสั่งนี้เป็นครั้งแรก
score เป็นเลขจำนวนเต็มตั้งแต่ 0-255 ซึ่งแสดงความน่าจะเป็นที่ระบบตรวจพบคำสั่ง โค้ดตัวอย่างจะถือว่าคำสั่งถูกต้องก็ต่อเมื่อมีคะแนนมากกว่า 200 จากการทดสอบ คำสั่งที่ถูกต้องส่วนใหญ่อยู่ในช่วง 200-210
แก้ไขโค้ด
กระดาน SparkFun Edge มีไฟ LED 4 ดวง ตอนนี้เรากำลังกะพริบไฟ LED สีน้ำเงินเพื่อบ่งบอกว่ากำลังจดจำอยู่ ซึ่งคุณจะเห็นข้อมูลนี้ในไฟล์ command_responder.cc
static int count = 0;
// Toggle the blue LED every time an inference is performed.
++count;
if (count & 1) {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_BLUE);
} else {
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
}
เนื่องจากเรามีไฟ LED จำนวน 4 ดวง มาแก้ไขโปรแกรมให้ใช้เป็นไฟบอกสถานะ score ของคำสั่งที่มีให้กัน คะแนนต่ำจะได้ไฟ LED ดวงเดียวที่สว่าง และคะแนนสูงสุดจะทำให้มีไฟหลายดวง
เราจะทำให้แฟลช LED สีแดงสว่างขึ้นอย่างต่อเนื่องแทนสีน้ำเงิน เพื่อให้แน่ใจว่าโปรแกรมกำลังทำงาน ระบบจะใช้ไฟ LED สีน้ำเงิน สีเขียว และสีเหลืองที่อยู่ติดกันเพื่อแสดงความแรงของ score ล่าสุด และเพื่อให้เข้าใจง่าย เราจะจุดไฟ LED เหล่านั้นให้สว่างก็ต่อเมื่อคำว่า "ใช่" เท่านั้น เป็นเสียงพูด หากตรวจพบคำอื่น ไฟ LED จะล้างออก
หากต้องการทำการเปลี่ยนแปลงนี้ ให้แทนที่โค้ดทั้งหมดในไฟล์ command_responder.cc ด้วยข้อมูลโค้ดต่อไปนี้
#include "tensorflow/lite/micro/examples/micro_speech/command_responder.h"
#include "am_bsp.h"
// This implementation will light up the LEDs on the board in response to different commands.
void RespondToCommand(tflite::ErrorReporter* error_reporter,
int32_t current_time, const char* found_command,
uint8_t score, bool is_new_command) {
static bool is_initialized = false;
if (!is_initialized) {
// Setup LEDs as outputs
am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_RED, g_AM_HAL_GPIO_OUTPUT_12);
am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_BLUE, g_AM_HAL_GPIO_OUTPUT_12);
am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_GREEN, g_AM_HAL_GPIO_OUTPUT_12);
am_hal_gpio_pinconfig(AM_BSP_GPIO_LED_YELLOW, g_AM_HAL_GPIO_OUTPUT_12);
// Ensure all pins are cleared
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_RED);
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_GREEN);
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_YELLOW);
is_initialized = true;
}
static int count = 0;
// Toggle the red LED every time an inference is performed.
++count;
if (count & 1) {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_RED);
} else {
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_RED);
}
if (is_new_command) {
// Clear the last three LEDs
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_BLUE);
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_GREEN);
am_hal_gpio_output_clear(AM_BSP_GPIO_LED_YELLOW);
error_reporter->Report("Heard %s (%d) @%dms", found_command, score,
current_time);
// Only indicate a 'yes'
if (found_command[0] == 'y') {
// Always light the blue LED
am_hal_gpio_output_set(AM_BSP_GPIO_LED_BLUE);
// Light the other LEDs depending on score
if (score >= 205) {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_GREEN);
}
if(score >= 210) {
am_hal_gpio_output_set(AM_BSP_GPIO_LED_YELLOW);
}
}
}
}
หากตรวจพบคำสั่งใหม่ is_new_command จะเป็นจริง เราจะล้างไฟ LED สีน้ำเงิน เขียว และเหลือง จากนั้นจะสว่างขึ้นอีกครั้งตามค่าของ found_command และ score
สร้างใหม่และแฟลช
เมื่อเปลี่ยนแปลงโค้ดแล้ว ให้ทดสอบโดยเรียกใช้ขั้นตอนทั้งหมดจากสร้างและเตรียมไบนารี
10. ขั้นตอนถัดไป
ยินดีด้วย คุณสร้างเครื่องมือตรวจจับเสียงพูดบนไมโครคอนโทรลเลอร์สำเร็จแล้ว
เราหวังว่าคุณจะชอบบทนำสั้นๆ เกี่ยวกับการพัฒนาด้วย TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ แนวคิดเรื่องการเรียนรู้เชิงลึกในไมโครคอนโทรลเลอร์เป็นเรื่องใหม่ที่น่าตื่นเต้น เราขอแนะนำให้คุณออกไปทดลองเลย
เอกสารอ้างอิง
- ฝึกโมเดลของคุณเองเพื่อทำความเข้าใจคำสั่งต่างๆ ตอนนี้คุณมีประสบการณ์ในการทำงานกับโปรแกรมพื้นฐานแล้ว หมายเหตุ: การฝึกอบรมจะใช้เวลา 2-3 ชั่วโมง
- ดูข้อมูลเพิ่มเติมเกี่ยวกับ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ ( เว็บไซต์, GitHub)
- ลองใช้ตัวอย่างอื่นๆ แล้วลองเรียกใช้บน SparkFun Edge หากมีการรองรับ
- ลองดูหนังสือของ O'Reilly เรื่อง TinyML: Machine Learning with TensorFlow on Arduino และ Ultra-Low Power Micro-Controllers ซึ่งจะแนะนำแมชชีนเลิร์นนิงในอุปกรณ์ขนาดจิ๋วและพาไปดูโปรเจ็กต์สนุกๆ มากมาย Codelab นี้อิงตามบทที่ 7 และ 8 ของหนังสือ
ขอขอบคุณและขอให้สนุกกับการสร้างสรรค์