TensorFlow.js की मदद से नोड में TFlite मॉडल चलाने के लिए, कोरल एज TPU का इस्तेमाल करें

1. परिचय

पिछले अपडेट की तारीख: 11-04-2022

इस कोडलैब में, Teachable Machine का इस्तेमाल करके इमेज को अलग-अलग कैटगरी में बांटने वाले मॉडल को ट्रेन करने का तरीका बताया गया है. साथ ही, TensorFlow.js का इस्तेमाल करके, Coral हार्डवेयर ऐक्सलरेशन की मदद से मॉडल को चलाने का तरीका बताया गया है. TensorFlow.js, JavaScript के लिए मशीन लर्निंग की एक बेहतरीन और फ़्लेक्सिबल लाइब्रेरी है. आपने एक ऐसा Electron ऐप्लिकेशन बनाया है जो वेबकैम से इमेज दिखाता है और Coral edge TPU का इस्तेमाल करके उन्हें क्लासिफ़ाई करता है. इस कोडलैब का पूरी तरह से काम करने वाला वर्शन, sig-tfjs GitHub रिपॉज़िटरी में उपलब्ध है.

क्या मुझे Coral डिवाइस की ज़रूरत है?

नहीं. इस कोडलैब को Coral डिवाइस के बिना भी आज़माया जा सकता है. इसके अलावा, WebNN ऐक्सलरेटर का इस्तेमाल करके, डेस्कटॉप मशीन पर भी अच्छी परफ़ॉर्मेंस पाई जा सकती है.

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

इस कोडलैब में, इमेज को कैटगरी में बांटने वाला एक Electron ऐप्लिकेशन बनाया जाता है. आपका ऐप्लिकेशन:

• यह वेबकैम से ली गई इमेज को, आपके ट्रेन किए गए मॉडल में तय की गई कैटगरी में बांटता है.
• अगर Coral ऐक्सलरेटर उपलब्ध है, तो इसका इस्तेमाल परफ़ॉर्मेंस को बेहतर बनाने के लिए किया जाता है.
• अगर आपके प्लैटफ़ॉर्म पर WebNN काम करता है, तो इसका इस्तेमाल परफ़ॉर्मेंस को बेहतर बनाने के लिए किया जाता है.

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

• Node.js में TFLite मॉडल चलाने के लिए, tfjs-tflite-node NPM पैकेज को इंस्टॉल और सेट अप करने का तरीका.
• Coral डिवाइस पर मॉडल चलाने के लिए, Edge TPU रनटाइम लाइब्रेरी को इंस्टॉल करने का तरीका.
• Coral Edge TPU का इस्तेमाल करके, मॉडल इन्फ़रेंस को तेज़ करने का तरीका.
• WebNN की मदद से, मॉडल इन्फ़रेंस की प्रोसेस को तेज़ करने का तरीका.

यह कोडलैब, Node.js में TFLite पर फ़ोकस करता है. इसमें काम के न होने वाले कॉन्सेप्ट और कोड-ब्लॉक को हटा दिया जाता है. साथ ही, आपको सिर्फ़ कॉपी और चिपकाने के लिए कॉन्टेंट दिया जाता है.

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

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

• वेबकैम की सुविधा वाला कंप्यूटर.
• Coral के लिए, हमारा सुझाव है कि आप डेस्कटॉप के साथ Raspberry Pi OS (64-bit) का इस्तेमाल करें.
• WebNN के लिए, हमारा सुझाव है कि Intel x86-64 मशीन पर Ubuntu 20.04 या Windows 10 का इस्तेमाल करें.
• Node.js का वर्शन >= 12.
• JavaScript की जानकारी होनी चाहिए.
• (सुझाया गया) मॉडल को तेज़ करने के लिए, Coral USB Accelerator.

2. सेट अप करें

कोड पाएं

हमने इस प्रोजेक्ट के लिए ज़रूरी सभी कोड को Git repo में डाल दिया है. शुरू करने के लिए, कोड लें और इसे अपने पसंदीदा डेवलपमेंट एनवायरमेंट में खोलें. इस कोडलैब के लिए, हमारा सुझाव है कि आप डेस्कटॉप के साथ Raspberry Pi OS (64-bit) पर चलने वाले Raspberry Pi का इस्तेमाल करें. इससे Coral ऐक्सलरेटर को कनेक्ट करना आसान हो जाता है.

हमारा सुझाव है कि आप Git का इस्तेमाल करके, Raspberry Pi पर रिपो को क्लोन करें

कोड पाने के लिए, नई टर्मिनल विंडो खोलें और रेपो को क्लोन करें:

git clone https://github.com/tensorflow/sig-tfjs.git

कोड लैब के लिए, आपको जिन फ़ाइलों में बदलाव करना है वे tfjs-tflite-node-codelab डायरेक्ट्री (sig-tfjs के अंदर) में मौजूद हैं. इस डायरेक्ट्री में, आपको starter_code, cpu_inference_working, coral_inference_working, और webnn_inference_working नाम की सबडायरेक्ट्री मिलेंगी. ये इस कोडलैब के चरणों के लिए चेकपॉइंट हैं.

रिपॉज़िटरी में मौजूद अन्य फ़ाइलों में, NPM पैकेज शामिल होते हैं. tfjs-tflite-node-codelab इन पर निर्भर करता है. आपको इनमें से किसी भी फ़ाइल में बदलाव करने की ज़रूरत नहीं होगी. हालांकि, आपको कुछ टेस्ट चलाने होंगे, ताकि यह पक्का किया जा सके कि आपका एनवायरमेंट सही तरीके से सेट अप किया गया है.

Edge TPU रनटाइम लाइब्रेरी इंस्टॉल करना

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

Linux / Raspberry Pi पर

Linux पर, यह लाइब्रेरी Google के पीपीए से Debian पैकेज, libedgetpu1-std के तौर पर उपलब्ध है. यह x86-64 और Armv8 (64-बिट) आर्किटेक्चर के लिए उपलब्ध है. अगर आपके प्रोसेसर में किसी दूसरे आर्किटेक्चर का इस्तेमाल किया जाता है, तो आपको इसे सोर्स से कंपाइल करना होगा.

Google के Coral PPA को जोड़ने और Edge TPU Runtime लाइब्रेरी को इंस्टॉल करने के लिए, यह कमांड चलाएं.

# None of this is needed on Coral boards
# This repo is needed for almost all packages below
echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
# This repo is needed for only python3-coral-cloudiot and python3-coral-enviro
echo "deb https://packages.cloud.google.com/apt coral-cloud-stable main" | sudo tee /etc/apt/sources.list.d/coral-cloud.list

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

sudo apt-get update
sudo apt-get install libedgetpu1-std

Windows / अन्य ओएस पर

प्री-कंपाइल किए गए बाइनरी, MacOS और Windows के x86-64 वर्शन के लिए उपलब्ध हैं. इन्हें डाउनलोड करने के बाद, install.sh या install.bat स्क्रिप्ट चलाकर इंस्टॉल किया जा सकता है.

डिवाइस रीस्टार्ट करना

Edge TPU Runtime इंस्टॉल होने के बाद, डिवाइस को रीस्टार्ट करें. इससे इंस्टॉलर ने जो नया Coral Udev नियम जोड़ा है वह चालू हो जाएगा.

पुष्टि करें कि आपका Coral डिवाइस मिला है

यह पुष्टि करने के लिए कि आपका Coral डिवाइस खोजा गया है और काम कर रहा है, coral-tflite-delegate पैकेज के लिए इंटिग्रेशन टेस्ट चलाएं. यह पैकेज, रिपॉज़िटरी की रूट डायरेक्ट्री में मौजूद है. इंटिग्रेशन टेस्ट चलाने के लिए, Coral ऐक्सलरेटर को प्लग इन करें. इसके बाद, पैकेज की डायरेक्ट्री में ये कमांड चलाएं:

npx yarn
npx yarn build-deps
npx yarn test-integration

ध्यान दें: अगर npx उपलब्ध नहीं है, तो पक्का करें कि आपने Node.js इंस्टॉल किया हो. nodejs.org पर दिए गए निर्देशों का पालन करके, Node इंस्टॉल किया जा सकता है. पक्का करें कि आपने 12 या इसके बाद का वर्शन इंस्टॉल किया हो. apt install nodejs चलाने पर, Node 10 इंस्टॉल हो सकता है. इसका इस्तेमाल इस कोडलैब के लिए नहीं किया जाना चाहिए.

आपको इस तरह का आउटपुट दिखेगा:

yarn run v1.22.17
$ yarn build && yarn test-integration-dev
$ tsc
$ jasmine --config=jasmine-integration.json
Platform node has already been set. Overwriting the platform with node.
Randomized with seed 78904
Started

============================
Hi there 👋. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================
WARNING: converting 'int32' to 'uint8'
.


1 spec, 0 failures
Finished in 2.777 seconds
Randomized with seed 78904 (jasmine --random=true --seed=78904)
Done in 6.36s.

लॉग में बताए गए तरीके से @tensorflow/tfjs-node, इंस्टॉल करने की ज़रूरत नहीं है, क्योंकि आपको मॉडल को TFLite में चलाना है.

अगर आउटपुट में Encountered unresolved custom op: edgetpu-custom-op दिखता है, तो इसका मतलब है कि आपके Coral डिवाइस का पता नहीं चला. पक्का करें कि आपने edge TPU रनटाइम लाइब्रेरी इंस्टॉल की हो और Coral डिवाइस को अपने कंप्यूटर से कनेक्ट किया हो. Coral के Python वर्शन की बाइंडिंग को टेस्ट करने के लिए, Coral की 'शुरू करें' गाइड को भी फ़ॉलो किया जा सकता है. अगर Python का वर्शन काम करता है, लेकिन ये टेस्ट अब भी पूरे नहीं हो रहे हैं, तो कृपया गड़बड़ी की रिपोर्ट सबमिट करें.

स्टार्टर कोड चलाना

अब स्टार्टर कोड चलाने के लिए तैयार हैं. शुरू करने के लिए, यह तरीका अपनाएं.

1. tfjs-tflite-node-codelab डायरेक्ट्री में मौजूद starter_code डायरेक्ट्री पर जाएं.
2. डिपेंडेंसी इंस्टॉल करने के लिए, npm install चलाएं.
3. प्रोजेक्ट लॉन्च करने के लिए, npm start चलाएं. आपके कंप्यूटर के वेबकैम से वीडियो फ़ीड दिखाने वाला ऐप्लिकेशन खुलना चाहिए.

ध्यान दें: अगर Coral dev board का इस्तेमाल किया जा रहा है और npm install से ENOMEM गड़बड़ी का मैसेज मिलता है, तो खराब हो चुके पैकेज को फिर से बनाने के लिए npm rebuild && npm install चलाएं.

हम कहां से शुरुआत करें?

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

स्टार्टर कोड एक्सप्लोर करना

इस स्टार्टर कोड में कई फ़ाइलें हैं, लेकिन आपको सिर्फ़ renderer.js में बदलाव करना है. यह तय करता है कि पेज पर क्या दिखेगा. इसमें वीडियो फ़ीड और एचटीएमएल एलिमेंट शामिल हैं. साथ ही, यह वह जगह है जहाँ आपको ऐप्लिकेशन में अपना मशीन लर्निंग मॉडल जोड़ना होता है. अन्य फ़ाइलों में एक index.html फ़ाइल भी शामिल है. हालाँकि, यह सिर्फ़ renderer.js फ़ाइल को लोड करती है. इसमें main.js फ़ाइल भी होती है, जो Electron के लिए एंट्री पॉइंट होती है. यह ऐप्लिकेशन के लाइफ़साइकल को कंट्रोल करता है. इसमें यह भी शामिल है कि ऐप्लिकेशन खोलने पर क्या दिखाना है और बंद करने पर क्या करना है. हालांकि, आपको इसमें कोई बदलाव करने की ज़रूरत नहीं होगी.

डीबगर खोलें

इस कोडलैब को पूरा करते समय, आपको अपने ऐप्लिकेशन को डीबग करना पड़ सकता है. यह ऐप्लिकेशन Electron पर आधारित है. इसलिए, इसमें Chrome डिबगर पहले से मौजूद होता है. ज़्यादातर प्लैटफ़ॉर्म पर, इसे Ctrl + Shift + i दबाकर खोला जा सकता है. ऐप्लिकेशन के लॉग और गड़बड़ी के मैसेज देखने के लिए, कंसोल टैब पर क्लिक करें.

यहां एक्सप्लोर करने के लिए और कुछ नहीं है. इसलिए, इमेज क्लासिफ़ायर को ट्रेनिंग देने की प्रोसेस शुरू करते हैं!

3. इमेज क्लासिफ़ायर को ट्रेन करना

इस सेक्शन में, कस्टम इमेज क्लासिफ़िकेशन मॉडल के TFLite और Coral वर्शन को ट्रेन किया जाता है.

डेटा की कैटगरी तय करने वाले सिस्टम को ट्रेन करना

इमेज क्लासिफ़ायर, इनपुट इमेज लेता है और उन्हें लेबल असाइन करता है. इस कोडलैब के लिए, आपको अपने ब्राउज़र में मॉडल को ट्रेन करने के लिए Teachable Machine का इस्तेमाल करना होगा. इस सेक्शन के लिए ट्रेनिंग को तेज़ करने के लिए, Raspberry Pi के बजाय डेस्कटॉप या लैपटॉप कंप्यूटर का इस्तेमाल किया जा सकता है. हालांकि, आपको नतीजे के तौर पर मिली फ़ाइलों को Pi पर कॉपी करना होगा.

अब आपके पास मॉडल को ट्रेन करने का विकल्प है. अगर आपको यह नहीं पता कि किस तरह के मॉडल को ट्रेन करना है, तो व्यक्ति का पता लगाने वाले मॉडल को ट्रेन करना आसान होता है. यह मॉडल सिर्फ़ यह पता लगाता है कि फ़्रेम में कोई व्यक्ति है या नहीं.

1. Teachable Machine का ट्रेनिंग पेज नए टैब में खोलें.
2. इमेज प्रोजेक्ट और फिर स्टैंडर्ड इमेज मॉडल चुनें.
3. हर क्लास के लिए इमेज के सैंपल जोड़ें. वेबकैम का इस्तेमाल करके, आसानी से ऐसा किया जा सकता है. क्लास के नाम भी बदले जा सकते हैं.
4. जब आपने हर क्लास के लिए ज़रूरत के मुताबिक डेटा इकट्ठा कर लिया हो (आम तौर पर, 50 सैंपल काफ़ी होते हैं), तो मॉडल को ट्रेन करें पर क्लिक करें.

मॉडल की ट्रेनिंग पूरी होने के बाद, आपको मॉडल के आउटपुट की झलक दिखेगी.

मॉडल को अलग-अलग इनपुट देकर देखें. अगर आपको कोई ऐसा इनपुट मिलता है जिसे गलत तरीके से कैटगरी में रखा गया है, तो उसे ट्रेनिंग डेटा में जोड़ें और मॉडल को फिर से ट्रेन करें.

5. मॉडल के सटीक होने पर, मॉडल एक्सपोर्ट करें पर क्लिक करें. आपको मॉडल के दो अलग-अलग वर्शन डाउनलोड करने होंगे.
6. अपने मॉडल को TensorFlow Lite फ़्लोटिंग पॉइंट मॉडल के तौर पर एक्सपोर्ट करें. इससे converted_tflite.zip नाम की फ़ाइल डाउनलोड होती है. जो सीपीयू पर चलता है.
7. अपने मॉडल को TensorFlow Lite EdgeTPU मॉडल के तौर पर एक्सपोर्ट करें. इससे converted_edgetpu.zip नाम की एक फ़ाइल डाउनलोड होती है, जो Coral Edge TPU पर चलती है.

अहम जानकारी: ज़्यादा सटीक नतीजे पाने के लिए, इमेज के सैंपल में अलग-अलग रोटेशन, पोज़िशन, और बैकग्राउंड का इस्तेमाल करें. अगर आपके पास लैपटॉप है, तो उसका इस्तेमाल करके इन सैंपल को आसानी से इकट्ठा करें.

4. अपने ऐप्लिकेशन में सीपीयू मॉडल को लागू करना

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

ऐप्लिकेशन में मॉडल फ़ाइल जोड़ना

क्लासिफ़ायर को ट्रेन करते समय डाउनलोड की गई, converted_tflite.zip मॉडल फ़ाइल को अनज़िप करें. संग्रह में दो फ़ाइलें हैं. model_uquant.tflite सेव किया गया TFLite मॉडल है. इसमें मॉडल ग्राफ़ और वेट शामिल हैं. labels.txt में, उन क्लास के ऐसे लेबल होते हैं जिन्हें कोई भी व्यक्ति आसानी से पढ़ सकता है. ये लेबल, मॉडल के अनुमान के आधार पर तय किए जाते हैं. दोनों फ़ाइलों को modeldirectory में रखें.

डिपेंडेंसी इंस्टॉल करना

मॉडल लोड करने और इनपुट को पहले से प्रोसेस करने के लिए, TensorFlow.js की कुछ डिपेंडेंसी की ज़रूरत होती है:

• tfjs-tflite-node: Node.js में TFLite मॉडल चलाने के लिए, TensorFlow.js का पैकेज.
• @tensorflow/tfjs: TensorFlow.js का मुख्य पैकेज.

@tensorflow/tfjs पहले से इंस्टॉल है. हालांकि, आपको इस कमांड का इस्तेमाल करके tfjs-tflite-node इंस्टॉल करना होगा:

npm install --save tfjs-tflite-node

इसे इंस्टॉल करने के बाद, ऐप्लिकेशन में renderer.js के सबसे ऊपर इसे जोड़ें:

कोडलैब का पहला हिस्सा: tfjs-tflite-node को इंपोर्ट करें.

const {loadTFLiteModel} = require('tfjs-tflite-node');

मॉडल लोड करना

अब मॉडल लोड किया जा सकता है. tfjs-tflite-node में, ऐसा करने के लिए loadTFLiteModel फ़ंक्शन उपलब्ध है. यह मॉडल को फ़ाइल पाथ, ArrayBuffer या TFHub यूआरएल से लोड कर सकता है. अपने मॉडल और उसके वेट को लोड करने के लिए, इसे main फ़ंक्शन में जोड़ें:

कोडलैब का पहला हिस्सा: मॉडल को यहां लोड करें.

const modelPath = './model/model_unquant.tflite';
const model = await loadTFLiteModel(modelPath);
const labels = fs.readFileSync('./model/labels.txt', 'utf8')
      .split('\n');

मॉडल को चलाना

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

वेबकैम के इनपुट को पहले से प्रोसेस करना

फ़िलहाल, वेबकैम सिर्फ़ एक एचटीएमएल एलिमेंट है. साथ ही, यह जो फ़्रेम दिखाता है वे JavaScript के renderer.js फ़ाइल के लिए उपलब्ध नहीं हैं. वेबकैम से फ़्रेम पाने के लिए, TensorFlow.js tf.data.webcam उपलब्ध कराता है. यह कैमरे से फ़्रेम कैप्चर करने के लिए, इस्तेमाल में आसान capture() तरीका उपलब्ध कराता है.

इसका इस्तेमाल करने के लिए, इस सेटअप कोड को main() में जोड़ें:

कोडलैब का पहला हिस्सा: यहां tf.data.webcam सेट अप करें.

const tensorCam = await tf.data.webcam(webcam);

इसके बाद, हर फ़्रेम की इमेज कैप्चर करने के लिए, run() में यह जोड़ें:

कोडलैब का पहला हिस्सा: यहां वेबकैम के फ़्रेम कैप्चर करें.

const image = await tensorCam.capture();

आपको हर फ़्रेम को मॉडल के साथ काम करने के लिए, प्रीप्रोसेस भी करना होगा. इस कोडलैब में इस्तेमाल किए गए मॉडल का इनपुट शेप [1, 224, 224, 3] है. इसलिए, इसे 224 x 224 पिक्सल वाली RGB इमेज की ज़रूरत होती है. tensorCam.capture()का शेप [224, 224, 3] है. इसलिए, आपको tf.expandDims का इस्तेमाल करके, टेंसर के सामने एक और डाइमेंशन जोड़ना होगा. इसके अलावा, सीपीयू मॉडल को -1 से 1 के बीच Float32 इनपुट की ज़रूरत होती है. हालांकि, वेबकैम 0 से 255 के बीच की वैल्यू कैप्चर करता है. इनपुट टेंसर को 127 से भाग देकर, उसकी रेंज को [0, 255] से [0, ~2] में बदला जा सकता है. इसके बाद, 1 घटाकर, मनचाही रेंज [-1, ~1] पाई जा सकती है. इसके लिए, run() फ़ंक्शन में tf.tidy() में ये लाइनें जोड़ें:

कोडलैब का पहला हिस्सा: यहां वेबकैम फ़्रेम को पहले से प्रोसेस करें.

const expanded = tf.expandDims(image, 0);
const divided = tf.div(expanded, tf.scalar(127));
const normalized = tf.sub(divided, tf.scalar(1));

टेंसर का इस्तेमाल करने के बाद, उन्हें हटाना ज़रूरी है. tf.tidy(), अपने कॉलबैक में मौजूद कोड के लिए ऐसा अपने-आप करता है. हालांकि, यह एसिंक फ़ंक्शन के साथ काम नहीं करता. आपको पहले बनाए गए इमेज टेंसर को मैन्युअल तरीके से हटाना होगा. इसके लिए, आपको इसके dispose() तरीके को कॉल करना होगा.

कोडलैब का पहला हिस्सा: यहां वेबकैम फ़्रेम हटाएं.

image.dispose();

मॉडल को चलाएं और नतीजे दिखाएं

प्रीप्रोसेस किए गए इनपुट पर मॉडल चलाने के लिए, सामान्य किए गए टेंसर पर model.predict() को कॉल करें. इससे एक डाइमेंशन वाला ऐसा टेंसर मिलता है जिसमें हर लेबल की अनुमानित संभावना होती है. हर लेबल के मिलने की संभावना का प्रतिशत जानने के लिए, इस संभावना को 100 से गुणा करें. साथ ही, स्क्रीन पर मॉडल के अनुमान को दिखाने के लिए, स्टार्टर कोड में शामिल showPrediction फ़ंक्शन का इस्तेमाल करें.

यह कोड, stats.js का भी इस्तेमाल करता है. इससे यह पता चलता है कि अनुमान लगाने में कितना समय लगता है. इसके लिए, यह कोड model.predict के आस-पास stats.begin और stats.end को कॉल करता है.

कोडलैब का पहला हिस्सा: मॉडल को चलाएं और यहां नतीजे दिखाएं.

stats.begin();
const prediction = model.predict(normalized);
stats.end();
const percentage = tf.mul(prediction, tf.scalar(100));
showPrediction(percentage.dataSync(), labels);

yarn start के साथ ऐप्लिकेशन को फिर से चलाएं. आपको अपने मॉडल से मिले क्लासिफ़िकेशन दिखेंगे.

परफ़ॉर्मेंस

फ़िलहाल, मॉडल को सीपीयू पर चलाया जा रहा है. यह डेस्कटॉप कंप्यूटर और ज़्यादातर लैपटॉप के लिए ठीक है. हालांकि, अगर इसे Raspberry Pi या कम पावर वाले किसी अन्य डिवाइस पर चलाया जाता है, तो यह सही नहीं हो सकता. Raspberry Pi 4 पर, आपको शायद 10 एफ़पीएस के आस-पास दिखेगा. यह कुछ ऐप्लिकेशन के लिए काफ़ी तेज़ नहीं हो सकता. तेज़ मशीन का इस्तेमाल किए बिना बेहतर परफ़ॉर्मेंस पाने के लिए, ऐप्लिकेशन के हिसाब से सिलिकॉन का इस्तेमाल किया जा सकता है. जैसे, Coral Edge TPU.

5. अपने ऐप्लिकेशन में Coral मॉडल को चलाना

अगर आपके पास Coral डिवाइस नहीं है, तो इस सेक्शन को छोड़ा जा सकता है.

इस कोडलैब का यह चरण, पिछले सेक्शन में लिखे गए कोड पर आधारित है. हालांकि, अगर आपको नए सिरे से शुरुआत करनी है, तो cpu_inference_working चेकपॉइंट का इस्तेमाल किया जा सकता है.

Coral मॉडल को चलाने का तरीका, सीपीयू मॉडल को चलाने के तरीके से काफ़ी मिलता-जुलता है. इनके मॉडल फ़ॉर्मैट में मुख्य अंतर होता है. Coral सिर्फ़ uint8 टेंसर के साथ काम करता है. इसलिए, मॉडल को क्वांटाइज़ किया जाता है. इससे मॉडल को पास किए गए इनपुट टेंसर और उससे मिले आउटपुट टेंसर पर असर पड़ता है. एक और अंतर यह है कि Coral TPU पर मॉडल चलाने के लिए, उन्हें Edge TPU कंपाइलर का इस्तेमाल करके कंपाइल करना होता है. TeachableMachine ने यह चरण पहले ही पूरा कर लिया है. हालांकि, अन्य मॉडल के लिए यह चरण पूरा करने का तरीका जानने के लिए, Coral का दस्तावेज़ पढ़ें.

ऐप्लिकेशन में Coral मॉडल फ़ाइल जोड़ना

क्लासिफ़ायर को ट्रेन करते समय डाउनलोड की गई, converted_edgetpu.zip मॉडल फ़ाइल को अनज़िप करें. संग्रह में दो फ़ाइलें शामिल हैं. model_edgetpu.tflite सेव किया गया TFLite मॉडल है. इसमें मॉडल ग्राफ़ और वेट शामिल हैं. labels.txt में, उन क्लास के ऐसे लेबल होते हैं जिन्हें कोई भी व्यक्ति आसानी से पढ़ सकता है. ये लेबल, मॉडल के अनुमान के आधार पर तय किए जाते हैं. मॉडल फ़ाइल को coral_model डायरेक्ट्री में रखें.

डिपेंडेंसी इंस्टॉल करना

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

Coral डिवाइसों को TFLite डेलिगेट के तौर पर ऐक्सेस किया जाता है. इन्हें JavaScript से ऐक्सेस करने के लिए, coral-tflite-delegate पैकेज इंस्टॉल करें:

npm install --save coral-tflite-delegate

इसके बाद, renderer.js फ़ाइल में सबसे ऊपर यह लाइन जोड़कर, डेलिगेट को इंपोर्ट करें:

CODELAB part 2: Import the delegate here.

const {CoralDelegate} = require('coral-tflite-delegate');

मॉडल लोड करना

अब Coral मॉडल लोड किया जा सकता है. इसे सीपीयू मॉडल की तरह ही किया जाता है. हालांकि, अब आपको loadTFLiteModel फ़ंक्शन में विकल्प पास करने होंगे, ताकि Coral डेलिगेट लोड हो सके.

कोडलैब का दूसरा हिस्सा: डेलिगेट मॉडल को यहां लोड करें.

const coralModelPath = './coral_model/model_edgetpu.tflite';
const options = {delegates: [new CoralDelegate()]};
const coralModel = await loadTFLiteModel(coralModelPath, options);

आपको लेबल लोड करने की ज़रूरत नहीं है, क्योंकि वे सीपीयू मॉडल के लिए इस्तेमाल किए गए लेबल के जैसे ही हैं.

सीपीयू और कोरल के बीच स्विच करने के लिए बटन जोड़ना

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

इस कोड का इस्तेमाल करके बटन जोड़ें:

CODELAB का दूसरा हिस्सा: यहां डेलिगेट बटन बनाएं.

let useCoralDelegate = false;
const toggleCoralButton = document.createElement('button');
function toggleCoral() {
  useCoralDelegate = !useCoralDelegate;
  toggleCoralButton.innerText = useCoralDelegate
      ? 'Using Coral. Press to switch to CPU.'
      : 'Using CPU. Press to switch to Coral.';
}
toggleCoralButton.addEventListener('click', toggleCoral);
toggleCoral();
document.body.appendChild(toggleCoralButton);

आइए, इस शर्त को run()फ़ंक्शन में जोड़ते हैं. useCoralDelegate की वैल्यू 'गलत है' पर सेट होने पर, इसे सीपीयू वर्शन पर चलना चाहिए. इसके अलावा, यह Coral वर्शन को चलाता है. हालांकि, फ़िलहाल यह कुछ नहीं करेगा. सीपीयू मॉडल को चलाने वाले कोड को if स्टेटमेंट में रैप करें. ध्यान दें कि expanded टेंसर को if स्टेटमेंट से बाहर रखा गया है, क्योंकि Coral मॉडल इसका इस्तेमाल करता है.

CODELAB का दूसरा हिस्सा: देखें कि यहां डेलिगेट का इस्तेमाल करना है या नहीं.

// NOTE: Don't just copy-paste this code into the app.
// You'll need to edit the code from the CPU section.
const expanded = tf.expandDims(image, 0);
if (useCoralDelegate) {
  // CODELAB part 2: Run Coral prediction here.
} else {
  const divided = tf.div(expanded, tf.scalar(127));
  const normalized = tf.sub(divided, tf.scalar(1));
  stats.begin();
  const prediction = model.predict(normalized);
  stats.end();
  const percentage = tf.mul(prediction, tf.scalar(100));
  showPrediction(percentage.dataSync(), labels);
}

मॉडल को चलाना

मॉडल के Coral वर्शन को 0 से 255 तक के uint8 टेंसर की ज़रूरत होती है. इसलिए, इसके इनपुट को सामान्य करने की ज़रूरत नहीं होती. हालांकि, आउटपुट भी 0 से 255 की रेंज में uint8 टेंसर होता है. इसे दिखाने से पहले, 0 से 100 के बीच की फ़्लोट वैल्यू में बदलना होगा.

कोडलैब का दूसरा हिस्सा: यहां Coral की मदद से अनुमान लगाएं. (यह ऊपर दिए गए कोड स्निपेट का हिस्सा है)

stats.begin();
const prediction = coralModel.predict(expanded);
stats.end();
const percentage = tf.div(tf.mul(prediction, tf.scalar(100)), tf.scalar(255));
showPrediction(percentage.dataSync(), labels);

ऐप्लिकेशन को yarn start के साथ फिर से चलाएं. इससे, Coral ऐक्सलरेटर से मिले क्लासिफ़िकेशन दिखने चाहिए.

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

परफ़ॉर्मेंस के बारे में जानकारी

आपको दिखने वाली फ़्रेम रेट में प्रीप्रोसेसिंग और पोस्टप्रोसेसिंग शामिल होती है. इसलिए, यह नहीं कहा जा सकता कि Coral हार्डवेयर क्या-क्या कर सकता है. परफ़ॉर्मेंस के बारे में बेहतर तरीके से जानने के लिए, एफपीएस मीटर पर तब तक क्लिक करें, जब तक वह मिलीसेकंड में लेटेन्सी न दिखाने लगे. यह सिर्फ़ model.predict को कॉल करने की प्रोसेस को मेज़र करता है. हालांकि, इसमें अब भी Tensor को TFLite के नेटिव C बाइंडिंग और फिर Coral डिवाइस पर ले जाने में लगने वाला समय शामिल है. इसलिए, यह सटीक मेज़रमेंट नहीं है. C++ में लिखे गए, ज़्यादा सटीक परफ़ॉर्मेंस बेंचमार्क के लिए, EdgeTPU बेंचमार्क पेज देखें.

यह भी ध्यान दें कि वीडियो को Raspberry Pi के बजाय लैपटॉप पर रिकॉर्ड किया गया था. इसलिए, आपको एफ़पीएस अलग दिख सकता है.

Coral की प्रीप्रोसेसिंग की स्पीड बढ़ाना

कुछ मामलों में, TFJS बैकएंड बदलकर प्रीप्रोसेसिंग की प्रोसेस को तेज़ किया जा सकता है. डिफ़ॉल्ट बैकएंड WebGL है. यह समानांतर रूप से की जा सकने वाली बड़ी कार्रवाइयों के लिए अच्छा है. हालांकि, यह ऐप्लिकेशन प्रीप्रोसेसिंग फ़ेज़ में इस तरह की ज़्यादा कार्रवाइयां नहीं करता. यह सिर्फ़ expandDims ऑप का इस्तेमाल करता है, जो समानांतर नहीं है. फ़ाइल में सबसे ऊपर इंपोर्ट के बाद यह लाइन जोड़कर, सीपीयू बैकएंड पर स्विच किया जा सकता है. इससे, टेंसर को जीपीयू पर ले जाने और वहां से वापस लाने में लगने वाले अतिरिक्त समय से बचा जा सकता है.

tf.setBackend(‘cpu');

इससे TFLite CPU मॉडल के लिए प्रीप्रोसेसिंग पर भी असर पड़ता है. इसे पैरललाइज़ किया जाता है, ताकि मॉडल इस बदलाव के साथ ज़्यादा तेज़ी से काम कर सके.

6. WebNN की मदद से, सीपीयू मॉडल को बेहतर बनाएं

अगर आपके पास Coral ऐक्सलरेटर नहीं है या आपको मॉडल को तेज़ करने का कोई दूसरा तरीका आज़माना है, तो WebNN TFLite डेलिगेट का इस्तेमाल करें. यह डेलिगेट, Intel प्रोसेसर में बने मशीन लर्निंग हार्डवेयर का इस्तेमाल करता है. इससे OpenVINO टूलकिट की मदद से, मॉडल इन्फ़रेंस को बेहतर बनाया जा सकता है. इसलिए, इसमें कुछ अतिरिक्त ज़रूरी शर्तें हैं. ये शर्तें, इस कोडलैब के सेटअप सेक्शन में शामिल नहीं की गई हैं. साथ ही, आपको OpenVINO टूलकिट इंस्टॉल करना होगा. आगे बढ़ने से पहले, पक्का करें कि आपका सेटअप, टारगेट सिस्टम प्लैटफ़ॉर्म के साथ काम करता हो. हालांकि, ध्यान दें कि WebNN डेलिगेट, macOS के साथ काम नहीं करता है.

OpenVINO टूलकिट इंस्टॉल करना

OpenVINO टूलकिट, Intel प्रोसेसर में बने मशीन लर्निंग हार्डवेयर का इस्तेमाल करके, मॉडल को तेज़ी से प्रोसेस करता है. Intel से पहले से कंपाइल किया गया वर्शन डाउनलोड किया जा सकता है. इसके अलावा, इसे सोर्स से बनाया जा सकता है. OpenVINO को इंस्टॉल करने के कई तरीके हैं. हालांकि, इस कोडलैब के लिए हमारा सुझाव है कि आप Windows या Linux के लिए इंस्टॉलर स्क्रिप्ट का इस्तेमाल करें. 2021.4.2 LTS रनटाइम वर्शन इंस्टॉल करना न भूलें, क्योंकि अन्य वर्शन काम नहीं कर सकते. इंस्टॉलर चलाने के बाद, पक्का करें कि आपने अपने शेल के एनवायरमेंट वैरिएबल को कॉन्फ़िगर कर लिया हो. इसके लिए, Linux या Windows ( स्थायी समाधान) के लिए दिए गए इंस्टॉलेशन निर्देशों का पालन करें. इसके अलावा, webnn-tflite-delegate डायरेक्ट्री में मौजूद setupvars.sh (Linux) या setupvars.bat (Windows) कमांड चलाकर भी ऐसा किया जा सकता है.

Windows के लिए ध्यान दें: setupvars.bat कमांड, Git bash के साथ काम नहीं करती है. इसलिए, इस कोडलैब में दी गई इस कमांड और अन्य कमांड को Windows के कमांड प्रॉम्प्ट से चलाएं.

पुष्टि करना कि WebNN Delegate काम कर रहा है

यह पुष्टि करने के लिए कि WebNN डेलिगेट सही तरीके से काम कर रहा है, इंटिग्रेशन टेस्ट चलाएं. ये टेस्ट, रिपॉज़िटरी की रूट डायरेक्ट्री में मौजूद webnn-tflite-delegate पैकेज के लिए चलाए जाते हैं. इंटिग्रेशन टेस्ट चलाने के लिए, पैकेज की डायरेक्ट्री में ये कमांड चलाएं:

# In webnn-tflite-delegate/
npx yarn
npx yarn test-integration

आपको इस तरह का आउटपुट दिखेगा:

WebNN delegate: WebNN device set to 0.
INFO: Created TensorFlow Lite WebNN delegate for device Default and power Default.

============================
Hi there 👋. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================
label: wine bottle
score:  0.934505045413971
.


1 spec, 0 failures
Finished in 0.446 seconds
Randomized with seed 58441 (jasmine --random=true --seed=58441)
Done in 8.07s.

अगर आपको इस तरह का आउटपुट दिखता है, तो इसका मतलब है कि कॉन्फ़िगरेशन में गड़बड़ी हुई है:

Platform node has already been set. Overwriting the platform with node.
Randomized with seed 05938
Started
error Command failed with exit code 3221225477.
info Visit https://yarnpkg.com/en/docs/cli/run for documentation about this command.

इस आउटपुट का मतलब है कि आपने OpenVINO के एनवायरमेंट वैरिएबल सेट नहीं किए हैं. फ़िलहाल, setupvars.sh (Linux) या setupvars.bat (Windows) कमांड चलाकर इन्हें सेट किया जा सकता है. हालांकि, Linux या Windows ( स्थायी समाधान) के निर्देशों का पालन करके, इन्हें हमेशा के लिए सेट किया जा सकता है. अगर Windows का इस्तेमाल किया जा रहा है, तो यह

setupvars.bat

कमांड, Git bash के साथ काम नहीं करती. इसलिए, पक्का करें कि आपने इसे और इस कोडलैब की अन्य कमांड को Windows कमांड प्रॉम्प्ट से चलाया हो.

WebNN Delegate इंस्टॉल करना

OpenVINO इंस्टॉल करने के बाद, अब WebNN की मदद से सीपीयू मॉडल को बेहतर बनाया जा सकता है. इस कोडलैब का यह सेक्शन, "अपने ऐप्लिकेशन में सीपीयू मॉडल चलाना" सेक्शन में लिखे गए कोड पर आधारित है. इस चरण में लिखे गए कोड का इस्तेमाल किया जा सकता है. हालांकि, अगर आपने Coral सेक्शन पहले ही पूरा कर लिया है, तो cpu_inference_working चेकपॉइंट का इस्तेमाल करें, ताकि आप नए सिरे से शुरुआत कर सकें.

WebNN डेलिगेट का Node.js हिस्सा, npmjs पर डिस्ट्रिब्यूट किया जाता है. इसे इंस्टॉल करने के लिए, यह निर्देश चलाएं:

npm install --save webnn-tflite-delegate

इसके बाद, renderer.js फ़ाइल में सबसे ऊपर यह लाइन जोड़कर, डेलिगेट को इंपोर्ट करें:

CODELAB part 2: Import the delegate here.

const {WebNNDelegate, WebNNDevice} = require('webnn-tflite-delegate');

WebNN डेलिगेट, सीपीयू या जीपीयू पर काम करता है. WebNNDevice की मदद से, यह चुना जा सकता है कि किसका इस्तेमाल करना है.

मॉडल लोड करना

अब WebNN डेलिगेट चालू करके, मॉडल को लोड किया जा सकता है. Coral के लिए, आपको एक अलग मॉडल फ़ाइल लोड करनी पड़ती थी. हालांकि, WebNN, TFLite के मॉडल फ़ॉर्मैट के साथ काम करता है. इसे चालू करने के लिए, WebNNDelegate को मॉडल को पास किए गए डेलिगेट की सूची में जोड़ें:

कोडलैब का दूसरा हिस्सा: डेलिगेट मॉडल को यहां लोड करें.

let webnnModel = await loadTFLiteModel(modelPath, {
  delegates: [new WebNNDelegate({webnnDevice: WebNNDevice.DEFAULT})],
});

आपको लेबल को फिर से लोड करने की ज़रूरत नहीं है, क्योंकि यह एक ही मॉडल है.

TfLite CPU और WebNN के बीच स्विच करने के लिए बटन जोड़ना

मॉडल का WebNN वर्शन तैयार हो गया है. अब WebNN और TfLite CPU इन्फ़रेंस के बीच स्विच करने के लिए, एक बटन जोड़ें. दोनों को एक साथ चलाने पर, परफ़ॉर्मेंस में अंतर देखना मुश्किल हो जाता है.

इस कोड का इस्तेमाल करके बटन जोड़ें. ध्यान दें कि इससे मॉडल तुरंत स्विच नहीं होंगे:

CODELAB का दूसरा हिस्सा: यहां डेलिगेट बटन बनाएं.

let useWebNNDelegate = false;
const divElem = document.createElement('div');
const toggleWebNNButton = document.createElement('button');
function toggleWebNN() {
  useWebNNDelegate = !useWebNNDelegate;
  toggleWebNNButton.innerHTML = useWebNNDelegate
      ? 'Using WebNN. Press to switch to TFLite CPU.'
      : 'Using TFLite CPU. Press to switch to WebNN.';
  divElem.hidden = useWebNNDelegate ? false : true;
}

toggleWebNNButton.addEventListener('click', toggleWebNN);
toggleWebNN();
document.body.appendChild(toggleWebNNButton);
document.body.appendChild(divElem);

इस कोड में एक div एलिमेंट भी जोड़ा गया है. इसका इस्तेमाल अगले सेक्शन में WebNN की सेटिंग कॉन्फ़िगर करने के लिए किया जाता है.

WebNN डिवाइसों के बीच स्विच करने के लिए, ड्रॉपडाउन जोड़ना

WebNN, सीपीयू और जीपीयू पर काम करता है. इसलिए, इनके बीच स्विच करने के लिए ड्रॉपडाउन जोड़ें. बटन बनाने वाले कोड के बाद, यह कोड जोड़ें:

// Create elements for WebNN device selection
divElem.innerHTML = '<br/>WebNN Device: ';
const selectElem = document.createElement('select');
divElem.appendChild(selectElem);

const webnnDevices = ['Default', 'GPU', 'CPU'];
// append the options
for (let i = 0; i < webnnDevices.length; i++) {
  var optionElem = document.createElement('option');
  optionElem.value = i;
  optionElem.text = webnnDevices[i];
  selectElem.appendChild(optionElem);
}

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

ड्रॉपडाउन से डिवाइस बदलना

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

ड्रॉपडाउन जोड़ने वाले कोड के बाद, यह कोड जोड़ें:

selectElem.addEventListener('change', async () => {
  let webnnDevice;
  switch(selectElem.value) {
    case '1':
      webnnDevice = WebNNDevice.GPU;
      break;
    case '2':
      webnnDevice = WebNNDevice.CPU;
      break;
    default:
      webnnDevice = WebNNDevice.DEFAULT;
      break;
  }
  webnnModel = await loadTFLiteModel(modelPath, {
    delegates: [new WebNNDelegate({webnnDevice})],
  });
});

इस बदलाव के बाद, ड्रॉपडाउन को बदलने पर, हर बार सही सेटिंग वाला नया मॉडल बन जाता है. अब WebNN मॉडल को हुक अप करने और अनुमान लगाने के लिए इसका इस्तेमाल करने का समय है.

WebNN मॉडल को चलाना

WebNN मॉडल इस्तेमाल करने के लिए तैयार है. हालांकि, WebNN और TfLite CPU के बीच स्विच करने वाला बटन, अब तक मॉडल को स्विच नहीं करता है. मॉडल बदलने के लिए, आपको सबसे पहले model वैरिएबल का नाम बदलना होगा. यह वैरिएबल, कोडलैब के पहले सेक्शन में TfLite CPU मॉडल लोड करते समय इस्तेमाल किया गया था.

इस लाइन को बदलें...

const model = await loadTFLiteModel(modelPath);

...ताकि यह लाइन से मेल खाए.

const cpuModel = await loadTFLiteModel(modelPath);

model वैरिएबल का नाम बदलकर cpuModel कर दिया गया है. बटन की स्थिति के आधार पर सही मॉडल चुनने के लिए, इसे run फ़ंक्शन में जोड़ें:

CODELAB का दूसरा हिस्सा: देखें कि यहां डेलिगेट का इस्तेमाल करना है या नहीं.

let model;
if (useWebNNDelegate) {
  model = webnnModel;
} else {
  model = cpuModel;
}

अब ऐप्लिकेशन चलाने पर, बटन TfLite CPU और WebNN के बीच स्विच करता है.

अगर आपके पास इंटिग्रेटेड Intel GPU है, तो WebNN CPU और GPU इन्फ़रेंस के बीच स्विच भी किया जा सकता है.

परफ़ॉर्मेंस के बारे में जानकारी

आपको दिखने वाली फ़्रेम रेट में प्रीप्रोसेसिंग और पोस्टप्रोसेसिंग शामिल होती है. इसलिए, यह नहीं कहा जा सकता कि WebNN क्या कर सकता है. परफ़ॉर्मेंस के बारे में बेहतर तरीके से जानने के लिए, एफपीएस मीटर पर तब तक क्लिक करें, जब तक वह मिलीसेकंड में लेटेन्सी न दिखाने लगे. यह सिर्फ़ model.predict को कॉल करने की प्रोसेस को मेज़र करता है. हालांकि, इसमें अब भी टेंसर को TFLite के नेटिव C बाइंडिंग में ले जाने में लगने वाला समय शामिल है. इसलिए, यह पूरी तरह से सटीक मेज़रमेंट नहीं है.

7. बधाई हो

बधाई हो! आपने Electron में tfjs-tflite-node का इस्तेमाल करके, अपना पहला Coral / WebNN प्रोजेक्ट पूरा कर लिया है.

इसे आज़माएं और अलग-अलग तरह की इमेज पर टेस्ट करें. TeachableMachine पर, किसी बिलकुल अलग चीज़ को क्लासिफ़ाई करने के लिए, एक नया मॉडल भी ट्रेन किया जा सकता है.

रीकैप

इस कोडलैब में, आपने इनके बारे में सीखा:

• Node.js में TFLite मॉडल चलाने के लिए, tfjs-tflite-node npm पैकेज को इंस्टॉल और सेट अप करने का तरीका.
• Coral डिवाइस पर मॉडल चलाने के लिए, Edge TPU रनटाइम लाइब्रेरी को इंस्टॉल करने का तरीका.
• Coral Edge TPU का इस्तेमाल करके, मॉडल इन्फ़रेंस को तेज़ करने का तरीका.
• WebNN की मदद से, मॉडल इन्फ़रेंस की प्रोसेस को तेज़ करने का तरीका.

आगे क्या करना है?

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

अगर आपको इस बारे में ज़्यादा जानना है कि TeachableMachine ने आपके इस्तेमाल किए गए मॉडल को कैसे ट्रेन किया, तो ट्रांसफ़र लर्निंग के बारे में हमारा कोडलैब देखें. अगर आपको Coral के साथ काम करने वाले अन्य मॉडल चाहिए, जैसे कि स्पीच रिकग्निशन और पोज़ का अनुमान लगाने वाला मॉडल, तो coral.ai/models पर जाएं. आपको इन मॉडल के सीपीयू वर्शन और कई अन्य मॉडल, TensorFlow Hub पर भी मिल सकते हैं.

हमारे साथ अपनी बनाई गई चीज़ें शेयर करना

आज आपने जो भी बनाया है उसे अन्य क्रिएटिव कामों के लिए भी आसानी से इस्तेमाल किया जा सकता है. हमारा सुझाव है कि आप कुछ नया और अलग सोचें और हैकिंग जारी रखें.

हमें सोशल मीडिया पर टैग करना न भूलें. इसके लिए, #MadeWithTFJS हैशटैग का इस्तेमाल करें. इससे आपके प्रोजेक्ट को हमारे TensorFlow ब्लॉग या आने वाले इवेंट में शामिल किया जा सकता है. हमें आपके बनाए गए कॉन्टेंट को देखने में खुशी होगी.

एक्सप्लोर करने के लिए वेबसाइटें

• TensorFlow.js की आधिकारिक वेबसाइट
• TensorFlow.js के पहले से बने मॉडल
• TensorFlow.js API
• TensorFlow.js Show & Tell