TensorFlow के साथ Convolutional Neural Networks (CNN) ट्यूटोरियल

कल्पना करें कि आप किसी चिड़ियाघर में हैं और यह पहचानने की कोशिश कर रहे हैं कि कोई जानवर चीता है या तेंदुआ। एक इंसान के रूप में, आपका मस्तिष्क सहज ही शरीर और चेहरे की विशेषताओं का विश्लेषण करके सही निष्कर्ष पर पहुंच सकता है। इसी तरह, Convolutional Neural Networks (CNNs) को भी प्रशिक्षित किया जा सकता है ताकि वे समान पहचान कार्य कर सकें, चाहे पैटर्न कितने ही जटिल क्यों न हों। यही कारण है कि कंप्यूटर विज़न के क्षेत्र में वे अत्यंत शक्तिशाली हैं. 

यह वैचारिक CNN ट्यूटोरियल सबसे पहले बताएगा कि CNNs क्या हैं और मशीन लर्निंग में उनकी महत्ता क्या है। इसके बाद यह आपको TensorFlow Framework 2 में CNN के चरण-दर-चरण इम्प्लीमेंटेशन से गुजारेगा।

CNN क्या है?

Convolutional Neural Network (CNN या ConvNet) एक डीप लर्निंग एल्गोरिद्म है जिसे विशेष रूप से उन कार्यों के लिए डिज़ाइन किया गया है जहां ऑब्जेक्ट रिकग्निशन महत्वपूर्ण होता है, जैसे इमेज क्लासिफिकेशन, डिटेक्शन और सेगमेंटेशन।  कई वास्तविक-जीवन अनुप्रयोग, जैसे स्वचालित चलने वाली कारें, सर्विलांस कैमरे, आदि, CNNs का उपयोग करते हैं. 

CNNs का महत्व

निम्नलिखित कारणों से CNNs महत्वपूर्ण हैं:

• SVM और डिसिजन ट्री जैसे पारंपरिक मशीन लर्निंग मॉडलों के विपरीत, जिन्हें मैन्युअल फीचर एक्सट्रैक्शन की आवश्यकता होती है, CNNs बड़े पैमाने पर स्वचालित फीचर एक्सट्रैक्शन कर सकते हैं, जिससे वे कुशल बनते हैं. 
• कन्वोल्यूशन लेयर्स CNNs को ट्रांसलेशन इनवेरिएंट बनाती हैं, यानी वे डेटा से पैटर्न को पहचान सकती हैं और फीचर्स निकाल सकती हैं, चाहे उनकी स्थिति कुछ भी हो—चाहे इमेज घुमाई गई हो, स्केल की गई हो या शिफ्ट की गई हो।
• VGG-16, ResNet50, Inceptionv3, और EfficientNet जैसे कई प्री-ट्रेंड CNN मॉडल्स ने स्टेट-ऑफ-द-आर्ट परिणाम हासिल किए हैं और कम मात्रा के डेटा के साथ नए कार्यों पर फाइन-ट्यून किए जा सकते हैं. 
• CNNs का उपयोग गैर-इमेज क्लासिफिकेशन समस्याओं में भी किया जा सकता है और वे केवल नैचुरल लैंग्वेज प्रोसेसिंग, टाइम सीरीज़ विश्लेषण और स्पीच रिकग्निशन तक सीमित नहीं हैं।

CNN की आर्किटेक्चर

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

• कन्वोल्यूशनल लेयर्स
• रेक्टिफाइड लीनियर यूनिट (संक्षेप में ReLU)
• पूलिंग लेयर्स
• फुली कनेक्टेड लेयर्स 

हस्तलिखित अंकों के वर्गीकरण के निम्नलिखित उदाहरण का उपयोग करके समझते हैं कि इन लेयरों में से प्रत्येक कैसे काम करता है।

कन्वोल्यूशन लेयर्स

यह CNN का पहला निर्माण खंड है। नाम से स्पष्ट है कि मुख्य गणितीय कार्य कन्वोल्यूशन है, जो पिक्सेल्स की मैट्रिक्स (जो इमेज का प्रतिनिधित्व करती है) पर एक स्लाइडिंग विंडो फ़ंक्शन लागू करना है। मैट्रिक्स पर लगाया जाने वाला यह स्लाइडिंग फ़ंक्शन kernel या filter कहलाता है, और दोनों शब्द एक-दूसरे के स्थान पर प्रयुक्त हो सकते हैं. 

कन्वोल्यूशन लेयर में समान आकार के कई फ़िल्टर लगाए जाते हैं, और प्रत्येक फ़िल्टर का उपयोग इमेज से किसी विशिष्ट पैटर्न, जैसे अंकों की वक्रता, किनारों, अंकों के संपूर्ण आकार आदि को पहचानने में होता है. 

मान लीजिए हमारे पास 32x32 का ग्रेस्केल हस्तलिखित अंक की इमेज है। मैट्रिक्स में दिए मान केवल समझाने के लिए हैं।

साथ ही, कन्वोल्यूशन के लिए प्रयुक्त kernel पर विचार करें। यह 3x3 आयाम वाली एक मैट्रिक्स है। kernel के प्रत्येक तत्व के वेट्स ग्रिड में दर्शाए गए हैं। शून्य वेट्स काले ग्रिड में और एक (1) सफेद ग्रिड में दिखाए गए हैं. 

क्या हमें ये वेट्स मैन्युअली ढूंढने पड़ते हैं? 

वास्तविक जीवन में, kernel के वेट्स न्यूरल नेटवर्क के प्रशिक्षण के दौरान निर्धारित होते हैं. 

इन दो मैट्रिसेज़ का उपयोग करके, हम डॉट प्रोडक्ट लागू कर कन्वोल्यूशन ऑपरेशन कर सकते हैं, और यह इस प्रकार काम करता है: 

1. kernel मैट्रिक्स को ऊपर-बाएँ कोने से दाएँ की ओर स्लाइड करें।
2. एलीमेंट-वाइज गुणा करें.  
3. गुणनफल के मानों का योग लें।
4. प्राप्त मान कन्वोल्यूटेड मैट्रिक्स के पहले मान (ऊपर-बाएँ कोना) के अनुरूप होगा।
5. स्लाइडिंग विंडो के आकार के अनुसार kernel को नीचे की ओर बढ़ाएँ।
6. जब तक पूरी इमेज मैट्रिक्स कवर न हो जाए, चरण 1 से 5 दोहराते रहें।

कन्वोल्यूटेड मैट्रिक्स का आयाम स्लाइडिंग विंडो के आकार पर निर्भर करता है। विंडो जितनी बड़ी होगी, आयाम उतना छोटा होगा।

साहित्य में kernel से जुड़ा एक और नाम फीचर डिटेक्टर है क्योंकि वेट्स को इस तरह फाइन-ट्यून किया जा सकता है कि वे इनपुट इमेज में विशिष्ट फीचर्स का पता लगा सकें. 

उदाहरण के लिए: 

• पड़ोसी पिक्सेल का औसत लेने वाला kernel इनपुट इमेज को धुंधला करने में प्रयुक्त हो सकता है।
• पड़ोसी मानों को घटाने वाला kernel एज डिटेक्शन करने के लिए उपयोग होता है।

नेटवर्क में जितनी अधिक कन्वोल्यूशन लेयर्स होंगी, लेयर उतने अधिक अमूर्त फीचर्स का पता लगाने में बेहतर होती जाएगी. 

एक्टिवेशन फ़ंक्शन

प्रत्येक कन्वोल्यूशन ऑपरेशन के बाद ReLU एक्टिवेशन फ़ंक्शन लगाया जाता है। यह फ़ंक्शन नेटवर्क को इमेज के फीचर्स के बीच गैर-रेखीय संबंध सीखने में मदद करता है, जिससे विभिन्न पैटर्न की पहचान के लिए नेटवर्क अधिक सक्षम बनता है। यह वैनिशिंग ग्रेडिएंट समस्या को कम करने में भी मदद करता है. 

पूलिंग लेयर

पूलिंग लेयर का लक्ष्य कन्वोल्यूटेड मैट्रिक्स से सबसे महत्वपूर्ण फीचर्स को निकालना है। यह कुछ एग्रीगेशन ऑपरेशनों को लागू करके किया जाता है, जो फीचर मैप (कन्वोल्यूटेड मैट्रिक्स) के आयाम को कम करते हैं, और इस प्रकार नेटवर्क को प्रशिक्षित करते समय प्रयुक्त मेमोरी घटती है।  पूलिंग ओवरफिटिंग को कम करने में भी उपयोगी है।

सबसे सामान्य एग्रीगेशन फ़ंक्शंस जो लागू किए जा सकते हैं: 

• मैक्स पूलिंग, जो फीचर मैप का अधिकतम मान लेता है
• सम पूलिंग, जो फीचर मैप के सभी मानों का योग होता है
• औसत पूलिंग, जो सभी मानों का औसत है. 

नीचे पिछले उदाहरणों के प्रत्येक का चित्रण दिया गया है: 

साथ ही, जैसे-जैसे पूलिंग फ़ंक्शन लगाया जाता है, फीचर मैप का आयाम छोटा होता जाता है. 

अंतिम पूलिंग लेयर अपने फीचर मैप को फ्लैट कर देती है ताकि उसे फुली कनेक्टेड लेयर द्वारा प्रोसेस किया जा सके. 

फुली कनेक्टेड लेयर्स

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

अंत में, एक softmax प्रेडिक्शन लेयर का उपयोग संभावित आउटपुट लेबल्स के लिए प्रायिकता मान उत्पन्न करने के लिए किया जाता है, और अंतिम अनुमानित लेबल वह होता है जिसका प्रायिकता स्कोर सबसे अधिक होता है. 

ड्रॉपआउट 

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

चूंकि तकनीकी इम्प्लीमेंटेशन TensorFlow 2 का उपयोग करके किया जाएगा, अगला भाग इस फ्रेमवर्क के विभिन्न घटकों का संपूर्ण अवलोकन प्रदान करने का उद्देश्य रखता है ताकि डीप लर्निंग मॉडल्स को कुशलता से बनाया जा सके. 

TensorFlow फ्रेमवर्क क्या है?

Google ने नवंबर 2015 में TensorFlow विकसित किया। वे इसे कई कारणों से सभी के लिए एक ओपन-सोर्स मशीन लर्निंग फ्रेमवर्क के रूप में परिभाषित करते हैं. 

• ओपन-सोर्स: Apache 2.0 ओपन-सोर्स लाइसेंस के तहत जारी। यह शोधकर्ताओं, संगठनों और डेवलपर्स को बिना किसी प्रतिबंध के लाइब्रेरी पर निर्माण करके उसमें योगदान देने की अनुमति देता है. 
• मशीन लर्निंग फ्रेमवर्क: यानी इसमें मशीन लर्निंग मॉडल्स के निर्माण प्रक्रिया का समर्थन करने वाली लाइब्रेरियों और टूल्स का एक सेट है।
• सबके लिए: TensorFlow का उपयोग करना Python जैसी सामान्य प्रोग्रामिंग भाषाओं के माध्यम से मशीन लर्निंग मॉडल्स का इम्प्लीमेंटेशन आसान बनाता है। इसके अलावा, Keras जैसी इन-बिल्ट लाइब्रेरियां मजबूत डीप लर्निंग मॉडल बनाना और भी आसान कर देती हैं. 

ये सभी क्षमताएं TensorFlow को न्यूरल नेटवर्क बनाने के लिए एक अच्छा विकल्प बनाती हैं. 

इसके अलावा, TensorFlow 2 को इंस्टॉल करना सरल है और Python पैकेज मैनेजर pip का उपयोग करके, आधिकारिक दस्तावेज़ में समझाए अनुसार किया जा सकता है. 

इंस्टॉलेशन के बाद, हम देख सकते हैं कि प्रयुक्त संस्करण 2.9.1 है

import tensorflow as tf
print("TensorFlow version:", tf.__version__)संचालित द्वारा

अब, उन मुख्य घटकों की और पड़ताल करते हैं जिनसे ये नेटवर्क बनाए जाते हैं. 

Tensors क्या हैं?

मशीन लर्निंग और डीप लर्निंग मॉडल बनाते समय हम मुख्यतः उच्च-आयामी डेटा से निपटते हैं। Tensors समान प्रकार वाले बहु-आयामी एरे होते हैं जिनका उपयोग डेटा की विभिन्न विशेषताओं को प्रदर्शित करने के लिए किया जाता है. 

नीचे टेन्सर्स के विभिन्न आयामों का ग्राफिकल प्रतिनिधित्व दिया गया है. 

• 0-आयामी टेन्सर एक एकल मान रखता है।
• 1-आयामी टेन्सर, जिसे “रैंक-1” टेन्सर भी कहते हैं, मानों की एक सूची है. 
• 2-आयामी टेन्सर “रैंक-2” टेन्सर होता है।
• अंततः, हमारे पास N-आयामी टेन्सर हो सकता है, जहां N टेन्सर के भीतर आयामों की संख्या का प्रतिनिधित्व करता है। पिछले मामलों में, N क्रमशः 0, 1 और 2 है।

नीचे 0 से 3-आयामी टेन्सर का चित्रण है। प्रत्येक टेन्सर TensorFlow की constant() फ़ंक्शन का उपयोग करके बनाया गया है. 

# Zero dimensional tensor
zero_dim_tensor = tf.constant(20)
print(zero_dim_tensor)

# One dimensional tensor
one_dim_tensor = tf.constant([12, 20, 53, 26, 11, 56])
print(one_dim_tensor)

# Two dimensional tensor
two_dim_array = [[3, 6, 7, 5],
             	[9, 2, 3, 4],
             	[7, 1, 10,6],
             	[0, 8, 11,2]]

two_dim_tensor = tf.constant(two_dim_array)
print(two_dim_tensor)संचालित द्वारा

उपरोक्त कोड के सफल निष्पादन से नीचे दिए गए आउटपुट उत्पन्न होने चाहिए, और हम “tf.Tensor” कीवर्ड देख सकते हैं जिसका अर्थ है कि परिणाम एक टेन्सर है। इसके तीन पैरामीटर होते हैं:

•  टेन्सर का वास्तविक मान।
• टेन्सर का shape(), जो क्रमशः पहले, दूसरे और तीसरे टेन्सर के लिए 0, 6 बाय 1, और 4 बाय 4 है।
• डेटा प्रकार, जो dtype एट्रिब्यूट द्वारा दर्शाया जाता है, और सभी टेन्सर्स int32 हैं।

हमारा शुरुआती लोगों के लिए TensorFlow ट्यूटोरियल TensorFlow का एक संपूर्ण अवलोकन प्रदान करता है और मॉडल बनाना व प्रशिक्षित करना सिखाता है।

Tensors बनाम Matrices: अंतर

बहुत से लोग टेन्सर्स को मैट्रिसेज़ के साथ भ्रमित कर देते हैं। यद्यपि ये दोनों ऑब्जेक्ट्स समान दिखते हैं, परंतु उनकी विशेषताएँ पूरी तरह भिन्न हैं। यह खंड मैट्रिसेज़ और टेन्सर्स के बीच के अंतर को बेहतर ढंग से समझाता है।

• हम मैट्रिक्स को केवल दो आयामों वाले टेन्सर के रूप में सोच सकते हैं. 
• दूसरी ओर, टेन्सर्स एक अधिक सामान्य प्रारूप हैं जिनमें किसी भी संख्या के आयाम हो सकते हैं।

मैट्रिसेज़ के विपरीत, निम्न कारणों से टेन्सर्स डीप लर्निंग समस्याओं के लिए अधिक उपयुक्त हैं: 

• वे किसी भी संख्या के आयामों को संभाल सकते हैं, जिससे वे बहु-आयामी डेटा के लिए बेहतर फिट बनते हैं।
• डेटा प्रकारों, आकारों और आयामों की एक विस्तृत श्रृंखला के साथ संगत होने की टेन्सर्स की क्षमता उन्हें मैट्रिसेज़ की तुलना में अधिक बहुमुखी बनाती है।
• TensorFlow कंप्यूटेशन को तेज़ करने के लिए GPU और TPU समर्थन प्रदान करता है। टेन्सर्स का उपयोग करते हुए, मशीन लर्निंग इंजीनियर्स स्वतः ही इन लाभों का फायदा उठा सकते हैं।
• टेन्सर्स मूल रूप से ब्रॉडकास्टिंग का समर्थन करते हैं, जिसमें अलग-अलग आकार वाले टेन्सर्स के बीच अंकगणितीय ऑपरेशन्स करना शामिल है, जो मैट्रिसेज़ के साथ हमेशा संभव नहीं होता.  

TensorFlow: Constants, Variables, और Placeholders

Constants टेन्सर्स के एकमात्र प्रकार नहीं हैं। Variables और Placeholders भी होते हैं, जो सभी एक कंप्यूटेशनल ग्राफ के निर्माण खंड हैं. 

एक कंप्यूटेशनल ग्राफ मूलतः ऑपरेशनों की एक शृंखला और उनके बीच डेटा के प्रवाह का प्रतिनिधित्व है. 

अब, इन प्रकार के टेन्सर्स के बीच अंतर समझते हैं।

Constants

Constants वे टेन्सर्स हैं जिनके मान कंप्यूटेशनल ग्राफ के निष्पादन के दौरान नहीं बदलते। इन्हें tf.constant() फ़ंक्शन का उपयोग करके बनाया जाता है और मुख्य रूप से ऐसे फिक्स्ड पैरामीटर्स को स्टोर करने में उपयोग होते हैं जिन्हें मॉडल प्रशिक्षण के दौरान बदलने की आवश्यकता नहीं होती।

Variables

Variables वे टेन्सर्स हैं जिनके मान कंप्यूटेशनल ग्राफ के निष्पादन के दौरान बदले जा सकते हैं और इन्हें tf.Variable() फ़ंक्शन का उपयोग करके बनाया जाता है। उदाहरण के लिए, न्यूरल नेटवर्क्स के मामले में वेट्स और बायसिस को Variables के रूप में परिभाषित किया जा सकता है क्योंकि उन्हें प्रशिक्षण प्रक्रिया के दौरान अपडेट करने की आवश्यकता होती है. 

Placeholders

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

TensorFlow संस्करण 2 में, placeholders को tf.function() फ़ंक्शन द्वारा प्रतिस्थापित किया गया है, जो डेटा को कंप्यूटेशनल ग्राफ में फ़ीड करने का अधिक पाइथॉनिक और डायनेमिक तरीका है. 

CNN का चरण-दर-चरण इम्प्लीमेंटेशन

आइए अब तक सीखी गई हर बात को अभ्यास में लाते हैं। यह खंड TensorFlow में CIFAR-10 डेटासेट पर लागू एक कन्वोल्यूशनल न्यूरल नेटवर्क के एंड-टू-एंड इम्प्लीमेंटेशन को दर्शाएगा, जो एक इन-बिल्ट डेटासेट है और जिसकी निम्नलिखित विशेषताएँ हैं: 

• इसमें 60,000 32 बाय 32 रंगीन इमेजेज़ हैं
• डेटासेट में 10 अलग-अलग क्लासेज़ हैं
• प्रत्येक क्लास में 6000 इमेजेज़ हैं
• कुल मिलाकर 50,000 प्रशिक्षण इमेजेज़ हैं 
• और कुल 10,000 परीक्षण इमेजेज़ हैं

लेख का सोर्स कोड DataCamp के वर्कस्पेस पर उपलब्ध है

नेटवर्क की आर्किटेक्चर

तकनीकी इम्प्लीमेंटेशन में जाने से पहले, लागू किए जा रहे नेटवर्क की समग्र आर्किटेक्चर को समझते हैं. 

• मॉडल का इनपुट 32x32x3 टेन्सर है, जो क्रमशः चौड़ाई, ऊंचाई और चैनल्स के लिए है. 
• हमारे पास दो कन्वोल्यूशनल लेयर्स होंगी। पहली लेयर 3x3 आकार के 32 फ़िल्टर्स और ReLU एक्टिवेशन फ़ंक्शन लगाएगी। और दूसरी 3x3 आकार के 64 फ़िल्टर्स लगाएगी
• पहली पूलिंग लेयर 2x2 मैक्स पूलिंग लगाएगी
• दूसरी पूलिंग लेयर भी 2x2 मैक्स पूलिंग लगाएगी
• फुली कनेक्टेड लेयर में 128 यूनिट्स और ReLU एक्टिवेशन फ़ंक्शन होगा
• अंत में, आउटपुट 10 यूनिट्स का होगा जो 10 क्लासेज़ के अनुरूप है, और एक्टिवेशन फ़ंक्शन softmax होगा ताकि प्रायिकता वितरण उत्पन्न किया जा सके।

डेटासेट लोड करना

इन-बिल्ट डेटासेट को keras.datasets() से इस प्रकार लोड किया जाता है: 

(train_images, train_labels), (test_images, test_labels) = cf10.load_data()संचालित द्वारा

एक्सप्लोरेटरी डेटा एनालिसिस

इस खंड में, हम केवल कुछ सैंपल इमेजेज़ दिखाने पर ध्यान देंगे क्योंकि हमें पहले से ही पता है कि प्रशिक्षण और परीक्षण डेटा में प्रत्येक क्लास का अनुपात क्या है. 

सहायक फ़ंक्शन show_images() डिफॉल्ट रूप से कुल 12 इमेजेज़ दिखाता है और तीन मुख्य पैरामीटर्स लेता है: 

• ट्रेनिंग इमेजेज़
• क्लास के नाम
• और ट्रेनिंग लेबल्स।

import matplotlib.pyplot as plt

def show_images(train_images,
            	class_names,
            	train_labels,
            	nb_samples = 12, nb_row = 4):
    
	plt.figure(figsize=(12, 12))
	for i in range(nb_samples):
    	plt.subplot(nb_row, nb_row, i + 1)
    	plt.xticks([])
    	plt.yticks([])
    	plt.grid(False)
    	plt.imshow(train_images[i], cmap=plt.cm.binary)
    	plt.xlabel(class_names[train_labels[i][0]])
	plt.show()संचालित द्वारा

अब, हम आवश्यक पैरामीटर्स के साथ फ़ंक्शन को कॉल कर सकते हैं. 

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
           	'dog', 'frog', 'horse', 'ship', 'truck']

show_images(train_images, class_names, train_labels)संचालित द्वारा

उपरोक्त कोड का सफल निष्पादन नीचे दी गई इमेजेज़ उत्पन्न करता है. 

डेटा प्रीप्रोसेसिंग

मॉडल को प्रशिक्षित करने से पहले, हमें पिक्सेल मानों को एक ही रेंज (जैसे 0 से 1) में सामान्यीकृत करना होता है। इमेजेज़ के साथ काम करते समय यह एक आम प्रीप्रोसेसिंग चरण है ताकि स्केल इनवेरिएंस सुनिश्चित हो और प्रशिक्षण के दौरान तेज़ कन्वर्जेंस हो सके. 

max_pixel_value = 255

train_images = train_images / max_pixel_value
test_images = test_images / max_pixel_valueसंचालित द्वारा

साथ ही, हम देखते हैं कि लेबल श्रेणीय (categorical) प्रारूप में दर्शाए गए हैं जैसे cat, horse, bird आदि। हमें उन्हें संख्यात्मक प्रारूप में बदलने की आवश्यकता है ताकि उन्हें न्यूरल नेटवर्क द्वारा आसानी से प्रोसेस किया जा सके।

from tensorflow.keras.utils import to_categorical
train_labels = to_categorical(train_labels, len(class_names))
test_labels = to_categorical(test_labels, len(class_names))संचालित द्वारा

मॉडल आर्किटेक्चर इम्प्लीमेंटेशन

अगला चरण पूर्ववर्णित विवरण के आधार पर नेटवर्क की आर्किटेक्चर को इम्प्लीमेंट करना है. 

पहले, हम Sequential() क्लास का उपयोग करके मॉडल परिभाषित करते हैं, और प्रत्येक लेयर को add() फ़ंक्शन से मॉडल में जोड़ा जाता है. 

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Variables
INPUT_SHAPE = (32, 32, 3)
FILTER1_SIZE = 32
FILTER2_SIZE = 64
FILTER_SHAPE = (3, 3)
POOL_SHAPE = (2, 2)
FULLY_CONNECT_NUM = 128
NUM_CLASSES = len(class_names)

# Model architecture implementation
model = Sequential()
model.add(Conv2D(FILTER1_SIZE, FILTER_SHAPE, activation='relu', input_shape=INPUT_SHAPE))
model.add(MaxPooling2D(POOL_SHAPE))
model.add(Conv2D(FILTER2_SIZE, FILTER_SHAPE, activation='relu'))
model.add(MaxPooling2D(POOL_SHAPE))
model.add(Flatten())
model.add(Dense(FULLY_CONNECT_NUM, activation='relu'))
model.add(Dense(NUM_CLASSES, activation='softmax'))संचालित द्वारा

मॉडल पर summary() फ़ंक्शन लागू करने के बाद, हमें मॉडल की आर्किटेक्चर का एक व्यापक सारांश मिलता है जिसमें प्रत्येक लेयर, उसके प्रकार, आउटपुट आकार और कुल trainable पैरामीटर्स की जानकारी होती है. 

मॉडल प्रशिक्षण

अंततः मॉडल के प्रशिक्षण को कॉन्फ़िगर और ट्रिगर करने के लिए सभी संसाधन उपलब्ध हैं। यह क्रमशः compile() और fit() फ़ंक्शंस से किया जाता है, जो निम्न पैरामीटर्स लेते हैं: 

• ऑप्टिमाइज़र मॉडल के वेट्स और बायसिस को अपडेट करने के लिए जिम्मेदार है। हमारे मामले में, हम Adam ऑप्टिमाइज़र का उपयोग कर रहे हैं. 
• लॉस फ़ंक्शन मिसक्लासिफिकेशन त्रुटियों को मापने के लिए उपयोग होता है, और हम Crossentropy() का उपयोग कर रहे हैं।
• अंत में, मेट्रिक्स मॉडल के प्रदर्शन को मापने के लिए उपयोग होते हैं, और हमारे उपयोग मामले में accuracy, precision, और recall प्रदर्शित किए जाएंगे।

from tensorflow.keras.metrics import Precision, Recall

BATCH_SIZE = 32
EPOCHS = 30

METRICS = metrics=['accuracy',
               	Precision(name='precision'),
               	Recall(name='recall')]

model.compile(optimizer='adam',
          	loss='categorical_crossentropy',
          	metrics = METRICS)

# Train the model
training_history = model.fit(train_images, train_labels,
                	epochs=EPOCHS, batch_size=BATCH_SIZE,
                	validation_data=(test_images, test_labels))संचालित द्वारा

मॉडल मूल्यांकन

मॉडल प्रशिक्षण के बाद, हम show_performance_curve() सहायक फ़ंक्शन का उपयोग करके उपरोक्त मेट्रिक्स को दो आयामों में प्लॉट करके ट्रेनिंग और टेस्टिंग दोनों डेटासेट्स पर इसके प्रदर्शन की तुलना कर सकते हैं. 

• क्षैतिज अक्ष (x) epochs की संख्या है
• ऊर्ध्वाधर (y) मॉडल का अंतर्निहित प्रदर्शन है. 
• वक्र किसी विशिष्ट epoch पर मेट्रिक्स के मान का प्रतिनिधित्व करता है।

बेहतर विज़ुअलाइज़ेशन के लिए, ट्रेनिंग और वैलिडेशन प्रदर्शन मानों के प्रतिच्छेदन से होकर एक लाल ऊर्ध्वाधर रेखा खींची जाती है, साथ ही इष्टतम मान भी अंकित किया जाता है।

def show_performance_curve(training_result, metric, metric_label):
    
	train_perf = training_result.history[str(metric)]
	validation_perf = training_result.history['val_'+str(metric)]
	intersection_idx = np.argwhere(np.isclose(train_perf,
                                            	validation_perf, atol=1e-2)).flatten()[0]
	intersection_value = train_perf[intersection_idx]
    
	plt.plot(train_perf, label=metric_label)
	plt.plot(validation_perf, label = 'val_'+str(metric))
	plt.axvline(x=intersection_idx, color='r', linestyle='--', label='Intersection')
    
	plt.annotate(f'Optimal Value: {intersection_value:.4f}',
         	xy=(intersection_idx, intersection_value),
         	xycoords='data',
         	fontsize=10,
         	color='green')
            	 
	plt.xlabel('Epoch')
	plt.ylabel(metric_label)
	plt.legend(loc='lower right')संचालित द्वारा

इसके बाद, फ़ंक्शन को मॉडल की accuracy और precision दोनों के लिए लागू किया जाता है।

show_performance_curve(training_history, 'accuracy', 'accuracy')संचालित द्वारा

show_performance_curve(training_history, 'precision', 'precision')संचालित द्वारा

किसी भी फाइन-ट्यूनिंग और प्री-प्रोसेसिंग के बिना मॉडल को प्रशिक्षित करने के बाद, हमें प्राप्त होते हैं:  

• 67.09% की सटीकता (accuracy), अर्थात हर 100 सैंपल्स में से 67 को मॉडल सही तरह से वर्गीकृत करता है. 
• और 76.55% की प्रिसीज़न, यानी हर 100 पॉज़िटिव भविष्यवाणियों में से लगभग 77 सही पॉज़िटिव होते हैं, और शेष 23 फ़ॉल्स पॉज़िटिव होते हैं. 
• ये स्कोर क्रमशः accuracy और precision के लिए तीसरे और दूसरे epochs पर प्राप्त होते हैं।

ये दोनों मेट्रिक्स मॉडल के व्यवहार की समग्र समझ देती हैं. 

अगर हम प्रत्येक क्लास के लिए यह जानना चाहें कि किन पर मॉडल बेहतर भविष्यवाणी करता है और किन पर उसे कठिनाई होती है, तो क्या करें?

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

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

test_predictions = model.predict(test_images)

test_predicted_labels = np.argmax(test_predictions, axis=1)

test_true_labels = np.argmax(test_labels, axis=1)

cm = confusion_matrix(test_true_labels, test_predicted_labels)

cmd = ConfusionMatrixDisplay(confusion_matrix=cm)

cmd.plot(include_values=True, cmap='viridis', ax=None, xticks_rotation='horizontal')
plt.show()संचालित द्वारा

• क्लास 0, 1, 6, 7, 8, 9 क्रमशः airplane, automobile, frog, horse, ship, और truck विकर्ण (diagonal) पर उच्चतम मान रखते हैं। इसका अर्थ है कि मॉडल इन क्लासेज़ की भविष्यवाणी करने में बेहतर है. 
• दूसरी ओर, शेष क्लासेज़ के साथ यह संघर्ष करता दिखता है:  
• जिन क्लासेज़ के ऑफ-डायगोनल मान सबसे अधिक हैं, उनके साथ मॉडल अच्छी क्लासेज़ को गड़बड़ाता है। उदाहरण के लिए, यह birds (क्लास 2) को airplane से, और automobile को trucks (क्लास 9) से भ्रमित करता है।

कन्फ्यूज़न मैट्रिक्स के बारे में और जानें हमारे ट्यूटोरियल understanding confusion matrix in R से, जो DataCamp के Machine Learning toolbox कोर्स की सामग्री लेता है।

इस मॉडल को निम्न अतिरिक्त कार्यों से बेहतर किया जा सकता है:  

• इमेज ऑगमेंटेशन
• ResNet, MobileNet, या VGG जैसे प्री-ट्रेंड मॉडल्स का उपयोग करते हुए ट्रांसफर लर्निंग। हमारा ट्रांसफर लर्निंग ट्यूटोरियल बताता है कि ट्रांसफर लर्निंग क्या है और वास्तविक जीवन में इसके कुछ अनुप्रयोग।
• L1, L2 या ड्रॉपआउट जैसी विभिन्न रेग्युलराइज़ेशन तकनीकें लागू करना.  
• लर्निंग रेट, बैच साइज, नेटवर्क में लेयरों की संख्या जैसे विभिन्न हाइपरपैरामीटर्स का फाइन-ट्यूनिंग करना. 

निष्कर्ष

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

हमने इन सभी कौशलों को एक वास्तविक दुनिया के मल्टीक्लास क्लासिफिकेशन कार्य पर लागू किया.  

हमारा शुरुआती लोगों के लिए ऑब्जेक्ट डिटेक्शन गाइड कंप्यूटर विज़न के बारे में आपकी सीख को आगे बढ़ाने का एक बेहतरीन अगला कदम हो सकता है। यह ऑब्जेक्ट डिटेक्शन के प्रमुख घटकों की पड़ताल करता है और बताता है कि TensorFlow में उपलब्ध SSD और Faster RCNN में इसे कैसे लागू करें।