TensorFlow में ऑटोएनकोडर उदाहरण के साथ

डीप लर्निंग में ऑटोएनकोडर क्या है?

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

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

TensorFlow ऑटोएनकोडर कैसे काम करता है?

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

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

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

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

स्टैक्ड ऑटोएनकोडर उदाहरण

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

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

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

TensorFlow के साथ ऑटोएनकोडर कैसे बनाएं

इस ट्यूटोरियल में, आप सीखेंगे कि किसी छवि को पुनः निर्मित करने के लिए स्टैक्ड ऑटोएनकोडर का निर्माण कैसे किया जाता है।

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

• हवाई जहाज
• मोटर
• पक्षी
• बिल्ली
• हिरन
• कुत्ता
• मेंढक
• घोड़ा
• जहाज
• ट्रक

आपको इस URL https://www.cs.toronto.edu/~kriz/cifar.html में इमेज डाउनलोड करके उसे अनज़िप करना होगा। for-10-batches-py फ़ोल्डर में डेटा के पाँच बैच हैं, जिनमें से प्रत्येक में यादृच्छिक क्रम में 10000 इमेज हैं।

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

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

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

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

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

import numpy as np
import tensorflow as tf
import pickle
def unpickle(file):
    import pickle
    with 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 memory
data, labels = [], []
## Loop over the b
for 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)

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

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

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

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

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

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

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

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

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

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

आप डेटासेट में पहली छवि प्लॉट करने का प्रयास कर सकते हैं। आपको घोड़े पर सवार एक आदमी दिखाई देगा।

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

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

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

आप TensorFlow अनुमानक के साथ एक डेटासेट बनाएंगे। अपने दिमाग को तरोताजा करने के लिए, आपको इसका उपयोग करना होगा:

• टेंसर_स्लाइस से
• दोहराना
• बैच

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

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

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

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

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

उसके बाद, आपको इटरेटर बनाना होगा। कोड की इस लाइन के बिना, कोई भी डेटा पाइपलाइन से नहीं गुजरेगा।

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

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

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

## Parameters
n_inputs = 32 * 32
BATCH_SIZE = 1
batch_size = tf.placeholder(tf.int64)

# using a placeholder
x = tf.placeholder(tf.float32, shape=[None,n_inputs])
## Dataset
dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
iter = dataset.make_initializable_iterator() # create the iterator
features = iter.get_next()

## Print the image
with tf.Session() as sess:
    # feed the placeholder with data
    sess.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 बिंदुओं वाली एक इनपुट परत होगी, अर्थात, 32×32, जो छवि का आकार है।

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

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

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

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

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

चरण 1) पैरामीटर परिभाषित करें

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

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

आपको लर्निंग रेट और L2 हाइपरपैरामीटर को परिभाषित करना होगा। मान learning_rate और l2_reg में संग्रहीत हैं

from functools import partial

## Encoder
n_hidden_1 = 300
n_hidden_2 = 150  # codings

## Decoder
n_hidden_3 = n_hidden_1
n_outputs = n_inputs

learning_rate = 0.01
l2_reg = 0.0001

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

## Define the Xavier initialization
xav_init =  tf.contrib.layers.xavier_initializer()
## Define the L2 regularizer
l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

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

सघन परतों के सभी पैरामीटर सेट कर दिए गए हैं; आप आंशिक. सघन_परत ऑब्जेक्ट का उपयोग करके वेरिएबल सघन_परत में सब कुछ पैक कर सकते हैं, जो ELU सक्रियण, जेवियर आरंभीकरण और L2 नियमितीकरण का उपयोग करता है।

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

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

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

## Make the mat mul
hidden_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) अनुकूलन को परिभाषित करें

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

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

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

## Optimize
loss = 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 size
n_batches = horse_x.shape[0] // BATCH_SIZE
print(n_batches)
33

चरण 5) मॉडल चलाएँ

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

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

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

## Set params
n_epochs = 100

## Call Saver to save the model and re-use it later during evaluation
saver = tf.train.Saver()

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # initialise iterator with train data
    sess.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 shown
            print("\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.455
10 Train MSE: 1672.676
20 Train MSE: 1514.709
30 Train MSE: 1404.3118
40 Train MSE: 1425.058
50 Train MSE: 1479.0631
60 Train MSE: 1609.5259
70 Train MSE: 1482.3223
80 Train MSE: 1445.7035
90 Train MSE: 1453.8597
Model 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'])

ध्यान दें: के लिए Windows मशीन, कोड 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: परीक्षण डेटा आयात करें
• छवि संख्या: बताएं कि कौन सी छवि आयात करनी है

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

1. छवि को सही आयाम अर्थात 1, 1024 पर पुनः आकार दें
2. मॉडल को अदृश्य छवि प्रदान करें, छवि को एनकोड/डिकोड करें
3. वास्तविक और पुनर्निर्मित छवि प्रिंट करें

def reconstruct_image(df, image_number = 1):
    ## Part 1: Reshape the image to the correct dimension i.e 1, 1024
    x_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 image
    with 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 image
        outputs_val = outputs.eval()
        print(outputs_val.shape)
        fig = plt.figure()
      # Plot real
        ax1 = fig.add_subplot(121)
        plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")
      # Plot estimated
        ax2 = 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.ckpt
Model restored.
(1, 1024)

सारांश

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

आंशिक: विशिष्ट सेटिंग के साथ सघन परतें बनाने के लिए:

  	tf.layers.dense,                         
  	activation=tf.nn.elu,                         
  	kernel_initializer=xav_init,                         
  	kernel_regularizer=l2_regularizer

सघन_परत(): मैट्रिक्स गुणन करने के लिए

• आप हानि फ़ंक्शन और अनुकूलन को निम्न प्रकार से परिभाषित कर सकते हैं:

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

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