TensorFlow में CNN छवि वर्गीकरण चरणों और उदाहरणों के साथ
एवलिन क्लार्क
⚡ स्मार्ट सारांश
कन्वोल्यूशनल न्यूरल नेटवर्क्स हर पिक्सेल को समान रूप से भारित करने के बजाय छोटे फिल्टरों के साथ एक छवि को स्कैन करते हैं, यही कारण है कि वे कंप्यूटर विज़न में अग्रणी हैं। यह विस्तृत विवरण प्रत्येक परत की व्याख्या करता है और फिर टेन्सरफ्लो का उपयोग करके एमएनआईएसटी अंकों का वर्गीकरण करता है।
कन्वेन्शनल न्यूरल नेटवर्क क्या है?
कनवल्शनल न्यूरल नेटवर्ककन्वनेट या सीएनएन के नाम से भी जाना जाने वाला यह तरीका कंप्यूटर विज़न अनुप्रयोगों में एक प्रसिद्ध विधि है। यह डीप न्यूरल नेटवर्क का एक वर्ग है जिसका उपयोग दृश्य छवियों के विश्लेषण के लिए किया जाता है। इस प्रकार की संरचना किसी चित्र या वीडियो से वस्तुओं को पहचानने में प्रमुख भूमिका निभाती है। इसका उपयोग छवि या वीडियो पहचान, प्राकृतिक भाषा प्रसंस्करण और अनुशंसा प्रणालियों जैसे अनुप्रयोगों में किया जाता है।
Archiकन्वोल्यूशनल न्यूरल नेटवर्क की तकनीक
कुछ साल पहले फेसबुक के बारे में सोचिए, जब आप अपनी प्रोफ़ाइल पर कोई तस्वीर अपलोड करते थे, तो आपसे तस्वीर पर चेहरे के साथ मैन्युअल रूप से नाम जोड़ने के लिए कहा जाता था। आजकल, फेसबुक आपके मित्र को तस्वीर में टैग करने के लिए कॉन्वनेट का इस्तेमाल करता है।
छवि वर्गीकरण के लिए एक कन्वोल्यूशनल न्यूरल नेटवर्क को समझना बहुत मुश्किल नहीं है। एक इनपुट छवि को कन्वोल्यूशन चरण के दौरान संसाधित किया जाता है और बाद में एक लेबल दिया जाता है।
एक सामान्य कन्वनेट आर्किटेक्चर को नीचे दिए गए चित्र में संक्षेप में दर्शाया जा सकता है। सबसे पहले, एक छवि को नेटवर्क में भेजा जाता है; इसे इनपुट छवि कहा जाता है। फिर, इनपुट छवि कई चरणों से गुजरती है; यह नेटवर्क का कनवोल्यूशनल भाग है। अंत में, न्यूरल नेटवर्क छवि पर मौजूद अंक का अनुमान लगा सकता है।
एक छवि पिक्सेल की एक सरणी से बनी होती है जिसमें ऊंचाई और चौड़ाई होती है। एक ग्रेस्केल छवि में केवल एक चैनल होता है जबकि रंगीन छवि में तीन चैनल होते हैं (प्रत्येक लाल, हरा और नीला के लिए एक-एक)। ये चैनल एक दूसरे के ऊपर व्यवस्थित होते हैं। इस ट्यूटोरियल में, आप केवल एक चैनल वाली ग्रेस्केल छवि का उपयोग करेंगे। प्रत्येक पिक्सेल का मान 0 से 255 तक होता है जो रंग की तीव्रता को दर्शाता है। उदाहरण के लिए, 0 के बराबर मान वाला पिक्सेल सफेद रंग दिखाएगा जबकि 255 के करीब मान वाला पिक्सेल गहरा रंग दिखाएगा।
आइए, इसमें संग्रहीत एक छवि पर नजर डालें। एमएनआईएसटी डेटासेटनीचे दी गई तस्वीर में बाईं ओर की तस्वीर को मैट्रिक्स प्रारूप में दर्शाया गया है। ध्यान दें कि मूल मैट्रिक्स को 0 और 1 के बीच मानकीकृत किया गया है। गहरे रंगों के लिए, मैट्रिक्स में मान लगभग 0.9 होता है, जबकि सफेद पिक्सेल का मान 0 होता है।
संवलनात्मक ऑपरेशन
इस मॉडल का सबसे महत्वपूर्ण घटक कनवोल्यूशनल लेयर है। इसका उद्देश्य वेट्स की गणना को तेज़ करने और जनरलाइज़ेशन को बेहतर बनाने के लिए इमेज का आकार कम करना है।
कन्वोल्यूशनल भाग के दौरान, नेटवर्क छवि की आवश्यक विशेषताओं को बनाए रखता है और अप्रासंगिक शोर को बाहर करता है। उदाहरण के लिए, मॉडल सीख रहा है कि पृष्ठभूमि में पहाड़ वाली तस्वीर से हाथी को कैसे पहचाना जाए। यदि आप पारंपरिक न्यूरल नेटवर्क का उपयोग करते हैं, तो मॉडल पहाड़ से आने वाले पिक्सेल सहित सभी पिक्सेल को एक भार प्रदान करेगा जो आवश्यक नहीं है और नेटवर्क को गुमराह कर सकता है।
इसके बजाय, ए Keras कन्वोल्यूशनल न्यूरल नेटवर्क गणितीय तकनीक का उपयोग करके यह पता लगाएगा किtracकेवल सबसे प्रासंगिक पिक्सेल को ही चुनकर। इस गणितीय क्रिया को कनवोल्यूशन कहते हैं। यह तकनीक नेटवर्क को प्रत्येक परत पर उत्तरोत्तर जटिल विशेषताओं को सीखने में सक्षम बनाती है। कनवोल्यूशन मैट्रिक्स को छोटे-छोटे टुकड़ों में विभाजित करता है ताकि प्रत्येक टुकड़े के भीतर सबसे आवश्यक तत्वों को सीखा जा सके।
कन्वोल्यूशनल न्यूरल नेटवर्क (ConvNet या CNN) के घटक
कन्वनेट के चार घटक होते हैं:
- कनवल्शन
- गैर रेखीयता (ReLU)
- Poolinजी या उप नमूनाकरण
- वर्गीकरण (पूरी तरह से जुड़ी परत)
कनवल्शन
कनवोल्यूशन का उद्देश्य यह है किtracयह नेटवर्क छवि में मौजूद वस्तु की विशेषताओं को स्थानीय रूप से पहचानता है। इसका मतलब है कि नेटवर्क चित्र के भीतर विशिष्ट पैटर्न सीखेगा और उन्हें चित्र में हर जगह पहचान सकेगा।
कनवोल्यूशन एक तत्व-वार गुणन है। इसकी अवधारणा को समझना आसान है। कंप्यूटर छवि के एक भाग को स्कैन करता है, आमतौर पर 3×3 आयाम का, और उसे एक फ़िल्टर से गुणा करता है। तत्व-वार गुणन के परिणाम को फ़ीचर मैप कहा जाता है। यह प्रक्रिया तब तक दोहराई जाती है जब तक कि पूरी छवि स्कैन न हो जाए। ध्यान दें कि कनवोल्यूशन के बाद छवि का आकार कम हो जाता है।
नीचे दिया गया आरेख छवि के एक भाग को फ़िल्टर द्वारा गुणा किए जाने को दर्शाता है ताकि फ़ीचर मैप का एक एकल सेल उत्पन्न हो सके।
नीचे दिया गया एनिमेशन पूरी छवि पर समान कनवोल्यूशन प्रक्रिया को दर्शाता है।
कई तरह के फ़िल्टर उपलब्ध हैं। नीचे हमने उनमें से कुछ को सूचीबद्ध किया है। आप देख सकते हैं कि प्रत्येक फ़िल्टर का एक विशिष्ट उद्देश्य है। ध्यान दें कि नीचे दिए गए चित्र में कर्नेल फ़िल्टर का पर्यायवाची है।
संवलन के पीछे का अंकगणित
कनवोल्यूशन चरण में चित्र के पिक्सेल के एक छोटे समूह पर फ़िल्टर लगाया जाएगा। फ़िल्टर इनपुट छवि पर लगभग 3×3 या 5×5 के आकार में आगे बढ़ेगा। इसका मतलब है कि नेटवर्क इन विंडो को पूरी इनपुट छवि पर स्लाइड करेगा और कनवोल्यूशन की गणना करेगा। नीचे दिया गया एनिमेशन दिखाता है कि कनवोल्यूशन कैसे काम करता है। पैच का आकार 3×3 है, और आउटपुट मैट्रिक्स छवि मैट्रिक्स और फ़िल्टर के बीच एलिमेंट-वाइज़ ऑपरेशन का परिणाम है।
आप देखेंगे कि आउटपुट की चौड़ाई और ऊंचाई इनपुट की चौड़ाई और ऊंचाई से अलग हो सकती है। ऐसा बॉर्डर इफ़ेक्ट के कारण होता है।
सीमा प्रभाव
इस छवि में 5×5 फीचर मैप और 3×3 फ़िल्टर है। केंद्र में केवल एक विंडो है जहाँ फ़िल्टर 3×3 ग्रिड को स्क्रीन कर सकता है। आउटपुट फीचर मैप प्रत्येक अक्ष पर दो टाइल सिकुड़ जाता है, जिससे 3×3 आयाम बचता है।
इनपुट आयाम के समान आउटपुट आयाम प्राप्त करने के लिए, आपको पैडिंग जोड़नी होगी। पैडिंग में मैट्रिक्स के प्रत्येक तरफ पंक्तियों और स्तंभों की उचित संख्या जोड़ना शामिल है। इससे कनवोल्यूशन प्रत्येक इनपुट टाइल को सेंटर फिट कर पाएगा। नीचे दिए गए चित्र में, इनपुट और आउटपुट मैट्रिक्स का आयाम समान है, 5×5।
जब आप नेटवर्क को परिभाषित करते हैं, तो संवलित विशेषताएं तीन मापदंडों द्वारा नियंत्रित होती हैं:
गहराई: यह कनवोल्यूशन के दौरान लागू किए जाने वाले फ़िल्टरों की संख्या को परिभाषित करता है। पिछले उदाहरण में, आपने 1 की गहराई देखी, जिसका अर्थ है कि केवल एक फ़िल्टर का उपयोग किया गया है। अधिकांश मामलों में, एक से अधिक फ़िल्टर होते हैं। नीचे दिया गया एनिमेशन तीन फ़िल्टरों वाली स्थिति में की गई प्रक्रियाओं को दर्शाता है।
स्ट्राइड: यह दो स्लाइस के बीच "पिक्सेल जंप" की संख्या को परिभाषित करता है। यदि स्ट्राइड 1 के बराबर है, तो विंडो एक पिक्सेल के फैलाव के साथ आगे बढ़ेगी। यदि स्ट्राइड 2 के बराबर है, तो विंडो 2 पिक्सेल से आगे बढ़ेगी। यदि आप स्ट्राइड बढ़ाते हैं, तो आपको छोटे फीचर मैप मिलेंगे। नीचे दिए गए दो आरेख स्ट्राइड 1 और स्ट्राइड 2 की तुलना करते हैं।
उदाहरण चरण 1
स्ट्राइड २
शून्य पैडिंग: पैडिंग एक ऐसी प्रक्रिया है जिसमें इनपुट फीचर मैप के दोनों ओर संबंधित संख्या में पंक्तियाँ और स्तंभ जोड़े जाते हैं। इस स्थिति में, आउटपुट का आयाम इनपुट के आयाम के समान होता है।
गैर रेखीयता (ReLU)
कनवोल्यूशन प्रक्रिया के अंत में, आउटपुट पर नॉन-लीनियरिटी की अनुमति देने के लिए एक एक्टिवेशन फ़ंक्शन लागू किया जाता है। कन्वनेट के लिए सामान्य एक्टिवेशन फ़ंक्शन ReLU है। ऋणात्मक मान वाले सभी पिक्सेल को शून्य से बदल दिया जाएगा।
Pooling Operaउत्पादन
यह चरण समझना आसान है। पूलिंग का उद्देश्य इनपुट छवि की विमा को कम करना है। यह प्रक्रिया गणना की जटिलता को कम करने के लिए की जाती है। विमा को कम करने से नेटवर्क को कम भारों की गणना करनी पड़ती है, जिससे ओवरफिटिंग से बचाव होता है।
इस चरण में, आपको आकार और स्ट्राइड को परिभाषित करना होगा। इनपुट इमेज को पूल करने का एक मानक तरीका फीचर मैप के अधिकतम मान का उपयोग करना है। नीचे दिए गए चित्र को देखें। पूलिंग 4×4 फीचर मैप के चार सबमैट्रिक्स को स्क्रीन करेगी और अधिकतम मान लौटाएगी। पूलिंग 2×2 ऐरे का अधिकतम मान लेती है और फिर इस विंडो को दो पिक्सेल आगे बढ़ाती है। उदाहरण के लिए, पहला सबमैट्रिक्स [3,1,3,2] है, इसलिए पूलिंग अधिकतम मान, यानी 3 लौटाएगी।
एक अन्य पूलिंग ऑपरेशन भी है, जैसे कि माध्य।
यह प्रक्रिया फीचर मैप के आकार को तेजी से कम कर देती है।
पूरी तरह से जुड़ी हुई परतें
अंतिम चरण में एक पारंपरिक इमारत का निर्माण शामिल है कृत्रिम तंत्रिका नेटवर्क जैसा कि आपने पिछले ट्यूटोरियल में किया था। आप पिछली परत से सभी न्यूरॉन्स को अगली परत से जोड़ते हैं। आप इनपुट छवि पर संख्या को वर्गीकृत करने के लिए सॉफ्टमैक्स सक्रियण फ़ंक्शन का उपयोग करते हैं।
संक्षिप्त:
टेन्सरफ्लो कनवोल्यूशनल न्यूरल नेटवर्क भविष्यवाणी करने से पहले विभिन्न परतों को संयोजित करता है। एक न्यूरल नेटवर्क में निम्नलिखित विशेषताएं होती हैं:
- एक संवलन परत
- ReLU सक्रियण फ़ंक्शन
- Poolinजी परत
- सघन रूप से जुड़ी परत
कन्वोल्यूशनल लेयर्स चित्र के एक उपक्षेत्र पर विभिन्न फ़िल्टर लागू करती हैं। ReLU एक्टिवेशन फ़ंक्शन नॉन-लीनियरिटी जोड़ता है, और पूलिंग लेयर्स फ़ीचर मैप्स की डाइमेंशनैलिटी को कम करती हैं।
ये सभी परतें पूर्वtracछवियों से आवश्यक जानकारी प्राप्त की जाती है। अंत में, भविष्यवाणी करने के लिए फ़ीचर मैप्स को सॉफ्टमैक्स फ़ंक्शन के साथ एक पूर्णतः कनेक्टेड लेयर में फीड किया जाता है।
TensorFlow के साथ CNN को प्रशिक्षित करें
अब जब आप कन्वनेट के मूलभूत तत्वों से परिचित हो चुके हैं, तो आप इसे बनाने के लिए तैयार हैं। TensorFlowहम CNN छवि वर्गीकरण के लिए MNIST डेटासेट का उपयोग करेंगे।
डेटा तैयार करना पिछले ट्यूटोरियल जैसा ही है। आप कोड चला सकते हैं और सीधे CNN की आर्किटेक्चर पर जा सकते हैं।
आप CNN का उपयोग करके छवि वर्गीकरण के लिए नीचे दिए गए चरणों का पालन करेंगे:
- चरण 1: डेटासेट अपलोड करें
- चरण 2: इनपुट परत
- चरण 3: कन्वोल्यूशनल परत
- चरण १: Poolinजी परत
- चरण 5: दूसरी कन्वोल्यूशनल परत और Poolinजी परत
- चरण 6: सघन परत
- चरण 7: लॉगिट लेयर
संस्करण नोट: नीचे दी गई सूचियाँ TensorFlow 1.x को लक्षित करती हैं। TensorFlow 2 में tf.layers नेमस्पेस और tf.estimator.inputs.numpy_input_fn अब मौजूद नहीं हैं; इनके समकक्ष tf.keras.layers.Conv2D और Max हैं।Pooling2D, Dense और Dropout लेयर्स को tf.keras.Model में असेंबल करके model.fit() का उपयोग करके प्रशिक्षित किया गया है। प्रत्येक लेयर की कार्यप्रणाली को समझने के लिए दिए गए चरणों को पढ़ें और फिर उन्हें Keras API पर लागू करें।
चरण 1: डेटासेट अपलोड करें
MNIST डेटासेट scikit-learn के माध्यम से उपलब्ध है। कृपया इसे डाउनलोड करें और डाउनलोड फ़ोल्डर में सेव करें। आप इसे fetch_mldata('MNIST original') कमांड का उपयोग करके अपलोड कर सकते हैं।
संस्करण नोट: mldata.org बंद हो चुका है और scikit-learn 0.22 में fetch_mldata() फ़ंक्शन को हटा दिया गया था। वर्तमान में इंस्टॉल किए गए किसी भी सिस्टम पर, उन्हीं अंकों को लोड करने के लिए निम्नलिखित फ़ंक्शन का उपयोग करें: fetch_openml इसके बजाय, fetch_openml('mnist_784', version=1) का उपयोग करें। बाकी पाइपलाइन अपरिवर्तित है।
ट्रेन/टेस्ट सेट बनाएं
आपको train_test_split का उपयोग करके डेटासेट को विभाजित करने की आवश्यकता है।
सुविधाओं का पैमाना तय करें
अंत में, आप MinMaxScaler का उपयोग करके सुविधाओं को स्केल कर सकते हैं, जैसा कि नीचे दिए गए TensorFlow CNN उदाहरण का उपयोग करके छवि वर्गीकरण में दिखाया गया है।
import numpy as np import tensorflow as tf from sklearn.datasets import fetch_mldata #Change USERNAME by the username of your machine ## Windows USER mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original') ## Mac User mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original') print(mnist.data.shape) print(mnist.target.shape) from sklearn.model_selection import train_test_split X_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 ) ## resclae from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler() # Train X_train_scaled = scaler.fit_transform(X_train.astype(np.float64)) # test X_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:]
सीएनएन को परिभाषित करें
एक सीएनएन (कन्वेंशनल न्यूरल नेटवर्क) किसी छवि के कच्चे पिक्सेल पर फ़िल्टर का उपयोग करके पारंपरिक न्यूरल नेट द्वारा सीखे गए वैश्विक पैटर्न की तुलना में विस्तृत पैटर्न सीखता है। एक सीएनएन बनाने के लिए, आपको निम्नलिखित को परिभाषित करना होगा:
- कनवोल्यूशनल लेयर: फीचर मैप पर n संख्या में फ़िल्टर लागू करें। कनवोल्यूशन के बाद, नेटवर्क में नॉन-लीनियरिटी जोड़ने के लिए ReLU एक्टिवेशन फ़ंक्शन का उपयोग करना आवश्यक है।
- Poolinजी लेयर: कनवोल्यूशन के बाद अगला चरण फीचर मैप को डाउनसैंपल करना है। इसका उद्देश्य फीचर मैप की विमा को कम करना है ताकि ओवरफिटिंग को रोका जा सके और गणना की गति में सुधार किया जा सके। मैक्स पूलिंग एक पारंपरिक तकनीक है, जो फीचर मैप को उपक्षेत्रों (आमतौर पर 2×2 आकार के) में विभाजित करती है और केवल अधिकतम मानों को ही रखती है।
- पूरी तरह से जुड़ी हुई परतें: पिछली परतों के सभी न्यूरॉन्स अगली परतों से जुड़े हुए हैं। CNN कन्वोल्यूशनल परतों से सुविधाओं के अनुसार लेबल को वर्गीकृत करेगा और पूलिंग परत के साथ कम करेगा।
सीएनएन वास्तुकला
- कन्वोल्यूशनल लेयर: 14 5×5 फ़िल्टर लागू करता है (उदाहरण के लिएtracटिंग 5×5-पिक्सेल उपक्षेत्र), ReLU सक्रियण फ़ंक्शन के साथ
- Pooling परत: 2×2 फ़िल्टर और 2 की स्ट्राइड के साथ अधिकतम पूलिंग करता है (जो निर्दिष्ट करता है कि पूल किए गए क्षेत्र ओवरलैप नहीं होते हैं)
- कन्वोल्यूशनल लेयर: ReLU सक्रियण फ़ंक्शन के साथ 36 5×5 फ़िल्टर लागू करता है
- Pooling लेयर #2: फिर से, 2×2 फ़िल्टर और 2 स्ट्राइड के साथ अधिकतम पूलिंग करता है
- 1,764 न्यूरॉन्स, ड्रॉपआउट नियमितीकरण दर 0.4 (प्रशिक्षण के दौरान किसी भी दिए गए तत्व के ड्रॉप होने की संभावना 0.4)
- सघन परत (लॉगिट परत): 10 न्यूरॉन, प्रत्येक अंक लक्ष्य वर्ग (0-9) के लिए एक।
CNN बनाने के लिए तीन महत्वपूर्ण मॉड्यूल हैं:
- conv2d(). फिल्टर की संख्या, फिल्टर कर्नेल आकार, पैडिंग और सक्रियण फ़ंक्शन को तर्क के रूप में लेकर एक द्वि-आयामी कन्वोल्यूशनल परत का निर्माण करता है।
- max_pooling2d(). अधिकतम-पूलिंग एल्गोरिथ्म का उपयोग करके एक दो-आयामी पूलिंग परत का निर्माण करता है।
- सघन (). छिपी हुई परतों और इकाइयों के साथ एक सघन परत का निर्माण करता है
आप सीएनएन बनाने के लिए एक फ़ंक्शन परिभाषित करेंगे। आइए रैप करने से पहले प्रत्येक बिल्डिंग ब्लॉक के निर्माण की प्रक्रिया को विस्तार से देखें।ping फंक्शन में सब कुछ एक साथ।
चरण 2: इनपुट परत
def cnn_model_fn(features, labels, mode): input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
आपको डेटा के आकार के साथ एक टेंसर को परिभाषित करने की आवश्यकता है। इसके लिए, आप मॉड्यूल tf.reshape का उपयोग कर सकते हैं। इस मॉड्यूल में, आपको रीशेप करने के लिए टेंसर और टेंसर के आकार को घोषित करने की आवश्यकता है। पहला तर्क डेटा की विशेषताएँ हैं, जिन्हें फ़ंक्शन के तर्क में परिभाषित किया गया है।
एक चित्र में ऊंचाई, चौड़ाई और चैनल होते हैं। MNIST डेटासेट 28×28 आकार का एक मोनोक्रोम चित्र है। हमने शेप आर्गुमेंट में बैच साइज़ को -1 पर सेट किया है ताकि यह features[“x”] का आकार ले ले। इसका लाभ यह है कि बैच साइज़ को ट्यून करने के लिए एक हाइपरपैरामीटर बनाया जा सकता है। यदि बैच साइज़ को 7 पर सेट किया जाता है, तो टेंसर 5,488 मान (28*28*7) इनपुट करेगा।
चरण 3: कन्वोल्यूशनल परत
# first Convolutional Layer conv1 = tf.layers.conv2d( inputs=input_layer, filters=14, kernel_size=[5, 5], padding="same", activation=tf.nn.relu)
पहली कनवोल्यूशनल लेयर में 5×5 के कर्नेल आकार और समान पैडिंग वाले 14 फ़िल्टर हैं। समान पैडिंग का मतलब है कि आउटपुट टेंसर और इनपुट टेंसर दोनों की ऊँचाई और चौड़ाई समान होनी चाहिए। समान आकार सुनिश्चित करने के लिए TensorFlow पंक्तियों और स्तंभों में शून्य जोड़ता है।
आप ReLU सक्रियण फ़ंक्शन का उपयोग करते हैं। आउटपुट का आकार [28, 28, 14] होगा।
चरण १: Poolinजी परत
कनवोल्यूशन के बाद अगला चरण पूलिंग गणना है। पूलिंग गणना डेटा की विमा को कम कर देगी। आप 2×2 आकार और 2 के स्ट्राइड के साथ max_pooling2d मॉड्यूल का उपयोग कर सकते हैं। आप पिछली परत को इनपुट के रूप में उपयोग करते हैं। आउटपुट आकार [batch_size, 14, 14, 14] होगा।
# first Pooling Layer
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
चरण 5: दूसरी कन्वोल्यूशनल परत और Poolinजी परत
दूसरी कनवोल्यूशनल लेयर 36 फ़िल्टर लगाती है, जिससे आउटपुट का आकार [batch_size, 14, 14, 36] हो जाता है। पूलिंग लेयर पहले की तरह ही 2×2 विंडो और 2 के स्ट्राइड का उपयोग करती है, इसलिए यह प्रत्येक स्थानिक अक्ष को आधा कर देती है और आउटपुट का आकार [batch_size, 7, 7, 36] हो जाता है।
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 साइज वाले मॉड्यूल रीशेप का उपयोग कर सकते हैं।
सघन परत 1,764 न्यूरॉन्स को जोड़ेगी। आप एक ReLU सक्रियण फ़ंक्शन जोड़ते हैं। इसके अलावा, आप 0.3 की दर के साथ एक ड्रॉपआउट रेगुलराइजेशन टर्म जोड़ते हैं, जिसका अर्थ है कि 30 प्रतिशत सक्रियणों को 0 पर सेट किया जाएगा। ध्यान दें कि ड्रॉपआउट केवल प्रशिक्षण चरण के दौरान होता है। cnn_model_fn फ़ंक्शन में एक तर्क मोड होता है जो यह बताता है कि मॉडल को प्रशिक्षित किया जाना है या मूल्यांकन किया जाना है, जैसा कि नीचे दिए गए CNN छवि वर्गीकरण TensorFlow उदाहरण में दिखाया गया है।
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: लॉगिट लेयर
अंत में, TensorFlow इमेज क्लासिफिकेशन उदाहरण में, आप मॉडल के पूर्वानुमान के साथ अंतिम परत को परिभाषित कर सकते हैं। आउटपुट का आकार बैच आकार और 10 के बराबर होता है, जो लक्ष्य वर्गों की कुल संख्या है।
# Logits Layer
logits = 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)
TensorFlow CNN उदाहरण का अंतिम चरण मॉडल को ऑप्टिमाइज़ करना है, यानी वज़न के सर्वोत्तम मान ज्ञात करना। इसके लिए, आप 0.001 की लर्निंग रेट के साथ ग्रेडिएंट डिसेंट ऑप्टिमाइज़र का उपयोग करते हैं। उद्देश्य लॉस को न्यूनतम करना है।
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
loss=loss,
global_step=tf.train.get_global_step())
आपने CNN का काम पूरा कर लिया है। हालाँकि, आप मूल्यांकन मोड के दौरान प्रदर्शन मेट्रिक्स प्रदर्शित करना चाहते हैं। मल्टीक्लास मॉडल के लिए प्रदर्शन मेट्रिक सटीकता है। 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 Layer input_layer = tf.reshape(features["x"], [-1, 28, 28, 1]) # Convolutional Layer conv1 = tf.layers.conv2d( inputs=input_layer, filters=32, kernel_size=[5, 5], padding="same", activation=tf.nn.relu) # Pooling Layer pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2) # Convolutional Layer #2 and Pooling Layer 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) # Dense Layer 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.4, training=mode == tf.estimator.ModeKeys.TRAIN) # Logits Layer logits = 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 Loss loss = 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 mode 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)
असेंबल किए गए फ़ंक्शन पर टिप्पणी: ऊपर दिए गए रैप्ड वर्शन में पहली कनवोल्यूशनल लेयर में 32 फ़िल्टर और ड्रॉपआउट 0.4 पर सेट किया गया है, जबकि स्टेप-बाय-स्टेप स्निपेट में 14 फ़िल्टर और 0.3 का उपयोग किया गया है। दोनों को चलाया जाता है, लेकिन मानों का एक जोड़ा चुनें और उसे स्थिर रखें ताकि प्रिंट किए गए आकार लेयर टेबल से मेल खाएं।
नीचे दिए गए चरण पिछले ट्यूटोरियल के समान ही हैं।
सबसे पहले, आप छवि वर्गीकरण के लिए CNN मॉडल के साथ एक अनुमानक परिभाषित करते हैं।
# Create the Estimator mnist_classifier = tf.estimator.Estimator( model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")
एक CNN को प्रशिक्षित करने में काफी समय लगता है, इसलिए आप प्रत्येक 50 पुनरावृत्तियों के बाद सॉफ्टमैक्स परतों के मानों को संग्रहीत करने के लिए एक लॉगिंग हुक बनाते हैं।
# Set up logging for predictions tensors_to_log = {"probabilities": "softmax_tensor"} logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)
आप मॉडल का अनुमान लगाने के लिए तैयार हैं। आपने बैच का आकार 100 निर्धारित किया है और डेटा को शफल किया है। ध्यान दें कि हमने प्रशिक्षण चरणों की संख्या 16,000 निर्धारित की है, जिसमें प्रशिक्षण में काफी समय लग सकता है। कृपया धैर्य रखें।
# Train the model train_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 results eval_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:41 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56 INFO: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}
वर्तमान आर्किटेक्चर के साथ, मूल्यांकन डिक्शनरी 0.9689286 की सटीकता दर्शाती है, जो लगभग 97% है। सटीकता में सुधार के लिए आप आर्किटेक्चर, बैच आकार और पुनरावृति की संख्या बदल सकते हैं। CNN ने इससे कहीं बेहतर प्रदर्शन किया है। कृत्रिम तंत्रिका नेटवर्क लॉजिस्टिक रिग्रेशन: कृत्रिम तंत्रिका नेटवर्क पर ट्यूटोरियल में, आपकी सटीकता 96% थी, जो सीएनएन से कम है। बड़े इमेज सेट के साथ सीएनएन का प्रदर्शन गणना गति और सटीकता दोनों के संदर्भ में प्रभावशाली है।
