संवादी तंत्रिका नेटवर्क क्या है?
संवेदी तंत्रिका नेटवर्क, जिसे कॉननेट या सीएनएन के रूप में भी जाना जाता है, कंप्यूटर दृष्टि अनुप्रयोगों में एक प्रसिद्ध तरीका है। चित्र या वीडियो से वस्तुओं को पहचानने के लिए इस प्रकार की वास्तुकला प्रमुख है।
इस ट्यूटोरियल में, आप सीखेंगे कि कनवे कैसे बनाएं और हस्तलिखित डेटासेट को हल करने के लिए TensorFlow का उपयोग कैसे करें।
इस ट्यूटोरियल में, आप सीखेंगे
- संवादी तंत्रिका नेटवर्क
- एक संवादात्मक तंत्रिका नेटवर्क की वास्तुकला
- कॉन्वेंट के घटक
- TensorFlow के साथ CNN को प्रशिक्षित करें
- चरण 1: डेटासेट अपलोड करें
- चरण 2: इनपुट परत
- चरण 3: संवैधानिक परत
- चरण 4: पूलिंग परत
- चरण 5: दूसरा संवेदी परत और पूलिंग परत
- चरण 6: घनी परत
- चरण 7: लॉग परत
एक संवादात्मक तंत्रिका नेटवर्क की वास्तुकला
कुछ साल पहले फेसबुक के बारे में सोचें, जब आपने अपनी प्रोफ़ाइल पर तस्वीर अपलोड की थी, तो आपको मैन्युअल रूप से तस्वीर पर चेहरे का नाम जोड़ने के लिए कहा गया था। आजकल, फ़ेसबुक अपने दोस्त को तस्वीर में स्वचालित रूप से टैग करने के लिए कॉनेट का उपयोग करता है।
एक दृढ़ तंत्रिका नेटवर्क को समझना बहुत मुश्किल नहीं है। एक इनपुट छवि को कन्वेंशन चरण के दौरान संसाधित किया जाता है और बाद में एक लेबल को जिम्मेदार ठहराया जाता है।
नीचे दी गई तस्वीर में एक ठेठ कंफर्ट आर्किटेक्चर को संक्षेप में प्रस्तुत किया जा सकता है। सबसे पहले, एक छवि नेटवर्क पर धकेल दी जाती है; इसे इनपुट छवि कहा जाता है। फिर, इनपुट छवि अनंत चरणों से गुजरती है; यह नेटवर्क का दृढ़ भाग है। अंत में, तंत्रिका नेटवर्क छवि पर अंक की भविष्यवाणी कर सकता है।
एक छवि ऊंचाई और चौड़ाई के साथ पिक्सेल के एक सरणी से बना है। एक ग्रेस्केल छवि में केवल एक चैनल होता है जबकि रंग छवि में तीन चैनल होते हैं (प्रत्येक एक लाल, हरे और नीले रंग के लिए)। एक चैनल एक दूसरे के ऊपर ढेर हो गया है। इस ट्यूटोरियल में, आप केवल एक चैनल के साथ एक ग्रेस्केल इमेज का उपयोग करेंगे। रंग की तीव्रता को दर्शाने के लिए प्रत्येक पिक्सेल का मान 0 से 255 तक होता है। उदाहरण के लिए, 0 के बराबर एक पिक्सेल एक सफेद रंग दिखाएगा, जबकि 255 के करीब मूल्य वाला पिक्सेल गहरा होगा।
आइए, MNIST डेटासेट में संग्रहीत एक छवि को देखें। नीचे दी गई तस्वीर दिखाती है कि मैट्रिक्स प्रारूप में बाईं ओर की तस्वीर का प्रतिनिधित्व कैसे करें। ध्यान दें कि, मूल मैट्रिक्स को 0 और 1. के बीच होने के लिए मानकीकृत किया गया है। गहरे रंग के लिए, मैट्रिक्स का मूल्य लगभग 0.9 है जबकि सफेद पिक्सेल का मूल्य 0 है।
संवैधानिक संचालन
मॉडल में सबसे महत्वपूर्ण घटक दृढ़ परत है। इस हिस्से का उद्देश्य वज़न की तेज़ गणना के लिए छवि के आकार को कम करना और इसके सामान्यीकरण में सुधार करना है।
दृढ़ भाग के दौरान, नेटवर्क छवि की आवश्यक विशेषताओं को रखता है और अप्रासंगिक शोर को बाहर करता है। उदाहरण के लिए, मॉडल सीख रहा है कि पृष्ठभूमि में पहाड़ के साथ चित्र से हाथी को कैसे पहचाना जाए। यदि आप एक पारंपरिक तंत्रिका नेटवर्क का उपयोग करते हैं, तो मॉडल सभी पिक्सेल को एक वजन प्रदान करेगा, जिसमें पहाड़ से भी शामिल है जो आवश्यक नहीं है और नेटवर्क को गुमराह कर सकता है।
इसके बजाय, एक दृढ़ तंत्रिका नेटवर्क केवल सबसे प्रासंगिक पिक्सल निकालने के लिए एक गणितीय तकनीक का उपयोग करेगा। इस गणितीय ऑपरेशन को कनविक्शन कहा जाता है। यह तकनीक नेटवर्क को प्रत्येक स्तर पर तेजी से जटिल विशेषताओं को सीखने की अनुमति देती है। प्रत्येक टुकड़े के भीतर सबसे आवश्यक तत्वों को सीखने के लिए कन्वेंशन मैट्रिक्स को छोटे टुकड़ों में विभाजित करता है।
कॉन्वेंट के घटक
एक रूपांतरण के चार घटक हैं
- कनवल्शन
- नॉन लीनियरिटी (ReLU)
- पूलिंग या उप नमूनाकरण
- वर्गीकरण (पूरी तरह से जुड़ा हुआ परत)
- कनवल्शन
कनवल्शन का उद्देश्य छवि पर स्थानीय रूप से ऑब्जेक्ट की विशेषताओं को निकालना है। इसका मतलब है कि नेटवर्क तस्वीर के भीतर विशिष्ट पैटर्न सीखेगा और तस्वीर में हर जगह इसे पहचानने में सक्षम होगा।
वार्तालाप एक तत्व-वार गुणन है। अवधारणा को समझना आसान है। कंप्यूटर छवि के एक हिस्से को स्कैन करेगा, आमतौर पर 3x3 के आयाम के साथ और इसे एक फ़िल्टर पर गुणा करता है। तत्व-वार गुणन के आउटपुट को फीचर मैप कहा जाता है। यह कदम तब तक दोहराया जाता है जब तक कि सभी छवि को स्कैन नहीं किया जाता है। ध्यान दें, दृढ़ संकल्प के बाद, छवि का आकार कम हो जाता है।
नीचे, एक URL क्रिया में देखने के लिए है कि कैसे कन्वेंशन काम करता है।
कई चैनल उपलब्ध हैं। नीचे, हमने कुछ चैनलों को सूचीबद्ध किया है। आप देख सकते हैं कि प्रत्येक फ़िल्टर का एक विशिष्ट उद्देश्य है। ध्यान दें, नीचे दी गई तस्वीर में; कर्नेल फ़िल्टर का एक पर्याय है।
स्रोत
सजा के पीछे अंकगणित
दृढ़ चरण चित्र के भीतर पिक्सेल के एक छोटे से सरणी पर फ़िल्टर लागू करेगा। फ़िल्टर 3x3 या 5x5 के सामान्य आकार के साथ इनपुट छवि के साथ आगे बढ़ेगा। इसका मतलब है कि नेटवर्क इन विंडो को सभी इनपुट छवि पर स्लाइड करेगा और कनवल्शन की गणना करेगा। नीचे दी गई छवि दिखाती है कि दृढ़ विश्वास कैसे संचालित होता है। पैच का आकार 3x3 है, और आउटपुट मैट्रिक्स छवि मैट्रिक्स और फिल्टर के बीच तत्व-वार ऑपरेशन का परिणाम है।
स्रोत
आप ध्यान दें कि आउटपुट की चौड़ाई और ऊंचाई इनपुट की चौड़ाई और ऊंचाई से भिन्न हो सकती है। यह सीमा प्रभाव के कारण होता है।
सीमा प्रभाव
इमेज में 5x5 फीचर मैप और एक 3x3 फिल्टर है। केंद्र में केवल एक खिड़की है जहां फ़िल्टर एक 3x3 ग्रिड को स्क्रीन कर सकता है। आउटपुट फीचर मैप 3x3 आयाम के साथ दो टाइलों के साथ सिकुड़ जाएगा।
इनपुट आयाम के समान आउटपुट आयाम प्राप्त करने के लिए, आपको पैडिंग को जोड़ना होगा। पैडिंग में मैट्रिक्स के प्रत्येक तरफ सही संख्या में पंक्तियों और स्तंभों को जोड़ना होता है। यह हर इनपुट टाइल को फिट करने के लिए कन्वेंशन की अनुमति देगा। नीचे दी गई छवि में, इनपुट / आउटपुट मैट्रिक्स का आयाम 5x5 है
जब आप नेटवर्क को परिभाषित करते हैं, तो दी गई विशेषताएँ तीन मापदंडों द्वारा नियंत्रित होती हैं:
- गहराई: यह कनवल्शन के दौरान लगाने के लिए फिल्टर की संख्या को परिभाषित करता है। पिछले उदाहरण में, आपने 1 की गहराई देखी, जिसका अर्थ है कि केवल एक फ़िल्टर का उपयोग किया जाता है। अधिकांश मामलों में, एक से अधिक फ़िल्टर होते हैं। नीचे दी गई तस्वीर तीन फिल्टर के साथ एक स्थिति में किए गए कार्यों को दिखाती है
- स्ट्राइड: यह दो स्लाइस के बीच "पिक्सेल की छलांग" की संख्या को परिभाषित करता है। यदि स्ट्राइड 1 के बराबर है, तो विंडोज़ एक पिक्सेल के प्रसार के साथ आगे बढ़ेगी। यदि स्ट्राइड दो के बराबर है, तो विंडो 2 पिक्सेल से कूद जाएगी। यदि आप स्ट्राइड बढ़ाते हैं, तो आपके पास छोटे फीचर मैप होंगे।
उदाहरण स्ट्राइड 1
छवि स्ट्राइड 2
- जीरो-पेडिंग: एक पेडिंग इनपुट फीचर्स मैप्स के हर तरफ संबंधित पंक्तियों और कॉलम को जोड़ने की एक क्रिया है। इस मामले में, आउटपुट में इनपुट के समान आयाम है।
- नॉन लीनियरिटी (ReLU)
कनवल्शन ऑपरेशन के अंत में, आउटपुट गैर-रैखिकता की अनुमति देने के लिए एक सक्रियण फ़ंक्शन के अधीन है। कॉननेट के लिए सामान्य सक्रियण समारोह रिलु है। नकारात्मक मूल्य वाले सभी पिक्सेल को शून्य से बदल दिया जाएगा।
- मैक्स-पूलिंग ऑपरेशन
इस कदम को समझना आसान है। पूलिंग का उद्देश्य इनपुट छवि की गतिशीलता को कम करना है। ऑपरेशन की कम्प्यूटेशनल जटिलता को कम करने के लिए कदम उठाए जाते हैं। आयामीता को कम करके, नेटवर्क की गणना करने के लिए कम वजन है, इसलिए यह ओवरफिटिंग को रोकता है।
इस चरण में, आपको आकार और स्ट्राइड को परिभाषित करने की आवश्यकता है। इनपुट छवि को पूल करने का एक मानक तरीका फीचर मैप के अधिकतम मूल्य का उपयोग करना है। नीचे दी गई तस्वीर को देखें। "पूलिंग" 4x4 फ़ीचर मैप के चार सबमेट्रिक्स प्रदर्शित करेगा और अधिकतम मूल्य लौटाएगा। पूलिंग एक 2x2 सरणी का अधिकतम मूल्य लेता है और फिर इस विंडो को दो पिक्सेल से स्थानांतरित करता है। उदाहरण के लिए, पहला उप-मैट्रिक्स [3,1,3,2] है, पूलिंग अधिकतम वापस आ जाएगी, जो कि 3 है।
इस तरह के रूप में एक और पूलिंग ऑपरेशन है।
यह ऑपरेशन आक्रामक रूप से फीचर मैप के आकार को कम करता है
- पूरी तरह से जुड़ी हुई परतें
अंतिम चरण में पारंपरिक कृत्रिम तंत्रिका नेटवर्क का निर्माण होता है जैसा आपने पिछले ट्यूटोरियल में किया था। आप पिछली परत से अगली परत तक सभी न्यूरॉन्स को जोड़ते हैं। आप इनपुट छवि पर संख्या को वर्गीकृत करने के लिए सॉफ्टमैक्स सक्रियण फ़ंक्शन का उपयोग करते हैं।
पुनर्प्राप्त करें:
संवादी तंत्रिका नेटवर्क एक भविष्यवाणी करने से पहले विभिन्न परतों को संकलित करता है। एक तंत्रिका नेटवर्क है:
- एक दृढ़ परत
- Relu सक्रियण समारोह
- पूलिंग परत
- घनी जुड़ी हुई परत
चित्र के उप-भाग पर विभिन्न परतें फिल्टर करती हैं। Relu सक्रियण फ़ंक्शन गैर-रैखिकता जोड़ता है, और पूलिंग परतें सुविधाओं के नक्शे की गतिशीलता को कम करती हैं।
ये सभी परतें छवियों से आवश्यक जानकारी निकालती हैं। आखिर में, फीचर्स मैप को प्राइमरी बनाने के लिए सॉफ्टमैक्स फंक्शन वाली प्राइमरी से पूरी तरह कनेक्टेड लेयर को फीड किया जाता है।
TensorFlow के साथ CNN को प्रशिक्षित करें
अब जब आप एक काफिले के निर्माण खंड से परिचित हैं, तो आप TensorFlow के साथ एक बनाने के लिए तैयार हैं। हम छवि वर्गीकरण के लिए MNIST डेटासेट का उपयोग करेंगे।
डेटा तैयारी पिछले ट्यूटोरियल के समान है। आप कोड चला सकते हैं और सीधे सीएनएन की वास्तुकला में कूद सकते हैं।
आप नीचे दिए गए चरणों का पालन करेंगे:
चरण 1: डेटासेट अपलोड करें
चरण 2: इनपुट परत
चरण 3: संवैधानिक परत
चरण 4: पूलिंग परत
चरण 5: दूसरा संवेदी परत और पूलिंग परत
चरण 6: घनी परत
चरण 7: लॉग परत
चरण 1: डेटासेट अपलोड करें
MNIST डेटासेट इस URL पर सीखने के लिए scikit के साथ उपलब्ध है। कृपया इसे डाउनलोड करें और इसे डाउनलोड में संग्रहीत करें। आप इसे fetch_mldata ('MNIST मूल') के साथ अपलोड कर सकते हैं।
एक ट्रेन / परीक्षण सेट बनाएँ
आपको डाटासेट को train_test_split से विभाजित करने की आवश्यकता है
सुविधाओं को स्केल करें
अंत में, आप MinMaxScaler के साथ फीचर को स्केल कर सकते हैं
import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)y_train = y_train.astype(int)y_test = y_test.astype(int)batch_size =len(X_train)print(X_train.shape, y_train.shape,y_test.shape )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_test_scaled = scaler.fit_transform(X_test.astype(np.float64))feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]X_train_scaled.shape[1:]
CNN को परिभाषित करें
एक सीएनएन एक पारंपरिक तंत्रिका जाल के साथ वैश्विक पैटर्न की तुलना में विवरण पैटर्न सीखने के लिए एक छवि के कच्चे पिक्सेल पर फिल्टर का उपयोग करता है। CNN का निर्माण करने के लिए, आपको परिभाषित करने की आवश्यकता है:
- एक दृढ़ परत: फ़ीचर मानचित्र पर फ़िल्टर की संख्या लागू करें। सजा के बाद, आपको नेटवर्क में गैर-रैखिकता जोड़ने के लिए एक रिले सक्रियण फ़ंक्शन का उपयोग करने की आवश्यकता है।
- पूलिंग लेयर: कन्वेंशन के बाद अगला कदम फीचर मैक्स को नीचे करना है। उद्देश्य ओवरफ़िटिंग को रोकने और गणना की गति में सुधार करने के लिए फ़ीचर मैप की गतिशीलता को कम करना है। मैक्स पूलिंग एक पारंपरिक तकनीक है, जो फीचर मैप्स को उप-भागों (आमतौर पर एक 2x2 आकार के साथ) में विभाजित करती है और केवल अधिकतम मान रखती है।
- पूरी तरह से जुड़ी हुई परतें: पिछली परतों के सभी न्यूरॉन्स अगली परतों से जुड़े होते हैं। CNN लेबल को वर्गीकृत करेगा, जो कि संकेंद्रित परतों से सुविधाओं के अनुसार और पूलिंग परत के साथ कम हो जाएगा।
CNN वास्तुकला
- संवैधानिक परत: 14 5x5 फ़िल्टर (5x5-पिक्सेल उप-भागों को निकालते हुए), ReLU बाइनरी सूची के साथ लागू होता है
- पूलिंग लेयर: अधिकतम 2x2 फ़िल्टर और 2 स्ट्राइड के साथ अधिकतम पूलिंग करता है (जो निर्दिष्ट करता है कि पूल किए गए क्षेत्र ओवरलैप नहीं होते हैं)
- संवैधानिक परत: 36 5x5 फ़िल्टर लागू करता है, ReLU सक्रियण फ़ंक्शन के साथ
- पूलिंग लेयर # 2: फिर से, 2x2 फिल्टर और 2 के स्ट्राइड के साथ अधिकतम पूलिंग करता है
- 1,764 न्यूरॉन्स, ड्रॉपआउट नियमितीकरण दर 0.4 के साथ (0.4 की संभावना है कि किसी भी तत्व को प्रशिक्षण के दौरान गिरा दिया जाएगा)
- घने परत (लॉग्स लेयर): 10 न्यूरॉन्स, प्रत्येक अंक लक्ष्य वर्ग (0-9) के लिए एक।
CNN बनाने के लिए उपयोग करने के लिए तीन महत्वपूर्ण मॉड्यूल हैं:
- conv2d ()। तर्कों के रूप में फ़िल्टर, फ़िल्टर कर्नेल आकार, गद्दी और सक्रियण फ़ंक्शन की संख्या के साथ एक दो-आयामी दृढ़ परत का निर्माण करता है।
- max_pooling2d ()। अधिकतम-पूलिंग एल्गोरिथ्म का उपयोग करके दो-आयामी पूलिंग परत का निर्माण करता है।
- घना ()। छिपी हुई परतों और इकाइयों के साथ एक घने परत का निर्माण करता है
आप CNN बनाने के लिए फ़ंक्शन को परिभाषित करेंगे। आइए विस्तार से देखें कि फ़ंक्शन में एक साथ सब कुछ लपेटने से पहले प्रत्येक बिल्डिंग ब्लॉक का निर्माण कैसे करें।
चरण 2: इनपुट परत
def cnn_model_fn(features, labels, mode):input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
आपको डेटा के आकार के साथ एक टेंसर को परिभाषित करने की आवश्यकता है। उसके लिए, आप मॉड्यूल tf.reshape का उपयोग कर सकते हैं। इस मॉड्यूल में, आपको टेंसर को पुनः आकार देने और टेंसर के आकार को घोषित करने की आवश्यकता है। पहला तर्क डेटा की विशेषताएं है, जो फ़ंक्शन के तर्क में परिभाषित किया गया है।
एक तस्वीर की ऊंचाई, चौड़ाई और एक चैनल है। एमएनआईएसटी डेटासेट 28x28 आकार के साथ एक मोनोक्रोमिक चित्र है। हमने आकार के तर्क में बैच आकार को -1 पर सेट किया है ताकि यह सुविधाओं का आकार ले सके ["x"]। इसका फायदा यह है कि बैच के आकार के हाइपरपैरामीटर को ट्यून करने के लिए। यदि बैच का आकार 7 पर सेट है, तो टेंसर 5,488 मूल्यों (28 * 28 * 7) को खिलाएगा।
Step 3: Convolutional layer
# first Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
पहली दृढ़ परत में 5x5 के कर्नेल आकार के साथ 14 फ़िल्टर हैं, जिसमें एक ही गद्दी है। समान पैडिंग का मतलब आउटपुट टेंसर और इनपुट टेंसर दोनों में समान ऊंचाई और चौड़ाई होनी चाहिए। Tensorflow समान आकार सुनिश्चित करने के लिए पंक्तियों और स्तंभों में शून्य जोड़ देगा।
आप Relu सक्रियण फ़ंक्शन का उपयोग करते हैं। आउटपुट का आकार [28, 28, 14] होगा।
चरण 4: पूलिंग परत
कनविक्शन के बाद अगला कदम पूलिंग कम्प्यूटेशन है। पूलिंग कम्प्यूटेशन से डेटा की गतिशीलता कम हो जाएगी। आप 2x2 के आकार और 2 के स्ट्राइड के साथ मॉड्यूल max_pooling2d का उपयोग कर सकते हैं। आप इनपुट के रूप में पिछली परत का उपयोग करते हैं। आउटपुट का आकार [बैच_साइज़, 14, 14, 14] होगा
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
चरण 5: दूसरा संवेदी परत और पूलिंग परत
दूसरी दृढ़ परत में 32 फिल्टर होते हैं, जिनमें [बैच_साइज़, 14, 14, 32] का आउटपुट साइज़ होता है। पूलिंग परत का आकार पहले जैसा है और आउटपुट आकार [बैच_साइज़, 14, 14, 18] है।
conv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)
चरण 6: घनी परत
फिर, आपको पूरी तरह से जुड़ी हुई परत को परिभाषित करने की आवश्यकता है। फीचर मैप को घनी परत के साथ जोड़ने से पहले समतल करना पड़ता है। आप मॉड्यूल के आकार का उपयोग 7 * 7 * 36 के आकार के साथ कर सकते हैं।
घनी परत 1764 न्यूरॉन्स को जोड़ेगी। आप एक Relu सक्रियण फ़ंक्शन जोड़ते हैं। इसके अलावा, आप 0.3 की दर के साथ एक ड्रॉपआउट नियमितिकरण शब्द जोड़ते हैं, जिसका अर्थ है कि वजन के 30 प्रतिशत 0. नोट पर सेट होंगे, ड्रॉपआउट प्रशिक्षण चरण के दौरान ही होता है। फ़ंक्शन cnn_model_fn में एक तर्क विधा है जिसे यह घोषित करने के लिए कि मॉडल को प्रशिक्षित करने या मूल्यांकन करने की आवश्यकता है।
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
चरण 7: लॉग परत
अंत में, आप मॉडल की भविष्यवाणी के साथ अंतिम परत को परिभाषित कर सकते हैं। आउटपुट आकार बैच आकार और 10, छवियों की कुल संख्या के बराबर है।
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
आप एक शब्दकोश बना सकते हैं जिसमें कक्षाएं और प्रत्येक वर्ग की संभावना हो सकती है। मॉड्यूल tf.argmax () के साथ उच्चतम मान लौटाता है यदि लॉगिट लेयर्स। सॉफ्टमैक्स फ़ंक्शन प्रत्येक वर्ग की संभावना देता है।
predictions = {# Generate predictions"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor") }
आप केवल डिक्शनरी प्रेडिक्शन लौटना चाहते हैं जब मोड प्रेडिक्शन पर सेट हो। आप भविष्यवाणियों को निकालने के लिए इस कोड को जोड़ते हैं
if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
अगले चरण में मॉडल के नुकसान की गणना करना शामिल है। अंतिम ट्यूटोरियल में, आपको पता चला कि एक मल्टीस्कलैस मॉडल के लिए हानि फ़ंक्शन क्रॉस एन्ट्रॉपी है। नुकसान की गणना आसानी से निम्नलिखित कोड के साथ की जाती है:
# Calculate Loss (for both TRAIN and EVAL modes)loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
अंतिम चरण मॉडल को अनुकूलित करना है, अर्थात भार के सर्वोत्तम मूल्यों को खोजना है। उसके लिए, आप 0.001 के सीखने की दर के साथ एक ग्रेडिएंट डिसेंट ऑप्टिमाइज़र का उपयोग करते हैं। उद्देश्य नुकसान को कम करना है
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())
आपको सीएनएन के साथ किया जाता है। हालाँकि, आप मूल्यांकन मोड के दौरान प्रदर्शन मीट्रिक प्रदर्शित करना चाहते हैं। एक मल्टीस्कल मॉडल के लिए प्रदर्शन मैट्रिक्स सटीकता मैट्रिक्स है। Tensorflow दो तर्कों, लेबल और अनुमानित मूल्यों के साथ एक मॉड्यूल सटीकता से सुसज्जित है।
eval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
यही बात है। आपने अपना पहला CNN बनाया था और आप मॉडल को प्रशिक्षित करने और उसका मूल्यांकन करने के लिए एक फ़ंक्शन में सब कुछ लपेटने के लिए तैयार हैं।
def cnn_model_fn(features, labels, mode):"""Model function for CNN."""# Input Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)# Dense Layerpool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)predictions = {# Generate predictions (for PREDICT and EVAL mode)"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor")}if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)# Calculate Lossloss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)# Configure the Training Op (for TRAIN mode)if mode == tf.estimator.ModeKeys.TRAIN:optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)# Add evaluation metrics Evaluation modeeval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
नीचे दिए गए चरण पिछले ट्यूटोरियल के समान हैं।
सबसे पहले, आप सीएनएन मॉडल के साथ एक अनुमानक को परिभाषित करते हैं।
# Create the Estimatormnist_classifier = tf.estimator.Estimator(model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")
एक सीएनएन को प्रशिक्षित करने में कई बार लगता है, इसलिए, आप प्रत्येक 50 पुनरावृत्तियों में सॉफ्टमैक्स परतों के मूल्यों को संग्रहीत करने के लिए एक लॉगिंग हुक बनाते हैं।
# Set up logging for predictionstensors_to_log = {"probabilities": "softmax_tensor"}logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)
आप मॉडल का अनुमान लगाने के लिए तैयार हैं। आप 100 का एक बैच आकार निर्धारित करते हैं और डेटा को फेरबदल करते हैं। ध्यान दें कि हमने 16.000 का प्रशिक्षण चरण निर्धारित किया है, इसे प्रशिक्षित करने में बहुत समय लग सकता है। धैर्य रखें।
# Train the modeltrain_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_train_scaled},y=y_train,batch_size=100,num_epochs=None,shuffle=True)mnist_classifier.train(input_fn=train_input_fn,steps=16000,hooks=[logging_hook])
अब जब मॉडल ट्रेन है, तो आप इसका मूल्यांकन कर सकते हैं और परिणाम प्रिंट कर सकते हैं
# Evaluate the model and print resultseval_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_test_scaled},y=y_test,num_epochs=1,shuffle=False)eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)print(eval_results)
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}
वर्तमान वास्तुकला के साथ, आपको 97% की सटीकता प्राप्त होती है। आप सटीकता में सुधार करने के लिए वास्तुकला, बैच आकार और पुनरावृति की संख्या को बदल सकते हैं। सीएनएन न्यूरल नेटवर्क ने एएनएन या लॉजिस्टिक रिग्रेशन की तुलना में कहीं बेहतर प्रदर्शन किया है। कृत्रिम तंत्रिका नेटवर्क पर ट्यूटोरियल में, आपके पास 96% की सटीकता थी, जो सीएनएन कम है। सीएनएन के प्रदर्शन एक बड़े छवि सेट के साथ प्रभावशाली हैं , दोनों गति गणना और सटीकता की अवधि में।
सारांश
चित्र का मूल्यांकन करने के लिए एक दृढ़ तंत्रिका नेटवर्क बहुत अच्छी तरह से काम करता है। चित्र या वीडियो से वस्तुओं को पहचानने के लिए इस प्रकार की वास्तुकला प्रमुख है।
CNN बनाने के लिए, आपको छह चरणों का पालन करना होगा:
चरण 1: इनपुट परत:
यह चरण डेटा को रीसेट करता है। आकार पिक्सेल की संख्या के वर्गमूल के बराबर है। उदाहरण के लिए, यदि किसी चित्र में 156 पिक्सेल हैं, तो आकृति 26x26 है। आपको यह निर्दिष्ट करना होगा कि चित्र में रंग है या नहीं। यदि हाँ, तो आपके पास आरजीबी के लिए 3 आकार- 3 है, अन्यथा 1।
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
चरण 2: संवैधानिक परत
इसके बाद, आपको कंसिस्टेंट लेयर्स बनाने की आवश्यकता है। आप नेटवर्क को महत्वपूर्ण सुविधा सीखने के लिए विभिन्न फ़िल्टर लागू करते हैं। आप कर्नेल का आकार और फ़िल्टर की मात्रा निर्दिष्ट करते हैं।
conv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
चरण 3: पूलिंग परत
तीसरे चरण में, आप एक पूलिंग परत जोड़ते हैं। यह परत इनपुट के आकार को घटाती है। यह उप-मैट्रिक्स का अधिकतम मूल्य लेकर ऐसा करता है। उदाहरण के लिए, यदि उप-मैट्रिक्स [3,1,3,2] है, तो पूलिंग अधिकतम वापस आ जाएगी, जो कि 3 है।
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
चरण 4: संवेदी परत और पूलिंग परत जोड़ें
इस चरण में, आप जितनी चाहें उतनी परतें और पूलिंग परतें जोड़ सकते हैं। Google 20 से अधिक दृढ़ परतों के साथ वास्तुकला का उपयोग करता है।
चरण 5: घनी परत
चरण 5 पूरी तरह से जुड़े परतों को बनाने के लिए पिछले को समतल करता है। इस चरण में, आप विभिन्न सक्रियण फ़ंक्शन का उपयोग कर सकते हैं और ड्रॉपआउट प्रभाव जोड़ सकते हैं।
pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)
चरण 6: लॉग परत
अंतिम चरण भविष्यवाणी है।
logits = tf.layers.dense(inputs=dropout, units=10)