TensorFlow में ऑटोएनकोडर उदाहरण के साथ
एवलिन क्लार्क
⚡ स्मार्ट सारांश
ऑटोएनकोडर इनपुट को एक छोटे आंतरिक प्रतिनिधित्व में संपीड़ित करते हैं और फिर उसे पुनर्निर्मित करते हैं, लेबल के बिना सबसे महत्वपूर्ण विशेषताओं को सीखते हैं। यह वॉकथ्रू टेन्सरफ्लो में चार सघन परतों को स्टैक करता है और CIFAR-10 घोड़े की छवियों का पुनर्निर्माण करता है।
डीप लर्निंग में ऑटोएनकोडर क्या है?
An स्वयंभू यह एक ऐसा उपकरण है जिसके द्वारा डेटा कोडिंग को कुशलतापूर्वक सीखा जा सकता है। के चलते किसी तरीका। यह एक प्रकार का है। कृत्रिम तंत्रिका नेटवर्क यह आपको डेटा सेट के निरूपण को समझने में मदद करता है, जिससे आप सिग्नल नॉइज़ को अनदेखा करने के लिए न्यूरल नेटवर्क को प्रशिक्षित करके आयाम में कमी ला सकते हैं। यह इनपुट को पुनः उत्पन्न करने के लिए एक बेहतरीन उपकरण है।
सरल शब्दों में कहें तो, मशीन एक छवि लेती है और उससे मिलती-जुलती तस्वीर बना सकती है। इस प्रकार के न्यूरल नेटवर्क में इनपुट अनलेबल होता है, जिसका अर्थ है कि नेटवर्क बिना किसी पर्यवेक्षण के सीखने में सक्षम है। अधिक सटीक रूप से कहें तो, नेटवर्क इनपुट को इस तरह से एन्कोड करता है कि वह केवल सबसे महत्वपूर्ण विशेषता पर ही ध्यान केंद्रित करे। यही कारण है कि ऑटोएनकोडर आयाम घटाने के लिए लोकप्रिय है। इसके अलावा, ऑटोएनकोडर का उपयोग जनरेटिव लर्निंग मॉडल बनाने के लिए किया जा सकता है। उदाहरण के लिए, न्यूरल नेटवर्क को चेहरों के एक सेट के साथ प्रशिक्षित किया जा सकता है और फिर वह नए चेहरे बना सकता है।
TensorFlow ऑटोएनकोडर कैसे काम करता है?
ऑटोएनकोडर का उद्देश्य केवल आवश्यक विशेषताओं पर ध्यान केंद्रित करके इनपुट का अनुमान लगाना है। आप सोच सकते हैं कि क्यों न केवल इनपुट को कॉपी करके पेस्ट करना सीख लिया जाए ताकि आउटपुट प्राप्त हो सके। वास्तव में, ऑटोएनकोडर बाधाओं का एक सेट है जो नेटवर्क को डेटा को प्रस्तुत करने के नए तरीके सीखने के लिए मजबूर करता है, जो केवल आउटपुट की प्रतिलिपि बनाने से अलग है।
एक सामान्य ऑटोएनकोडर को इनपुट, आंतरिक निरूपण और आउटपुट (इनपुट का अनुमानित निरूपण) के साथ परिभाषित किया जाता है। सीखने की प्रक्रिया आंतरिक निरूपण से जुड़ी परतों में होती है। वास्तव में, इसमें परतों के दो मुख्य ब्लॉक होते हैं जो एक पारंपरिक न्यूरल नेटवर्क की तरह दिखते हैं। मामूली अंतर यह है कि आउटपुट वाली परत इनपुट के बराबर होनी चाहिए। नीचे दिए गए चित्र में, मूल इनपुट पहले ब्लॉक में जाता है जिसे एनकोडर कहते हैं। यह आंतरिक निरूपण इनपुट के आकार को संपीड़ित (कम) करता है। दूसरे ब्लॉक में इनपुट का पुनर्निर्माण होता है। यह डिकोडिंग चरण है।
मॉडल हानि फ़ंक्शन को न्यूनतम करके वज़न को अपडेट करेगा। यदि पुनर्निर्माण आउटपुट इनपुट से अलग है तो मॉडल को दंडित किया जाता है।
उदाहरण के लिए, एक 50×50 पिक्सेल (यानी 2,500 पिक्सेल) वाली तस्वीर और एक न्यूरल नेटवर्क की कल्पना करें जिसमें केवल एक हिडन लेयर है और उसमें सौ न्यूरॉन्स हैं। लर्निंग एक फीचर मैप पर की जाती है जो इनपुट से पच्चीस गुना छोटा है। इसका मतलब है कि नेटवर्क को केवल 100 न्यूरॉन्स के वेक्टर का उपयोग करके 2,500 पिक्सेल को पुनर्निर्मित करने का तरीका खोजना होगा।
स्टैक्ड ऑटोएनकोडर उदाहरण
इस ऑटोएनकोडर ट्यूटोरियल में, आप स्टैक्ड ऑटोएनकोडर का उपयोग करना सीखेंगे। इसकी संरचना पारंपरिक न्यूरल नेटवर्क के समान है। इनपुट को संपीड़ित करने (यानी उसका आकार कम करने) के लिए एक हिडन लेयर में भेजा जाता है, और फिर वह पुनर्निर्माण लेयर्स तक पहुँचता है। इसका उद्देश्य मूल छवि के यथासंभव निकट आउटपुट छवि तैयार करना है। मॉडल को कुछ सीमाओं के भीतर, यानी कम आयाम में, अपना कार्य पूरा करने का तरीका सीखना होता है।
आजकल, डीप लर्निंग में ऑटोएनकोडर का उपयोग मुख्य रूप से इमेज से नॉइज़ हटाने के लिए किया जाता है। एक ऐसी इमेज की कल्पना करें जिसमें खरोंचें हों; फिर भी मनुष्य उसमें मौजूद सामग्री को पहचान सकता है। नॉइज़ हटाने वाले ऑटोएनकोडर का विचार यह है कि चित्र में नॉइज़ जोड़ा जाए ताकि नेटवर्क को डेटा के पीछे के पैटर्न को सीखने के लिए मजबूर किया जा सके।
ऑटोएनकोडर का दूसरा उपयोगी परिवार गहरी सीख यह एक वेरिएशनल ऑटोएनकोडर है। इस प्रकार का नेटवर्क नई छवियां उत्पन्न कर सकता है। कल्पना कीजिए कि आप एक पुरुष की छवि के साथ एक नेटवर्क को प्रशिक्षित करते हैं; ऐसा नेटवर्क नए चेहरे उत्पन्न कर सकता है।
नीचे दी गई तालिका में इस ट्यूटोरियल में निर्मित स्टैक्ड ऑटोएनकोडर को उन अन्य परिवारों के साथ रखा गया है जिनसे आपका सामना होने की संभावना है, ताकि प्रत्येक द्वारा जोड़ी गई बाधा की तुलना करना आसान हो सके।
| ऑटोएनकोडर प्रकार | प्रतिबंध जोड़ा गया | विशिष्ट उपयोग |
|---|---|---|
| अपूर्ण / ढेर | इनपुट की तुलना में कोडिंग परत संकरी होती है | आयामी कमी, फ़ीचर एक्सtracउत्पादन |
| डीनोइज़िंग | इनपुट में शोर जोड़ा गया, स्वच्छ लक्ष्य | छवि और सिग्नल की सफाई |
| विरल | सक्रिय इकाइयों की संख्या पर जुर्माना | व्याख्या योग्य, भाग-आधारित विशेषताएँ |
| परिवर्तन संबंधी | कोडिंग लेयर एक संभाव्यता वितरण सीखती है | नए नमूने तैयार करना |
TensorFlow के साथ ऑटोएनकोडर कैसे बनाएं
इस ट्यूटोरियल में, आप सीखेंगे कि किसी छवि को पुनः निर्मित करने के लिए स्टैक्ड ऑटोएनकोडर का निर्माण कैसे किया जाता है।
आप CIFAR-10 डेटासेट का उपयोग करेंगे जिसमें 60000 32×32 रंगीन छवियां हैं। ऑटोएनकोडर डेटासेट पहले से ही प्रशिक्षण के लिए 50000 छवियों और परीक्षण के लिए 10000 छवियों में विभाजित है। इसमें अधिकतम दस श्रेणियां हैं:
- हवाई जहाज
- मोटर
- पक्षी
- बिल्ली
- हिरन
- कुत्ता
- मेंढक
- घोड़ा
- जहाज
- ट्रक
आपको छवियों को डाउनलोड करना होगा CIFAR-10 डेटासेट पृष्ठ और आर्काइव को अनज़िप करें। cifar-10-batches-py फोल्डर में यादृच्छिक क्रम में 10000 छवियों वाले डेटा के पांच बैच हैं।
अपने मॉडल को बनाने और प्रशिक्षित करने से पहले, आपको कुछ डेटा प्रोसेसिंग लागू करने की आवश्यकता है। आप निम्न प्रकार से आगे बढ़ेंगे:
- डेटा आयात करें
- डेटा को काले और सफेद प्रारूप में परिवर्तित करें
- सभी बैचों को जोड़ें
- प्रशिक्षण डेटासेट का निर्माण करें
- एक छवि विज़ुअलाइज़र का निर्माण करें
संस्करण नोट: इस ट्यूटोरियल में दिया गया कोड TensorFlow 1.x के लिए बनाया गया है। TensorFlow 2 में tf.contrib मॉड्यूल मौजूद नहीं है, और प्लेसहोल्डर, सेशन और इनिशियलाइज़ेबल इटरेटर tf.compat.v1 के अंतर्गत आते हैं। इंपोर्ट के बाद tf.compat.v1.disable_v2_behavior() को कॉल करना लिस्टिंग को बिना किसी बदलाव के चलाने का सबसे तेज़ तरीका है।
छवि प्रीप्रोसेसिंग
चरण 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 पिक्सेल अब 1024 पिक्सेल में बदल दिए गए हैं।
# 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) प्रशिक्षण डेटासेट का निर्माण करें
प्रशिक्षण को तेज़ और आसान बनाने के लिए, आप केवल घोड़ों की छवियों पर ही मॉडल को प्रशिक्षित करेंगे। लेबल डेटा में घोड़ों को लेबल 7 दिया गया है। CIFAR-10 डेटासेट के दस्तावेज़ीकरण में बताया गया है कि प्रत्येक वर्ग में 5000 छवियां हैं। नीचे दिए गए TensorFlow ऑटोएनकोडर उदाहरण चरण में दिखाए अनुसार, आप डेटा का आकार प्रिंट करके पुष्टि कर सकते हैं कि इसमें 1024 कॉलम के साथ 5,000 छवियां हैं।
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 तर्क लेता है:
- छवि: इनपुट
- आकार: सूची, छवि का आयाम
- Cmap: रंग मानचित्र चुनें। डिफ़ॉल्ट रूप से, रंग ग्रे होता है।
आप डेटासेट में पहली छवि प्लॉट करने का प्रयास कर सकते हैं। आपको घोड़े पर सवार एक आदमी दिखाई देगा।
plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")
यह कॉल नीचे दिए गए ग्रेस्केल थंबनेल को लौटाता है, और यह पुष्टि करता है कि 1024 मानों से 32×32 छवि में रीशेप करना सही है।
डेटासेट अनुमानक सेट करें
ठीक है, अब जबकि डेटासेट उपयोग के लिए तैयार है, आप 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)
यह पाइपलाइन वही राइडर लौटाती है जिसे सीधे NumPy मैट्रिक्स से प्लॉट किया गया था, जो यह साबित करता है कि प्लेसहोल्डर, इटरेटर और बैच साइज सही ढंग से जुड़े हुए हैं।
नेटवर्क बनाएं
अब नेटवर्क बनाने का समय आ गया है। आप एक स्टैक्ड ऑटोएनकोडर को प्रशिक्षित करेंगे, यानी कई छिपी हुई परतों वाला एक नेटवर्क।
आपके नेटवर्क में 1024 बिंदुओं वाली एक इनपुट लेयर होगी, यानी 32×32, जो कि छवि का आकार है।
एनकोडर ब्लॉक में 300 न्यूरॉन्स वाली एक शीर्ष हिडन लेयर और 150 न्यूरॉन्स वाली एक केंद्रीय लेयर होगी। डिकोडर ब्लॉक एनकोडर के सममित है। आप नीचे दिए गए चित्र में नेटवर्क को देख सकते हैं। ध्यान दें कि आप हिडन और केंद्रीय लेयर्स के मान बदल सकते हैं।
ऑटोएनकोडर का निर्माण किसी भी अन्य गहन शिक्षण मॉडल के समान ही है।
आप इन चरणों का पालन करके मॉडल का निर्माण करेंगे:
- पैरामीटर परिभाषित करें
- परतों को परिभाषित करें
- वास्तुकला को परिभाषित करें
- अनुकूलन को परिभाषित करें
- मॉडल चलाएँ
- मॉडल का मूल्यांकन करें
पिछले भाग में, आपने मॉडल को डेटा फीड करने के लिए पाइपलाइन बनाना सीखा, इसलिए डेटासेट को दोबारा बनाने की आवश्यकता नहीं है। आप चार परतों वाला एक ऑटोएनकोडर बनाएंगे। आप ज़ेवियर इनिशियलाइज़ेशन का उपयोग करेंगे। यह इनपुट और आउटपुट दोनों के विचरण के अनुसार प्रारंभिक भार निर्धारित करने की एक तकनीक है। अंत में, आप 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)
संस्करण नोट: TensorFlow 2 में tf.contrib को हटा दिया गया था। इसके सीधे प्रतिस्थापन xavier_initializer() के लिए tf.keras.initializers.GlorotUniform() और l2_regularizer() के लिए tf.keras.regularizers.l2() हैं।
चरण 2) परतों को परिभाषित करें
सघन परतों के सभी पैरामीटर सेट कर दिए गए हैं; आप ऑब्जेक्ट पार्शियल का उपयोग करके सब कुछ dense_layer नामक वेरिएबल में पैक कर सकते हैं। dense_layer प्रत्येक कॉल पर 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 भारों वाले मैट्रिक्स के बीच डॉट प्रोडक्ट की गणना करती है। डॉट प्रोडक्ट की गणना के बाद, आउटपुट ELU सक्रियण फ़ंक्शन में जाता है। आउटपुट अगली परत का इनपुट बन जाता है, इसलिए आप इसका उपयोग हिडन_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) का उपयोग करते हैं। यदि आपको रैखिक प्रतिगमन पर ट्यूटोरियल याद है, तो आप जानते हैं कि 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 छवियां हैं, तो पुनरावृति की संख्या 5000 को 150 से विभाजित करने के बराबर होगी। Python आप निम्नलिखित कोड चला सकते हैं और सुनिश्चित कर सकते हैं कि आउटपुट 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")
यह ग्राफ इस बात की पुष्टि करता है कि टेस्ट बैच सही ढंग से लोड हो गया है और छवि 13 उसी वर्ग से संबंधित है जिस पर मॉडल को प्रशिक्षित किया गया था।
मॉडल का मूल्यांकन करने के लिए, आप इस छवि के पिक्सेल मान का उपयोग करेंगे और देखेंगे कि क्या एनकोडर इसे 1024 पिक्सेल तक सिकोड़ने के बाद उसी छवि को पुनर्निर्मित कर सकता है। ध्यान दें कि, आप विभिन्न चित्रों पर मॉडल का मूल्यांकन करने के लिए एक फ़ंक्शन परिभाषित करते हैं। यह मॉडल केवल घोड़ों पर ही बेहतर काम करना चाहिए।
फ़ंक्शन दो तर्क लेता है:
- df: परीक्षण डेटा आयात करें
- image_number: यह दर्शाता है कि कौन सी छवि आयात करनी है
यह कार्य तीन भागों में विभाजित है:
- छवि को सही आयाम अर्थात 1, 1024 पर पुनः आकार दें
- मॉडल को अदृश्य छवि प्रदान करें, छवि को एनकोड/डिकोड करें
- वास्तविक और पुनर्निर्मित छवि प्रिंट करें
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)
इस चित्र में मूल परीक्षण छवि को बाईं ओर और ऑटोएनकोडर आउटपुट को दाईं ओर रखा गया है, जिससे 1024 से 150 के संपीड़न के बाद बारीक विवरणों की हानि का आसानी से आकलन किया जा सकता है।
