1. शुरू करने से पहले
इस कोडलैब में आप इमेज को अलग-अलग ग्रुप में बांटने वाले मॉडल में सुधार करने के लिए सीएनएन इस्तेमाल करना सीखेंगे.
ज़रूरी शर्तें
यह कोडलैब दो पिछली किस्तों में पूरे होने वाले काम के लिए काम करता है, कंप्यूटर विज़न मॉडल बनाएं. इसमें हम कुछ ऐसे कोड पेश करेंगे जिन्हें आप यहां इस्तेमाल करेंगे. यहां कन्वर्ज़न बनाने और पूल करने का कोड दिया जा सकता है.
आप क्या #39;जानेंगे
- कन्वर्ज़न की मदद से, कंप्यूटर के विज़न और सटीक होने की क्षमता को बेहतर बनाने का तरीका
आप क्या बनाते हैं
- न्यूरल नेटवर्क को बेहतर बनाने के लिए लेयर
आपको क्या चाहिए
आप Colab में चल रहे कोडलैब के बाकी कोड के लिए कोड देख सकते हैं.
आपको #39; TensorFlow इंस्टॉल करने के साथ ही, पिछले कोडलैब में इंस्टॉल की गई लाइब्रेरी की भी ज़रूरत होगी.
2. कन्वर्ज़न की मदद से, कंप्यूटर दृष्टि को सटीक बनाएं
अब आप डीप न्यूरल नेटवर्क (डीएनएन) का इस्तेमाल करके फ़ैशन इमेज की पहचान करने का तरीका जानते हैं, जिसमें तीन लेयर शामिल हैं— इनपुट लेयर (इनपुट डेटा के आकार में), आउटपुट लेयर (पसंदीदा आउटपुट के आकार में) और एक छिपी हुई लेयर. आपने आखिरी पैरामीटर को प्रभावित करने वाले कई पैरामीटर के साथ प्रयोग किया है, जैसे कि छिपे हुए लेयर के अलग-अलग आकार और ट्रेनिंग के समय की संख्या.
सुविधा के लिए, यहां पूरा कोड फिर से उपलब्ध है. आखिर में इसे जांच लें और जांच के नतीजे के सटीक होने की जानकारी लें.
import tensorflow as tf
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(128, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5)
test_loss, test_accuracy = model.evaluate(test_images, test_labels)
print ('Test loss: {}, Test accuracy: {}'.format(test_loss, test_accuracy*100))
हो सकता है कि आपकी ट्रेनिंग के 89% नतीजे और पुष्टि के लिए 87% सही हो. आप कन्वर्ज़न का इस्तेमाल करके इसे और भी बेहतर बना सकते हैं. इससे इमेज की सामग्री का दायरा सीमित हो जाता है और वह खास और खास जानकारी पर फ़ोकस कर पाता है.
अगर आपने कभी फ़िल्टर का इस्तेमाल करके इमेज को प्रोसेस किया है, तो कॉन्वोल्यूशन बहुत आसानी से समझ में आएंगे.
कम शब्दों में कहें, तो आप एक श्रेणी (आम तौर पर 3x3 या 5x5) लें और उसे इमेज के ऊपर भेज दें. उस मैट्रिक्स में दिए गए फ़ॉर्मूला के आधार पर दिए गए पिक्सल में बदलाव करके, आप उम्र की पहचान जैसे काम कर सकते हैं. उदाहरण के लिए, आम तौर पर 3x3 को एज डिटेक्शन के लिए तय किया जाता है, जबकि बीच वाला सेल 8 होता है और इसके सभी पड़ोसी -1 होते हैं. ऐसी स्थिति में, हर पिक्सल के लिए, आप इसकी वैल्यू को 8 से गुणा करेंगे, फिर हर पड़ोसी का मान घटाएँ. हर पिक्सल के लिए ऐसा करें और आपको एक नई इमेज मिलेगी जिसके किनारों को बेहतर बनाया गया है.
यह कंप्यूटर दृष्टि के लिए बिल्कुल सही है, क्योंकि किनारों जैसी सुविधाओं को बेहतर बनाने से कंप्यूटर को एक आइटम को दूसरे से अलग करने में मदद मिलती है. इससे भी बेहतर बात यह है कि आपकी जानकारी की ज़रूरत बहुत कम हो, क्योंकि आप #39;सिर्फ़ हाइलाइट की गई सुविधाओं के ज़रिए ही ट्रेनिंग ले पाएंगे.
यह कॉन्वोलूशनल न्यूरल नेटवर्क का कॉन्सेप्ट है#. घने लेयर होने से पहले कॉन्फ़िगरेशन में कुछ लेयर जोड़ें. इसके बाद, घने लेयर पर जाने से जुड़ी जानकारी ज़्यादा सटीक और ज़्यादा सटीक हो जाएगी.
3. कोड डालकर देखें
यह कोड चलाएं. यह पहले की तरह ही न्यूरल नेटवर्क है, लेकिन इस बार पहले लेयर जोड़े गए. इसमें ज़्यादा समय लगेगा, लेकिन इसे कितना सही माना जाएगा, इस पर नज़र डालें:
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.reshape(60000, 28, 28, 1)
training_images=training_images / 255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images=test_images / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(64, (3, 3), activation='relu', input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D(2, 2),
tf.keras.layers.Conv2D(64, (3, 3), activation='relu'),
tf.keras.layers.MaxPooling2D(2,2),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.summary()
model.fit(training_images, training_labels, epochs=5)
test_loss, test_accuracy = model.evaluate(test_images, test_labels)
print ('Test loss: {}, Test accuracy: {}'.format(test_loss, test_accuracy*100))
यह ट्रेनिंग डेटा पर करीब 93% और पुष्टि के डेटा पर 91% तक बढ़ सकता है.
अब इसे ज़्यादा epoch (जैसे कि 20) के तौर पर चलाने की कोशिश करें और नतीजों को एक्सप्लोर करें. वैसे, ट्रेनिंग के नतीजे बहुत सही लग सकते हैं, लेकिन ओवरफ़िटिंग नाम की एक घटना की वजह से पुष्टि करने के नतीजे कम हो सकते हैं.
ओवरफ़िटिंग तब होती है, जब नेटवर्क को ट्रेनिंग सेट किए गए डेटा से बहुत अच्छी तरह जानकारी मिलती है. इसलिए, यह सिर्फ़ उस डेटा की पहचान करने में माहिर होती है. इसलिए, सामान्य स्थितियों में अन्य डेटा देखने पर यह कम असरदार होता है. उदाहरण के लिए, अगर आपने सिर्फ़ हील बनाने की ट्रेनिंग ली है, तो नेटवर्क, हील को पहचानने में बहुत अच्छा साबित हो सकता है, लेकिन स्नीकर गुमराह कर सकते हैं.
कोड पर एक बार नज़र डालें और चरण-दर-चरण देखें कि कन्वर्ज़न कैसे बनाए गए.
4. डेटा इकट्ठा करें
पहला कदम, डेटा इकट्ठा करना है.
आप ध्यान देंगे कि यहां एक बदलाव होगा. साथ ही, ट्रेनिंग के डेटा में बदलाव करने की भी ज़रूरत है. ऐसा इसलिए है, क्योंकि पहले कॉन्वोल्यूशन की वजह से एक ही टेंशन वाला सारा कॉन्टेंट हो. इसलिए, सूची में 60,000 28x28x1 आइटम के बजाय, आपके पास एक 4D सूची होती है जो 60,000x28x28x1 फ़ॉर्मैट की होती है. साथ ही, टेस्ट इमेज के लिए वही सूची होती है. अगर आप ऐसा नहीं करते हैं, तो आपको #39
import tensorflow as tf
mnist = tf.keras.datasets.fashion_mnist
(training_images, training_labels), (test_images, test_labels) = mnist.load_data()
training_images=training_images.reshape(60000, 28, 28, 1)
training_images = training_images/255.0
test_images = test_images.reshape(10000, 28, 28, 1)
test_images = test_images/255.0
5. मॉडल तय करें
इसके बाद, अपना मॉडल तय करें. ऊपर इनपुट लेयर के बजाय, आप एक कॉन्वोल्यूशन लेयर जोड़ने वाले हैं{0}. इसके पैरामीटर्स हैं:
- उन कॉन्वोल्यूशन की संख्या जिन्हें आप जनरेट करना चाहते हैं. 32 जैसी वैल्यू एक अच्छी शुरुआत है.
- कंवेंशनल मैट्रिक्स का साइज़, इस मामले में 3x3 ग्रिड.
- इस्तेमाल करने के लिए, ऐक्टिवेशन फ़ंक्शन, इस मामले में
reluका इस्तेमाल करें. - पहली लेयर में, इनपुट डेटा का आकार.
आप सबसे ज़्यादा पूलिंग लेयर के साथ रिज़ॉल्यूशन को फ़ॉलो करेंगे. यह लेयर, कंवोल्यूशन की ओर से हाइलाइट की गई सुविधाओं के कॉन्टेंट को बरकरार रखते हुए, इमेज को कंप्रेस करने के लिए बनाया गया है. ज़्यादा से ज़्यादा पूल के लिए (2,2) तय करने से, इसका असर इमेज के आकार को 4 के फ़ैक्टर से कम करने के लिए होता है. यह पिक्सल की 2x2 अरै तय करता है और सबसे बड़ा पिक्सल मान चुनता है, जिससे 4 पिक्सल बदलकर 1 पिक्सल हो जाता है. यह इमेज की इस गणना को दोहराता है और ऐसा करने से हॉरिज़ॉन्टल पिक्सल की संख्या को आधा कर देता है और वर्टिकल पिक्सल की संख्या को आधा कर देता है.
नेटवर्क का साइज़ और आकार देखने के लिए, आप model.summary() को कॉल कर सकते हैं. ध्यान दें कि हर ज़्यादा से ज़्यादा पूलिंग लेयर के बाद, इमेज का साइज़ इस तरह कम हो जाता है:
_________________________________________________________________ Layer (type) Output Shape Param # ================================================================= conv2d_2 (Conv2D) (None, 26, 26, 64) 640 _________________________________________________________________ max_pooling2d_2 (MaxPooling2 (None, 13, 13, 64) 0 _________________________________________________________________ conv2d_3 (Conv2D) (None, 11, 11, 64) 36928 _________________________________________________________________ max_pooling2d_3 (MaxPooling2 (None, 5, 5, 64) 0 _________________________________________________________________ flatten_2 (Flatten) (None, 1600) 0 _________________________________________________________________ dense_4 (Dense) (None, 128) 204928 _________________________________________________________________ dense_5 (Dense) (None, 10) 1290 =================================================================
यहां CNN के लिए पूरा कोड दिया गया है:
model = tf.keras.models.Sequential([
tf.keras.layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
tf.keras.layers.MaxPooling2D(2, 2),
#Add another convolution
tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
tf.keras.layers.MaxPooling2D(2, 2),
#Now flatten the output. After this you'll just have the same DNN structure as the non convolutional version
tf.keras.layers.Flatten(),
#The same 128 dense layers, and 10 output layers as in the pre-convolution example:
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(10, activation='softmax')
])
6. मॉडल को कंपाइल करना और ट्रेनिंग देना
मॉडल को कंपाइल करें, ट्रेनिंग के लिए सही तरीके को कॉल करें, और टेस्ट सेट से होने वाले नुकसान और सटीक होने का आकलन करें.
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(training_images, training_labels, epochs=5)
test_loss, test_acc = model.evaluate(test_images, test_labels)
print ('Test loss: {}, Test accuracy: {}'.format(test_loss, test_acc*100))
7. कन्वोलेशन और पूलिंग को विज़ुअलाइज़ करें
यह कोड कॉन्वोल्यूशन को ग्राफ़िक के साथ दिखाता है. print (test_labels[:100]), टेस्ट सेट में पहले 100 लेबल दिखाता है. साथ ही, आप देख सकते हैं कि इंडेक्स 0, इंडेक्स 23, और इंडेक्स 28 के समान मान (9) हैं. ये सभी जूते{0}. हर एक चरण में कन्वर्ज़न के नतीजे पर नज़र डालें और आप दोनों के बीच सामान्य सुविधाओं का दिखना शुरू हो जाएगा. अब, जब डीएनएन उस डेटा पर ट्रेनिंग लेता है, तो यह बहुत कम जानकारी के साथ काम करता है. साथ ही, यह भी पता लगाता है कि उस कॉन्वोल्यूशन और पूलिंग के कॉम्बिनेशन के आधार पर, जूतों के बीच क्या समानता है.
print(test_labels[:100])
[9 2 1 1 6 1 4 6 5 7 4 5 7 3 4 1 2 4 8 0 2 5 7 9 1 4 6 0 9 3 8 8 3 3 8 0 7 5 7 9 6 1 3 7 6 7 2 1 2 2 4 4 5 8 2 2 8 4 8 0 7 7 8 5 1 1 2 3 9 8 7 0 2 6 2 3 1 2 8 4 1 8 5 9 5 0 3 2 0 6 5 3 6 7 1 8 0 1 4 2]
अब आप उन लेबल के लिए कुछ मिलती-जुलती इमेज चुन सकते हैं और रेंडर करने की प्रक्रिया से गुज़रने के बाद, इमेज के रेंडर होने के तरीके को रेंडर कर सकते हैं. इसलिए, नीचे दिए गए कोड में, FIRST_IMAGE, SECOND_IMAGE, और THIRD_IMAGE, टखनी के बूट 9 वैल्यू के सभी इंडेक्स हैं.
import matplotlib.pyplot as plt
f, axarr = plt.subplots(3,4)
FIRST_IMAGE=0
SECOND_IMAGE=23
THIRD_IMAGE=28
CONVOLUTION_NUMBER = 6
from tensorflow.keras import models
layer_outputs = [layer.output for layer in model.layers]
activation_model = tf.keras.models.Model(inputs = model.input, outputs = layer_outputs)
for x in range(0,4):
f1 = activation_model.predict(test_images[FIRST_IMAGE].reshape(1, 28, 28, 1))[x]
axarr[0,x].imshow(f1[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
axarr[0,x].grid(False)
f2 = activation_model.predict(test_images[SECOND_IMAGE].reshape(1, 28, 28, 1))[x]
axarr[1,x].imshow(f2[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
axarr[1,x].grid(False)
f3 = activation_model.predict(test_images[THIRD_IMAGE].reshape(1, 28, 28, 1))[x]
axarr[2,x].imshow(f3[0, : , :, CONVOLUTION_NUMBER], cmap='inferno')
axarr[2,x].grid(False)
साथ ही, आपको कुछ ऐसा दिखना चाहिए, जहां कॉन्वोल्यूशन की वजह से जूते का ही मतलब हो जाता है. इससे यह पता चलता है कि यह जूते सभी जूतों में एक आम सुविधा है.
8. अभ्यास
पहला व्यायाम
कन्वर्ज़न में बदलाव करने की कोशिश करें. कन्वर्ज़न की संख्या को 32 से बदलकर 16 या 64 करें. सटीक और ट्रेनिंग के समय पर इसका क्या असर होता है?
दूसरा व्यायाम
फ़ाइनल कन्वर्ज़न देखें. सटीक या ट्रेनिंग के समय पर इसका क्या असर होता है?
तीसरा व्यायाम
और कन्वर्ज़न जोड़ें. इसका क्या असर होगा?
चौथा व्यायाम
सबसे पहले, सभी कॉन्फ़िगरेशन हटाएं. इसका क्या असर होगा? इसे आज़माएं.
9. बधाई हो
आपने अपना पहला CNN बनाया है! अपने कंप्यूटर के विज़न मॉडल को बेहतर बनाने का तरीका जानने के लिए, जटिल इमेज के साथ कन्वर्ज़न न्यूरल नेटवर्क (CNN) का इस्तेमाल करना पर जाएं.