माइक्रोकंट्रोलर और SparkFun Edge के लिए, TensorFlow Lite की मदद से, एआई की मदद से बोली पहचानने की सुविधा

1. परिचय

आपको क्या बनाने को मिलेगा

इस कोडलैब में, हम SparkFun Edge डेवलपमेंट बोर्ड पर डीप लर्निंग मॉडल चलाने के लिए, माइक्रोकंट्रोलर के लिए TensorFlow Lite का इस्तेमाल करना सीखेंगे. हम बोर्ड में पहले से मौजूद, बोली का पता लगाने वाले मॉडल के साथ काम करेंगे. यह मॉडल, कनवोल्यूशनल न्यूरल नेटवर्क का इस्तेमाल करके, बोर्ड के दो माइक्रोफ़ोन से बोले गए "हाँ" और "नहीं" शब्दों का पता लगाता है.

माइक्रोकंट्रोलर पर मशीन लर्निंग

मशीन लर्निंग का इस्तेमाल करके, ऐसे स्मार्ट टूल बनाए जा सकते हैं जो लोगों की ज़िंदगी को आसान बनाते हैं. जैसे, Google Assistant. हालांकि, अक्सर इन अनुभवों के लिए बहुत ज़्यादा कंप्यूटेशन या संसाधनों की ज़रूरत होती है. इनमें एक पावरफ़ुल क्लाउड सर्वर या डेस्कटॉप शामिल हो सकता है. हालांकि, अब मशीन लर्निंग इन्फ़्रेंस को छोटे और कम पावर वाले हार्डवेयर, जैसे कि माइक्रोकंट्रोलर पर चलाया जा सकता है.

माइक्रोकंट्रोलर का इस्तेमाल बहुत ज़्यादा किया जाता है. ये सस्ते होते हैं और इनमें बहुत कम ऊर्जा की ज़रूरत होती है. साथ ही, ये बहुत भरोसेमंद होते हैं. ये हर तरह के घरेलू डिवाइसों का हिस्सा होते हैं. जैसे, उपकरण, कारें, और खिलौने. हर साल, माइक्रोकंट्रोलर से चलने वाले करीब 30 अरब डिवाइस बनाए जाते हैं.

मशीन लर्निंग को छोटे-छोटे माइक्रोकंट्रोलर में शामिल करके, हम उन अरबों डिवाइसों को ज़्यादा स्मार्ट बना सकते हैं जिनका इस्तेमाल हम अपनी ज़िंदगी में करते हैं. इसके लिए, हमें महंगे हार्डवेयर या भरोसेमंद इंटरनेट कनेक्शन की ज़रूरत नहीं होगी. कल्पना करें कि आपके घर में ऐसे स्मार्ट डिवाइस हैं जो आपके रोज़ के रूटीन के हिसाब से काम करते हैं. साथ ही, इंडस्ट्री में ऐसे स्मार्ट सेंसर हैं जो समस्याओं और सामान्य ऑपरेशन के बीच के अंतर को समझते हैं. इसके अलावा, ऐसे जादुई खिलौने हैं जो बच्चों को मज़ेदार और दिलचस्प तरीके से सीखने में मदद करते हैं.

माइक्रोकंट्रोलर के लिए TensorFlow Lite (सॉफ़्टवेयर)

TensorFlow, Google का ओपन सोर्स मशीन लर्निंग फ़्रेमवर्क है. इसका इस्तेमाल मॉडल को ट्रेनिंग देने और उन्हें चलाने के लिए किया जाता है. TensorFlow Lite एक सॉफ़्टवेयर फ़्रेमवर्क है. यह TensorFlow का ऑप्टिमाइज़ किया गया वर्शन है. इसे मोबाइल फ़ोन जैसे छोटे और कम पावर वाले डिवाइसों पर TensorFlow मॉडल चलाने के लिए बनाया गया है.

TensorFlow Lite For Microcontrollers एक सॉफ़्टवेयर फ़्रेमवर्क है. यह TensorFlow का ऑप्टिमाइज़ किया गया वर्शन है. इसे छोटे और कम पावर वाले हार्डवेयर, जैसे कि माइक्रोकंट्रोलर पर TensorFlow मॉडल चलाने के लिए बनाया गया है. यह एम्बेड किए गए इन एनवायरमेंट में ज़रूरी शर्तों का पालन करता है.जैसे, इसका बाइनरी साइज़ छोटा होता है, इसे ऑपरेटिंग सिस्टम, किसी भी स्टैंडर्ड C या C++ लाइब्रेरी या डाइनैमिक मेमोरी ऐलोकेशन की ज़रूरत नहीं होती.

SparkFun Edge (Hardware)

SparkFun Edge एक माइक्रोकंट्रोलर पर आधारित प्लैटफ़ॉर्म है. यह एक सर्किट बोर्ड पर मौजूद छोटा कंप्यूटर होता है. इसमें एक प्रोसेसर, मेमोरी, और I/O हार्डवेयर होता है. इससे यह दूसरे डिवाइसों को डिजिटल सिग्नल भेज और उनसे डिजिटल सिग्नल पा सकता है. इसमें चार एलईडी हैं, जिन्हें सॉफ़्टवेयर से कंट्रोल किया जा सकता है. ये Google के पसंदीदा रंगों में उपलब्ध हैं.

कंप्यूटर के उलट, माइक्रोकंट्रोलर में ऑपरेटिंग सिस्टम नहीं होता. इसके बजाय, लिखे गए प्रोग्राम सीधे तौर पर हार्डवेयर पर चलते हैं. कंप्यूटर पर कोड लिखा जाता है. इसके बाद, उसे प्रोग्रामर नाम के डिवाइस की मदद से माइक्रोकंट्रोलर में डाउनलोड किया जाता है.

माइक्रोकंट्रोलर, पावरफुल कंप्यूटर नहीं होते. इनमें छोटे प्रोसेसर होते हैं और इनकी मेमोरी भी ज़्यादा नहीं होती. हालांकि, इन्हें इस तरह से डिज़ाइन किया जाता है कि ये कम से कम ऊर्जा का इस्तेमाल करें. इसलिए, एक माइक्रोकंट्रोलर बहुत कम ऊर्जा का इस्तेमाल कर सकता है. आपके प्रोग्राम के आधार पर, SparkFun Edge को एक ही बटन बैटरी पर कई हफ़्तों तक चलाया जा सकता है!

आपको क्या सीखने को मिलेगा

अपने कंप्यूटर पर SparkFun Edge के लिए, सैंपल प्रोग्राम को कंपाइल करना
प्रोग्राम को अपने डिवाइस पर डिप्लॉय करना
प्रोग्राम में बदलाव करें और उसे फिर से डिप्लॉय करें

आपको इन चीज़ों की ज़रूरत होगी

आपको इन हार्डवेयर की ज़रूरत होगी:

Linux या MacOS कंप्यूटर
SparkFun Edge बोर्ड
SparkFun USB-C Serial Basic प्रोग्रामर
यूएसबी-सी से यूएसबी-ए केबल (अगर आपके पास यूएसबी-सी पोर्ट वाला कंप्यूटर है, तो यूएसबी-सी से यूएसबी-सी केबल लें)
(ज़रूरी नहीं) प्रोग्रामर और केबल के बिना अनुमान लगाने के लिए, 3V 20mm कॉइन सेल लिथियम बैटरी (CR2032)

आपको इन सॉफ़्टवेयर की ज़रूरत होगी:

Git (कमांड लाइन पर git चलाकर देखें कि यह इंस्टॉल है या नहीं)
Python 3 (यह देखने के लिए कि यह इंस्टॉल है या नहीं, कमांड लाइन पर python3 या python --version चलाएं)
Python 3 के लिए Pip ( StackOverflow का मददगार जवाब)
इसे 4.2.1 या इसके बाद के वर्शन पर अपडेट करें. यह देखने के लिए कि यह इंस्टॉल है या नहीं, कमांड लाइन पर make --version चलाएं
SparkFun Serial Basic ड्राइवर

2. हार्डवेयर सेट अप करना

SparkFun Edge माइक्रोकंट्रोलर में पहले से इंस्टॉल किया गया बाइनरी होता है, जो स्पीच मॉडल को चला सकता है. इससे पहले कि हम इसे अपने वर्शन से बदलें, आइए पहले इस मॉडल को चलाएं.

अपने बोर्ड को बेहतर बनाने के लिए:

बोर्ड के पिछले हिस्से में मौजूद बैटरी कनेक्टर में, कॉइन सेल बैटरी को डाला जा रहा है. बैटरी का "+" वाला हिस्सा ऊपर की ओर है. अगर आपके बोर्ड में पहले से ही बैटरी लगी हुई है, तो प्लास्टिक का टैब बाहर निकालें. इसके बाद, बैटरी को तब तक अंदर की ओर दबाएं, जब तक वह पूरी तरह से अंदर न चली जाए)

ध्यान दें: SparkFun Edge बोर्ड में बंद करने का स्विच नहीं होता. इसलिए, जब इसका इस्तेमाल न किया जा रहा हो, तो बैटरी निकाल दें, ताकि बैटरी लाइफ़ बनी रहे. इसके लिए, पेन, पेंसिल या चिमटी जैसे छोटे औज़ार का इस्तेमाल करके, बैटरी को कनेक्टर से बाहर निकालें. ध्यान रखें कि बोर्ड को नुकसान न पहुंचे. साथ ही, बैटरी के दोनों किनारों को एक साथ न रखें.

अगर आपके पास कॉइन बैटरी नहीं है, तो बोर्ड को पावर देने के लिए SparkFun USB-C Serial Basic प्रोग्रामर डिवाइस का इस्तेमाल किया जा सकता है. इस डिवाइस को अपने बोर्ड से जोड़ने के लिए, यह तरीका अपनाएं:

SparkFun Edge के किनारे पर मौजूद छह पिन वाले हेडर को ढूंढें.
SparkFun USB-C Serial Basic को इन पिन में प्लग करें. साथ ही, यह पक्का करें कि हर डिवाइस पर "BLK" और "GRN" लेबल वाली पिन सही तरीके से लाइन अप की गई हों.
SparkFun USB-C Serial Basic और अपने कंप्यूटर के बीच यूएसबी-सी केबल कनेक्ट करें.

बैटरी लगाने या यूएसबी प्रोग्रामर कनेक्ट करने के बाद, बोर्ड चालू हो जाएगा. इसके बाद, बोर्ड के माइक्रोफ़ोन चालू हो जाएंगे और वे सुनना शुरू कर देंगे. नीली लाइट फ़्लैश होने लगेगी.

बोर्ड पर मौजूद मशीन लर्निंग मॉडल को "हां" और "नहीं" शब्दों को पहचानने के लिए ट्रेन किया गया है. साथ ही, इसे आवाज़ की मौजूदगी और गैर-मौजूदगी का पता लगाने के लिए भी ट्रेन किया गया है. यह रंगीन एलईडी लाइटें जलाकर, अपने नतीजे दिखाता है. इस टेबल में, हर एलईडी रंग का मतलब बताया गया है:

डिटेक्शन का नतीजा	एलईडी का रंग
"हां"	पीला
"नहीं"	लाल
अनजान आवाज़	हरा
कोई आवाज़ नहीं सुनाई दी	कोई एलईडी लाइट नहीं जल रही है

इसे आज़माएं

बोर्ड को अपने मुंह के पास रखें और कुछ बार "हां" बोलें. आपको पीले रंग की एलईडी लाइट जलती-बुझती दिखेगी. अगर "हां" बोलने पर कुछ नहीं होता है, तो यहां दिए गए तरीके आज़माएं:

बोर्ड को अपने मुंह से करीब 10 इंच की दूरी पर रखें
बैकग्राउंड में बहुत ज़्यादा शोर न हो
जल्दी-जल्दी कई बार "हां" बोलें (जैसे, "हां हां हां")

3. सॉफ़्टवेयर सेट अप करना

अब हम माइक्रो कंट्रोलर पर स्पीच मॉडल को डाउनलोड, इंस्टॉल, और रन करेंगे. इसके लिए, हम सबसे पहले इस प्रोग्राम का सोर्स कोड और इसे बनाने के लिए ज़रूरी डिपेंडेंसी डाउनलोड करते हैं. यह प्रोग्राम C++ में लिखा गया है. इसे बोर्ड पर डाउनलोड करने से पहले, बाइनरी में कंपाइल करना ज़रूरी है. बाइनरी एक ऐसी फ़ाइल होती है जिसमें प्रोग्राम को इस तरह से सेव किया जाता है कि SparkFun Edge हार्डवेयर इसे सीधे तौर पर चला सके.

यहां दिए गए निर्देश, Linux या MacOS के लिए हैं.

TensorFlow repo डाउनलोड करना

यह कोड, GitHub पर TensorFlow रिपॉज़िटरी में यहां उपलब्ध है:

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

Python की डिपेंडेंसी डाउनलोड करना

हम अपने बाइनरी को तैयार करने और उसे डिवाइस पर फ़्लैश करने के लिए, Python 3 का इस्तेमाल करेंगे. Python स्क्रिप्ट, कुछ लाइब्रेरी की उपलब्धता पर निर्भर करती हैं. इन डिपेंडेंसी को इंस्टॉल करने के लिए, यह कमांड चलाएं:

pip3 install pycrypto pyserial --user

4. बाइनरी बनाना और उसे तैयार करना

हम बाइनरी बनाएंगे और ऐसे निर्देश चलाएंगे जो इसे डिवाइस पर डाउनलोड करने के लिए तैयार करेंगे.

बाइनरी बनाएं

सभी ज़रूरी डिपेंडेंसी डाउनलोड करने और बाइनरी बनाने के लिए, यह कमांड चलाएं:

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 फ़ाइल बन जाएगी. अब हम एक और कमांड चलाएंगे, ताकि फ़ाइल का फ़ाइनल वर्शन बनाया जा सके. इस फ़ाइल का इस्तेमाल, डिवाइस को बूटलोडर स्क्रिप्ट के साथ फ़्लैश करने के लिए किया जा सकता है. हम अगले चरण में इस स्क्रिप्ट का इस्तेमाल करेंगे:

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 सीरियल प्रोग्रामर का इस्तेमाल करेंगे. इस डिवाइस की मदद से, आपका कंप्यूटर यूएसबी के ज़रिए माइक्रोकंट्रोलर से कम्यूनिकेट कर पाता है.

इस डिवाइस को अपने बोर्ड से जोड़ने के लिए, यह तरीका अपनाएं:

SparkFun Edge के किनारे पर मौजूद छह पिन वाले हेडर को ढूंढें.
SparkFun USB-C Serial Basic को इन पिन में प्लग करें. साथ ही, यह पक्का करें कि हर डिवाइस पर "BLK" और "GRN" लेबल वाली पिन सही तरीके से लाइन अप की गई हों.

प्रोग्रामर को अपने कंप्यूटर से अटैच करना

हम बोर्ड को यूएसबी के ज़रिए आपके कंप्यूटर से कनेक्ट करेंगे. बोर्ड को प्रोग्राम करने के लिए, हमें उस नाम की ज़रूरत होगी जो आपके कंप्यूटर ने डिवाइस को दिया है. ऐसा करने का सबसे अच्छा तरीका यह है कि कंप्यूटर से अटैच करने से पहले और बाद में, सभी डिवाइसों की सूची बनाएं. इसके बाद, देखें कि कौनसे डिवाइस नए हैं.

यूएसबी के ज़रिए डिवाइस अटैच करने से पहले, यह निर्देश चलाएं:

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

अब प्रोग्रामर को अपने कंप्यूटर के यूएसबी पोर्ट से कनेक्ट करें. यह कमांड फिर से डालें:

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. बाइनरी फ़्लैश करना

बोर्ड को फ़्लैश करने के लिए स्क्रिप्ट चलाना

बोर्ड को फ़्लैश करने के लिए, हमें इसे "बूटलोडर" मोड में डालना होगा. इससे यह नए बाइनरी को पाने के लिए तैयार हो जाएगा. इसके बाद, हम बोर्ड पर बाइनरी भेजने के लिए स्क्रिप्ट चलाएंगे.

बोर्ड पर मौजूद इन बटन के बारे में जानें:

बोर्ड को रीसेट और फ़्लैश करने के लिए, यह तरीका अपनाएं:

पक्का करें कि आपका बोर्ड, प्रोग्रामर से कनेक्ट हो और पूरा सेटअप, यूएसबी के ज़रिए आपके कंप्यूटर से कनेक्ट हो.
बोर्ड पर मौजूद 14 बटन को दबाकर रखें. छठे चरण तक इसे दबाकर रखें.
14 के तौर पर मार्क किए गए बटन को दबाए रखें. इसके बाद, बोर्ड को बूटलोडर की स्थिति में रीसेट करने के लिए, 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...]

Sending Data Packet of length 8180 दिखने के बाद, बोर्ड पर मौजूद 14 बटन को दबाकर रखना बंद करें. हालांकि, अगर आप इसे दबाकर रखते हैं, तो भी कोई समस्या नहीं है. प्रोग्राम, टर्मिनल पर लाइनें प्रिंट करता रहेगा. आखिर में यह कुछ ऐसा दिखेगा:

[...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 प्रिंट हुआ है या नहीं. अगर ऐसा है, तो गड़बड़ी के बावजूद फ़्लैशिंग पूरी हो गई होगी.

Linux मशीन पर, आपको NoResponse Error दिख सकता है. ऐसा इसलिए है, क्योंकि मौजूदा सीरियल ड्राइवर के साथ-साथ ch34x सीरियल ड्राइवर भी इंस्टॉल किया गया है. इसे इस तरह से ठीक किया जा सकता है:

पहला चरण: ch34x लाइब्रेरी का सही वर्शन फिर से इंस्टॉल करें. पक्का करें कि इंस्टॉलेशन के दौरान, डिवाइस कंप्यूटर से डिसकनेक्ट हो.

git clone https://github.com/juliagoda/CH341SER.git
cd CH341SER/
make
sudo insmod ch34x.ko
sudo rmmod ch341

दूसरा चरण: बोर्ड के यूएसबी को प्लग इन करें और यह कमांड चलाएं:

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 दबाएं. अगर नीली एलईडी लाइट ब्लिंक करने लगती है, तो इसका मतलब है कि फ़्लैशिंग हो गई है. अगर ऐसा नहीं होता है, तो नीचे दिए गए "अगर यह तरीका काम नहीं करता है, तो क्या करें?" सेक्शन पर जाएं.

डिटेक्शन का नतीजा	एलईडी का रंग
"हां"	पीला
"नहीं"	लाल
अनजान आवाज़	हरा
कोई आवाज़ नहीं सुनाई दी	कोई एलईडी लाइट नहीं जल रही है

इसे आज़माएं

बोर्ड को अपने मुंह से करीब 10 इंच की दूरी पर रखें
बैकग्राउंड में बहुत ज़्यादा शोर न हो
जल्दी-जल्दी कई बार "हां" बोलें (जैसे, "हां हां हां")

अगर यह तरीका काम न करे, तो क्या होगा?

यहां कुछ समस्याएं और उन्हें डीबग करने का तरीका बताया गया है:

समस्या: फ़्लैश करने के बाद, कोई भी एलईडी चालू नहीं हो रही है.

समाधान: RST बटन दबाकर देखें. इसके अलावा, बोर्ड को प्रोग्रामर से डिसकनेक्ट करके फिर से कनेक्ट करें. अगर इनमें से कोई भी तरीका काम नहीं करता है, तो बोर्ड को फिर से फ़्लैश करें.

समस्या: नीली एलईडी जल रही है, लेकिन इसकी रोशनी बहुत कम है.

हल: बैटरी बदलें, क्योंकि यह कम हो रही है. इसके अलावा, प्रोग्रामर और केबल का इस्तेमाल करके, बोर्ड को कंप्यूटर से भी पावर दी जा सकती है.

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 तरीके का इस्तेमाल तब किया जाता है, जब कोई वॉइस कमांड डिटेक्ट होती है. मौजूदा कोड, "हां", "नहीं" या कोई अनजान कमांड सुने जाने के आधार पर, अलग-अलग एलईडी चालू करता है. नीचे दिए गए स्निपेट में, इसके काम करने का तरीका बताया गया है:

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 स्टेटमेंट का यह सेट, पहले वर्ण की जांच करके यह तय करता है कि कौनसी एलईडी लाइट जलानी है.

RespondToCommand तरीके को कई तर्कों के साथ कॉल किया जाता है:

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 बोर्ड में चार एलईडी होती हैं. फ़िलहाल, हम नीली एलईडी को चालू करके यह दिखाते हैं कि गाने की पहचान की जा रही है. इसे 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);
}

हमारे पास चार एलईडी का बैंक है. इसलिए, प्रोग्राम में बदलाव करके, इनका इस्तेमाल किसी कमांड की score के विज़ुअल इंडिकेटर के तौर पर किया जा सकता है. कम स्कोर होने पर, सिर्फ़ एक एलईडी लाइट जलेगी. वहीं, ज़्यादा स्कोर होने पर, कई लाइटें जलेंगी.

यह पक्का करने के लिए कि हमें पता चल सके कि प्रोग्राम चल रहा है, हम नीले रंग की एलईडी की जगह लाल रंग की एलईडी को लगातार चमकाएंगे. नीले, हरे, और पीले रंग की आस-पास की एलईडी का इस्तेमाल, हमारे सबसे नए score की ताकत दिखाने के लिए किया जाएगा. आसानी के लिए, हम सिर्फ़ तब एलईडी जलाएंगे, जब "हाँ" शब्द बोला जाएगा. अगर कोई दूसरा शब्द सुनाई देता है, तो एलईडी बंद हो जाएंगी.

यह बदलाव करने के लिए, अपनी 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 की वैल्यू सही होगी. हम नीले, हरे, और पीले रंग की एलईडी को बंद कर देंगे. इसके बाद, found_command और score की वैल्यू के आधार पर, उन्हें फिर से चालू कर देंगे.

फिर से बनाना और फ़्लैश करना

कोड में बदलाव करने के बाद, बाइनरी बनाएं और तैयार करें में दिए गए सभी चरणों को पूरा करके, कोड की जाँच करें.

10. अगले चरण

बधाई हो, आपने माइक्रो कंट्रोलर पर अपना पहला स्पीच डिटेक्टर बना लिया है!

हमें उम्मीद है कि आपको माइक्रोकंट्रोलर के लिए TensorFlow Lite का इस्तेमाल करके डेवलपमेंट करने के बारे में यह छोटी सी जानकारी पसंद आई होगी. माइक्रोकंट्रोलर पर डीप लर्निंग का कॉन्सेप्ट नया और दिलचस्प है. हम आपको इसे आज़माने के लिए बढ़ावा देते हैं!

रेफ़रंस दस्तावेज़

अब आपके पास बुनियादी प्रोग्राम के साथ काम करने का अनुभव है. इसलिए, अपने मॉडल को ट्रेनिंग दें, ताकि वह अलग-अलग निर्देशों को समझ सके. ध्यान दें: ट्रेनिंग में कुछ घंटे लगेंगे!
माइक्रोकंट्रोलर के लिए TensorFlow Lite के बारे में ज़्यादा जानें ( वेबसाइट, GitHub).
अन्य उदाहरण आज़माएं. अगर SparkFun Edge पर ये उदाहरण काम करते हैं, तो उन्हें चलाकर देखें.
O'Reilly की किताब TinyML: Machine Learning with TensorFlow on Arduino and Ultra-Low Power Micro-Controllers पढ़ें. इसमें छोटे डिवाइसों पर मशीन लर्निंग के बारे में बताया गया है. साथ ही, इसमें कई मज़ेदार प्रोजेक्ट के बारे में भी जानकारी दी गई है. यह कोडलैब, किताब के सातवें और आठवें चैप्टर पर आधारित है.

धन्यवाद, और मज़े से वीडियो बनाते रहें!