การจดจำคำพูดด้วย AI ด้วย TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์และ SparkFun Edge

1. บทนำ

สิ่งที่คุณจะสร้าง

ใน Codelab นี้ เราจะเรียนรู้วิธีใช้ TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์เพื่อเรียกใช้โมเดลการเรียนรู้เชิงลึกในSparkFun Edge Development Board เราจะทำงานร่วมกับโมเดลการตรวจจับคำพูดที่ติดตั้งมาในตัวของกระดานซึ่งใช้โครงข่ายระบบประสาทเทียมแบบ Convolutional เพื่อตรวจจับคำว่า "ใช่" และ "ไม่" กำลังพูดผ่านไมโครโฟน 2 ตัวของกระดาน

bf256d403a1821af.gif

แมชชีนเลิร์นนิงในไมโครคอนโทรลเลอร์

การเรียนรู้ของเครื่องสามารถใช้เพื่อสร้างเครื่องมือ อัจฉริยะที่ทำให้ผู้ใช้ ชีวิตง่ายขึ้น เช่น Google Assistant แต่บ่อยครั้งที่ประสบการณ์เหล่านี้ต้องการการประมวลผลหรือทรัพยากรจำนวนมาก ซึ่งอาจรวมไปถึงเซิร์ฟเวอร์ระบบคลาวด์ที่มีประสิทธิภาพหรือเดสก์ท็อป แต่ปัจจุบันคุณสามารถเรียกใช้การอนุมานของแมชชีนเลิร์นนิงบนฮาร์ดแวร์ขนาดเล็กแต่ใช้พลังงานต่ำ เช่น ไมโครคอนโทรลเลอร์

ไมโครคอนโทรลเลอร์ใช้กันทั่วไป มีราคาถูก ใช้พลังงานน้อยมาก และเสถียรมาก โดยเป็นส่วนหนึ่งของอุปกรณ์ในครัวเรือนทุกประเภท ได้แก่ เครื่องใช้ รถยนต์ และของเล่น ในความเป็นจริงมีการผลิตอุปกรณ์ที่ใช้ไมโครคอนโทรลเลอร์ประมาณ 3 หมื่นล้านเครื่องต่อปี

1360b61fbfa33657.jpeg

การนำแมชชีนเลิร์นนิงเข้ามาสู่ไมโครคอนโทรลเลอร์ขนาดจิ๋ว ช่วยให้เราเพิ่มความชาญฉลาดของอุปกรณ์หลายพันล้านเครื่องที่เราใช้ในชีวิตได้โดยไม่ต้องอาศัยฮาร์ดแวร์ราคาแพงหรือการเชื่อมต่ออินเทอร์เน็ตที่เสถียร ลองจินตนาการถึงเครื่องใช้ไฟฟ้าอัจฉริยะที่สามารถปรับให้เข้ากับกิจวัตรประจำวันของคุณได้ เซ็นเซอร์อัจฉริยะในอุตสาหกรรมที่เข้าใจความแตกต่างระหว่างปัญหาและการทำงานตามปกติ และยังมีของเล่นวิเศษที่ช่วยให้เด็กๆ เรียนรู้ได้ด้วยวิธีที่สนุกและน่าประทับใจ

TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ (ซอฟต์แวร์)

358ffdb9eb758b90.png

TensorFlow คือเฟรมเวิร์กแมชชีนเลิร์นนิงโอเพนซอร์สของ Google สำหรับการฝึกและการเรียกใช้โมเดล TensorFlow Lite เป็นเฟรมเวิร์กซอฟต์แวร์ซึ่งเป็น TensorFlow เวอร์ชันที่ได้รับการเพิ่มประสิทธิภาพซึ่งกำหนดเป้าหมายเพื่อเรียกใช้โมเดล tensorflow ในอุปกรณ์ขนาดเล็กที่ใช้พลังงานต่ำ เช่น โทรศัพท์มือถือ

TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์คือเฟรมเวิร์กซอฟต์แวร์ซึ่งเป็น TensorFlow เวอร์ชันที่เพิ่มประสิทธิภาพซึ่งกำหนดเป้าหมายเพื่อเรียกใช้โมเดล tensorflow บนฮาร์ดแวร์ขนาดจิ๋วที่ใช้พลังงานต่ำ เช่น ไมโครคอนโทรลเลอร์ และเป็นไปตามข้อจำกัดที่จำเป็นในสภาพแวดล้อมแบบฝังเหล่านี้ กล่าวคือมีไบนารีขนาดเล็ก ไม่จำเป็นต้องมีการรองรับระบบปฏิบัติการ ไลบรารี C หรือ C++ มาตรฐานใดๆ หรือการจัดสรรหน่วยความจำแบบไดนามิก ฯลฯ

SparkFun Edge (ฮาร์ดแวร์)

SparkFun Edge เป็นแพลตฟอร์มจากไมโครคอนโทรลเลอร์ ซึ่งก็คือคอมพิวเตอร์ขนาดเล็กบนแผงวงจรเดียว โดยมีโปรเซสเซอร์ หน่วยความจำ และฮาร์ดแวร์ I/O ที่ช่วยให้อุปกรณ์รับส่งสัญญาณดิจิทัลไปยังอุปกรณ์อื่นๆ ได้ มาพร้อมไฟ LED 4 ดวงในสีโปรดจาก Google

aa4493835a2338c6.png

ไมโครคอนโทรลเลอร์ต่างจากคอมพิวเตอร์ตรงที่ไม่ได้ใช้ระบบปฏิบัติการ แต่โปรแกรมที่คุณเขียนจะทำงานบนฮาร์ดแวร์โดยตรง คุณเขียนโค้ดบนคอมพิวเตอร์และดาวน์โหลดลงในไมโครคอนโทรลเลอร์ผ่านอุปกรณ์ที่เรียกว่าโปรแกรมเมอร์

ไมโครคอนโทรลเลอร์ไม่ใช่คอมพิวเตอร์ที่มีประสิทธิภาพ โดยมีโปรเซสเซอร์ขนาดเล็กและมีหน่วยความจำไม่มากนัก แต่เนื่องจากไมโครคอนโทรลเลอร์ออกแบบมาให้เรียบง่ายที่สุด ทำให้ไมโครคอนโทรลเลอร์ใช้พลังงานน้อยมาก SparkFun Edge จะทำงานได้หลายสัปดาห์โดยใช้แบตเตอรี่เซลล์แบบเหรียญเดียว ทั้งนี้ขึ้นอยู่กับว่าโปรแกรมของคุณทำอะไร

สิ่งที่คุณจะได้เรียนรู้

  • คอมไพล์โปรแกรมตัวอย่างสำหรับ SparkFun Edge ในคอมพิวเตอร์
  • ทำให้โปรแกรมใช้งานได้ในอุปกรณ์ของคุณ
  • ทำการเปลี่ยนแปลงโปรแกรมแล้วทำให้ใช้งานได้อีกครั้ง

สิ่งที่คุณต้องมี

คุณจะต้องมีฮาร์ดแวร์ดังต่อไปนี้

คุณจะต้องมีซอฟต์แวร์ต่อไปนี้

  • Git (ตรวจสอบว่าติดตั้งแล้วหรือไม่โดยเรียกใช้ git ในบรรทัดคำสั่ง)
  • Python 3 (ตรวจสอบว่าติดตั้งแล้วหรือไม่โดยเรียกใช้ python3 หรือ python --version ในบรรทัดคำสั่ง)
  • Pip สำหรับ Python 3 ( คำตอบ StackOverflow ที่เป็นประโยชน์)
  • สร้างเวอร์ชัน 4.2.1 ขึ้นไป (ตรวจสอบว่าติดตั้งแล้วหรือไม่โดยเรียกใช้ make --version ในบรรทัดคำสั่ง)
  • ไดรเวอร์ SparkFun Serial Basic

2. ตั้งค่าฮาร์ดแวร์

ไมโครคอนโทรลเลอร์ SparkFun Edge มาพร้อมกับไบนารีที่ติดตั้งไว้ล่วงหน้าซึ่งเรียกใช้โมเดลเสียงพูดได้ ก่อนที่เราจะเขียนทับสิ่งนี้ด้วยเวอร์ชันของเราเอง ให้เรียกใช้โมเดลนี้ก่อน

เพิ่มประสิทธิภาพกระดานของคุณโดย:

  1. ใส่แบตเตอรี่เซลล์แบบเหรียญเข้ากับขั้วต่อแบตเตอรี่ที่ด้านหลังของแผง (โดยหงายด้าน "+" ของแบตเตอรี่ขึ้น หากบอร์ดของคุณใส่แบตเตอรี่ไว้แล้ว ให้ดึงแท็บพลาสติกออก แล้วดันแบตเตอรี่เข้าไปเพื่อให้เสียบเข้าไปจนสุด)

25a6cc6b208e8a4e.png

  1. หากไม่มีแบตเตอรี่ คุณสามารถใช้อุปกรณ์โปรแกรมเมอร์ SparkFun USB-C Serial Basic เพื่อจ่ายไฟให้กระดานได้ หากต้องการติดอุปกรณ์นี้กับกระดาน ให้ทำตามขั้นตอนต่อไปนี้
  • มองหาส่วนหัว 6 หมุดที่ด้านข้างของ SparkFun Edge
  • เสียบ SparkFun USB-C Serial Basic กับพินเหล่านี้โดยให้พินที่มีป้ายกำกับว่า "BLK" และ "GRN" บนอุปกรณ์แต่ละเครื่องจัดเรียงอย่างถูกต้อง
  • เชื่อมต่อสาย USB-C ระหว่าง SparkFun USB-C Serial Basic กับคอมพิวเตอร์

b140822f0019f92a.png

เมื่อคุณเปิดเครื่องบอร์ดโดยใส่แบตเตอรี่หรือเชื่อมต่อโปรแกรมเมอร์แบบ 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 ได้

หากต้องการติดอุปกรณ์นี้กับกระดาน ให้ทำตามขั้นตอนต่อไปนี้

  1. มองหาส่วนหัว 6 หมุดที่ด้านข้างของ SparkFun Edge
  2. เสียบ SparkFun USB-C Serial Basic เข้ากับพินเหล่านี้โดยให้พินที่มีป้ายกำกับว่า "BLK" และ "GRN" บนอุปกรณ์แต่ละเครื่องจัดเรียงอย่างถูกต้อง

b140822f0019f92a.png

ต่อโปรแกรมเมอร์กับคอมพิวเตอร์

เราจะเชื่อมต่อกระดานกับคอมพิวเตอร์ผ่าน 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" พิเศษ ที่เตรียมพร้อมในการรับไบนารีใหม่ จากนั้นเราจะเรียกใช้สคริปต์เพื่อส่งไบนารีไปยังกระดาน

มาทำความคุ้นเคยกับปุ่มต่อไปนี้บนกระดานกัน

64c620570b9d2f83.png

ทำตามขั้นตอนต่อไปนี้เพื่อรีเซ็ตและแฟลชกระดาน:

  1. ตรวจสอบว่าบอร์ดของคุณเชื่อมต่อกับโปรแกรมเมอร์ และการตั้งค่าทั้งหมดเชื่อมต่อกับคอมพิวเตอร์ผ่าน USB
  2. เริ่มกดปุ่ม 14 บนกระดานค้างไว้ ถือสายรอจนถึงขั้นตอนที่ 6
  3. หากยังกดปุ่ม 14 ค้างไว้ หากต้องการรีเซ็ตกระดานให้อยู่ในสถานะ Bootloader ให้คลิกปุ่ม RST เพื่อรีเซ็ตกระดาน
  4. หากยังคงกดปุ่ม 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
  1. หากยังคงกดปุ่ม 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...]
  1. หยุดกดปุ่มที่มีเครื่องหมาย 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 สีน้ำเงินเริ่มกะพริบ แสดงว่าไฟกะพริบสําเร็จ หากยังไม่ได้ผล ให้เลื่อนลงไปที่ส่วน "จะเกิดอะไรขึ้นหากไม่ได้ผล" ด้านล่าง

bf256d403a1821af.gif

โมเดลแมชชีนเลิร์นนิงบนกระดานได้รับการฝึกให้รู้จักคำว่า "ใช่" "ไม่" และเพื่อตรวจจับการมีอยู่และไม่มีเสียงพูด สื่อสารผลลัพธ์ด้วยไฟ 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 ของหนังสือ

26699b18f2b199f.png

ขอขอบคุณและขอให้สนุกกับการสร้างสรรค์