TensorFlow Image Classification: बिल्डिंग क्लासिफायरफायर्स के बारे में आप सभी जानते होंगे

यह TensorFlow Image वर्गीकरण लेख आपको छवि वर्गीकरण का एक विस्तृत और व्यापक ज्ञान प्रदान करेगा।

इमेज क्लासिफिकेशन एक ऐसा कार्य जिसे एक बच्चा भी सेकेंडों में कर सकता है, लेकिन मशीन के लिए, यह एक कठिन काम है जब तक कि हाल ही में प्रगति नहीं हुई तथा ध्यान लगा के पढ़ना या सीखना । सेल्फ-ड्राइविंग कार वस्तुओं का पता लगा सकती है और वास्तविक समय में आवश्यक कार्रवाई कर सकती है और इसका कारण संभव है छवि वर्गीकरण। इस लेख में, मैं निम्नलिखित विषयों के माध्यम से आपका मार्गदर्शन करूंगा:

TensorFlow क्या है?

TensorFlow कई कार्यों में डेटाफ़्लो प्रोग्रामिंग के लिए Google का ओपन सोर्स मशीन लर्निंग फ्रेमवर्क है। ग्राफ़ में नोड्स गणितीय परिचालनों का प्रतिनिधित्व करते हैं, जबकि ग्राफ़ किनारों के बीच संचारित बहुआयामी डेटा सरणियों का प्रतिनिधित्व करते हैं।





TensorFlow-Image-Recognition
सेंसर सिर्फ बहुआयामी सरणियाँ हैं, उच्च आयाम वाले डेटा के लिए 2-आयामी तालिकाओं का विस्तार। Tensorflow की कई विशेषताएं हैं जो इसे डीप लर्निंग के लिए उपयुक्त बनाती हैं और यह कोर ओपन सोर्स लाइब्रेरी आपको ML मॉडल विकसित करने और प्रशिक्षित करने में मदद करती है।

छवि वर्गीकरण क्या है?

इमेज क्लासिफिकेशन का उद्देश्य डिजिटल छवि में सभी पिक्सल को कई में से एक में वर्गीकृत करना है भूमि का आवरण कक्षाएं या थीम । यह वर्गीकृत डेटा तब उत्पादन के लिए उपयोग किया जा सकता है विषयगत नक्शे एक छवि में मौजूद भूमि कवर।



अब वर्गीकरण के दौरान विश्लेषक और कंप्यूटर के बीच बातचीत के आधार पर वर्गीकरण दो प्रकार के होते हैं:



वस्तुओं की एक सरणी बनाएँ
  • पर्यवेक्षित और
  • अनसुना कर दिया

इसलिए, बिना किसी समय को बर्बाद किए TensorFlow Image वर्गीकरण में कूदें। मेरे पास 2 उदाहरण हैं: आसान और कठिन। चलो आसान के साथ आगे बढ़ें

TensorFlow छवि वर्गीकरण: फैशन MNIST

फैशन MNIST डेटासेट

यहां हम फैशन एमएनआईएसटी डेटासेट का उपयोग करने जा रहे हैं, जिसमें 10 श्रेणियों में 70,000 स्केल चित्र हैं। हम प्रशिक्षण के लिए 60000 और परीक्षण प्रयोजनों के लिए बाकी 10000 का उपयोग करेंगे। आप TensorFlow से सीधे फैशन MNIST तक पहुंच सकते हैं, बस डेटा आयात और लोड कर सकते हैं।

  • पहले पुस्तकालयों का आयात करें
__future__ से निरपेक्ष_इम्पोर्ट, डिविजन, प्रिंट_फंक्शन # TensorFlow और tf.keras आयात टेंसरफ़्लो को ts के रूप में आयात करें।
  • डेटा लोड करें
Fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data (^)
  • अगला, हम छवियों को कक्षाओं में मैप करने जा रहे हैं
class_names = ['टी-शर्ट / टॉप', 'ट्राउजर', 'स्वेटर', 'ड्रेस', 'कोट', 'सैंडल', 'शर्ट', 'स्नीकर', 'बैग', 'एंकल बूट]
  • डेटा की खोज
train_imagesआकार 
# प्रत्येक लेबल 0-9 के बीच है
train_labels 
test_imagesआकार
  • अब, डेटा को पूर्व-संसाधित करने का समय आ गया है।
पीएलटीआंकड़ा() पीएलटीimshow()train_images[]] पीएलटीरंग रेखा() पीएलटीग्रिड()असत्य) पीएलटीप्रदर्शन() 
#यदि आप प्रशिक्षण सेट में पहली छवि का निरीक्षण करते हैं, तो आप देखेंगे कि पिक्सेल मान 0 से 255 की सीमा में आते हैं।

  • हमें इसे न्यूरल नेटवर्क में फीड करने के लिए 0-1 से छवियों को स्केल करना होगा
train_images = = train_images / 255.0 है test_images = = test_images / 255.0 है
  • कुछ छवियों को प्रदर्शित करते हैं।
पीएलटीआंकड़ा()अंजीर= =()१०,१०)) के लिये मैं में है सीमा()२५): पीएलटीसबप्लॉट(),,मैं+एक) पीएलटीxticks([]) पीएलटीyticks([]) पीएलटीग्रिड()असत्य) पीएलटीimshow()train_images[मैं], सीमैप= =पीएलटीसेमीबाइनरी) पीएलटीxlabel()वर्ग_नाम[train_labels[मैं]]) पीएलटीप्रदर्शन()
 

  • परतों को सेट करें
नमूना = = कठिनअनुक्रमिक([ कठिनपरतेंचपटा()input_shape= =()२।, २।)), कठिनपरतेंघना()128, सक्रियण= =tfनगrelu), कठिनपरतेंघना()१०, सक्रियण= =tfनगमुलायम) ]]
  • मॉडल संकलित करें
नमूनासंकलन करें()आशावादी= ='अदम', हानि= ='sparse_categorical_crossentropy', मेट्रिक्स= =['']]
  • मॉडल प्रशिक्षण
नमूनाफिट है()train_images, train_labels, युगों= =१०)

  • मूल्यांकन की सटीकता
test_loss, test_acc = = नमूनामूल्यांकन करना()test_images, test_labels) प्रिंट करें()'परीक्षण सटीकता:', test_acc)

  • पूर्वानुमान करना
पूर्वानुमान = = नमूनाभविष्यवाणी()test_images)
पूर्वानुमान[]

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

जैसेअर्गमाक्स()पूर्वानुमान[]]#Model को सबसे ज्यादा भरोसा है कि वह टखने का बूट है। चलो देखते हैं कि क्या यह सही है

आउटपुट: 9

test_labels[]

आउटपुट: 9

जावा और वर्ग के बीच अंतर
  • अब, 10 चैनलों का पूरा सेट देखने का समय आ गया है
हार प्लॉट_इमेज()मैं, भविष्यवाणियां, true_label, img): भविष्यवाणियां, true_label, img = = भविष्यवाणियां[मैं], true_label[मैं], img[मैं] पीएलटीग्रिड()असत्य) पीएलटीxticks([]) पीएलटीyticks([]) पीएलटीimshow()img, सीमैप= =पीएलटीसेमीबाइनरी) भविष्यवाणी की गई_लाब = = जैसेअर्गमाक्स()भविष्यवाणियां) अगर भविष्यवाणी की गई_लाब == true_label: रंग = = 'हरा' अन्य: रंग = = '' पीएलटीxlabel()'{} {: 2.0f}% ({}) 'प्रारूप()वर्ग_नाम[भविष्यवाणी की गई_लाब], 100*जैसेअधिकतम()भविष्यवाणियां), वर्ग_नाम[true_label], रंग= =रंग) हार plot_value_array()मैं, भविष्यवाणियां, true_label): भविष्यवाणियां, true_label = = भविष्यवाणियां[मैं], true_label[मैं] पीएलटीग्रिड()असत्य) पीएलटीxticks([]) पीएलटीyticks([]) इस = = पीएलटीबार()सीमा()१०), भविष्यवाणियां, रंग= ='# 777777') पीएलटीख़ुशी([, एक]] भविष्यवाणी की गई_लाब = = जैसेअर्गमाक्स()भविष्यवाणियां) इस[भविष्यवाणी की गई_लाब]set_color()'') इस[true_label]set_color()'हरा')
  • आइए पहले 0 और 10 वीं छवि को देखें
मैं = =  पीएलटीआंकड़ा()अंजीर= =(),)) पीएलटीसबप्लॉट()एक,,एक) प्लॉट_इमेज()मैं, पूर्वानुमान, test_labels, test_images) पीएलटीसबप्लॉट()एक,,) plot_value_array()मैं, पूर्वानुमान, test_labels) पीएलटीप्रदर्शन()

मैं = = १० पीएलटीआंकड़ा()अंजीर= =(),)) पीएलटीसबप्लॉट()एक,,एक) प्लॉट_इमेज()मैं, पूर्वानुमान, test_labels, test_images) पीएलटीसबप्लॉट()एक,,) plot_value_array()मैं, पूर्वानुमान, test_labels) पीएलटीप्रदर्शन()

  • अब, कई चित्र और उनकी भविष्यवाणियां करें। सही वाले हरे हैं, जबकि गलत लाल हैं।
num_row = =  num_cols = =  num_images = = num_row*num_cols पीएलटीआंकड़ा()अंजीर= =()**num_cols, *num_row)) के लिये मैं में है सीमा()num_images): पीएलटीसबप्लॉट()num_row, *num_cols, *मैं+एक) प्लॉट_इमेज()मैं, पूर्वानुमान, test_labels, test_images) पीएलटीसबप्लॉट()num_row, *num_cols, *मैं+) plot_value_array()मैं, पूर्वानुमान, test_labels) पीएलटीप्रदर्शन()

  • अंत में, हम एक एकल छवि के बारे में भविष्यवाणी करने के लिए प्रशिक्षित मॉडल का उपयोग करेंगे।
# परीक्षण डाटासेट से एक छवि ले लो img = = test_images[] प्रिंट करें()imgआकार)
# छवि को एक ऐसे बैच में जोड़ें जहां यह एकमात्र सदस्य है। img = = ()जैसेExpand_dims()img,)) प्रिंट करें()imgआकार)
भविष्यवाणियां = = नमूनाभविष्यवाणी()img) प्रिंट करें()भविष्यवाणियां)

plot_value_array(), भविष्यवाणियां, test_labels) पीएलटीxticks()सीमा()१०), वर्ग_नाम, रोटेशन= =चार पाच) पीएलटीप्रदर्शन()

  • जैसा कि आप बैच में हमारी एकमात्र छवि के लिए भविष्यवाणी देख सकते हैं।
prediction_result = = जैसेअर्गमाक्स()भविष्यवाणियां[]]

आउटपुट: 9

CIFAR-10: सी.एन.एन.

CIFAR-10 डेटासेट में हवाई जहाज, कुत्ते, बिल्लियाँ और अन्य वस्तुएँ होती हैं। आप छवियों को पूर्वप्रमाणित करेंगे, फिर सभी नमूनों पर एक दृढ़ तंत्रिका नेटवर्क को प्रशिक्षित करेंगे। छवियों को सामान्यीकृत करने की आवश्यकता है और लेबल को एक-हॉट एन्कोडेड होना चाहिए। यह उपयोग-मामला निश्चित रूप से TensorFlow Image वर्गीकरण के बारे में आपके संदेह को स्पष्ट करेगा।

  • डेटा डाउनलोड करना
से urllib.request आयात उतावलापन से ओस.पथ आयात इस्फ़ाइल, कालिख है से tqdm आयात tqdm आयात तारकोल cifar10_dataset_folder_path = = 'सिफर -10-बैट्स-पी' कक्षा DownloadProgress()tqdm): last_block = =  हार हुक()स्व, ब्लॉक_नम= =एक, ब्लॉक का आकार= =एक, कुल आकार= =कोई नहीं): स्वकुल = = कुल आकार स्वअपडेट करें(ब्लॉक_नम - स्वlast_block) * ब्लॉक का आकार) स्वlast_block = = ब्लॉक_नम '' '' जांचें कि डेटा (ज़िप) फ़ाइल पहले से डाउनलोड है या नहीं यदि नहीं, तो इसे 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' से डाउनलोड करें और cifar-10-python.tar.gz के रूप में सहेजें '' '' अगर नहीं इस्फ़ाइल()'cifar-10-python.tar.gz'): साथ से DownloadProgress()इकाई= ='', Unit_scale= =सच, मंत्री= =एक, उतर= ='CIFAR-10 डेटासेट') जैसा पबार: उतावलापन() 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', पबारहुक) अगर नहीं कालिख है()cifar10_dataset_folder_path): साथ से तारकोलखुला हुआ()'cifar-10-python.tar.gz') जैसा टार: टारसभी निकालो() टारबंद करे()
  • आवश्यक पुस्तकालयों का आयात करना
आयात अचार आयात सुन्न जैसा जैसे आयात matplotlib.pyplot जैसा पीएलटी
  • डेटा को समझना

डेटा का मूल बैच 10000 × 3072 टेंसर है जो एक संख्यात्मक सरणी में व्यक्त किया गया है, जहां 10000 नमूना डेटा की संख्या है। छवि रंगीन है और आकार 32 × 32 है। फीडिंग (चौड़ाई x ऊँचाई x num_channel) या (num_channel x चौड़ाई x ऊँचाई) के एक प्रारूप में की जा सकती है। लेबल को परिभाषित करते हैं।

हार load_label_names(): वापसी ['विमान', 'ऑटोमोबाइल', 'चिड़िया', 'बिल्ली', 'हिरन', 'कुत्ता', 'मेंढक', 'घोड़ा', 'समुंद्री जहाज', '']
  • डेटा को फिर से आकार देना

हम दो चरणों में डेटा को फिर से साझा करने जा रहे हैं

सबसे पहले, पंक्ति वेक्टर (3072) को 3 टुकड़ों में विभाजित करें। प्रत्येक टुकड़ा प्रत्येक चैनल से मेल खाता है। यह (3 x 1024) एक टेंसर के आयाम का परिणाम है। फिर 32 के साथ पिछले चरण से परिणामी टेंसर को विभाजित करें। 32 यहाँ एक छवि की चौड़ाई का मतलब है। इसका परिणाम (3x32x32) है।

दूसरे, हमें डेटा को (num_channel, चौड़ाई, ऊंचाई) से (चौड़ाई, ऊंचाई, num_channel) में स्थानांतरित करना होगा। उसके लिए, हम ट्रांज़ोज़ फ़ंक्शन का उपयोग करने जा रहे हैं।

हार load_cfar10_batch()cifar10_dataset_folder_path, बैच_एड): साथ से खुला हुआ()cifar10_dataset_folder_path + '/ data_batch_' + पी()बैच_एड), मोड= ='आरबी') जैसा फ़ाइल: # ध्यान दें एन्कोडिंग प्रकार 'लैटिन 1' है बैच = = अचारभार()फ़ाइल, एन्कोडिंग= ='लैटिन 1') विशेषताएं = = बैच['डेटा']फेरबदल करना(लीन()बैच['डेटा'], , 32, 32))पारगमन(), , , एक) लेबल = = बैच['लेबल'] वापसी विशेषताएं, लेबल
  • डेटा की खोज
हार डिस्प्ले_स्टेट्स()cifar10_dataset_folder_path, बैच_एड, नमूना_द): विशेषताएं, लेबल = = load_cfar10_batch()cifar10_dataset_folder_path, बैच_एड) अगर नहीं () <= नमूना_द < लीन()विशेषताएं)): प्रिंट करें()'{}नमूने बैच में{}{}सीमा से बाहर है। 'प्रारूप()लीन()विशेषताएं), बैच_एड, नमूना_द)) वापसी कोई नहीं प्रिंट करें()' बैच # के आँकड़े{}: 'प्रारूप()बैच_एड)) प्रिंट करें()नमूने के #:{} 'प्रारूप()लीन()विशेषताएं))) लेबल_ नाम = = load_label_names() Label_counts = = तानाशाही()जिप()*जैसेअद्वितीय()लेबल, return_counts= =सच))) के लिये चाभी, मान में है Label_countsआइटम(): प्रिंट करें()'लेबल की गिनती [{}] ({}):{}'प्रारूप()चाभी, लेबल_ नाम[चाभी]ऊपरी(), मान)) sample_image = = विशेषताएं[नमूना_द] नमूना_ लेलबेल = = लेबल[नमूना_द] प्रिंट करें()' छवि का उदाहरण{}: 'प्रारूप()नमूना_द)) प्रिंट करें()'छवि - न्यूनतम मूल्य:{}अधिकतम मूल्य:{}'प्रारूप()sample_imageमि(), sample_imageअधिकतम()) प्रिंट करें()'छवि - आकार:{}'प्रारूप()sample_imageआकार)) प्रिंट करें()'लेबल - लेबल आईडी:{}नाम:{}'प्रारूप()नमूना_ लेलबेल, लेबल_ नाम[नमूना_ लेलबेल]) पीएलटीimshow()sample_image)
%matplotlib पंक्ति में %विन्यास इनलाइनबैकफिगर_फॉर्मेट = = 'रेटिना' आयात सुन्न जैसा जैसे # डाटासेट का अन्वेषण करें बैच_एड = =  नमूना_द = = 7000 है डिस्प्ले_स्टेट्स()cifar10_dataset_folder_path, बैच_एड, नमूना_द)

java में क्या करता है
  • प्रीप्रोसेसिंग फ़ंक्शंस लागू करना

हम मिन-मैक्स सामान्यीकरण के माध्यम से डेटा को सामान्य करने जा रहे हैं। यह केवल 0 और 1 के बीच की सीमा के लिए सभी x मान बनाता है।
y = (x-min) / (अधिकतम-मिनट)

हार सामान्य करें()एक्स): '' '' बहस - x: इनपुट छवि डेटा में सुन्न सरणी [32, 32, 3] वापसी - सामान्यीकृत x '' '' min_val = = जैसेमि()एक्स) अधिक से अधिक = = जैसेअधिकतम()एक्स) एक्स = = ()एक्स-min_val) / ()अधिक से अधिक-min_val) वापसी एक्स
  • एक-हॉट एनकोड
हार one_hot_encode()एक्स): '' '' बहस - x: लेबल की एक सूची वापसी - एक हॉट एन्कोडिंग मैट्रिक्स (लेबल की संख्या, कक्षा की संख्या) '' '' एन्कोड किया गया = = जैसेशून्य(लीन()एक्स), १०)) के लिये आइडीएक्स, बजे में है गुनगुनाना()एक्स): एन्कोड किया गया[आइडीएक्स] [बजे] = = एक वापसी एन्कोड किया गया
  • डेटा को प्रीप्रोसेस और सेव करें
हार _preprocess_and_save()सामान्य करें, one_hot_encode, विशेषताएं, लेबल, फ़ाइल का नाम): विशेषताएं = = सामान्य करें()विशेषताएं) लेबल = = one_hot_encode()लेबल) अचारडंप करना(विशेषताएं, लेबल), खुला हुआ()फ़ाइल का नाम, 'wb')) हार preprocess_and_save_data()cifar10_dataset_folder_path, सामान्य करें, one_hot_encode): n_batches = =  valid_features = = [] valid_labels = = [] के लिये बैच_आई में है सीमा()एक, n_batches + एक): विशेषताएं, लेबल = = load_cfar10_batch()cifar10_dataset_folder_path, बैच_आई) # बैच के पूरे डेटासेट में सत्यापन डेटा के रूप में सूचकांक को ढूंढें (10%) index_of_validation = = int()लीन()विशेषताएं) * 0.1) # बैच के संपूर्ण डेटासेट का 90% पूर्वप्रक्रम # - सुविधाओं को सामान्य करें # - one_hot_encode लैब्स # - 'preprocess_batch_' + बैच_नंबर नामक एक नई फ़ाइल में सहेजें # - प्रत्येक बैच के लिए प्रत्येक फ़ाइल _preprocess_and_save()सामान्य करें, one_hot_encode, विशेषताएं[:-index_of_validation], लेबल[:-index_of_validation], 'preprocess_batch_' + पी()बैच_आई) + '.p') # प्रशिक्षण डेटासेट के विपरीत, सत्यापन डेटासेट सभी बैच डेटासेट के माध्यम से जोड़ा जाएगा # - बैच के व्हॉट्स डेटासेट का 10% हिस्सा लें # - उन्हें सूची में जोड़ें # - valid_features # - valid_labels valid_featuresविस्तार करें()विशेषताएं[-index_of_validation:]) valid_labelsविस्तार करें()लेबल[-index_of_validation:]) # सभी स्टैक्ड वैलिडेशन डेटासेट को प्रीप्रोसेस करें _preprocess_and_save()सामान्य करें, one_hot_encode, जैसेसरणी()valid_features), जैसेसरणी()valid_labels), 'preprocess_validation.p') # परीक्षण डेटासेट लोड करें साथ से खुला हुआ()cifar10_dataset_folder_path + '/ test_batch', मोड= ='आरबी') जैसा फ़ाइल: बैच = = अचारभार()फ़ाइल, एन्कोडिंग= ='लैटिन 1') # परीक्षण डेटा प्रीप्रोसेस test_features = = बैच['डेटा']फेरबदल करना(लीन()बैच['डेटा'], , 32, 32))पारगमन(), , , एक) test_labels = = बैच['लेबल'] # प्रीप्रोसेस और सभी परीक्षण डेटा सहेजें _preprocess_and_save()सामान्य करें, one_hot_encode, जैसेसरणी()test_features), जैसेसरणी()test_labels), 'preprocess_training.p')
preprocess_and_save_data()cifar10_dataset_folder_path, सामान्य करें, one_hot_encode)
  • चौकी
आयात अचार valid_features, valid_labels = = अचारभार()खुला हुआ()'preprocess_validation.p', मोड= ='आरबी'))
  • नेटवर्क का निर्माण

पूरे मॉडल में कुल 14 परतें हैं।

आयात टेंसरफ्लो जैसा tf हार conv_net()एक्स, Keep_prob): conv1_filter = = tfचर()tftruncated_normal()आकार= =[, , , 64], मतलब= =, मानक विचलन= =0.08)) conv2_filter = = tfचर()tftruncated_normal()आकार= =[, , 64, 128], मतलब= =, मानक विचलन= =0.08)) conv3_filter = = tfचर()tftruncated_normal()आकार= =[, , 128, 256], मतलब= =, मानक विचलन= =0.08)) conv4_filter = = tfचर()tftruncated_normal()आकार= =[, , 256, 512], मतलब= =, मानक विचलन= =0.08)) # 1, 2 आक्षेप १ = = tfनगconv2d()एक्स, conv1_filter, प्रगति करता है= =[एक,एक,एक,एक], गद्दी= ='वही') आक्षेप १ = = tfनगrelu()आक्षेप १) conv1_pool = = tfनगअधिकतम_पूल()आक्षेप १, ksize= =[एक,,,एक], प्रगति करता है= =[एक,,,एक], गद्दी= ='वही') conv1_bn = = tfपरतेंबैच_स्वाभाविकता()conv1_pool) # 3. 4 आक्षेप २ = = tfनगconv2d()conv1_bn, conv2_filter, प्रगति करता है= =[एक,एक,एक,एक], गद्दी= ='वही') आक्षेप २ = = tfनगrelu()आक्षेप २) conv2_pool = = tfनगअधिकतम_पूल()आक्षेप २, ksize= =[एक,,,एक], प्रगति करता है= =[एक,,,एक], गद्दी= ='वही') conv2_bn = = tfपरतेंबैच_स्वाभाविकता()conv2_pool) # 5, 6 आक्षेप ३ = = tfनगconv2d()conv2_bn, conv3_filter, प्रगति करता है= =[एक,एक,एक,एक], गद्दी= ='वही') आक्षेप ३ = = tfनगrelu()आक्षेप ३) conv3_pool = = tfनगअधिकतम_पूल()आक्षेप ३, ksize= =[एक,,,एक], प्रगति करता है= =[एक,,,एक], गद्दी= ='वही') conv3_bn = = tfपरतेंबैच_स्वाभाविकता()conv3_pool) # 7, 8 आक्षेप ४ = = tfनगconv2d()conv3_bn, conv4_filter, प्रगति करता है= =[एक,एक,एक,एक], गद्दी= ='वही') आक्षेप ४ = = tfनगrelu()आक्षेप ४) conv4_pool = = tfनगअधिकतम_पूल()आक्षेप ४, ksize= =[एक,,,एक], प्रगति करता है= =[एक,,,एक], गद्दी= ='वही') conv4_bn = = tfपरतेंबैच_स्वाभाविकता()conv4_pool) # 9 समतल = = tfविरोध करनापरतेंचपटा()conv4_bn) # 10 पूर्ण १ = = tfविरोध करनापरतेंपूरी तरह से जुड़ा हुआ()इनपुट्स= =समतल, num_output= =128, सक्रियण_फ़न= =tfनगrelu) पूर्ण १ = = tfनगड्रॉप आउट()पूर्ण १, Keep_prob) पूर्ण १ = = tfपरतेंबैच_स्वाभाविकता()पूर्ण १) # ग्यारह पूर्ण २ = = tfविरोध करनापरतेंपूरी तरह से जुड़ा हुआ()इनपुट्स= =पूर्ण १, num_output= =256, सक्रियण_फ़न= =tfनगrelu) पूर्ण २ = = tfनगड्रॉप आउट()पूर्ण २, Keep_prob) पूर्ण २ = = tfपरतेंबैच_स्वाभाविकता()पूर्ण २) # 12 पूर्ण ३ = = tfविरोध करनापरतेंपूरी तरह से जुड़ा हुआ()इनपुट्स= =पूर्ण २, num_output= =512, सक्रियण_फ़न= =tfनगrelu) पूर्ण ३ = = tfनगड्रॉप आउट()पूर्ण ३, Keep_prob) पूर्ण ३ = = tfपरतेंबैच_स्वाभाविकता()पूर्ण ३) # 13 पूर्ण 4 = = tfविरोध करनापरतेंपूरी तरह से जुड़ा हुआ()इनपुट्स= =पूर्ण ३, num_output= =1024 है, सक्रियण_फ़न= =tfनगrelu) पूर्ण 4 = = tfनगड्रॉप आउट()पूर्ण 4, Keep_prob) पूर्ण 4 = = tfपरतेंबैच_स्वाभाविकता()पूर्ण 4) # 14 बाहर = = tfविरोध करनापरतेंपूरी तरह से जुड़ा हुआ()इनपुट्स= =पूर्ण ३, num_output= =१०, सक्रियण_फ़न= =कोई नहीं) वापसी बाहर
  • हाइपरपैरामीटर
युगों = = १० बैच का आकार = = 128 Keep_probability = = 0.7 सीखने की दर = = 0.001
लॉग करता है = = conv_net()एक्स, Keep_prob) नमूना = = tfपहचान()लॉग करता है, नाम= ='लॉगिन') # नाम टेन्सर लॉग करता है, ताकि प्रशिक्षण के बाद डिस्क से लोड किया जा सके # नुकसान और ऑप्टिमाइज़र लागत = = tfको कम करें()tfनगsoftmax_cross_entropy_with_logits()लॉग करता है= =लॉग करता है, लेबल= =)) आशावादी = = tfरेल गाडीएडमऑप्टिमाइज़र()सीखने की दर= =सीखने की दर)छोटा करना()लागत) # सटीकता correct_pred = = tfबराबरी का()tfअर्गमाक्स()लॉग करता है, एक), tfअर्गमाक्स(), एक)) सटीकता = = tfको कम करें()tfडाली()correct_pred, tfफ्लोट 32), नाम= ='')
  • तंत्रिका नेटवर्क को प्रशिक्षित करें
# एकल अनुकूलन 
हार
train_neural_network()सत्र, आशावादी, Keep_probability, feature_batch, लेबल_बच): सत्रDaud()आशावादी, feed_dict= ={{ एक्स: feature_batch, : लेबल_बच, Keep_prob: Keep_probability })
# शोटिंग स्टैट्स डीफ़ प्रिंट_स्टेट्स()सत्र, feature_batch, लेबल_बच, लागत, सटीकता): हानि = = संप्रदायDaud()लागत, feed_dict= ={{ एक्स: feature_batch, : लेबल_बच, Keep_prob: एक। }) valid_acc = = संप्रदायDaud()सटीकता, feed_dict= ={{ एक्स: valid_features, : valid_labels, Keep_prob: एक। }) प्रिंट करें()'हानि:{:> 10.4f}सत्यापन सटीकता:{.6f}'प्रारूप()हानि, valid_acc))
  • पूरी तरह से प्रशिक्षण और मॉडल की बचत
हार बैच_फिट्स_लैबल्स()विशेषताएं, लेबल, बैच का आकार): '' '' विभाजन सुविधाओं और लेबल बैचों में '' '' के लिये शुरू में है सीमा(), लीन()विशेषताएं), बैच का आकार): समाप्त = = मि()शुरू + बैच का आकार, लीन()विशेषताएं)) प्राप्ति विशेषताएं[शुरू:समाप्त], लेबल[शुरू:समाप्त] हार load_preprocess_training_batch()बैच_एड, बैच का आकार): '' '' प्रीप्रोसेड ट्रेनिंग डेटा लोड करें और उन्हें कम या ज्यादा के बैच में लौटाएं '' '' फ़ाइल का नाम = = 'preprocess_batch_' + पी()बैच_एड) + '.p' विशेषताएं, लेबल = = अचारभार()खुला हुआ()फ़ाइल का नाम, मोड= ='आरबी')) # आकार या उससे कम के बैचों में प्रशिक्षण डेटा लौटाएं वापसी बैच_फिट्स_लैबल्स()विशेषताएं, लेबल, बैच का आकार)
#Saving मॉडल और पथ 
save_model_path
= = './image_classification' प्रिंट करें()'प्रशिक्षण...') साथ से tfसत्र() जैसा संप्रदाय: # वेरिएबल्स की शुरुआत संप्रदायDaud()tfGlobal_variables_initializer()) # प्रशिक्षण चक्र के लिये युग में है सीमा()युगों): # सभी बैचों पर लूप n_batches = = के लिये बैच_आई में है सीमा()एक, n_batches + एक): के लिये बैच_फ्रीचर, बैच_लैबल्स में है load_preprocess_training_batch()बैच_आई, बैच का आकार): train_neural_network()संप्रदाय, आशावादी, Keep_probability, बैच_फ्रीचर, बैच_लैबल्स) प्रिंट करें()'युग{:> 2}, CIFAR-10 बैच{}: 'प्रारूप()युग + एक, बैच_आई), समाप्त= ='') प्रिंट_स्टेट्स()संप्रदाय, बैच_फ्रीचर, बैच_लैबल्स, लागत, सटीकता) # मॉडल सहेजें बचाने वाला = = tfरेल गाडीसेवर() save_path = = बचाने वालाबचा ले()संप्रदाय, save_model_path)

अब, Tensorflow Image Classification का महत्वपूर्ण भाग किया गया है। अब, मॉडल का परीक्षण करने का समय आ गया है।

  • मॉडल का परीक्षण
आयात अचार आयात सुन्न जैसा जैसे आयात matplotlib.pyplot जैसा पीएलटी से sklearn.preprocessing आयात लेबलबिनेराइज़र हार बैच_फिट्स_लैबल्स()विशेषताएं, लेबल, बैच का आकार): '' '' विभाजन सुविधाओं और लेबल बैचों में '' '' के लिये शुरू में है सीमा(), लीन()विशेषताएं), बैच का आकार): समाप्त = = मि()शुरू + बैच का आकार, लीन()विशेषताएं)) प्राप्ति विशेषताएं[शुरू:समाप्त], लेबल[शुरू:समाप्त] हार display_image_predictions()विशेषताएं, लेबल, पूर्वानुमान, top_n_predictions): n_classes = = १० लेबल_ नाम = = load_label_names() लेबल_ संयोजक = = लेबलबिनेराइज़र() लेबल_ संयोजकफिट है()सीमा()n_classes)) label_ids = = लेबल_ संयोजकinverse_transform()जैसेसरणी()लेबल)) अंजीर, कुल्हाड़ियों = = पीएलटीसबप्लॉट()nrows= =top_n_predictions, नोक= =, अंजीर= =()बीस, १०)) अंजीरकसकर() अंजीरएक प्रकार का पौधा()'सॉफ्टमैक्स प्रेडिक्शन', फ़ॉन्ट आकार= =बीस, = =१.१) n_predictions = =  मार्जिन = = 0.05 ind = = जैसेव्यवस्था()n_predictions) चौड़ाई = = ()एक। - २। * मार्जिन) / n_predictions के लिये image_i, ()सुविधा, label_id, प्री_डाइमेट्रीज, pred_values) में है गुनगुनाना()जिप()विशेषताएं, label_ids, पूर्वानुमानसंकेत देता है, पूर्वानुमानमान)): अगर ()image_i < top_n_predictions): पूर्व_नाम = = [लेबल_ नाम[pred_i] के लिये pred_i में है प्री_डाइमेट्रीज] सही नाम = = लेबल_ नाम[label_id] कुल्हाड़ियों[image_i] []imshow(सुविधा*255 है)विस्मय()जैसेint32, नकल= =असत्य)) कुल्हाड़ियों[image_i] []set_title()सही नाम) कुल्हाड़ियों[image_i] []set_axis_off() कुल्हाड़ियों[image_i] [एक]barh()ind + मार्जिन, pred_values[:], चौड़ाई) कुल्हाड़ियों[image_i] [एक]set_yticks()ind + मार्जिन) कुल्हाड़ियों[image_i] [एक]set_yticklabels()पूर्व_नाम[::-एक]] कुल्हाड़ियों[image_i] [एक]set_xticks([, 0.5, 1.0]]
%matplotlib पंक्ति में %विन्यास इनलाइनबैकफिगर_फॉर्मेट = = 'रेटिना' आयात टेंसरफ्लो जैसा tf आयात अचार आयात यादृच्छिक save_model_path = = './image_classification' बैच का आकार = = 64 n_samples = = १० top_n_predictions = =  हार test_model(): test_features, test_labels = = अचारभार()खुला हुआ()'preprocess_training.p', मोड= ='आरबी')) भरा हुआ_ग्राफ = = tfग्राफ() साथ से tfसत्र()रेखांकन= =भरा हुआ_ग्राफ) जैसा संप्रदाय: # लोड मॉडल लोडर = = tfरेल गाडीimport_meta_graph()save_model_path + '.मेटा') लोडरबहाल करना()संप्रदाय, save_model_path) # लोड किए गए मॉडल से सेंसर प्राप्त करें भरी हुई_x = = भरा हुआ_ग्राफget_tensor_by_name()'input_x: 0') भरी हुई = = भरा हुआ_ग्राफget_tensor_by_name()'output_y: 0') load_keep_prob = = भरा हुआ_ग्राफget_tensor_by_name()'Keep_prob: 0') load_logits = = भरा हुआ_ग्राफget_tensor_by_name()'लॉगिन: 0') भरी हुई = = भरा हुआ_ग्राफget_tensor_by_name()'सटीकता: 0') # स्मृति सीमाओं के लिए बैचों में सटीकता प्राप्त करें test_batch_acc_total = =  test_batch_count = =  के लिये train_feature_batch, train_label_batch में है बैच_फिट्स_लैबल्स()test_features, test_labels, बैच का आकार): test_batch_acc_total + = संप्रदायDaud() भरी हुई, feed_dict= ={{भरी हुई_x: train_feature_batch, भरी हुई: train_label_batch, load_keep_prob: 1.0}) test_batch_count + = एक प्रिंट करें()'परीक्षण सटीकता:{} 'प्रारूप()test_batch_acc_total/test_batch_count)) # रैंडम सैंपल प्रिंट करें random_test_features, random_test_labels = = टप्पल()जिप()*यादृच्छिकनमूना है()सूची()जिप()test_features, test_labels)), n_samples))) random_test_predictions = = संप्रदायDaud() tfनगtop_k()tfनगमुलायम()load_logits), top_n_predictions), feed_dict= ={{भरी हुई_x: random_test_features, भरी हुई: random_test_labels, load_keep_prob: 1.0}) display_image_predictions()random_test_features, random_test_labels, random_test_predictions, top_n_predictions) test_model()

आउटपुट: परीक्षण सटीकता: 0.5882762738853503

अब, यदि आप अधिक अवधि के लिए अपने तंत्रिका नेटवर्क को प्रशिक्षित करते हैं या सक्रियण फ़ंक्शन को बदलते हैं, तो आपको एक अलग परिणाम मिल सकता है जिसमें बेहतर सटीकता हो सकती है।

तो, इसके साथ, हम इस TensorFlow Image वर्गीकरण लेख के अंत में आते हैं। मुझे यकीन है कि अब आप किसी भी प्रकार की छवियों को वर्गीकृत करने के लिए उसी का उपयोग कर सकते हैं और आप छवि वर्गीकरण के लिए शुरुआती नहीं हैं।

एडुर्का की अजगर प्रमाणन प्रशिक्षण के साथ उद्योग की आवश्यकताओं और मांगों के अनुसार उद्योग के पेशेवरों द्वारा क्यूरेट किया जाता है। आप SoftMax फ़ंक्शन, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn जैसी अवधारणाओं में महारत हासिल करेंगे। पाठ्यक्रम को विशेष रूप से वास्तविक समय के मामले के अध्ययन के साथ उद्योग के विशेषज्ञों द्वारा क्यूरेट किया गया है।