इस पेज का अनुवाद Cloud Translation API से किया गया है.

TensorFlow की मदद से, कंप्यूटर का विज़न मॉडल बनाएं

1. शुरू करने से पहले

इस कोडलैब में आप #39

ज़रूरी शर्तें

Python की पूरी जानकारी
प्रोग्रामिंग की बुनियादी जानकारी

आप क्या #39;जानेंगे

इस कोडलैब में आप: #39;ll:

कपड़ों में मौजूद लेखों की पहचान करने के लिए, न्यूरल नेटवर्क की ट्रेनिंग लें
नेटवर्क की अलग-अलग लेयर पर प्रयोग करने के लिए, कसरत की सीरीज़ पूरी करें

आप क्या बनाते हैं

कपड़ों में मौजूद लेखों की पहचान करने वाला न्यूरल नेटवर्क

आपको क्या चाहिए

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

इसके अलावा, ट्रेनिंग के लिए आप Python को मुख्य भाषा के तौर पर इस्तेमाल करते हैं, इसलिए आपको इसे इंस्टॉल करना होगा. इसके अलावा, आपको TensorFlow और NumPy लाइब्रेरी की भी ज़रूरत होगी. आप TensorFlow यहां जाकर, इसके बारे में ज़्यादा जानें और इसे इंस्टॉल करें. NumPy को यहां इंस्टॉल करें.

2. कोडिंग शुरू करें

सबसे पहले, एक्ज़ीक्यूटेबल Colab नोटबुक पर जाएं.

TensorFlow इंपोर्ट करके शुरू करें.

import tensorflow as tf
print(tf.__version__)

आप एक फ़ैशन न्यूरल नेटवर्क को ट्रेनिंग देंगे. यह नेटवर्क, फ़ैशन MNIST नाम के एक डेटासेट से, कपड़ों के सामान की पहचान करता है. इसमें, 10 अलग-अलग कैटगरी में मौजूद 70,000 कपड़ों की सूची है. कपड़ों की हर चीज़ 28x28 के ग्रेस्केल इमेज में है. यहां कुछ उदाहरण दिए गए हैं:

डेटासेट से जुड़े लेबल:

लेबल	जानकारी
0	टी-शर्ट/टॉप
1	ट्राउज़र
2	पुलओवर
3	पोशाक
4	कोट
5	सैंडल
6	कमीज़
7	जूता
8	बैग
9	टखनों के बूट

फ़ैशन MNIST डेटा, tf.keras.datasets एपीआई में उपलब्ध है. इसे इस तरह लोड करें:

mnist = tf.keras.datasets.fashion_mnist

उस ऑब्जेक्ट पर load_data को कॉल करने से आपको दो सूचियों के दो सेट मिलते हैं: ट्रेनिंग वैल्यू और टेस्टिंग वैल्यू, जो कपड़े वाले सामान और उनके लेबल दिखाने वाले ग्राफ़िक दिखाती हैं.

(training_images, training_labels), (test_images, test_labels) = mnist.load_data()

ये वैल्यू कैसी दिखती हैं? देखने के लिए, किसी ट्रेनिंग इमेज और ट्रेनिंग लेबल को प्रिंट करें. आप श्रेणी में अलग-अलग इंडेक्स के साथ प्रयोग कर सकते हैं.

import matplotlib.pyplot as plt
plt.imshow(training_images[0])
print(training_labels[0])
print(training_images[0])

0 आइटम के डेटा का प्रिंट ऐसा दिखता है:

आप देखेंगे कि सभी मान 0 और 255 के बीच के पूर्णांक हैं. न्यूरल नेटवर्क को ट्रेनिंग देते समय, सभी मानों को 0 से 1 के बीच और आसानी से इस्तेमाल किया जा सकता है. इसे सामान्य बनाना कहा जाता है. अच्छी बात यह है कि Python आपको लूप में रखे बिना, सूची को सामान्य बनाने का आसान तरीका देता है.

training_images  = training_images / 255.0
test_images = test_images / 255.0

हो सकता है कि आप इंडेक्स 0 में दिए गए बूट से अलग, 42 को भी देखना चाहें.

अब आप यह सोच रहे होंगे कि दो डेटासेट किस वजह से काम करते हैं—ट्रेनिंग और टेस्टिंग.

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

3. मॉडल डिज़ाइन करें

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

model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), 
                                    tf.keras.layers.Dense(128, activation=tf.nn.relu), 
                                    tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

Sequential न्यूरल नेटवर्क में लेयर के क्रम के बारे में बताता है.
Flatten एक वर्ग लेता है और उसे एक आयाम वाले वेक्टर में बदल देता है.
Dense, न्यूरॉन की एक लेयर जोड़ता है.
Activation फ़ंक्शन, न्यूरॉन की हर लेयर को बताता है कि क्या करना है. इसके लिए कई विकल्प मौजूद हैं, लेकिन अभी इनका इस्तेमाल करें:
Relu का मतलब है कि अगर X, 0 X से ज़्यादा है, तो 0 लौटाता है. यह नेटवर्क में अगली लेयर को सिर्फ़ 0 या उससे ज़्यादा वैल्यू देता है.
Softmax में कई वैल्यू सेट की जाती हैं और सबसे बड़ी वैल्यू चुनी जाती है. उदाहरण के लिए, अगर आखिरी लेयर का आउटपुट [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05] दिखता है, तो यह आपको सबसे बड़ी वैल्यू के लिए क्रम से लगाने से रोकता है—यह [0,0,0,0,1,0,0,0] दिखाता है.

4. मॉडल को कंपाइल करना और ट्रेनिंग देना

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

metrics= के इस्तेमाल को एक पैरामीटर के तौर पर देखें, जिससे TensorFlow ट्रेनिंग के सटीक होने की रिपोर्ट कर पाता है. इसके लिए, यह जाने-पहचाने जवाबों (लेबल) के मुताबिक अनुमानित नतीजों की जांच करता है.

model.compile(optimizer = tf.keras.optimizers.Adam(),
              loss = 'sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(training_images, training_labels, epochs=5)

model.fit के एक्ज़ीक्यूशन होने के बाद, आपको'नुकसान और सटीक दिखेगा:

Epoch 1/5
60000/60000 [=======] - 6s 101us/sample - loss: 0.4964 - acc: 0.8247
Epoch 2/5
60000/60000 [=======] - 5s 86us/sample - loss: 0.3720 - acc: 0.8656
Epoch 3/5
60000/60000 [=======] - 5s 85us/sample - loss: 0.3335 - acc: 0.8780
Epoch 4/5
60000/60000 [=======] - 6s 103us/sample - loss: 0.3134 - acc: 0.8844
Epoch 5/5
60000/60000 [=======] - 6s 94us/sample - loss: 0.2931 - acc: 0.8926

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

5. मॉडल की जांच करें

मॉडल उस डेटा पर कैसा परफ़ॉर्म करेगा जो #39 नहीं दिखा? इसलिए, आपने टेस्ट सेट सेट किया है. model.evaluate को कॉल करें और दो सेट में पास करें और यह हर सेट के नुकसान की जानकारी देता है. इसे आज़माकर देखें:

model.evaluate(test_images, test_labels)

और आउटपुट यहां है:

10000/10000 [=====] - 1s 56us/sample - loss: 0.3365 - acc: 0.8789
[0.33648381242752073, 0.8789]

उस उदाहरण ने .8789 की सटीक जानकारी दी, यानी कि यह करीब 88% सटीक थी. (आपके पास थोड़े अलग मान हो सकते हैं.)

उम्मीद के मुताबिक, यह मॉडल उतना सटीक नहीं होता जितना कि अनजान डेटा था. साथ ही, यह उस डेटा के साथ सटीक नहीं था जिस पर इसे ट्रेनिंग दी गई थी! TensorFlow के बारे में जैसे-जैसे आप जानकारी हासिल करते जाएंगे, वैसे-वैसे आपको इसे बेहतर बनाने के तरीके भी मिलते रहेंगे.

और जानकारी पाने के लिए, अगले चरण में व्यायाम करें.

6. कसरत का अभ्यास

पहला व्यायाम

इस पहली कसरत के लिए, नीचे दिया गया कोड चलाएं:

classifications = model.predict(test_images)
print(classifications[0])

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

print(test_labels[0]) चलाकर देखें और आपको #39;9 मिलेंगे. क्या इससे आपको यह समझने में मदद मिलेगी कि सूची कैसी दिखती है?

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

सूची और लेबल 0 पर आधारित हैं, इसलिए टखनों के बूट का लेबल 9 है, तो इसका मतलब है कि यह 10 क्लास का 10वां है. सबसे ज़्यादा वैल्यू वाली 10वीं एलिमेंट वाली सूची का मतलब है कि न्यूरल नेटवर्क ने अनुमान लगाया है कि जिस आइटम की कैटगरी तय की जा रही है वह टनल बूट हो सकता है.

दूसरा व्यायाम

अपने मॉडल में लेयर पर नज़र डालें. 512 न्यूरॉन के साथ सघन परत के लिए अलग-अलग मानों के साथ प्रयोग करें.

आपको खोने और ट्रेनिंग में लगने वाले समय के क्या अलग-अलग नतीजे मिलते हैं? आपको ऐसा क्यों लगता है?

उदाहरण के लिए, अगर आप 1,024 न्यूरॉन तक बढ़ते हैं, तो इस प्रोसेस को धीमा करने के लिए आपको और गिनती करनी होगी. हालांकि, इस मामले में इनका अच्छा असर पड़ता है, क्योंकि मॉडल ज़्यादा सटीक होता है. इसका मतलब यह नहीं है कि #39 हमेशा बेहतर होता है. सामान लौटाने की प्रक्रिया बहुत जल्दी कम हो सकती है.

व्यायाम 3

अगर आप Flatten() लेयर हटा देते हैं, तो क्या होगा. आपको ऐसा क्यों लगता है?

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

सभी कोड लिखने के बजाय, शुरुआत में Flatten() लेयर जोड़ें. जब श्रेणियों को बाद में मॉडल में लोड कर दिया जाता है, तो वे आपके लिए अपने-आप फ़्लैट हो जाती हैं.

कसरत 4

फ़ाइनल (आउटपुट) लेयर पर विचार करें. इनमें से 10 क्यों हैं? अगर आपके खाते में 10 से ज़्यादा पैसे हों, तो क्या होगा?

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

पांचवां व्यायाम

नेटवर्क में अतिरिक्त लेयर के असर पर विचार करें. अगर आप 512 वाली और 10 की अंतिम लेयर के बीच एक और लेयर जोड़ते हैं, तो क्या होगा?

यह ज़्यादा अहम असर नहीं डालता है, क्योंकि यह डेटा बहुत आसान है. ज़्यादा जटिल डेटा के लिए, अक्सर अतिरिक्त लेयर ज़रूरी होते हैं.

छठा अभ्यास

ट्रेनिंग देने से पहले, आपने डेटा को सामान्य मान दिया था. इसमें 0 से 255 तक की वैल्यू से लेकर 0 से 1 तक की वैल्यू शामिल थीं. इसे हटाने का क्या असर होगा? इसे पूरा आज़माने के लिए पूरा कोड यहां दिया गया है (ध्यान दें कि डेटा को सामान्य बनाने वाली दो लाइनें टिप्पणी की जाती हैं).

आपको ऐसा क्यों लगता है कि आपको अलग-अलग नतीजे मिल रहे हैं? यह एक शानदार जवाब है स्टैक ओवरफ़्लो पर यहां.

import tensorflow as tf
print(tf.__version__)
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
#training_images=training_images/255.0
#test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(training_images, training_labels, epochs=5)
model.evaluate(test_images, test_labels)
classifications = model.predict(test_images)
print(classifications[0])
print(test_labels[0])

7. कॉलबैक एक्सप्लोर करें

पहले, जब आपने अतिरिक्त अवधियों के लिए प्रशिक्षण लिया था, तब आपको एक समस्या थी, जिसमें आपके नुकसान में बदलाव हो सकता था. ऐसा करने में आपको थोड़ा समय लग सकता है. शायद आपने यह सोचा था कि आपको 35% सटीक ट्रेनिंग जैसी कोई ट्रेनिंग मिल जाएगी, नहीं. अगर आप तीन epoch के बाद उस तक पहुंचते हैं, तो बहुत ज़्यादा epoch खत्म करने के लिए, इंतज़ार क्यों करें?

किसी भी दूसरे प्रोग्राम की तरह, आपके पास कॉलबैक हैं! उन्हें चलाकर देखें:

import tensorflow as tf

class myCallback(tf.keras.callbacks.Callback):
  def on_epoch_end(self, epoch, logs={}):
    if(logs.get('accuracy')>0.95):
      print("\nReached 95% accuracy so cancelling training!")
      self.model.stop_training = True

callbacks = myCallback()
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images/255.0
test_images=test_images/255.0
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(),
  tf.keras.layers.Dense(512, activation=tf.nn.relu),
  tf.keras.layers.Dense(10, activation=tf.nn.softmax)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5, callbacks=[callbacks])

8. बधाई हो

आपने #39;अपना पहला कंप्यूटर दृष्टि मॉडल बनाया है! अपने कंप्यूटर के विज़न मॉडल को बेहतर बनाने का तरीका जानने के लिए, कन्वर्ज़न बनाएं और पूल करें.