TensorFlow Autoencoder: डीटसेट डीप लर्निंग उदाहरण के साथ

विषय - सूची:

Anonim

एक Autoencoder क्या है?

एक Autoencoder एक असुरक्षित तरीके से कुशलतापूर्वक डेटा कोडिंग सीखने के लिए एक उपकरण है। यह एक प्रकार का कृत्रिम तंत्रिका नेटवर्क है जो सिग्नल शोर को अनदेखा करने के लिए तंत्रिका नेटवर्क को प्रशिक्षित करके आयामीता में कमी के लिए डेटा सेट का प्रतिनिधित्व सीखने में आपकी मदद करता है। यह एक इनपुट को पुनः बनाने के लिए एक महान उपकरण है।

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

इस TensorFlow Autoencoder ट्यूटोरियल में, आप सीखेंगे:

  • एक Autoencoder क्या है?
  • Autoencoder कैसे काम करता है?
  • Stacked Autoencoder उदाहरण
  • TensorFlow के साथ एक Autoencoder बनाएँ
  • छवि प्रीप्रोसेसिंग
  • डेटासेट अनुमानक सेट करें
  • नेटवर्क बनाएँ

Autoencoder कैसे काम करता है?

एक ऑटोएन्कोडर का उद्देश्य केवल आवश्यक विशेषताओं पर ध्यान केंद्रित करके इनपुट का एक अनुमान प्रस्तुत करना है। आप सोच सकते हैं कि केवल आउटपुट का उत्पादन करने के लिए इनपुट को कॉपी और पेस्ट करना क्यों न सीखें। वास्तव में, एक ऑटोटेन्कोडर बाधाओं का एक सेट है जो नेटवर्क को डेटा का प्रतिनिधित्व करने के लिए नए तरीके सीखने के लिए मजबूर करता है, केवल आउटपुट की प्रतिलिपि बनाने से अलग।

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

Autoencoder का कार्य करना

मॉडल नुकसान फ़ंक्शन को कम करके वजन को अपडेट करेगा। यदि इनपुट से इनपुट अलग है, तो मॉडल को दंडित किया जाता है।

लगातार, एक चित्र की कल्पना करें जिसका आकार 50x50 (यानी, 250 पिक्सल) और एक तंत्रिका नेटवर्क है जिसमें केवल एक छिपी हुई परत एक सौ न्यूरॉन्स से बनी है। लर्निंग एक फीचर मैप पर किया जाता है जो इनपुट से दो गुना छोटा होता है। इसका मतलब है कि नेटवर्क को केवल 100 के बराबर न्यूरॉन्स के वेक्टर के साथ 250 पिक्सेल को फिर से बनाने का एक तरीका खोजने की आवश्यकता है।

Stacked Autoencoder उदाहरण

इस Autoencoder ट्यूटोरियल में, आप सीखेंगे कि स्टैक्ड Autoencoder का उपयोग कैसे करें। वास्तुकला एक पारंपरिक तंत्रिका नेटवर्क के समान है। इनपुट संकुचित होने के लिए एक छिपी हुई परत में जाता है, या इसके आकार को कम करता है, और फिर पुनर्निर्माण परतों तक पहुंचता है। उद्देश्य मूल के रूप में करीब के रूप में एक उत्पादन छवि का उत्पादन करने के लिए है। मॉडल को अपने कार्य को कम करने के लिए बाधाओं के एक सेट के तहत प्राप्त करने का एक तरीका सीखना है, अर्थात कम आयाम के साथ।

आजकल, डीप लर्निंग में Autoencoders मुख्य रूप से एक छवि को दर्शाने के लिए उपयोग किया जाता है। खरोंच के साथ एक छवि की कल्पना करें; एक मानव अभी भी सामग्री को पहचानने में सक्षम है। ऑटोएन्कोडर को बदनाम करने का विचार नेटवर्क के लिए डेटा के पीछे के पैटर्न को सीखने के लिए मजबूर करने के लिए शोर को जोड़ना है।

ऑटोएन्कोडर डीप लर्निंग का अन्य उपयोगी परिवार वैरिएबल ऑटोएन्कोडर है। इस प्रकार का नेटवर्क नई छवियां उत्पन्न कर सकता है। कल्पना कीजिए कि आप एक आदमी की छवि के साथ एक नेटवर्क को प्रशिक्षित करते हैं; इस तरह के नेटवर्क से नए चेहरे तैयार किए जा सकते हैं।

TensorFlow के साथ एक Autoencoder बनाएँ

इस ट्यूटोरियल में, आप सीखेंगे कि किसी इमेज को रीकंस्ट्रक्ट करने के लिए स्टैक्ड ऑटोकेनर कैसे बनाया जाए।

आप CIFAR-10 डेटासेट का उपयोग करेंगे जिसमें 60000 32x32 रंगीन चित्र हैं। Autoencoder डाटासेट पहले से ही प्रशिक्षण के लिए 50000 छवियों और परीक्षण के लिए 10000 के बीच विभाजित है। अधिकतम दस वर्ग हैं:

  • विमान
  • ऑटोमोबाइल
  • चिड़िया
  • बिल्ली
  • हिरन
  • कुत्ता
  • मेढक
  • घोड़ा
  • समुंद्री जहाज
  • ट्रक

आपको इस URL https://www.cs.toronto.edu/~kriz/cifar.html में चित्र डाउनलोड करने और इसे अनज़िप करने की आवश्यकता है। 10-बैच-पाई के लिए फ़ोल्डर में यादृच्छिक क्रम में प्रत्येक में 10000 छवियों के साथ पांच बैच डेटा होते हैं।

अपना मॉडल बनाने और प्रशिक्षित करने से पहले, आपको कुछ डेटा प्रोसेसिंग लागू करने की आवश्यकता है। आप निम्नानुसार आगे बढ़ेंगे:

  1. डेटा आयात करें
  2. डेटा को काले और सफेद प्रारूप में बदलें
  3. सभी बैचों को जोड़ें
  4. प्रशिक्षण डेटासेट का निर्माण करें
  5. एक छवि विज़ुअलाइज़र का निर्माण

छवि प्रीप्रोसेसिंग

चरण 1) डेटा आयात करें।

आधिकारिक वेबसाइट के अनुसार, आप निम्न कोड के साथ डेटा अपलोड कर सकते हैं। Autoencoder कोड डेटा और लेबल के साथ शब्दकोश में डेटा लोड करेगा । ध्यान दें कि कोड एक फ़ंक्शन है।

import numpy as npimport tensorflow as tfimport pickledef unpickle(file):import picklewith open(file, 'rb') as fo:dict = pickle.load(fo, encoding='latin1')return dict

चरण 2) डेटा को काले और सफेद प्रारूप में बदलें

सरलता के लिए, आप डेटा को ग्रेस्केल में बदल देंगे। यही है, रंग छवि के लिए तीन के खिलाफ केवल एक आयाम के साथ। अधिकांश तंत्रिका नेटवर्क केवल एक आयाम इनपुट के साथ काम करता है।

def grayscale(im):return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

चरण 3) सभी बैचों को जोड़ें

अब जब दोनों फ़ंक्शन बन गए हैं और लोड किए गए डेटासेट, आप मेमोरी में डेटा को जोड़ने के लिए एक लूप लिख सकते हैं। यदि आप ध्यान से जांचते हैं, तो डेटा के साथ अनज़िप फ़ाइल का नाम data_batch_ है, जिसकी संख्या 1 से 5 है। आप फ़ाइलों पर लूप कर सकते हैं और इसे डेटा में जोड़ सकते हैं।

जब यह चरण पूरा हो जाता है, तो आप रंगों के डेटा को ग्रे स्केल प्रारूप में बदल देते हैं। जैसा कि आप देख सकते हैं, डेटा का आकार 50000 और 1024 है। 32 * 32 पिक्सेल अब 2014 तक समतल हैं।

# Load the data into memorydata, labels = [], []## Loop over the bfor i in range(1, 6):filename = './cifar-10-batches-py/data_batch_' + str(i)open_data = unpickle(filename)if len(data)> 0:data = np.vstack((data, open_data['data']))labels = np.hstack((labels, open_data['labels']))else:data = open_data['data']labels = open_data['labels']data = grayscale(data)x = np.matrix(data)y = np.array(labels)print(x.shape)(50000, 1024)

नोट: अपनी फ़ाइल के वास्तविक स्थान पर '/ .ifar-10-batches-py/data_batch_' बदलें। उदाहरण के लिए विंडोज मशीन के लिए, पथ फ़ाइल नाम = 'E: \ cifar-10-batches-py \ data_batch_' + str (i) हो सकता है

चरण 4) प्रशिक्षण डेटासेट का निर्माण करें

प्रशिक्षण को तेज और आसान बनाने के लिए, आप केवल घोड़े की छवियों पर एक मॉडल को प्रशिक्षित करेंगे। लेबल डेटा में घोड़े सातवें वर्ग हैं। जैसा कि CIFAR-10 डेटासेट के प्रलेखन में उल्लेख किया गया है, प्रत्येक वर्ग में 5000 चित्र हैं। आप पुष्टि करने के लिए डेटा के आकार को प्रिंट कर सकते हैं। नीचे दिए गए TensorFlow Autoencoder कदम में दिखाए गए 1024 कॉलम के साथ 5.000 चित्र हैं।

horse_i = np.where(y == 7)[0]horse_x = x[horse_i]print(np.shape(horse_x))(5000, 1024)

चरण 5) एक छवि विज़ुअलाइज़र का निर्माण करें

अंत में, आप छवियों को प्लॉट करने के लिए एक फ़ंक्शन का निर्माण करते हैं। Autoencoder से पुनर्निर्मित छवि को प्रिंट करने के लिए आपको इस फ़ंक्शन की आवश्यकता होगी।

छवियों को प्रिंट करने का एक आसान तरीका है, matplotlib लाइब्रेरी से ऑब्जेक्ट imshow का उपयोग करना। ध्यान दें, आपको 1024 से 32 * 32 (यानी एक छवि का प्रारूप) डेटा के आकार को बदलने की आवश्यकता है।

# To plot pretty figures%matplotlib inlineimport matplotlibimport matplotlib.pyplot as pltdef plot_image(image, shape=[32, 32], cmap = "Greys_r"):plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")plt.axis("off")

फ़ंक्शन 3 तर्क लेता है:

  • चित्र: इनपुट
  • आकार: सूची, छवि का आयाम
  • Cmap: कलर मैप चुनें। डिफ़ॉल्ट रूप से, ग्रे

आप डेटासेट में पहली छवि बनाने की कोशिश कर सकते हैं। आपको एक आदमी को घोड़े पर देखना चाहिए।

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")

डेटासेट अनुमानक सेट करें

सब ठीक है, अब जब डेटासेट उपयोग करने के लिए तैयार है, तो आप Tensorflow का उपयोग करना शुरू कर सकते हैं। मॉडल बनाने से पहले, नेटवर्क को खिलाने के लिए टेंसरफ़्लो के डेटासेट अनुमानक का उपयोग करें।

आप TensorFlow अनुमानक के साथ एक डेटासेट का निर्माण करेंगे। अपने दिमाग को ताज़ा करने के लिए, आपको उपयोग करने की आवश्यकता है:

  • from_tensor_slices
  • दोहराना
  • जत्था

डेटासेट बनाने का पूरा कोड है:

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

ध्यान दें कि, x एक प्लेसहोल्डर है जिसमें निम्नलिखित आकृति है:

  • [कोई नहीं, n_inputs]: नेटवर्क पर छवि फ़ीड की संख्या बैच आकार के बराबर होने के कारण कोई भी सेट नहीं करता है।

विवरण के लिए, कृपया रेखीय प्रतिगमन पर ट्यूटोरियल देखें।

उसके बाद, आपको पुनरावृत्त बनाने की आवश्यकता है। इस कोड की रेखा के बिना, कोई भी डेटा पाइपलाइन के माध्यम से नहीं जाएगा।

iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()

अब जब पाइपलाइन तैयार हो गई है, तो आप जांच सकते हैं कि क्या पहली छवि पहले की तरह है (यानी, घोड़े पर एक आदमी)।

आप बैच आकार को 1 पर सेट करते हैं क्योंकि आप केवल एक छवि के साथ डेटासेट खिलाना चाहते हैं। आप प्रिंट (sess.run (सुविधाएँ) .shape) के साथ डेटा का आयाम देख सकते हैं। यह (1, 1024) के बराबर है। 1 का मतलब है कि 1024 में से केवल एक छवि प्रत्येक को खिलाती है। यदि बैच का आकार दो पर सेट है, तो दो चित्र पाइपलाइन के माध्यम से जाएंगे। (बैच का आकार न बदलें। अन्यथा, यह एक त्रुटि फेंक देगा। एक समय में केवल एक छवि फ़ंक्शन प्लॉट_इमेज () में जा सकती है।

## Parametersn_inputs = 32 * 32BATCH_SIZE = 1batch_size = tf.placeholder(tf.int64)# using a placeholderx = tf.placeholder(tf.float32, shape=[None,n_inputs])## Datasetdataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)iter = dataset.make_initializable_iterator() # create the iteratorfeatures = iter.get_next()## Print the imagewith tf.Session() as sess:# feed the placeholder with datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print(sess.run(features).shape)plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")(1, 1024)

नेटवर्क बनाएँ

यह नेटवर्क के निर्माण का समय है। आप एक स्टैक किए गए ऑटोएन्कोडर को प्रशिक्षित करेंगे, अर्थात, एक नेटवर्क जिसमें कई छिपी हुई परतें हैं।

आपके नेटवर्क में 1024 बिंदुओं, यानी 32x32, छवि के आकार के साथ एक इनपुट परतें होंगी।

एनकोडर ब्लॉक में 300 न्यूरॉन्स के साथ एक शीर्ष छिपी परत होगी, 150 न्यूरॉन्स के साथ एक केंद्रीय परत। डिकोडर ब्लॉक एनकोडर के सममित है। आप नीचे दी गई तस्वीर में नेटवर्क की कल्पना कर सकते हैं। ध्यान दें कि आप छिपे हुए और केंद्रीय परतों के मूल्यों को बदल सकते हैं।

Autoencoder के लिए नेटवर्क का निर्माण

एक ऑटोएन्कोडर का निर्माण करना किसी अन्य गहरे शिक्षण मॉडल के समान है।

आप इन चरणों का पालन करते हुए मॉडल का निर्माण करेंगे:

  1. मापदंडों को परिभाषित करें
  2. परतों को परिभाषित करें
  3. वास्तुकला को परिभाषित करें
  4. अनुकूलन को परिभाषित करें
  5. मॉडल को चलाएं
  6. मॉडल का मूल्यांकन करें

पिछले अनुभाग में, आपने सीखा कि मॉडल को खिलाने के लिए पाइप लाइन कैसे बनाई जाए, इसलिए एक बार और डेटासेट बनाने की आवश्यकता नहीं है। आप चार परतों के साथ एक ऑटोकेन्डर का निर्माण करेंगे। आप ज़ेवियर इनिशियलाइज़ेशन का उपयोग करते हैं। यह इनपुट और आउटपुट दोनों के विचरण के बराबर प्रारंभिक भार निर्धारित करने की एक तकनीक है। अंत में, आप एलु सक्रियण फ़ंक्शन का उपयोग करते हैं। आप L2 नियमित के साथ नुकसान फ़ंक्शन को नियमित करते हैं।

चरण 1) मापदंडों को परिभाषित करें

पहला चरण प्रत्येक परत में न्यूरॉन्स की संख्या, सीखने की दर और नियमित रूप से हाइपरपरमीटर को परिभाषित करने के लिए है।

इससे पहले, आप फ़ंक्शन को आंशिक रूप से आयात करते हैं। यह घने परतों के मापदंडों को परिभाषित करने के लिए एक बेहतर विधि है। नीचे दिया गया कोड ऑटोएन्कोडर आर्किटेक्चर के मूल्यों को परिभाषित करता है। जैसा कि पहले सूचीबद्ध किया गया है, ऑटोकेनोडर की दो परतें हैं, पहली परतों में 300 न्यूरॉन्स और दूसरी परतों में 150। उनके मान n_hidden_1 और n_hidden_2 में संग्रहीत हैं।

आपको सीखने की दर और L2 हाइपरपरमीटर को परिभाषित करने की आवश्यकता है। मान Learning_rate और l2_reg में संग्रहीत हैं

from functools import partial## Encodern_hidden_1 = 300n_hidden_2 = 150 # codings## Decodern_hidden_3 = n_hidden_1n_outputs = n_inputslearning_rate = 0.01l2_reg = 0.0001

जेवियर इनिशियलाइज़ेशन तकनीक को अनुमानक कंट्राब से ऑब्जेक्ट xavier_initializer कहा जाता है। एक ही अनुमानक में, आप नियमित रूप से l2_ अनियमित के साथ जोड़ सकते हैं

## Define the Xavier initializationxav_init = tf.contrib.layers.xavier_initializer()## Define the L2 regularizerl2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

चरण 2) परतों को परिभाषित करें

घने परतों के सभी मापदंडों को निर्धारित किया गया है; आप ऑब्जेक्ट को आंशिक रूप से उपयोग करके चर dense_layer में सब कुछ पैक कर सकते हैं। dense_layer जो ELU सक्रियण, ज़ेवियर आरंभीकरण और L2 नियमितीकरण का उपयोग करता है।

## Create the dense layerdense_layer = partial(tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer)

चरण 3) वास्तुकला को परिभाषित करें

यदि आप वास्तुकला की तस्वीर को देखते हैं, तो आप ध्यान दें कि नेटवर्क आउटपुट परत के साथ तीन परतों को ढेर करता है। नीचे दिए गए कोड में, आप उपयुक्त परतों को जोड़ते हैं। उदाहरण के लिए, पहली परत डॉट्स की विशेषताओं के बीच मैट उत्पाद और 300 वज़न वाले मेट्रिसेस की गणना करती है। डॉट उत्पाद की गणना होने के बाद, आउटपुट एलु सक्रियण फ़ंक्शन में जाता है। आउटपुट अगली लेयर का इनपुट बन जाता है, यही कारण है कि आप इसका उपयोग छिपे हुए २.२ इत्यादि की गणना के लिए करते हैं। मैट्रिसेस गुणा प्रत्येक परत के लिए समान है क्योंकि आप एक ही सक्रियण फ़ंक्शन का उपयोग करते हैं। ध्यान दें कि अंतिम परत, आउटपुट, सक्रियण फ़ंक्शन लागू नहीं करता है। यह समझ में आता है क्योंकि यह पुनर्निर्मित इनपुट है

## Make the mat mulhidden_1 = dense_layer(features, n_hidden_1)hidden_2 = dense_layer(hidden_1, n_hidden_2)hidden_3 = dense_layer(hidden_2, n_hidden_3)outputs = dense_layer(hidden_3, n_outputs, activation=None)

चरण 4) अनुकूलन को परिभाषित करें

अंतिम चरण ऑप्टिमाइज़र का निर्माण करना है। आप एक हानि फ़ंक्शन के रूप में मीन स्क्वायर त्रुटि का उपयोग करते हैं। यदि आप रेखीय प्रतिगमन पर ट्यूटोरियल को याद करते हैं, तो आप जानते हैं कि एमएसई की गणना अनुमानित आउटपुट और वास्तविक लेबल के बीच अंतर के साथ की जाती है। यहां, लेबल सुविधा है क्योंकि मॉडल इनपुट को फिर से संगठित करने की कोशिश करता है। इसलिए, आप अनुमानित आउटपुट और इनपुट के बीच वर्ग के अंतर का योग चाहते हैं। TensorFlow के साथ, आप निम्न फ़ंक्शन को निम्नानुसार कोड कर सकते हैं:

loss = tf.reduce_mean(tf.square(outputs - features))

फिर, आपको नुकसान फ़ंक्शन को अनुकूलित करने की आवश्यकता है। आप ग्रेडर की गणना करने के लिए एडम ऑप्टिमाइज़र का उपयोग करते हैं। उद्देश्य समारोह नुकसान को कम करने के लिए है।

## Optimizeloss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)

मॉडल को प्रशिक्षित करने से पहले एक और सेटिंग। आप 150 के एक बैच आकार का उपयोग करना चाहते हैं, अर्थात्, 150 छवियों के साथ पाइपलाइन को प्रत्येक पुनरावृत्ति को खिलाएं। आपको मैन्युअल रूप से पुनरावृत्तियों की संख्या की गणना करने की आवश्यकता है। यह करने के लिए तुच्छ है:

यदि आप हर बार 150 छवियां पास करना चाहते हैं और आपको पता है कि डेटासेट में 5000 छवियां हैं, तो पुनरावृत्तियों की संख्या बराबर है। अजगर में आप निम्नलिखित कोड चला सकते हैं और सुनिश्चित कर सकते हैं कि आउटपुट 33 है:

BATCH_SIZE = 150### Number of batches : length dataset / batch sizen_batches = horse_x.shape[0] // BATCH_SIZEprint(n_batches)33

चरण 5) मॉडल को चलाएं

अंतिम लेकिन कम से कम, मॉडल को प्रशिक्षित करें। आप 100 युगों के साथ मॉडल का प्रशिक्षण ले रहे हैं। यही है, मॉडल अनुकूलित वज़न के लिए छवियों को 100 गुना देखेंगे।

Tensorflow में एक मॉडल को प्रशिक्षित करने के लिए आप पहले से ही कोड से परिचित हैं। मामूली अंतर प्रशिक्षण चलाने से पहले डेटा को पाइप करने के लिए है। इस तरह, मॉडल तेजी से ट्रेन करता है।

आप दस युगों के बाद नुकसान को प्रिंट करने में रुचि रखते हैं यह देखने के लिए कि क्या मॉडल कुछ सीख रहा है (यानी, नुकसान कम हो रहा है)। आपके मशीन के हार्डवेयर के आधार पर प्रशिक्षण में 2 से 5 मिनट का समय लगता है।

## Set paramsn_epochs = 100## Call Saver to save the model and re-use it later during evaluationsaver = tf.train.Saver()with tf.Session() as sess:sess.run(tf.global_variables_initializer())# initialise iterator with train datasess.run(iter.initializer, feed_dict={x: horse_x,batch_size: BATCH_SIZE})print('Training… ')print(sess.run(features).shape)for epoch in range(n_epochs):for iteration in range(n_batches):sess.run(train)if epoch % 10 == 0:loss_train = loss.eval() # not shownprint("\r{}".format(epoch), "Train MSE:", loss_train)#saver.save(sess, "./my_model_all_layers.ckpt")save_path = saver.save(sess, "./model.ckpt")print("Model saved in path: %s" % save_path)Training… (150, 1024)0 Train MSE: 2934.45510 Train MSE: 1672.67620 Train MSE: 1514.70930 Train MSE: 1404.311840 Train MSE: 1425.05850 Train MSE: 1479.063160 Train MSE: 1609.525970 Train MSE: 1482.322380 Train MSE: 1445.703590 Train MSE: 1453.8597Model saved in path: ./model.ckpt

चरण 6) मॉडल का मूल्यांकन करें

अब जब आपके पास अपना मॉडल प्रशिक्षित है, तो इसका मूल्यांकन करने का समय आ गया है। आपको फ़ाइल / cifar-10-batches-py / से टेस्ट सेर आयात करना होगा।

test_data = unpickle('./cifar-10-batches-py/test_batch')test_x = grayscale(test_data['data'])#test_labels = np.array(test_data['labels'])

नोट: एक विंडोज़ मशीन के लिए, कोड test_data = unpickle (r "E: \ cifar-10-batches-py \ test_batch") बन जाता है

आप छवियों को मुद्रित करने का प्रयास कर सकते हैं 13, जो एक घोड़ा है

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")

मॉडल का मूल्यांकन करने के लिए, आप इस छवि के पिक्सेल मूल्य का उपयोग करेंगे और देखें कि एन्कोडर 1024 पिक्सल सिकुड़ने के बाद उसी छवि को फिर से बना सकता है या नहीं। ध्यान दें, आप विभिन्न चित्रों पर मॉडल का मूल्यांकन करने के लिए एक फ़ंक्शन को परिभाषित करते हैं। मॉडल को केवल घोड़ों पर बेहतर काम करना चाहिए।

फ़ंक्शन दो तर्क लेता है:

  • df: परीक्षण डेटा आयात करें
  • image_number: इंगित करें कि आयात करने के लिए क्या छवि है

फ़ंक्शन को तीन भागों में विभाजित किया गया है:

  1. सही आयाम यानी 1, 1024 में छवि को फिर से आकार दें
  2. मॉडल को अनदेखी छवि के साथ फ़ीड करें, छवि को एनकोड / डीकोड करें
  3. वास्तविक और पुनर्निर्मित छवि मुद्रित करें
def reconstruct_image(df, image_number = 1):## Part 1: Reshape the image to the correct dimension i.e 1, 1024x_test = df[image_number]x_test_1 = x_test.reshape((1, 32*32))## Part 2: Feed the model with the unseen image, encode/decode the imagewith tf.Session() as sess:sess.run(tf.global_variables_initializer())sess.run(iter.initializer, feed_dict={x: x_test_1,batch_size: 1})## Part 3: Print the real and reconstructed image# Restore variables from disk.saver.restore(sess, "./model.ckpt")print("Model restored.")# Reconstruct imageoutputs_val = outputs.eval()print(outputs_val.shape)fig = plt.figure()# Plot realax1 = fig.add_subplot(121)plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")# Plot estimatedax2 = fig.add_subplot(122)plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")plt.tight_layout()fig = plt.gcf()

अब जब मूल्यांकन फ़ंक्शन परिभाषित किया गया है, तो आप पुनर्निर्मित छवि संख्या तेरह का एक रूप देख सकते हैं

reconstruct_image(df =test_x, image_number = 13) 
INFO:tensorflow:Restoring parameters from ./model.ckptModel restored.(1, 1024)

सारांश

एक ऑटोएन्कोडर का प्राथमिक उद्देश्य इनपुट डेटा को संपीड़ित करना है, और फिर इसे मूल डेटा की तरह करीब से देखने वाले आउटपुट में खोल देना है।

केंद्रीय परत नामक एक धुरी परत के साथ एक ऑटोकेनोड सममित की वास्तुकला।

आप स्वत: कोड का उपयोग करके बना सकते हैं:

  • आंशिक: विशिष्ट सेटिंग के साथ घनी परतें बनाने के लिए:
  • tf.layers.dense,activation=tf.nn.elu,kernel_initializer=xav_init,kernel_regularizer=l2_regularizer
  • dense_layer (): मैट्रिक्स गुणा करने के लिए

आप के साथ नुकसान समारोह और अनुकूलन को परिभाषित कर सकते हैं:

loss = tf.reduce_mean(tf.square(outputs - features))optimizer = tf.train.AdamOptimizer(learning_rate)train = optimizer.minimize(loss)

पिछले मॉडल को प्रशिक्षित करने के लिए एक सत्र चलाएं।