इमेज क्लासिफिकेशन एक ऐसा कार्य जिसे एक बच्चा भी सेकेंडों में कर सकता है, लेकिन मशीन के लिए, यह एक कठिन काम है जब तक कि हाल ही में प्रगति नहीं हुई तथा ध्यान लगा के पढ़ना या सीखना । सेल्फ-ड्राइविंग कार वस्तुओं का पता लगा सकती है और वास्तविक समय में आवश्यक कार्रवाई कर सकती है और इसका कारण संभव है छवि वर्गीकरण। इस लेख में, मैं निम्नलिखित विषयों के माध्यम से आपका मार्गदर्शन करूंगा:
TensorFlow क्या है?
TensorFlow कई कार्यों में डेटाफ़्लो प्रोग्रामिंग के लिए Google का ओपन सोर्स मशीन लर्निंग फ्रेमवर्क है। ग्राफ़ में नोड्स गणितीय परिचालनों का प्रतिनिधित्व करते हैं, जबकि ग्राफ़ किनारों के बीच संचारित बहुआयामी डेटा सरणियों का प्रतिनिधित्व करते हैं।
सेंसर सिर्फ बहुआयामी सरणियाँ हैं, उच्च आयाम वाले डेटा के लिए 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।चर()tf।truncated_normal()आकार= =[३, ३, ३, 64], मतलब= =०, मानक विचलन= =0.08)) conv2_filter = = tf।चर()tf।truncated_normal()आकार= =[३, ३, 64, 128], मतलब= =०, मानक विचलन= =0.08)) conv3_filter = = tf।चर()tf।truncated_normal()आकार= =[५, ५, 128, 256], मतलब= =०, मानक विचलन= =0.08)) conv4_filter = = tf।चर()tf।truncated_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()tf।Global_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 जैसी अवधारणाओं में महारत हासिल करेंगे। पाठ्यक्रम को विशेष रूप से वास्तविक समय के मामले के अध्ययन के साथ उद्योग के विशेषज्ञों द्वारा क्यूरेट किया गया है।