1. परिचय
आपने TensorFlow.js का इस्तेमाल शुरू कर लिया है, हमारे पहले से बने मॉडल आज़माए हैं, या अपने खुद के मॉडल बनाए हैं - लेकिन आपने देखा कि Python में कुछ बेहतरीन रिसर्च सामने आई हैं और क्या आपको यह जानना है कि क्या यह वेब ब्राउज़र में चलेगा और उस बेहतरीन आइडिया को हकीकत में बदल देगा. क्या आपको इसके बारे में जानकारी है? अगर हां, तो यह आपके लिए CodeLab है!
TensorFlow.js की टीम ने कमांड लाइन कन्वर्टर के ज़रिए SavedModel फ़ॉर्मैट में मौजूद मॉडल को TensorFlow.js में बदलने के लिए एक सुविधाजनक टूल बनाया है. इससे आपको वेब की पहुंच और स्केल के साथ ऐसे मॉडल के इस्तेमाल का मज़ा लेने में मदद मिलेगी.
आपको इनके बारे में जानकारी मिलेगी
इस कोड लैब में, आपको TensorFlow.js कमांड लाइन कन्वर्टर को इस्तेमाल करने का तरीका बताया गया है. इसकी मदद से, Python से जनरेट किए गए सेव किए गए मॉडल को मॉडल.json फ़ॉर्मैट में पोर्ट करने के लिए इसका इस्तेमाल किया जा सकता है. यह फ़ॉर्मैट, वेब ब्राउज़र में क्लाइंट-साइड पर एक्ज़ीक्यूशन करने के लिए ज़रूरी होता है.
खास तौर पर:
- आसान Python ML मॉडल बनाने और उसे TensorFlow.js कन्वर्टर के लिए ज़रूरी फ़ॉर्मैट में सेव करने का तरीका जानें.
- Python से एक्सपोर्ट किए गए SafeModel पर, TensorFlow.js कन्वर्टर को इंस्टॉल और इस्तेमाल करने का तरीका.
- कन्वर्ज़न से बनने वाली फ़ाइल लें और उसे अपने JS वेब ऐप्लिकेशन में इस्तेमाल करें.
- जानें कि कुछ गलत होने पर क्या करें (सभी मॉडल में बदलाव नहीं होगा) और आपके पास कौन-कौनसे विकल्प हैं.
मान लें कि आप रिलीज़ की गई कुछ नई रिसर्च कर सकते हैं और उस मॉडल को दुनिया भर के लाखों JS डेवलपर को उपलब्ध करा सकते हैं. या हो सकता है कि आप इसका इस्तेमाल खुद अपने क्रिएशन में करें, अगर यह वेब ब्राउज़र पर चलता है, तो इसे दुनिया का कोई भी व्यक्ति अनुभव कर सकता है. ऐसा इसलिए, क्योंकि इसके लिए किसी जटिल निर्भरता या एनवायरमेंट सेटअप की ज़रूरत नहीं पड़ती. क्या आप हैकिंग के लिए तैयार हैं? चलिए शुरू करते हैं!
आपने जो ग्राहक बदले हैं उन्हें हमारे साथ शेयर करें!
आज से मिली जानकारी का इस्तेमाल करके, अपने कुछ पसंदीदा मॉडल को Python से आज़माया जा सकता है. अगर आपके पास इस मॉडल की डेमो वेबसाइट है, जो काम कर रही है, तो #MadeWithTFJS हैशटैग का इस्तेमाल करके, हमें सोशल मीडिया पर टैग करें. इससे आपको हमारे TensorFlow ब्लॉग या आने वाले समय में, आने वाले समय में इवेंट के बारे में जानकारी देने या अपने प्रोजेक्ट को दिखाने का मौका मिल सकता है. हम चाहते हैं कि इस शानदार उदाहरण की तरह ही, शानदार रिसर्च को वेब पर पोर्ट किया जाए. साथ ही, हम चाहते हैं कि ज़्यादा से ज़्यादा लोग इन मॉडल को नए या क्रिएटिव तरीके से इस्तेमाल कर पाएं.
2. TensorFlow.js क्या है?
TensorFlow.js एक ओपन सोर्स मशीन लर्निंग लाइब्रेरी है जो JavaScript की किसी भी जगह पर काम कर सकती है. यह ऐप्लिकेशन, Python में लिखी गई TensorFlow लाइब्रेरी पर आधारित है. इसका मकसद, डेवलपर अनुभव को फिर से तैयार करना और JavaScript नेटवर्क के लिए एपीआई के सेट को फिर से तैयार करना है.
इसका इस्तेमाल कहां किया जा सकता है?
JavaScript की पोर्टेबिलिटी की वजह से, अब एक भाषा में लिखा जा सकता है और इन सभी प्लैटफ़ॉर्म पर मशीन लर्निंग का इस्तेमाल आसानी से किया जा सकता है:
- वैनिला JavaScript का इस्तेमाल करके वेब ब्राउज़र में क्लाइंट साइड
- Node.js का इस्तेमाल करके सर्वर साइड और यहां तक कि Raspberry Pi जैसे IoT डिवाइस भी
- Electronicn का इस्तेमाल करके डेस्कटॉप ऐप्लिकेशन
- React Native का इस्तेमाल करने वाले नेटिव मोबाइल ऐप्लिकेशन
TensorFlow.js इनमें से हर एक एनवायरमेंट में एक से ज़्यादा बैकएंड के साथ काम करता है. उदाहरण के लिए, यह हार्डवेयर पर आधारित असल एनवायरमेंट है जिन्हें यह सीपीयू या WebGL में एक्ज़ीक्यूट कर सकता है. एक "बैकएंड" का मतलब सर्वर साइड एनवायरमेंट नहीं है - उदाहरण के लिए, WebGL में एक्ज़ीक्यूट करने के लिए बैकएंड क्लाइंट साइड हो सकता है.) फ़िलहाल, TensorFlow.js इनके साथ काम करता है:
- डिवाइस के ग्राफ़िक्स कार्ड पर WebGL एक्ज़ीक्यूशन (जीपीयू) - यह जीपीयू ऐक्सेलरेशन के साथ बड़े मॉडल (3 एमबी से ज़्यादा साइज़ वाले) को एक्ज़ीक्यूट करने का सबसे तेज़ तरीका है.
- सीपीयू पर वेब असेंबली (डब्ल्यूएएसएम) का एक्ज़ीक्यूशन - इससे पुराने जनरेशन के मोबाइल फ़ोन समेत सभी डिवाइसों पर सीपीयू की परफ़ॉर्मेंस को बेहतर बनाने में मदद मिलती है. यह उन छोटे मॉडल (3 एमबी से कम के साइज़) के लिए बेहतर है जो ग्राफ़िक्स प्रोसेसर पर कॉन्टेंट अपलोड करने के ओवरहेड की वजह से, WebGL के मुकाबले WASM वाले सीपीयू पर तेज़ी से काम कर सकते हैं.
- सीपीयू एक्ज़ीक्यूशन - फ़ॉलबैक के लिए कोई भी अन्य एनवायरमेंट उपलब्ध नहीं होना चाहिए. यह तीनों में से सबसे धीमा है, लेकिन आपकी मदद के लिए हमेशा मौजूद है.
ध्यान दें: अगर आपको पता है कि आपको किस डिवाइस पर बैकएंड को लागू करना है, तो इनमें से किसी एक बैकएंड को लागू करने का विकल्प चुनें. अगर आपको यह जानकारी नहीं देनी है, तो TensorFlow.js को यह तय करने की अनुमति दी जा सकती है.
क्लाइंट साइड सुपर पावर
क्लाइंट मशीन पर वेब ब्राउज़र में TensorFlow.js चलाने से कई फ़ायदे मिल सकते हैं, जिन पर गौर किया जा सकता है.
निजता
किसी तीसरे पक्ष के वेब सर्वर को डेटा भेजे बिना भी, क्लाइंट मशीन पर डेटा को ट्रेनिंग दी जा सकती है और उसे कैटगरी में बांटा जा सकता है. कई बार ऐसा भी हो सकता है कि जीडीपीआर जैसे स्थानीय कानूनों का पालन करने के लिए इसकी ज़रूरत पड़े. इसके अलावा, ऐसा कोई भी डेटा प्रोसेस करते समय हो सकता है जिसे उपयोगकर्ता अपनी मशीन पर रखना चाहे और किसी तीसरे पक्ष को न भेजना चाहे.
स्पीड
ऐसा इसलिए, क्योंकि डेटा को रिमोट सर्वर पर भेजने की ज़रूरत नहीं पड़ती. इसलिए, अनुमान लगाने (डेटा को कैटगरी में बांटने की प्रक्रिया) तेज़ी से हो सकता है. इससे भी बेहतर यह है कि अगर उपयोगकर्ता आपको ऐक्सेस दें, तो आपको डिवाइस के सेंसर जैसे कैमरा, माइक्रोफ़ोन, GPS, एक्सलरोमीटर वगैरह का सीधा ऐक्सेस मिलता है.
पहुंच और स्केल
एक क्लिक से दुनिया में कोई भी व्यक्ति आपके द्वारा भेजे गए लिंक पर क्लिक कर सकता है, अपने ब्राउज़र में वेब पृष्ठ खोल सकता है और आपने जो कुछ भी बनाया है उसका उपयोग कर सकता है. CUDA ड्राइवर के साथ एक जटिल सर्वर साइड Linux सेटअप की कोई ज़रूरत नहीं है और सिर्फ़ मशीन लर्निंग सिस्टम का इस्तेमाल करने के लिए बहुत कुछ है.
लागत
किसी सर्वर का मतलब नहीं है. आपके एचटीएमएल, सीएसएस, JS, और मॉडल फ़ाइलों को होस्ट करने के लिए, आपको सिर्फ़ सीडीएन के लिए पेमेंट करना होगा. सीडीएन की कीमत, किसी सर्वर (जिसमें ग्राफ़िक कार्ड जुड़ा हो) को 24/7 चालू रखने की तुलना में काफ़ी कम है.
सर्वर साइड की सुविधाएं
TensorFlow.js के Node.js को इस्तेमाल करने से ये सुविधाएं चालू होती हैं.
CUDA की पूरी सहायता
ग्राफ़िक्स कार्ड से तेज़ी लाने के लिए, सर्वर साइड पर आपको NVIDIA CUDA ड्राइवर इंस्टॉल करने होंगे, ताकि TensorFlow, ग्राफ़िक्स कार्ड के साथ काम कर सके (WebGL का इस्तेमाल करने वाले ब्राउज़र के उलट - किसी इंस्टॉल की ज़रूरत नहीं होती). हालांकि, CUDA की पूरी क्षमता की मदद से, ग्राफ़िक्स कार्ड के निचले लेवल की क्षमताओं का पूरा फ़ायदा लिया जा सकता है. इससे ट्रेनिंग और अनुमान लगाने में कम समय लगता है. परफ़ॉर्मेंस और Python TensorFlow की परफ़ॉर्मेंस, दोनों एक जैसी C++ बैकएंड पर काम करती हैं.
मॉडल साइज़
रिसर्च पर आधारित आधुनिक मॉडल के लिए, हो सकता है कि आप बहुत बड़े मॉडल के साथ काम कर रहे हों, यानी जिनका साइज़ गीगाबाइट (जीबी) हो. प्रति ब्राउज़र टैब मेमोरी उपयोग की सीमाओं की वजह से इन मॉडल को वर्तमान में वेब ब्राउज़र में नहीं चलाया जा सकता. इन बड़े मॉडल को चलाने के लिए, Node.js को अपने सर्वर पर इस्तेमाल किया जा सकता है. इसके लिए, आपको हार्डवेयर की खास बातों का पालन करना होगा, ताकि इस तरह के मॉडल को बेहतर तरीके से चलाया जा सके.
आईओटी
Node.js की सुविधा Raspberry Pi जैसे मशहूर सिंगल बोर्ड कंप्यूटर पर काम करती है. इसका मतलब है कि ऐसे डिवाइसों पर भी TensorFlow.js मॉडल चलाए जा सकते हैं.
स्पीड
Node.js को JavaScript में लिखा जाता है. इसका मतलब है कि समय के साथ कंपाइलेशन काफ़ी काम का होता है. इसका मतलब है कि Node.js का इस्तेमाल करने पर आपको अक्सर परफ़ॉर्मेंस में सुधार दिख सकता है, क्योंकि इसे रनटाइम के दौरान ऑप्टिमाइज़ किया जाएगा. खास तौर पर, प्री-प्रोसेसिंग के दौरान ऐसा किया जा सकता है. इसका एक अच्छा उदाहरण इस केस स्टडी में देखा जा सकता है. इसमें दिखाया गया है कि हगिंग फ़ेस ने Node.js का इस्तेमाल करके, नैचुरल लैंग्वेज प्रोसेसिंग मॉडल की परफ़ॉर्मेंस को दोगुना कर दिया है.
अब आपको TensorFlow.js की बुनियादी बातों और इसके कुछ फ़ायदों के बारे में पता है. चलिए, अब इसकी मदद से काम की चीज़ें करना शुरू करते हैं!
3. आपका सिस्टम सेट अप किया जा रहा है
इस ट्यूटोरियल के लिए हम Ubuntu - एक लोकप्रिय Linux डिस्ट्रिब्यूशन का इस्तेमाल करेंगे जिसका इस्तेमाल कई लोग करते हैं. साथ ही, अगर आप क्लाउड आधारित वर्चुअल मशीन पर फ़ॉलो करना चुनते हैं, तो यह Google Cloud Compute Engine पर बेस इमेज के रूप में उपलब्ध है.
लिखने के समय हम नया वेनिला कंप्यूट इंजन इंस्टेंस बनाते समय Ubuntu 18.04.4 LTS की इमेज चुन सकते हैं. हम इसी का इस्तेमाल करेंगे. आप अपनी मशीन का या किसी अन्य ऑपरेटिंग सिस्टम का इस्तेमाल कर सकते हैं. हालांकि, इंस्टॉल करने के निर्देश और डिपेंडेंसी, अलग-अलग सिस्टम के हिसाब से अलग-अलग हो सकती हैं.
TensorFlow (Python का वर्शन) इंस्टॉल करना
अब जब आप Python पर आधारित किसी मौजूदा मॉडल को बदलने की कोशिश कर रहे हों, तो हम "SavedModel" एक्सपोर्ट करने से पहले ऐसा कर सकते हैं जो आपको मिल गया है / या लिखेंगे Python फ़ाइल अपलोड करते हैं, तो आपको अपने इंस्टेंस पर TensorFlow का Python वर्शन सेटअप करना होगा, अगर "SavedModel" डाउनलोड करने के लिए पहले से उपलब्ध नहीं है.
आपने ऊपर जो क्लाउड मशीन में एसएसएच का इस्तेमाल किया है उसमें एसएसएच जोड़ें. इसके बाद, टर्मिनल विंडो में यह टाइप करें:
टर्मिनल विंडो:
sudo apt update
sudo apt-get install python3
इससे यह पक्का होगा कि हमारे मशीन पर Python 3 इंस्टॉल हो चुका है. TensorFlow का इस्तेमाल करने के लिए, Python 3.4 या उसके बाद का वर्शन इंस्टॉल करना ज़रूरी है.
यह पुष्टि करने के लिए कि सही वर्शन इंस्टॉल किया गया है, निम्न लिखें:
टर्मिनल विंडो:
python3 --version
आपको वर्शन नंबर दिखाने वाले कुछ आउटपुट दिखेंगे, जैसे कि Python 3.6.9. अगर आपको यह सही तरह से प्रिंट हुआ दिखता है और यह 3.4 से ज़्यादा है, तो हम जारी रखने के लिए तैयार हैं.
इसके बाद, हम Python 3 के लिए PIP इंस्टॉल करेंगे, जो कि Python का पैकेज मैनेजर है और फिर उसे अपडेट करेंगे. प्रकार:
टर्मिनल विंडो:
sudo apt install python3-pip
pip3 install --upgrade pip
हम pip3 को इंस्टॉल करने की पुष्टि फिर से कर सकते हैं. इसके लिए, ये तरीके अपनाएं:
टर्मिनल विंडो:
pip3 --version
लिखते समय, हमें दिखता है कि इस निर्देश को लागू करने के बाद, टर्मिनल पर pip 20.2.3 प्रिंट किया गया है.
TensorFlow इंस्टॉल करने से पहले, इसके लिए Python पैकेज "setuptools" की ज़रूरत होती है वर्शन 41.0.0 या इसके बाद वाला वर्शन होना चाहिए. यह पक्का करने के लिए कि इसे सबसे नए वर्शन में अपडेट कर दिया गया है, इस निर्देश को चलाएं:
टर्मिनल विंडो:
pip3 install -U setuptools
आखिर में, अब हम Python के लिए TensorFlow इंस्टॉल कर सकते हैं:
टर्मिनल विंडो:
pip3 install tensorflow
इस प्रोसेस को पूरा होने में कुछ समय लग सकता है. इसलिए, कृपया इसके पूरा होने तक इंतज़ार करें.
आइए, देखते हैं कि TensorFlow ठीक से इंस्टॉल हुआ है. अपनी मौजूदा डायरेक्ट्री में test.py नाम की Python फ़ाइल बनाएं:
टर्मिनल विंडो:
nano test.py
नैनो के खुलने के बाद, हम इंस्टॉल किए गए TensorFlow के वर्शन को प्रिंट करने के लिए कुछ Python कोड लिख सकते हैं:
test.py:
import tensorflow as tf
print(tf.__version__)
डिस्क में बदलाव लिखने के लिए CTRL + O दबाएं और नैनो एडिटर से बाहर निकलने के लिए CTRL + X दबाएं.
अब हम इस Python फ़ाइल को चलाकर, स्क्रीन पर प्रिंट किए गए TensorFlow के वर्शन को देख सकते हैं:
टर्मिनल विंडो:
python3 test.py
लिखते समय हमें पता चलता है कि TensorFlow Python के हमारे वर्शन के लिए, कंसोल में 2.3.1 प्रिंट किया गया है.
4. Python मॉडल बनाना
इस कोडलैब के अगले चरण में, एक आसान Python मॉडल बनाया जाएगा. इससे यह पता चलेगा कि ट्रेन किए गए इस मॉडल को "SavedModel" में कैसे सेव किया जा सकता है फ़ॉर्मैट का इस्तेमाल करें. जिस Python मॉडल को बदलने की कोशिश की जा रही थी उसके लिए यह सिद्धांत काफ़ी मिलता-जुलता होगा. हालांकि, हम इस कोड को आसान रखेंगे, ताकि सभी लोग इसे समझ सकें.
पहले सेक्शन में बनाई गई उसकी test.py फ़ाइल में बदलाव करके कोड को यहां दिए गए तरीके से अपडेट करते हैं:
test.py:
import tensorflow as tf
print(tf.__version__)
# Import NumPy - package for working with arrays in Python.
import numpy as np
# Import useful keras functions - this is similar to the
# TensorFlow.js Layers API functionality.
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
# Create a new dense layer with 1 unit, and input shape of [1].
layer0 = Dense(units=1, input_shape=[1])
model = Sequential([layer0])
# Compile the model using stochastic gradient descent as optimiser
# and the mean squared error loss function.
model.compile(optimizer='sgd', loss='mean_absolute_error')
# Provide some training data! Here we are using some fictional data
# for house square footage and house price (which is simply 1000x the
# square footage) which our model must learn for itself.
xs = np.array([800.0, 850.0, 900.0, 950.0, 980.0, 1000.0, 1050.0, 1075.0, 1100.0, 1150.0, 1200.0, 1250.0, 1300.0, 1400.0, 1500.0, 1600.0, 1700.0, 1800.0, 1900.0, 2000.0], dtype=float)
ys = np.array([800000.0, 850000.0, 900000.0, 950000.0, 980000.0, 1000000.0, 1050000.0, 1075000.0, 1100000.0, 1150000.0, 1200000.0, 1250000.0, 1300000.0, 1400000.0, 1500000.0, 1600000.0, 1700000.0, 1800000.0, 1900000.0, 2000000.0], dtype=float)
# Train the model for 500 epochs.
model.fit(xs, ys, epochs=500, verbose=0)
# Test the trained model on a test input value
print(model.predict([1200.0]))
# Save the model we just trained to the "SavedModel" format to the
# same directory our test.py file is located.
tf.saved_model.save(model, './')
यह कोड, एक बहुत आसान लीनियर रिग्रेशन को ट्रेन करेगा, ताकि हमारे दिए गए x (इनपुट) और y y (आउटपुट) के बीच के संबंध का अनुमान लगाया जा सके. इसके बाद, हम ट्रेन किए गए मॉडल को डिस्क में सेव करेंगे. हर लाइन क्या काम करती है, इस बारे में ज़्यादा जानकारी के लिए इनलाइन टिप्पणियां देखें.
इस प्रोग्राम को चलाने के बाद (python3 test.py को कॉल करके) अगर हम हमारी डायरेक्ट्री देखते हैं, तो अब हमें अपनी मौजूदा डायरेक्ट्री में बनाई गई कुछ नई फ़ाइलें और फ़ोल्डर दिखेंगे:
- test.py
- saved_model.pb
- एसेट
- वैरिएबल
अब हमने वे फ़ाइलें जनरेट कर ली हैं जिनका इस्तेमाल TensorFlow.js कन्वर्टर करता है, ताकि इस मॉडल को ब्राउज़र में चलाया जा सके!
5. सेव किए गए मॉडल को TensorFlow.js फ़ॉर्मैट में बदलना
TensorFlow.js कन्वर्टर इंस्टॉल करें
कन्वर्टर को इंस्टॉल करने के लिए, नीचे दिया गया कमांड चलाएं:
टर्मिनल विंडो:
pip3 install tensorflowjs
यह आसान था.
यह मानते हुए कि हम कमांड लाइन कन्वर्टर (tensorflowjs_converter) का इस्तेमाल कर रहे थे न कि ऊपर दिखाए गए विज़र्ड वर्शन का, हम अभी-अभी बनाए गए सेव किए गए मॉडल को बदलने के लिए नीचे दिए गए कमांड को कॉल कर सकते हैं और कन्वर्टर में पैरामीटर को साफ़ तौर पर पास कर सकते हैं:
टर्मिनल विंडो:
tensorflowjs_converter \
--input_format=keras_saved_model \
./ \
./predict_houses_tfjs
यहां क्या चल रहा है? पहले हम उस tensorflowjs_converter बाइनरी को कॉल कर रहे हैं जिसे हमने अभी इंस्टॉल किया है. साथ ही, हम यह भी बता रहे हैं कि हम keras के सेव किए गए मॉडल को बदलने की कोशिश कर रहे हैं.
ऊपर दिए गए उदाहरण में आपने जो कोड दिया है उसमें बताया गया है कि हमने केरास इंपोर्ट किए हैं और हमारा मॉडल बनाने के लिए, उसके हाई लेवल लेयर एपीआई का इस्तेमाल किया है. अगर आपने अपने Python कोड में केरा का इस्तेमाल नहीं किया था, तो आपको किसी दूसरे इनपुट फ़ॉर्मैट का इस्तेमाल करना चाहिए:
- keras - keras फ़ॉर्मैट (HDF5 फ़ाइल टाइप) को लोड करने के लिए होता है
- tf_saved_model - इस मॉडल को लोड करने के लिए जो keras के बजाय tensorflow कोर एपीआई का इस्तेमाल करता है.
- tf_frozen_model - ऐसा मॉडल लोड करने के लिए जिसमें फ़्रीज़ किए गए वज़न हों.
- tf_hub - tensorflow Hub से जनरेट किए गए मॉडल को लोड करने के लिए.
इन दूसरे फ़ॉर्मैट के बारे में यहां ज़्यादा जानें.
अगले 2 पैरामीटर से यह तय होता है कि सेव किया गया मॉडल किस फ़ोल्डर में मौजूद है - ऊपर अपने डेमो में हम मौजूदा डायरेक्ट्री बताते हैं. इसके बाद, आखिर में हम यह बताते हैं कि कन्वर्ज़न किस डायरेक्ट्री में मिलेगा. इसे ऊपर "predict_houses_tfjs" नाम के फ़ोल्डर के तौर पर बताया जाता है मौजूदा डायरेक्ट्री में जाएं.
ऊपर दिए गए निर्देश को चलाने से, मौजूदा डायरेक्ट्री में predict_houses_tfjs नाम का एक नया फ़ोल्डर बन जाता है, जिसमें : शामिल होता है
- model.json
- ग्रुप1-शर्ड1of1.bin
ये वे फ़ाइलें हैं जिनकी हमें इस मॉडल को वेब ब्राउज़र में चलाने के लिए ज़रूरत होती है. इन फ़ाइलों को सेव कर लें, क्योंकि हम अगले सेक्शन में इनका इस्तेमाल करेंगे.
6. ब्राउज़र में हमारे रूपांतरित मॉडल का उपयोग करना
कन्वर्ट की गई फ़ाइलों को होस्ट करना
सबसे पहले हमें वेब सर्वर पर जनरेट किए गए अपने model.json और अपनी *.bin फ़ाइलों को सेव करना होगा, ताकि हम उन्हें अपने वेब पेज से ऐक्सेस कर सकें. इस डेमो के लिए हम Glitch.com का इस्तेमाल करेंगे, ताकि आपको इसे समझने में आसानी हो. हालांकि, अगर आप किसी वेब इंजीनियरिंग बैकग्राउंड से हैं, तो आप ऐसा करने के लिए अपने मौजूदा Ubuntu सर्वर के इंस्टेंस पर एक सामान्य एचटीटीपी सर्वर चालू कर सकते है. यह आपकी पसंद है.
glitch पर फ़ाइलें अपलोड करना
- Glitch.com में साइन इन करें
- हमारे boilerplate TensorFlow.js प्रोजेक्ट का क्लोन बनाने के लिए, इस लिंक का इस्तेमाल करें. इसमें html, css, और js फ़ाइलें शामिल होती हैं, जो TensorFlow.js लाइब्रेरी को हमारे इस्तेमाल के लिए तैयार करती हैं.
- "ऐसेट" पर क्लिक करें फ़ोल्डर खोलें.
- "कोई ऐसेट अपलोड करें" पर क्लिक करें इस फ़ोल्डर में अपलोड करने के लिए,
group1-shard1of1.binको चुनें. अपलोड हो जाने के बाद, यह इस तरह दिखना चाहिए:
- आपने अभी-अभी जो
group1-shard1of1.binफ़ाइल अपलोड की है उस पर क्लिक करने से, यूआरएल उसकी जगह पर कॉपी हो जाएगा. इस पाथ को अभी कॉपी करें, जैसा कि दिखाया गया है:
- अब अपनी लोकल मशीन पर अपने पसंदीदा टेक्स्ट एडिटर का इस्तेमाल करके
model.jsonमें बदलाव करें. साथ ही,group1-shard1of1.binफ़ाइल के लिए (CTRL+F का इस्तेमाल करके) खोजें, जिसके बारे में उसमें कहीं पर बताया जाएगा.
इस फ़ाइल नाम की जगह, पांचवें चरण से कॉपी किया गया यूआरएल डालें. हालांकि, पहले उस https://cdn.glitch.com/ नाम को मिटा दें जिसे कॉपी किए गए पाथ से ग्लिच जनरेट हुआ है.
बदलाव करने के बाद, यह कुछ इस तरह दिखना चाहिए (ध्यान दें कि सबसे आगे मौजूद सर्वर पाथ को कैसे हटाया गया है, ताकि सिर्फ़ अपलोड किया गया फ़ाइल नाम ही रखा जाए): 
7. अब ऐसेट पर क्लिक करके, इस बदलाव की गई model.json फ़ाइल को सेव और अपलोड करें. इसके बाद, "कोई ऐसेट अपलोड करें" पर क्लिक करें बटन (अहम) चुनें. अगर फ़िज़िकल बटन का इस्तेमाल नहीं किया जाता है और उसे खींचकर छोड़ा जाता है, तो वह सीडीएन के बजाय बदलाव की जा सकने वाली फ़ाइल के तौर पर अपलोड हो जाएगा. उस सीडीएन के फ़ोल्डर में ये फ़ाइलें नहीं होंगी. साथ ही, जब TensorFlow.js किसी मॉडल के लिए बाइनरी फ़ाइल डाउनलोड करने की कोशिश करेगा, तब संबंधित पाथ को सीडीएन के बजाय उस फ़ाइल के तौर पर अपलोड किया जाएगा. अगर आपने इसे सही तरीके से किया है, तो आपको assets फ़ोल्डर में इस तरह की दो फ़ाइलें दिखेंगी: 
बढ़िया! अब हम अपनी सेव की गई फ़ाइलों को ब्राउज़र में कुछ असल कोड के साथ इस्तेमाल करने के लिए तैयार हैं.
मॉडल लोड करना
अब जब हमने अपनी बदली गई फ़ाइलों को होस्ट कर लिया है, तो इन फ़ाइलों को लोड करने के लिए हम एक आसान वेबपेज लिख सकते हैं और कोई सुझाव देने के लिए इनका इस्तेमाल कर सकते हैं. script.js को Glitch प्रोजेक्ट फ़ोल्डर में खोलें और इस फ़ाइल का कॉन्टेंट, यहां दिए गए कॉन्टेंट से बदलें. ऐसा तब करें, जब आपने const MODEL_URL को Glitch पर अपलोड की गई model.json फ़ाइल के लिए जनरेट किए गए Glitch.com लिंक पर रीडायरेक्ट करना हो:
script.js:
// Grab a reference to our status text element on the web page.
// Initially we print out the loaded version of TFJS.
const status = document.getElementById('status');
status.innerText = 'Loaded TensorFlow.js - version: ' + tf.version.tfjs;
// Specify location of our Model.json file we uploaded to the Glitch.com CDN.
const MODEL_URL = ‘YOUR MODEL.JSON URL HERE! CHANGE THIS!';
// Specify a test value we wish to use in our prediction.
// Here we use 950, so we expect the result to be close to 950,000.
const TEST_VALUE = 950.0
// Create an asynchronous function.
async function run() {
// Load the model from the CDN.
const model = await tf.loadLayersModel(MODEL_URL);
// Print out the architecture of the loaded model.
// This is useful to see that it matches what we built in Python.
console.log(model.summary());
// Create a 1 dimensional tensor with our test value.
const input = tf.tensor1d([TEST_VALUE]);
// Actually make the prediction.
const result = model.predict(input);
// Grab the result of prediction using dataSync method
// which ensures we do this synchronously.
status.innerText = 'Input of ' + TEST_VALUE +
'sqft predicted as $' + result.dataSync()[0];
}
// Call our function to start the prediction!
run();
MODEL_URL कॉन्स्टेंट बदलने के बाद, उसे अपने model.json पाथ पर ले जाने के बाद, ऊपर दिए गए कोड को चलाने पर एक आउटपुट दिखेगा.
यदि हम वेब ब्राउज़र के कंसोल का निरीक्षण करते हैं (ब्राउज़र में डेवलपर टूल लाने के लिए F12 दबाएं), तो हम लोड किए गए मॉडल के मॉडल का विवरण भी देख सकते है जो प्रिंट करता है:
कोडलैब की शुरुआत में इसकी तुलना अपने Python कोड से करने पर, हमें पता चलता है कि यह वही नेटवर्क है जिसे हमने एक डेंस इनपुट और एक नोड वाली एक सघन लेयर के साथ बनाया है.
बधाई हो! आपने अभी-अभी वेब ब्राउज़र में, कन्वर्ट किए गए Python मॉडल को चलाया है!
7. रूपांतरित न होने वाले मॉडल
कभी-कभी, ऐसे जटिल मॉडल भी कन्वर्ज़न के लिए काम नहीं करेंगे जो आम तौर पर इस्तेमाल होने वाली कार्रवाइयों का इस्तेमाल करने के लिए कंपाइल किए जाते हैं. TensorFlow.js का ब्राउज़र आधारित वर्शन, TensorFlow का पूरी तरह से जवाब है और फ़िलहाल हम TensorFlow C++ API में मौजूद उन सभी लो लेवल ऑपरेशन का इस्तेमाल नहीं करते हैं जो अभी 1,000 सेकंड हैं. हालांकि, जैसे-जैसे हम बड़े होते जा रहे हैं और मुख्य ऑपरेशन ज़्यादा स्थिर होते जा रहे हैं.
टेक्स्ट लिखते समय, TensorFlow Python में मौजूद ऐसा ही एक फ़ंक्शन linalg.diag है. सेव किए गए मॉडल के तौर पर एक्सपोर्ट किए जाने पर, यह एक ऐसा ऑपरेट करता है जो काम नहीं करता. अगर हम किसी ऐसे savedmodel को बदलने की कोशिश करते हैं जो इसका इस्तेमाल Python में करता है (जो उससे बनने वाले ऑपरेशन के साथ काम करता है), तो हमें नीचे बताई गई गड़बड़ी के जैसी गड़बड़ी दिखेगी:
यहां लाल रंग से हाइलाइट किया गया यह देखा जा सकता है कि linalg.diag कॉल को कंपाइल करके MatrixDiagV3 नाम का एक ऑप बनाया गया. कोडलैब लिखते समय, यह वेब ब्राउज़र में TensorFlow.js पर काम नहीं करता.
क्या करें?
आपके पास दो विकल्प हैं.
- TensorFlow.js में इस अनुपलब्ध सेशन को लागू करें - यह एक ओपन सोर्स प्रोजेक्ट है और हम नए ऑपरेशन जैसी चीज़ों के लिए योगदान देने वालों का स्वागत करते हैं. TensorFlow.js के लिए नए ऑपरेशन लिखने से जुड़ी यह गाइड देखें. अगर आप ऐसा कर लेते हैं, तो आप हमारे कमांड लाइन कन्वर्टर पर
Skip_op_checkफ़्लैग का इस्तेमाल करके इस गड़बड़ी को अनदेखा कर सकते हैं और किसी भी तरह से कन्वर्ज़न को जारी रख सकते हैं (ऐसा माना जाएगा कि यह op आपके बनाए गए TensorFlow.js बिल्ड में उपलब्ध है जिसमें कोई ऑप मौज़ूद नहीं है). - यह पता लगाएं कि आपकी एक्सपोर्ट की गई
savedmodelफ़ाइल में, आपके Python कोड के किस हिस्से ने काम न करने वाली कार्रवाई की थी. कोड के छोटे सेट में, इसे ढूंढना आसान हो सकता है. हालांकि, ज़्यादा जटिल मॉडल में इसकी जांच करने की ज़रूरत पड़ सकती है, क्योंकि फ़िलहालsavedmodelफ़ाइल फ़ॉर्मैट में एक बार दिए गए सेशन को जनरेट करने वाले हाई लेवल Python फ़ंक्शन कॉल की पहचान करने का कोई तरीका नहीं है. हालांकि, पता लग जाने के बाद, इसे बदला जा सकता है और किसी दूसरे मान्य तरीके का इस्तेमाल किया जा सकता है.
8. बधाई हो
बधाई हो, आपने वेब ब्राउज़र में TensorFlow.js के ज़रिए Python मॉडल को इस्तेमाल करने का पहला चरण पूरा कर लिया है!
रीकैप
इस कोड लैब में, हमने जाना कि:
- Python पर आधारित TensorFlow इंस्टॉल करने के लिए, हमारा Linux एनवायरमेंट सेट अप करें
- Python ‘SavedModel' एक्सपोर्ट करें
- TensorFlow.js कमांड लाइन कन्वर्टर इंस्टॉल करें
- क्लाइंट साइड की ज़रूरी फ़ाइलें बनाने के लिए, TensorFlow.js कमांड लाइन कन्वर्टर का इस्तेमाल करें
- जनरेट की गई फ़ाइलों को रीयल वेब ऐप्लिकेशन में इस्तेमाल करें
- ऐसे मॉडल की पहचान करें जो कन्वर्ट नहीं होंगे और आने वाले समय में उन्हें कन्वर्ट करने की अनुमति देने के लिए क्या लागू करने की ज़रूरत होगी.
आगे क्या होगा?
#MadeWithTFJS का इस्तेमाल करके बनाई गई किसी भी चीज़ के लिए, हमें टैग करना न भूलें. इससे आपको सोशल मीडिया पर अपना कॉन्टेंट दिखाने या आने वाले समय में TensorFlow के इवेंट में दिखाने का मौका मिलेगा. हम यह देखना चाहेंगे कि आप क्या कन्वर्ट करते हैं और ब्राउज़र में क्लाइंट साइड का इस्तेमाल करना चाहेंगे!
ज़्यादा जानकारी के लिए, TensorFlow.js कोडलैब की ज़्यादा सुविधा
- TensorFlow.js में शुरुआत से न्यूरल नेटवर्क लिखना
- ऐसा स्मार्ट वेबकैम बनाना जो ऑब्जेक्ट की पहचान कर सके
- TensorFlow.js में ट्रांसफ़र लर्निंग का इस्तेमाल करके, पसंद के मुताबिक इमेज की कैटगरी तय करना