TensorFlow में CNN छवि वर्गीकरण चरणों और उदाहरणों के साथ

कन्वेन्शनल न्यूरल नेटवर्क क्या है?

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

Archiकन्वोल्यूशनल न्यूरल नेटवर्क की तकनीक

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

छवि वर्गीकरण के लिए एक कन्वोल्यूशनल न्यूरल नेटवर्क को समझना बहुत मुश्किल नहीं है। एक इनपुट छवि को कन्वोल्यूशन चरण के दौरान संसाधित किया जाता है और बाद में एक लेबल दिया जाता है।

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

Archiकन्वोल्यूशनल न्यूरल नेटवर्क (सीएनएन) की तकनीक
Archiकन्वोल्यूशनल न्यूरल नेटवर्क (सीएनएन) की तकनीक

एक छवि ऊंचाई और चौड़ाई वाले पिक्सेल की एक सरणी से बनी होती है। एक ग्रेस्केल छवि में केवल एक चैनल होता है जबकि रंगीन छवि में तीन चैनल होते हैं (प्रत्येक लाल, हरा और नीला होता है)। एक चैनल एक दूसरे के ऊपर स्टैक्ड होता है। इस ट्यूटोरियल में, आप केवल एक चैनल वाली ग्रेस्केल छवि का उपयोग करेंगे। रंग की तीव्रता को दर्शाने के लिए प्रत्येक पिक्सेल का मान 0 से 255 तक होता है। उदाहरण के लिए, 0 के बराबर पिक्सेल सफ़ेद रंग दिखाएगा जबकि 255 के करीब मान वाला पिक्सेल गहरा होगा।

आइए, इसमें संग्रहीत एक छवि पर नजर डालें। एमएनआईएसटी डेटासेटनीचे दी गई तस्वीर दिखाती है कि बाईं ओर की तस्वीर को मैट्रिक्स प्रारूप में कैसे दर्शाया जाए। ध्यान दें कि, मूल मैट्रिक्स को 0 और 1 के बीच मानकीकृत किया गया है। गहरे रंग के लिए, मैट्रिक्स में मान लगभग 0.9 है जबकि सफ़ेद पिक्सेल का मान 0 है।

कनवल्शनल न्यूरल नेटवर्क

संवलनात्मक ऑपरेशन

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

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

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

कन्वोल्यूशनल न्यूरल नेटवर्क (ConvNet या CNN) के घटक

एक कन्वेन्शन के चार घटक होते हैं

  1. कनवल्शन
  2. गैर रेखीयता (ReLU)
  3. Poolinजी या उप नमूनाकरण
  4. वर्गीकरण (पूरी तरह से जुड़ी परत)

कनवल्शन

कन्वोल्यूशन का उद्देश्य छवि पर मौजूद वस्तु की विशेषताओं को स्थानीय रूप से निकालना है। इसका मतलब है कि नेटवर्क चित्र के भीतर विशिष्ट पैटर्न सीखेगा और चित्र में हर जगह उसे पहचान सकेगा।

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

कनवल्शन

नीचे एक यूआरएल दिया गया है जिससे आप देख सकते हैं कि कन्वोल्यूशन किस प्रकार कार्य करता है।

कनवल्शन

कई चैनल उपलब्ध हैं। नीचे, हमने कुछ चैनलों को सूचीबद्ध किया है। आप देख सकते हैं कि प्रत्येक फ़िल्टर का एक विशिष्ट उद्देश्य है। ध्यान दें, नीचे दी गई तस्वीर में; कर्नेल फ़िल्टर का एक पर्याय है।

कनवल्शन

संवलन के पीछे का अंकगणित

कन्वोल्यूशनल चरण चित्र के भीतर पिक्सेल की एक छोटी सरणी पर फ़िल्टर लागू करेगा। फ़िल्टर इनपुट छवि के साथ 3×3 या 5×5 के सामान्य आकार के साथ आगे बढ़ेगा। इसका मतलब है कि नेटवर्क इन विंडो को सभी इनपुट इमेज में स्लाइड करेगा और कन्वोल्यूशन की गणना करेगा। नीचे दी गई छवि दिखाती है कि कन्वोल्यूशन कैसे काम करता है। पैच का आकार 3×3 है, और आउटपुट मैट्रिक्स छवि मैट्रिक्स और फ़िल्टर के बीच तत्व-वार संचालन का परिणाम है।

कनवल्शन के पीछे का अंकगणित

आप देखेंगे कि आउटपुट की चौड़ाई और ऊंचाई इनपुट की चौड़ाई और ऊंचाई से अलग हो सकती है। ऐसा बॉर्डर इफ़ेक्ट के कारण होता है।

सीमा प्रभाव

छवि में 5×5 फ़ीचर मैप और 3×3 फ़िल्टर है। बीच में सिर्फ़ एक विंडो है जहाँ फ़िल्टर 3×3 ग्रिड को स्क्रीन कर सकता है। आउटपुट फ़ीचर मैप 3×3 आयाम के साथ दो टाइलों से छोटा हो जाएगा।

सीमा प्रभाव

इनपुट आयाम के समान आउटपुट आयाम प्राप्त करने के लिए, आपको पैडिंग जोड़ने की आवश्यकता है। पैडिंग में मैट्रिक्स के प्रत्येक तरफ पंक्तियों और स्तंभों की सही संख्या जोड़ना शामिल है। यह कन्वोल्यूशन को प्रत्येक इनपुट टाइल को केंद्र में फिट करने की अनुमति देगा। नीचे दी गई छवि में, इनपुट/आउटपुट मैट्रिक्स का आयाम 5×5 समान है

सीमा प्रभाव

जब आप नेटवर्क को परिभाषित करते हैं, तो संवलित विशेषताएं तीन मापदंडों द्वारा नियंत्रित होती हैं:

  1. गहराई: यह कन्वोल्यूशन के दौरान लागू किए जाने वाले फ़िल्टर की संख्या को परिभाषित करता है। पिछले उदाहरण में, आपने 1 की गहराई देखी, जिसका अर्थ है कि केवल एक फ़िल्टर का उपयोग किया जाता है। अधिकांश मामलों में, एक से अधिक फ़िल्टर होते हैं। नीचे दी गई तस्वीर तीन फ़िल्टर वाली स्थिति में किए गए ऑपरेशन को दिखाती है

सीमा प्रभाव

  1. स्ट्राइड: यह दो स्लाइस के बीच "पिक्सेल की छलांग" की संख्या को परिभाषित करता है। यदि स्ट्राइड 1 के बराबर है, तो विंडो एक पिक्सेल के फैलाव के साथ आगे बढ़ेगी। यदि स्ट्राइड दो के बराबर है, तो विंडो 2 पिक्सेल से कूद जाएगी। यदि आप स्ट्राइड बढ़ाते हैं, तो आपके पास छोटे फ़ीचर मैप होंगे।

उदाहरण चरण 1

स्ट्राइड का उदाहरण

स्ट्राइड २

स्ट्राइड का उदाहरण

  1. शून्य-पैडिंगपैडिंग इनपुट फीचर मैप के प्रत्येक तरफ पंक्तियों और स्तंभों की एक संगत संख्या जोड़ने का एक ऑपरेशन है। इस मामले में, आउटपुट का आयाम इनपुट के समान ही होता है।

गैर रेखीयता (ReLU)

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

Pooling Operaउत्पादन

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

इस चरण में, आपको आकार और स्ट्राइड को परिभाषित करने की आवश्यकता है। इनपुट छवि को पूल करने का एक मानक तरीका फ़ीचर मैप के अधिकतम मान का उपयोग करना है। नीचे दी गई तस्वीर देखें। "पूलिंग" 4×4 फ़ीचर मैप के चार सबमैट्रिक्स को स्क्रीन करेगा और अधिकतम मान लौटाएगा। पूलिंग 2×2 सरणी का अधिकतम मान लेता है और फिर इस विंडो को दो पिक्सेल से आगे बढ़ाता है। उदाहरण के लिए, पहला सब-मैट्रिक्स [3,1,3,2] है, पूलिंग अधिकतम मान लौटाएगा, जो 3 है।

Pooling Operaउत्पादन

एक अन्य पूलिंग ऑपरेशन भी है, जैसे कि माध्य।

यह ऑपरेशन फ़ीचर मैप के आकार को आक्रामक रूप से कम कर देता है

पूरी तरह से जुड़ी हुई परतें

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

संक्षिप्त:

TensorFlow कन्वोल्यूशनल न्यूरल नेटवर्क भविष्यवाणी करने से पहले विभिन्न परतों को संकलित करता है। एक न्यूरल नेटवर्क में निम्न होते हैं:

  • एक संवलन परत
  • Relu सक्रियण फ़ंक्शन
  • Poolinजी परत
  • सघन रूप से जुड़ी परत

कन्वोल्यूशनल परतें चित्र के उपक्षेत्र पर अलग-अलग फ़िल्टर लागू करती हैं। रेलू एक्टिवेशन फ़ंक्शन गैर-रैखिकता जोड़ता है, और पूलिंग परतें फ़ीचर मैप की आयामीता को कम करती हैं।

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

TensorFlow के साथ CNN को प्रशिक्षित करें

अब जब आप एक कॉन्वेंट के निर्माण खंड से परिचित हैं, तो आप एक निर्माण के लिए तैयार हैं TensorFlowहम CNN छवि वर्गीकरण के लिए MNIST डेटासेट का उपयोग करेंगे।

डेटा तैयार करना पिछले ट्यूटोरियल जैसा ही है। आप कोड चला सकते हैं और सीधे CNN की आर्किटेक्चर पर जा सकते हैं।

आप CNN का उपयोग करके छवि वर्गीकरण के लिए नीचे दिए गए चरणों का पालन करेंगे:

चरण 1: डेटासेट अपलोड करें

चरण 2: इनपुट परत

चरण 3: कन्वोल्यूशनल परत

चरण १: Poolinजी परत

चरण 5: दूसरी कन्वोल्यूशनल परत और Poolinजी परत

चरण 6: सघन परत

चरण 7: लॉगिट लेयर

चरण 1: डेटासेट अपलोड करें

MNIST डेटासेट scikit पर सीखने के लिए उपलब्ध है यूआरएलकृपया इसे डाउनलोड करें और डाउनलोड में संग्रहीत करें। आप इसे fetch_mldata('MNIST original') के साथ अपलोड कर सकते हैं।

ट्रेन/टेस्ट सेट बनाएं

आपको डेटासेट को train_test_split के साथ विभाजित करना होगा

सुविधाओं का पैमाना तय करें

अंत में, आप TensorFlow CNN उदाहरण का उपयोग करके नीचे दी गई छवि वर्गीकरण में दिखाए अनुसार MinMaxScaler के साथ सुविधा को स्केल कर सकते हैं।

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:]

सीएनएन को परिभाषित करें

एक CNN एक पारंपरिक न्यूरल नेट के साथ वैश्विक पैटर्न की तुलना में विवरण पैटर्न सीखने के लिए एक छवि के कच्चे पिक्सेल पर फ़िल्टर का उपयोग करता है। CNN का निर्माण करने के लिए, आपको यह परिभाषित करने की आवश्यकता है:

  1. कन्वोल्यूशनल लेयर: फ़ीचर मैप पर n संख्या में फ़िल्टर लागू करें। कन्वोल्यूशन के बाद, आपको नेटवर्क में गैर-रैखिकता जोड़ने के लिए एक रेलू एक्टिवेशन फ़ंक्शन का उपयोग करना होगा।
  2. Poolinजी लेयर: कन्वोल्यूशन के बाद अगला चरण फीचर मैक्स को डाउनसैंपल करना है। इसका उद्देश्य ओवरफिटिंग को रोकने और गणना की गति में सुधार करने के लिए फीचर मैप की आयामीता को कम करना है। मैक्स पूलिंग पारंपरिक तकनीक है, जो फीचर मैप को उप-क्षेत्रों (आमतौर पर 2×2 आकार के साथ) में विभाजित करती है और केवल अधिकतम मान रखती है।
  3. पूरी तरह से जुड़ी हुई परतें: पिछली परतों के सभी न्यूरॉन्स अगली परतों से जुड़े हुए हैं। CNN कन्वोल्यूशनल परतों से सुविधाओं के अनुसार लेबल को वर्गीकृत करेगा और पूलिंग परत के साथ कम करेगा।

सीएनएन वास्तुकला

  • कन्वोल्यूशनल लेयर: ReLU सक्रियण फ़ंक्शन के साथ 14 5×5 फ़िल्टर (5×5-पिक्सेल उपक्षेत्रों को निकालना) लागू करता है
  • 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(). अधिकतम-पूलिंग एल्गोरिथ्म का उपयोग करके एक दो-आयामी पूलिंग परत का निर्माण करता है।
  • सघन (). छिपी हुई परतों और इकाइयों के साथ एक सघन परत का निर्माण करता है

आप CNN बनाने के लिए एक फ़ंक्शन परिभाषित करेंगे। आइए विस्तार से देखें कि फ़ंक्शन में सब कुछ एक साथ लपेटने से पहले प्रत्येक बिल्डिंग ब्लॉक का निर्माण कैसे किया जाता है।

चरण 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 पर सेट किया है ताकि यह सुविधाओं [“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)

पहली कन्वोल्यूशनल परत में 14 फ़िल्टर हैं जिनका कर्नेल आकार 5×5 है और पैडिंग समान है। समान पैडिंग का मतलब है कि आउटपुट टेंसर और इनपुट टेंसर दोनों की ऊंचाई और चौड़ाई समान होनी चाहिए। Tensorflow पंक्तियों और स्तंभों में शून्य जोड़ देगा ताकि उनका आकार समान रहे।

आप Relu एक्टिवेशन फ़ंक्शन का उपयोग करते हैं। आउटपुट का आकार [28, 28, 14] होगा।

चरण १: Poolinजी परत

कन्वोल्यूशन के बाद अगला चरण पूलिंग कंप्यूटेशन है। पूलिंग कंप्यूटेशन डेटा की डायमेंशनलिटी को कम कर देगा। आप 2×2 के आकार और 2 के स्ट्राइड के साथ मॉड्यूल max_pooling2d का उपयोग कर सकते हैं। आप पिछली परत को इनपुट के रूप में उपयोग करते हैं। आउटपुट का आकार [बैच_साइज़, 14, 14, 14] होगा

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

चरण 5: दूसरी कन्वोल्यूशनल परत और Poolinजी परत

दूसरी कन्वोल्यूशनल लेयर में 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 में एक तर्क मोड है जो यह घोषित करता है कि मॉडल को प्रशिक्षित करने की आवश्यकता है या मूल्यांकन करने की, जैसा कि नीचे 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)

नीचे दिए गए चरण पिछले ट्यूटोरियल के समान ही हैं।

सबसे पहले, आप छवि वर्गीकरण के लिए 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}

वर्तमान आर्किटेक्चर के साथ, आपको 97% की सटीकता मिलती है। सटीकता को बेहतर बनाने के लिए आप आर्किटेक्चर, बैच आकार और पुनरावृत्ति की संख्या बदल सकते हैं। CNN न्यूरल नेटवर्क ने ANN या लॉजिस्टिक रिग्रेशन से कहीं बेहतर प्रदर्शन किया है। आर्टिफिशियल न्यूरल नेटवर्क पर ट्यूटोरियल में, आपको 96% की सटीकता मिली, जो CNN से कम है। बड़ी छवि के साथ CNN का प्रदर्शन प्रभावशाली है सेटगति गणना और सटीकता दोनों के संदर्भ में।

सारांश

एक कन्वोल्यूशनल न्यूरल नेटवर्क तस्वीर का मूल्यांकन करने के लिए बहुत अच्छा काम करता है। इस प्रकार की वास्तुकला तस्वीर या वीडियो से वस्तुओं को पहचानने में प्रभावी है।

TensorFlow CNN बनाने के लिए, आपको सात चरणों का पालन करना होगा:

चरण 1: डेटासेट अपलोड करें:

MNIST डेटासेट सीखने के लिए scikit पर उपलब्ध है। कृपया इसे डाउनलोड करें और इसे डाउनलोड में संग्रहीत करें। आप इसे fetch_mldata('MNIST original') के साथ अपलोड कर सकते हैं।

चरण 2: इनपुट परत:

यह चरण डेटा को पुनः आकार देता है। आकार पिक्सेल की संख्या के वर्गमूल के बराबर होता है। उदाहरण के लिए, यदि किसी चित्र में 156 पिक्सेल हैं, तो आकार 26×26 है। आपको यह निर्दिष्ट करना होगा कि चित्र में रंग है या नहीं। यदि हाँ, तो आपके पास आकार के लिए 3 हैं- RGB के लिए 3, अन्यथा 1।

input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

चरण 3: संवलन परत

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

conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

चरण 4: Poolinजी परत

तीसरे चरण में, आप एक पूलिंग लेयर जोड़ते हैं। यह लेयर इनपुट के आकार को कम करती है। यह सब-मैट्रिक्स का अधिकतम मान लेकर ऐसा करता है। उदाहरण के लिए, यदि सब-मैट्रिक्स [3,1,3,2] है, तो पूलिंग अधिकतम मान लौटाएगा, जो 3 है।

pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

चरण 5: कन्वोल्यूशनल लेयर जोड़ें और Poolinजी परत

इस चरण में, आप जितनी चाहें उतनी कन्व लेयर्स और पूलिंग लेयर्स जोड़ सकते हैं। Google 20 से ज़्यादा कन्व लेयर्स वाली आर्किटेक्चर का इस्तेमाल करता है।

चरण 6: सघन परत

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

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: लॉगिट लेयर

अंतिम चरण भविष्यवाणी है।

logits = tf.layers.dense(inputs=dropout, units=10)