1. परिचय
आपको क्या बनाना होगा
इस कोडलैब में, हम SparkFun Edge डेवलपमेंट बोर्ड पर डीप लर्निंग मॉडल चलाने के लिए, TensorFlow Lite For Microcontrollers का इस्तेमाल करना सीखेंगे. हम बोर्ड के पहले से मौजूद बोली पहचानने वाले मॉडल की मदद से काम करेंगे. यह मॉडल "हां" शब्दों का पता लगाने के लिए कॉन्वलूशनल न्यूरल नेटवर्क का इस्तेमाल करता है और "नहीं" बोले जा रहे शब्दों को हाइलाइट करने की सुविधा मिलती है.
माइक्रोकंट्रोलर पर मशीन लर्निंग
मशीन लर्निंग का इस्तेमाल करके ऐसे काम के टूल बनाए जा सकते हैं जिनसे उपयोगकर्ता ज़िंदगी आसान होती है, जैसे Google Assistant. हालांकि, अक्सर इन अनुभवों को प्रोसेस करने के लिए बहुत सारे कंप्यूटेशन या संसाधनों की ज़रूरत होती है. इनमें ज़्यादा बेहतर क्लाउड सर्वर या डेस्कटॉप शामिल हो सकते हैं. हालांकि, अब माइक्रोकंट्रोलर जैसे छोटे और कम क्षमता वाले हार्डवेयर पर मशीन लर्निंग का अनुमान चलाया जा सकता है.
माइक्रोकंट्रोलर बहुत आम हैं, सस्ते हैं, इनके लिए बहुत कम ऊर्जा की ज़रूरत होती है, और ये बहुत भरोसेमंद होते हैं. वे सभी प्रकार के घरेलू उपकरणों का हिस्सा हैं: उपकरण, कार और खिलौनों के बारे में सोचें. बल्कि, माइक्रोकंट्रोलर से चलने वाले करीब 30 अरब डिवाइस हर साल तैयार किए जाते हैं.
हम मशीन लर्निंग को छोटे-छोटे माइक्रोकंट्रोलर पर उपलब्ध कराकर, उन अरबों डिवाइसों को बेहतर तरीके से इस्तेमाल करने की क्षमता बढ़ा सकते हैं जिनका इस्तेमाल हम अपनी ज़िंदगी में करते हैं. इसके लिए, हम महंगे हार्डवेयर या भरोसेमंद इंटरनेट कनेक्शन की ज़रूरत नहीं पड़ती. ऐसे स्मार्ट उपकरणों की कल्पना करें जो आपकी रोज़मर्रा की ज़िंदगी के हिसाब से खुद को बदल सकें. साथ ही, इंडस्ट्रियल सेंसर के साथ जो समस्याओं और सामान्य इस्तेमाल के बीच का फ़र्क़ समझ सकते हैं. साथ ही, ऐसे जादुई खिलौने भी सोचिए जो बच्चों को मज़ेदार और दिलचस्प तरीके से सीखने में मदद कर सकते हैं.
माइक्रोकंट्रोलर के लिए TensorFlow Lite (सॉफ़्टवेयर)
TensorFlow, Google का एक ओपन सोर्स मशीन लर्निंग फ़्रेमवर्क है. यह ट्रेनिंग और रनिंग मॉडल के लिए इस्तेमाल किया जाता है. TensorFlow Lite एक सॉफ़्टवेयर फ़्रेमवर्क है, जो TensorFlow का ऑप्टिमाइज़ किया गया वर्शन है. इसे मोबाइल फ़ोन जैसे छोटे और कम पावर वाले डिवाइसों पर tensorflow मॉडल चलाने के लिए बनाया गया है.
TensorFlow Lite For Microsoftcontrollers एक सॉफ़्टवेयर फ़्रेमवर्क है. यह TensorFlow का ऑप्टिमाइज़ किया गया वर्शन है. इसे माइक्रोकंट्रोलर जैसे छोटे हार्डवेयर पर टेंसरफ़्लो मॉडल चलाने के लिए बनाया गया है. यह एम्बेड किए गए इन एनवायरमेंट में ज़रूरी शर्तों को पूरा करता है.इसका मतलब है कि इसका बाइनरी साइज़ छोटा है, इसे ऑपरेटिंग सिस्टम के साथ काम करने, किसी स्टैंडर्ड C या C++ लाइब्रेरी या डाइनैमिक मेमोरी ऐलोकेशन वगैरह की ज़रूरत नहीं है.
SparkFun Edge (हार्डवेयर)
SparkFun Edge, माइक्रोकंट्रोलर पर आधारित प्लैटफ़ॉर्म है. यह एक छोटा सा कंप्यूटर है, जो एक सर्किट बोर्ड पर लगा होता है. इसका प्रोसेसर, मेमोरी, और I/O हार्डवेयर अन्य डिवाइसों पर डिजिटल सिग्नल भेजने और पाने में मदद करता है. इसमें आपके पसंदीदा Google रंगों में, सॉफ़्टवेयर से कंट्रोल की जा सकने वाली चार LED हैं.
किसी कंप्यूटर के विपरीत, माइक्रोकंट्रोलर कोई ऑपरेटिंग सिस्टम नहीं चलाता है. इसके बजाय, आपके लिखे गए प्रोग्राम सीधे हार्डवेयर पर चलते हैं. आप कंप्यूटर पर अपना कोड लिखते हैं और उसे प्रोग्रामर नाम के डिवाइस के ज़रिए माइक्रोकंट्रोलर में डाउनलोड करते हैं.
माइक्रोकंट्रोलर शक्तिशाली कंप्यूटर नहीं हैं. इनका प्रोसेसर छोटा होता है और इनकी मेमोरी कम होती है. लेकिन क्योंकि उन्हें जितना संभव हो सके उतने आसान होने के लिए डिज़ाइन किया गया है, इसलिए माइक्रोकंट्रोलर बहुत कम ऊर्जा का उपयोग कर सकता है. आपके प्रोग्राम के हिसाब से SparkFun Edge, एक कॉइन सेल की बैटरी पर कई हफ़्तों तक चल सकता है!
आपको इनके बारे में जानकारी मिलेगी
- अपने कंप्यूटर पर, SparkFun Edge के लिए सैंपल प्रोग्राम को कंपाइल करें
- प्रोग्राम को अपने डिवाइस पर डिप्लॉय करें
- प्रोग्राम में बदलाव करें और उसे फिर से डिप्लॉय करें
आपको इन चीज़ों की ज़रूरत होगी
आपको नीचे दिए गए हार्डवेयर की ज़रूरत होगी:
- Linux या MacOS कंप्यूटर
- SparkFun Edge बोर्ड
- SparkFun USB-C सीरियल बेसिक प्रोग्रामर
- यूएसबी-सी से यूएसबी-ए केबल (अगर यूएसबी-सी वाले कंप्यूटर का इस्तेमाल किया जा रहा है, तो इसके बजाय यूएसबी-सी से यूएसबी-सी केबल इस्तेमाल करें)
- (ज़रूरी नहीं) प्रोग्रामर और केबल के बिना अनुमान लगाने के लिए, 3V 20mm कॉइन सेल लिथियम बैटरी (CR2032)
आपको इस सॉफ़्टवेयर की ज़रूरत पड़ेगी:
- Git (देखें कि कमांड लाइन पर
gitचलाकर देखें कि इसे इंस्टॉल किया गया है या नहीं) - Python 3 (देखें कि कमांड लाइन पर
python3याpython --versionचलाकर इसे इंस्टॉल किया गया है या नहीं) - Python 3 के लिए पीआईपी ( मददगार StackOverflow का जवाब)
- 4.2.1 या उससे बाद का वर्शन बनाएं (देखें कि यह कमांड लाइन पर
make --versionचलाकर इंस्टॉल किया गया है या नहीं) - SparkFun सीरियल बेसिक ड्राइवर
2. अपना हार्डवेयर सेट अप करें
SparkFun Edge माइक्रोकंट्रोलर, पहले से इंस्टॉल की गई बाइनरी के साथ आता है, जो स्पीच मॉडल को चला सकता है. इससे पहले कि हम इसे अपने वर्शन से ओवरराइट करें, आइए पहले इस मॉडल को चलाएं.
अपने बोर्ड को इसके द्वारा सशक्त बनाएं:
- बोर्ड के पीछे मौजूद बैटरी कनेक्टर में सिक्का सेल की बैटरी डाली जा रही है (बैटरी का "+" साइड ऊपर की ओर है. अगर आपके बोर्ड पर बैटरी पहले से लगी हुई है, तो प्लास्टिक टैब को बाहर निकालें और यह पक्का करने के लिए कि बैटरी ठीक तरह से लग गई है, उसे बाहर निकालें)
- अगर आपके पास सिक्के की बैटरी नहीं है, तो इस बोर्ड को चार्ज करने के लिए SparkFun USB-C सीरियल बेसिक प्रोग्रामर डिवाइस का इस्तेमाल किया जा सकता है. इस डिवाइस को अपने बोर्ड से अटैच करने के लिए, नीचे दिया गया तरीका अपनाएं:
- SparkFun Edge की साइड में, छह पिन हेडर ढूंढें.
- SparkFun USB-C सीरियल बेसिक को इन पिन में प्लग करें, ताकि पिन पर "BLK" लेबल लगा हो और "जीआरएन" हर डिवाइस पर सही लाइन अप हों.
- SparkFun USB-C सीरियल बेसिक और अपने कंप्यूटर के बीच यूएसबी-सी केबल कनेक्ट करें.
आपके द्वारा बैटरी डालकर या USB प्रोग्रामर से कनेक्ट करके अपना बोर्ड चलाने के बाद, बोर्ड सक्रिय हो जाएगा और अपने माइक्रोफ़ोन से सुनना शुरू कर देगा. नीले रंग की लाइट फ़्लैश होना शुरू हो जानी चाहिए.
बोर्ड पर मौजूद मशीन लर्निंग मॉडल को "हां" शब्दों को पहचानने के लिए ट्रेनिंग दी गई है और "नहीं". यह अपने नतीजों के बारे में जानकारी देने के लिए, रंगीन एलईडी लाइट का इस्तेमाल करता है. नीचे दी गई टेबल में, हर एलईडी कलर का मतलब बताया गया है:
पहचान की पुष्टि का नतीजा | एलईडी का रंग |
"हां" | पीला |
"नहीं" | लाल |
बातचीत के बारे में कोई जानकारी नहीं है | हरा |
कोई आवाज़ नहीं आई | कोई एलईडी लाइट नहीं जल रही है |
इसे आज़माएं
बोर्ड को अपने मुंह के सामने रखें और "हां" कहें कुछ मामलों में. आपको पीला एलईडी फ़्लैश दिखेगा. अगर "हां" कहने पर कुछ नहीं होता है, तो ये चीज़ें आज़माकर देखें:
- बोर्ड को करीब 10" तक पकड़ें आपके मुंह से
- बैकग्राउंड के बहुत ज़्यादा शोर से बचें
- "हां" को दोहराएं एक के बाद एक कई बार ("हां हां हां" बोलकर देखें)
3. अपना सॉफ़्टवेयर सेट अप करना
अब हम खुद माइक्रोकंट्रोलर पर वाक मॉडल को डाउनलोड, इंस्टॉल और चलाने वाले हैं. इसके लिए, हम सबसे पहले इस प्रोग्राम का सोर्स कोड डाउनलोड करते हैं और यह भी कि इस प्रोग्राम को बनाने के लिए हमें किन डिपेंडेंसी की ज़रूरत है. प्रोग्राम को C++ में लिखा गया है, जिसे बोर्ड पर डाउनलोड करने से पहले एक बाइनरी में कंपाइल किया जाना चाहिए. बाइनरी एक ऐसी फ़ाइल होती है जिसमें प्रोग्राम ऐसे फ़ॉर्मैट में होता है जिसे सीधे SparkFun Edge हार्डवेयर से चलाया जा सकता है.
Linux या MacOS के लिए, नीचे दिए गए निर्देश लिखे गए हैं.
TensorFlow का रेपो डाउनलोड करें
यह कोड, 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 सीरियल बेसिक सीरियल प्रोग्रामर का इस्तेमाल करेंगे. यह डिवाइस आपके कंप्यूटर को USB के ज़रिए माइक्रोकंट्रोलर से संपर्क करने की अनुमति देता है.
इस डिवाइस को अपने बोर्ड से अटैच करने के लिए, नीचे दिया गया तरीका अपनाएं:
- SparkFun Edge की साइड में, छह पिन हेडर ढूंढें.
- SparkFun USB-C सीरियल बेसिक को इन पिन में प्लग करें, ताकि पिन पर "BLK" लेबल लगा हो और "जीआरएन" हर डिवाइस पर सही लाइन अप हों.
प्रोग्रामर को अपने कंप्यूटर से जोड़ना
हम बोर्ड को 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
अब प्रोग्रामर को अपने कंप्यूटर के यूएसबी पोर्ट से कनेक्ट करें. ये निर्देश फिर से डालें:
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
चरण 2: बोर्ड का यूएसबी प्लग लगाएं और चलाएं:
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_responseer.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 स्टेटमेंट का यह सेट तय करता है कि किस एलईडी पर रोशनी करनी है.
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 बोर्ड में चार एलईडी हैं. फ़िलहाल, हम यह बताने के लिए नीले रंग की एलईडी लाइट दिखा रहे हैं कि पहचान की जा रही है. इसे 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 हैं, इसलिए प्रोग्राम में बदलाव करते हैं ताकि उन्हें दिए गए कमांड के 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 और Ultra- कम पावर वाले माइक्रो-कंट्रोलर बुक की गई है. इसमें छोटे-छोटे डिवाइसों पर मशीन लर्निंग के बारे में बताया गया है. साथ ही, कई मज़ेदार प्रोजेक्ट के बारे में जानकारी दी गई है. यह कोडलैब, किताब के चैप्टर 7 और 8 पर आधारित है.
धन्यवाद और निर्माण का आनंद लें!