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

1. परिचय

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

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

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

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

आपको क्या बनाना होगा

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

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

आपको इनके बारे में जानकारी मिलेगी

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

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

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

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

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

2. सेट अप करें

कोड पाएं

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

इसका सुझाव दिया जाता है: Raspberry Pi के रेपो का क्लोन बनाने के लिए Git का इस्तेमाल करें

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

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 नाम की सबडायरेक्ट्री मिलेंगी. इस कोडलैब के चरणों के लिए, ये चेकपॉइंट हैं.

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

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

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

Linux / Raspberry Pi में

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

Google का कोरल पीपीए जोड़ने के लिए, इस निर्देश को चलाएं और Edge TPU रनटाइम लाइब्रेरी इंस्टॉल करें.

# 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 रनटाइम इंस्टॉल हो जाने के बाद, इंस्टॉलर से जुड़े नए कोरल Udev नियम को चालू करने के लिए, डिवाइस को रीस्टार्ट करें.

पुष्टि करें कि आपके कोरल डिवाइस का पता चल गया है

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

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 मौजूद है, तो इसका मतलब है कि आपके कोरल डिवाइस का पता नहीं चला. पक्का करें कि आपने एज TPU रनटाइम लाइब्रेरी इंस्टॉल की है और अपने कंप्यूटर में कोरल डिवाइस को प्लग-इन किया है. कोरल बाइंडिंग के Python वर्शन को टेस्ट करने के लिए, कोरल की शुरुआती गाइड पढ़ें. अगर Python वर्शन काम करता है, लेकिन फिर भी ये टेस्ट सफल नहीं होते, तो कृपया गड़बड़ी की रिपोर्ट दर्ज करके हमें बताएं.

स्टार्टर कोड चलाएं

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

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

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

शुरुआत करने के लिए हम क्या करना चाहते हैं?

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

स्टार्टर कोड के बारे में जानें

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

डीबगर खोलें

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

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

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

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

क्लासिफ़ायर को ट्रेनिंग दें

इमेज की कैटगरी तय करने वाला टूल, इमेज इनपुट करके उन्हें लेबल असाइन करता है. इस कोडलैब के लिए, अपने ब्राउज़र में किसी मॉडल को ट्रेनिंग देने के लिए, 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 नाम की फ़ाइल डाउनलोड हो जाती है, जो कोरल एज 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 के सबसे ऊपर मौजूद ऐप्लिकेशन में जोड़ें:

CODELAB का पहला हिस्सा: 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');

मॉडल चलाना

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

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

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

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

CODELAB का पहला हिस्सा: यहां tf.data.webcam सेट अप करें.

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

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

CODELAB का पहला चरण: यहां वेबकैम फ़्रेम कैप्चर करें.

const image = await tensorCam.capture();

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

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

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 फ़ंक्शन का इस्तेमाल करें.

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

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

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 FPS (फ़्रेम प्रति सेकंड) दिखेगा, जो शायद कुछ ऐप्लिकेशन के लिए तेज़ी से काम न करे. तेज़ मशीन का इस्तेमाल किए बिना बेहतर परफ़ॉर्मेंस पाने के लिए, अलग-अलग ऐप्लिकेशन के हिसाब से बने सिलिकॉन का इस्तेमाल किया जा सकता है. यह सिलिकॉन कोरल एज टीपीयू के रूप में होता है.

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

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

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

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

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

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

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

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

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

npm install --save coral-tflite-delegate

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

CODELAB का दूसरा हिस्सा: डेलिगेट का ऐक्सेस यहां से इंपोर्ट करें.

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

मॉडल लोड करना

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

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

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

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

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

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

इस कोड के साथ बटन जोड़ें:

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 के गलत होने पर, इसे सीपीयू वर्शन पर काम करना चाहिए. अगर ऐसा नहीं है, तो यह कोरल वर्शन चलाता है, लेकिन फ़िलहाल यह कुछ नहीं करेगा. कोड को किसी if स्टेटमेंट में सीपीयू मॉडल से रैप करें. ध्यान दें कि expanded टेंसर को if स्टेटमेंट से बाहर रखा जाता है, क्योंकि कोरल मॉडल इसका इस्तेमाल करता है.

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

// 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);
}

मॉडल चलाना

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

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

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 की मदद से फिर से चलाएं. ऐसा करने पर, कोरल ऐक्सेलरेटर की मदद से, अलग-अलग कैटगरी दिखनी चाहिए.

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

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

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

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

कोरल की प्रीप्रोसेसिंग को तेज़ करना

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

tf.setBackend(‘cpu');

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

6. WebNN की मदद से, सीपीयू मॉडल की रफ़्तार बढ़ाएं

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

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

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

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

यह पुष्टि करना कि WebNN डेलिगेट काम कर रहा है

यह पुष्टि करने के लिए कि 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

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

WebNN डेलिगेट को इंस्टॉल करना

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

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

npm install --save webnn-tflite-delegate

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

CODELAB का दूसरा हिस्सा: डेलिगेट का ऐक्सेस यहां से इंपोर्ट करें.

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

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

मॉडल लोड करना

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

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

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

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

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

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

इस कोड के साथ बटन जोड़ें (ध्यान दें कि यह अभी मॉडल में स्विच नहीं करेगा):

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

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

const model = await loadTFLiteModel(modelPath);

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

const cpuModel = await loadTFLiteModel(modelPath);

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

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

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

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

अगर आपके पास इंटिग्रेट किया गया Intel जीपीयू है, तो WebNN सीपीयू और जीपीयू के अनुमान के बीच भी स्विच किया जा सकता है.

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

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

7. बधाई हो

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

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

रीकैप

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

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

आगे क्या होगा?

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

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

आप जो भी बनाते हैं उसे हमारे साथ शेयर करें

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

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

इन वेबसाइटों पर पैसे चुकाएं

• TensorFlow.js की आधिकारिक वेबसाइट
• TensorFlow.js के पहले से बने मॉडल
• TensorFlow.js एपीआई
• TensorFlow.js शो और बताएं