तंत्रिका नेटवर्क का उपयोग कर TensorFlow: छवि वर्गीकरण

नमस्कार, हेब्र! मैं आपको लेख "अपने पहले तंत्रिका नेटवर्क को प्रशिक्षित करता हूं : मूल वर्गीकरण" का अनुवाद प्रस्तुत करता हूं।

यह स्नीकर्स और शर्ट जैसे कपड़ों की छवियों को वर्गीकृत करने के लिए एक तंत्रिका नेटवर्क मॉडल प्रशिक्षण मार्गदर्शिका है। एक तंत्रिका नेटवर्क बनाने के लिए, हम अजगर और टेन्सरफ्लो लाइब्रेरी का उपयोग करते हैं।

TensorFlow स्थापित करें

काम के लिए, हमें निम्नलिखित पुस्तकालयों की आवश्यकता है:

1. numpy (कमांड लाइन पर हम लिखते हैं: पाइप इंस्टॉल करें numpy)
2. matplotlib (कमांड लाइन पर हम लिखते हैं: matplotlib स्थापित करें)
3. केरस (कमांड लाइन पर हम लिखते हैं: पाइप स्थापित करेस)
4. jupyter (कमांड लाइन पर हम लिखते हैं: पाइप ज्यूपिटर स्थापित करें)

पिप का उपयोग करना: कमांड लाइन पर, पिप इंस्‍टॉल टेंसोरफ्लो लिखें
यदि आपको कोई त्रुटि मिलती है, तो आप .whl फ़ाइल डाउनलोड कर सकते हैं और पाइप का उपयोग करके इंस्टॉल कर सकते हैं: पाइप स्थापित करें file_path \ file_name.white.l

TensorFlow आधिकारिक स्थापना गाइड
जुपिटर लॉन्च करें। कमांड लाइन पर शुरू करने के लिए, ज्यूपिटर नोटबुक लिखें।

शुरुआत हो रही है

#  import tensorflow as tf from tensorflow import keras import numpy as np import matplotlib.pyplot as plt 

यह गाइड फैशन एमएनआईएसटी डेटासेट का उपयोग करता है, जिसमें 10 श्रेणियों में 70,000 स्केल चित्र हैं। चित्र कम रिज़ॉल्यूशन वाले कपड़ों के अलग-अलग आइटम दिखाते हैं (28 बाय 28 पिक्सल):

नेटवर्क को प्रशिक्षित करने के लिए हम 60,000 छवियों का उपयोग करेंगे और छवियों को वर्गीकृत करने के लिए नेटवर्क ने कितनी सही तरीके से मूल्यांकन किया है, इसका मूल्यांकन करने के लिए। आप केवल डेटा आयात और डाउनलोड करके TensorFlow से सीधे फैशन MNIST तक पहुँच सकते हैं:

 fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data() 

एक लोड हो रहा है डेटासेट चार NumPy सरणियों देता है:

1. Arrays train_images और train_labels डेटा है जो मॉडल प्रशिक्षण के लिए उपयोग करता है
2. मॉडल का परीक्षण करने के लिए सरणियों test_images और test_labels का उपयोग किया जाता है।

छवियाँ 28x28 न्यूमपे सरणियाँ हैं जिनके पिक्सेल मान 0 से 255 तक हैं। लेबल 0 से 9 तक पूर्णांकों की एक सरणी हैं। वे कपड़ों के वर्ग के अनुरूप हैं:

वर्ग नाम डेटा सेट में शामिल नहीं हैं, इसलिए हम इसे स्वयं लिखते हैं:

 class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot'] 

डेटा की खोज

मॉडल को प्रशिक्षित करने से पहले डेटा सेट प्रारूप पर विचार करें।

 train_images.shape #    60 000 ,     28 x 28  test_images.shape #    10 000 ,     28 x 28  len(train_labels) #   60 000  len(test_labels) #   10 000  train_labels #       0  9 (  3    3 ) 

डेटा प्रीप्रोसेसिंग

मॉडल तैयार करने से पहले, डेटा को पूर्व-संसाधित किया जाना चाहिए। यदि आप प्रशिक्षण सेट में पहली छवि की जांच करते हैं, तो आप देखेंगे कि पिक्सेल मान 0 से 255 तक की सीमा में हैं:

 plt.figure() plt.imshow(train_images[0]) plt.colorbar() plt.grid(False) 

हम इन मानों को 0 से 1 तक की सीमा में रखते हैं:

 train_images = train_images / 255.0 test_images = test_images / 255.0 

हम प्रशिक्षण सेट से पहले 25 छवियों को प्रदर्शित करते हैं और प्रत्येक छवि के तहत कक्षा का नाम दिखाते हैं। सुनिश्चित करें कि डेटा सही प्रारूप में है।

 plt.figure(figsize=(10,10)) for i in range(25): plt.subplot(5,5,i+1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(train_images[i], cmap=plt.cm.binary) plt.xlabel(class_names[train_labels[i]]) 

मॉडल बिल्डिंग

एक तंत्रिका नेटवर्क के निर्माण के लिए मॉडल की ट्यूनिंग परतों की आवश्यकता होती है।

तंत्रिका नेटवर्क का मुख्य बिल्डिंग ब्लॉक परत है। अधिकांश गहरी शिक्षा में साधारण परतों का संयोजन होता है। अधिकांश परतों, जैसे कि tf.keras.layers.Dense, में ऐसे पैरामीटर हैं जो प्रशिक्षण के दौरान सीखे जाते हैं।

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

नेटवर्क में पहली परत tf.keras.layers.Flatten 2d सरणी (28 बाय 28 पिक्सल) से छवि प्रारूप को 28 डी 28 = 784 पिक्सल से 1 डी सरणी में परिवर्तित करती है। इस परत का अध्ययन करने के लिए कोई पैरामीटर नहीं है, यह केवल डेटा को सुधारता है।

अगली दो परतें tf.keras.layers.Dense हैं। ये कसकर जुड़े हुए या पूरी तरह से जुड़े हुए तंत्रिका परतें हैं। पहले घने परत में 128 नोड्स (या न्यूरॉन्स) होते हैं। दूसरा (और अंतिम) स्तर 10 नोड्स tf.nn.softmax के साथ एक परत है, जो दस प्रायिकता अनुमानों की एक सरणी देता है, जिसका योग 1 है। प्रत्येक नोड में एक अनुमान होता है जो इस संभावना को इंगित करता है कि वर्तमान छवि 10 कक्षाओं में से एक है।

एक मॉडल का संकलन

इससे पहले कि मॉडल प्रशिक्षण के लिए तैयार हो, उसे कुछ और सेटिंग्स की आवश्यकता होगी। उन्हें मॉडल के संकलन चरण के दौरान जोड़ा जाता है:

• हानि समारोह - माप प्रशिक्षण के दौरान मॉडल कितना सही है
• ऑप्टिमाइज़र यह है कि मॉडल उस डेटा के आधार पर अपडेट किया जाता है जिसे वह देखता है और नुकसान फ़ंक्शन करता है।
• मेट्रिक्स (मेट्रिक्स) - प्रशिक्षण और परीक्षण के चरणों को नियंत्रित करने के लिए उपयोग किया जाता है

 model.compile(optimizer=tf.train.AdamOptimizer(), loss='sparse_categorical_crossentropy', metrics=['accuracy']) 

मॉडल प्रशिक्षण

तंत्रिका नेटवर्क मॉडल सीखना निम्नलिखित चरणों की आवश्यकता है:

1. मॉडल प्रशिक्षण डेटा प्रस्तुत करना (इस उदाहरण में, arrays train_images और train_labels)
2. एक मॉडल छवियों और टैग को जोड़ना सीखता है।
3. हम मॉडल को परीक्षण सूट के बारे में भविष्यवाणियां करने के लिए कहते हैं (इस उदाहरण में, सरणी test_images)। हम लेबल सरणी से लेबल पूर्वानुमान की अनुरूपता की जांच करते हैं (इस उदाहरण में, test_labels सरणी)

प्रशिक्षण शुरू करने के लिए, model.fit विधि पर कॉल करें:

 model.fit(train_images, train_labels, epochs=5) 

मॉडल को मॉडलिंग करते समय, नुकसान (हानि) और सटीकता (एसीसी) के संकेतक प्रदर्शित किए जाते हैं। यह मॉडल प्रशिक्षण डेटा के अनुसार लगभग 0.88 (या 88%) की सटीकता प्राप्त करता है।

सटीकता की रेटिंग

तुलना करें कि मॉडल परीक्षण डेटासेट में कैसे काम करता है:

 test_loss, test_acc = model.evaluate(test_images, test_labels) print('Test accuracy:', test_acc) 

यह पता चला है कि परीक्षण डाटासेट में सटीकता प्रशिक्षण डाटासेट में सटीकता से थोड़ा कम है। प्रशिक्षण सटीकता और परीक्षण सटीकता के बीच यह अंतर रिट्रेस्टिंग का एक उदाहरण है। जब एक मशीन लर्निंग मॉडल प्रशिक्षण डेटा के साथ नए डेटा के साथ बदतर काम करता है तो पीछे हटना है।

भविष्यवाणी

हम कुछ छवियों की भविष्यवाणी करने के लिए मॉडल का उपयोग करते हैं।

 predictions = model.predict(test_images) 

यहां, मॉडल ने परीक्षण के मामले में प्रत्येक छवि के लिए लेबल की भविष्यवाणी की। आइए पहले भविष्यवाणी को देखें:

 predictions[0] 

भविष्यवाणी 10 संख्याओं की एक सरणी है। वे उस मॉडल के "आत्मविश्वास" का वर्णन करते हैं जो छवि कपड़ों के 10 अलग-अलग मदों से मेल खाती है। हम देख सकते हैं कि किस लेबल में सबसे अधिक विश्वास मूल्य है:

 np.argmax(predictions[0]) #9 

इस प्रकार, मॉडल सबसे अधिक आश्वस्त है कि यह छवि एंकल बूट (टखने के जूते), या class_names [9] है। और हम यह सुनिश्चित करने के लिए परीक्षण लेबल की जांच कर सकते हैं कि यह सही है:

 test_labels[0] #9 

हम इन भविष्यवाणियों को देखने के लिए कार्य लिखेंगे।

 def plot_image(i, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[i], true_label[i], img[i] plt.grid(False) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binary) predicted_label = np.argmax(predictions_array) if predicted_label == true_label: color = 'blue' else: color = 'red' plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label], 100*np.max(predictions_array), class_names[true_label]), color=color) def plot_value_array(i, predictions_array, true_label): predictions_array, true_label = predictions_array[i], true_label[i] plt.grid(False) plt.xticks([]) plt.yticks([]) thisplot = plt.bar(range(10), predictions_array, color="#777777") plt.ylim([0, 1]) predicted_label = np.argmax(predictions_array) thisplot[predicted_label].set_color('red') thisplot[true_label].set_color('blue') 

चलो 0 की छवि, भविष्यवाणियों और भविष्यवाणियों की एक सरणी को देखें।

 i = 0 plt.figure(figsize=(6,3)) plt.subplot(1,2,1) plot_image(i, predictions, test_labels, test_images) plt.subplot(1,2,2) plot_value_array(i, predictions, test_labels) 

आइए उनके पूर्वानुमानों के साथ कुछ छवियों का निर्माण करें। सही पूर्वानुमान लेबल नीले हैं, और गलत पूर्वानुमान लेबल लाल हैं। कृपया ध्यान दें कि यह तब भी गलत हो सकता है जब वह बहुत आश्वस्त हो।

 num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.figure(figsize=(2*2*num_cols, 2*num_rows)) for i in range(num_images): plt.subplot(num_rows, 2*num_cols, 2*i+1) plot_image(i, predictions, test_labels, test_images) plt.subplot(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, predictions, test_labels) 

अंत में, हम एक एकल छवि के बारे में भविष्यवाणी करने के लिए एक प्रशिक्षित मॉडल का उपयोग करते हैं।

 #       img = test_images[0] 

Tf.keras मॉडल पैकेज (बैच) या संग्रह (संग्रह) के लिए पूर्वानुमान बनाने के लिए अनुकूलित हैं। इसलिए, हालांकि हम एक छवि का उपयोग करते हैं, हमें इसे सूची में जोड़ना होगा:

 #   ,      img = (np.expand_dims (img, 0)) 

छवि के लिए पूर्वानुमान:

 predictions_single = model.predict(img) print(predictions_single) 

 plot_value_array(0, predictions_single, test_labels) _ = plt.xticks(range(10), class_names, rotation=45) 

 np.argmax(predictions_single[0]) 

पहले की तरह, मॉडल लेबल 9 की भविष्यवाणी करता है।

यदि आपके कोई प्रश्न हैं, तो टिप्पणियों में या निजी संदेशों में लिखें।