1. खास जानकारी
यह ट्यूटोरियल Tensorflow 2.2 के लिए अपडेट किया गया है !
इस कोडलैब में, आपको हाथ से लिखे गए अंकों की पहचान करने वाला न्यूरल नेटवर्क बनाने और उसे ट्रेनिंग देने का तरीका पता चलेगा. इस प्रोसेस में, 99% सटीक हासिल करने के लिए न्यूरल नेटवर्क को बेहतर बनाने पर, आपको उन टूल के बारे में भी पता चलेगा जिनका इस्तेमाल, डीप लर्निंग के प्रोफ़ेशनल अपने मॉडल को बेहतर तरीके से ट्रेनिंग देने के लिए करते हैं.
यह कोडलैब MNIST डेटासेट का इस्तेमाल करता है. इसमें 60, 000 लेबल किए गए अंक होते हैं,जिन्होंने करीब दो दशकों से पीएचडी की पीढ़ियों को व्यस्त रखा है. Python / TensorFlow कोड की 100 से कम लाइनों का इस्तेमाल करके, सवाल हल करें.
आप इन चीज़ों के बारे में जानेंगे
- न्यूरल नेटवर्क क्या है और इसे कैसे ट्रेनिंग दें
- tf.keras का इस्तेमाल करके, एक लेयर वाला बुनियादी न्यूरल नेटवर्क बनाने का तरीका
- और लेयर जोड़ने का तरीका
- सीखने की दर का शेड्यूल सेट अप करने का तरीका
- कॉन्वलूशनल न्यूरल नेटवर्क बनाने का तरीका
- रेगुलराइज़ेशन तकनीकों को इस्तेमाल करने का तरीका: ड्रॉपआउट, बैच नॉर्मलाइज़ेशन
- ओवरफ़िटिंग क्या है
आपको इनकी ज़रूरत होगी
बस एक ब्राउज़र. इस वर्कशॉप को पूरी तरह से Google Colaboratory के साथ चलाया जा सकता है.
सुझाव, राय या शिकायत
अगर आपको इस लैब में कोई गड़बड़ी दिखती है या आपको लगता है कि इसमें सुधार किया जाना चाहिए, तो कृपया हमें बताएं. हम GitHub से जुड़ी समस्याओं के ज़रिए सुझाव, शिकायत या राय मैनेज करते हैं [ feedback link].
2. Google Colaboratory क्विक स्टार्ट
यह लैब, Google Colaboratory का इस्तेमाल करता है और इसके लिए आपको कोई सेटअप नहीं करना होता. इसे Chromebook से चलाया जा सकता है. कृपया नीचे दी गई फ़ाइल खोलें और Colab notebook के बारे में जानने के लिए, सेल एक्ज़ीक्यूट करें.
कुछ और निर्देश यहां दिए गए हैं:
जीपीयू बैकएंड चुनें
Colab मेन्यू में, रनटाइम > रनटाइम का टाइप बदलें और जीपीयू चुनें. पहली बार एक्ज़ीक्यूशन करने पर, रनटाइम से कनेक्शन अपने-आप हो जाएगा. इसके अलावा, आपके पास "कनेक्ट करें" का इस्तेमाल करने का भी विकल्प है बटन पर क्लिक करें.
नोटबुक चलाना
सेल पर क्लिक करके और Shift-ENTER का इस्तेमाल करके एक-एक करके सेल एक्ज़ीक्यूट करें. रनटाइम > सभी को चलाएं
विषय सूची
सभी नोटबुक में विषय सूची होती है. इसे खोलने के लिए, बाईं ओर मौजूद काले रंग के ऐरो का इस्तेमाल करें.
छिपे हुए सेल
कुछ सेल में सिर्फ़ उनका टाइटल दिखेगा. यह notebook की सुविधा है, जो खास तौर पर Colab के लिए बनाई गई है. अंदर का कोड देखने के लिए उन पर दो बार क्लिक करें, लेकिन आम तौर पर यह बहुत दिलचस्प नहीं होता. आम तौर पर, सहायता या विज़ुअलाइज़ेशन फ़ंक्शन. अंदर के फ़ंक्शन को परिभाषित करने के लिए, आपको अब भी इन सेल को चलाना होगा.
3. न्यूरल नेटवर्क को ट्रेनिंग दें
हम सबसे पहले न्यूरल नेटवर्क ट्रेन देखेंगे. कृपया नीचे दी गई नोटबुक खोलें और सभी सेल में चलाएं. अभी कोड पर ध्यान न दें, हम बाद में इसके बारे में समझाएंगे.
नोटबुक को एक्ज़ीक्यूट करते समय, विज़ुअलाइज़ेशन पर फ़ोकस करें. ज़्यादा जानकारी के लिए नीचे देखें.
ट्रेनिंग के लिए डेटा
हमारे पास हाथ से लिखे गए अंकों का डेटासेट है, जिसे लेबल किया गया है. इससे हमें पता चलता है कि हर तस्वीर में क्या है, जैसे कि 0 और 9 के बीच की कोई संख्या. नोटबुक में, आपको एक उद्धरण दिखेगा:
हम जो न्यूरल नेटवर्क बनाएंगे वह हाथ से लिखे अंकों को उनकी 10 क्लास (0, .., 9) में अलग-अलग कैटगरी में बांटता है. ऐसा करने के लिए, डेटा की कैटगरी इंटरनल पैरामीटर के आधार पर तय की जाती है. इसके लिए, डेटा की कैटगरी तय करने के लिए सही वैल्यू का होना ज़रूरी है. यह "सही वैल्यू" ट्रेनिंग प्रोसेस के ज़रिए हासिल की जाती है, जिसके लिए "लेबल वाले डेटासेट" की ज़रूरत होती है इमेज और उनसे जुड़े सही जवाबों के साथ.
हमें कैसे पता चलेगा कि ट्रेन किया गया न्यूरल नेटवर्क अच्छा परफ़ॉर्म कर रहा है या नहीं? नेटवर्क की जांच करने के लिए ट्रेनिंग डेटासेट का इस्तेमाल करना, धोखा हो सकता है. यह पहले ही देखा जा चुका है कि ट्रेनिंग के दौरान डेटासेट को कई बार इस्तेमाल किया जाता है और यह इस पर काफ़ी अच्छा परफ़ॉर्म करता है. "असल दुनिया" का मूल्यांकन करने के लिए हमें लेबल किए गए ऐसे दूसरे डेटासेट की ज़रूरत होती है जो ट्रेनिंग के दौरान कभी नहीं दिखा नेटवर्क की परफ़ॉर्मेंस. इसे "पुष्टि करने के लिए इस्तेमाल होने वाला डेटासेट" कहा जाता है
ट्रेनिंग
ट्रेनिंग के दौरान, एक बार में ट्रेनिंग डेटा का एक बैच, इंटरनल मॉडल पैरामीटर अपडेट होता है. साथ ही, मॉडल मैन्युअल रूप से लिखे गए अंकों की पहचान बेहतर तरीके से करता है. इसे ट्रेनिंग ग्राफ़ पर देखा जा सकता है:
दाईं ओर, "सटीक" होना चाहिए सिर्फ़ सही तरह से पहचाने गए अंकों का प्रतिशत होता है. ट्रेनिंग के आगे बढ़ने के साथ-साथ यह अच्छी बात है.
बाईं ओर, हमें "नुकसान" दिख सकता है. इस ट्रेनिंग को पूरा करने के लिए, हम "नुकसान" के बारे में बताएंगे फ़ंक्शन का इस्तेमाल करता है, जो यह दिखाता है कि सिस्टम अंकों को कितनी अच्छी तरह से पहचानता है और फिर इसे छोटा करने की कोशिश करता है. यहां सिर्फ़ यह दिख रहा है कि जैसे-जैसे ट्रेनिंग आगे बढ़ती है, ट्रेनिंग और पुष्टि करने वाला डेटा, दोनों खराब हो जाते हैं: यह अच्छी बात है. इसका मतलब है कि न्यूरल नेटवर्क लर्निंग मोड में है.
X-ऐक्सिस, "epoch" की संख्या दिखाता है या पूरे डेटासेट में बार-बार इस्तेमाल किया जा सकता है.
अनुमान
इस मॉडल को ट्रेनिंग देने के बाद, हम इसका इस्तेमाल हाथ से लिखे गए अंकों को पहचानने के लिए कर सकते हैं. अगला विज़ुअलाइज़ेशन दिखाता है कि यह स्थानीय फ़ॉन्ट (फ़र्स्ट लाइन) से रेंडर किए गए कुछ अंकों और पुष्टि करने वाले डेटासेट के 10,000 अंकों पर कितना अच्छा परफ़ॉर्म कर रहा है. अनुमानित क्लास हर अंक के नीचे, अगर गलत था, तो लाल रंग में दिखती है.
जैसा कि आपको दिख रहा है, यह शुरुआती मॉडल ज़्यादा अच्छा नहीं है. हालांकि, फिर भी कुछ अंकों की सही पहचान करता है. इसकी पुष्टि करने पर मिली आखिरी सटीक जानकारी करीब 90% है. यह उस सामान्य मॉडल के लिए बहुत बुरा नहीं है जिसके साथ हम शुरुआत कर रहे हैं. हालांकि, इसका मतलब है कि इसकी पुष्टि के लिए 10,000 में से 1,000 अंक छूट जाते हैं. स्क्रीन पर सबसे ज़्यादा नतीजे दिखाए जा सकते हैं. इसलिए, ऐसा लगता है कि सभी जवाब गलत हैं (लाल रंग).
सेंसर
डेटा को मैट्रिक्स में सेव किया जाता है. 28x28 पिक्सल की ग्रेस्केल इमेज, 28x28 के 2-डाइमेंशन वाले मैट्रिक्स में फ़िट हो जाती है. हालांकि, कलर इमेज के लिए हमें ज़्यादा डाइमेंशन की ज़रूरत होती है. हर पिक्सल में तीन रंगों की वैल्यू (लाल, हरा, नीला) होती है. इसलिए, डाइमेंशन वाली थ्री-डाइमेंशन वाली टेबल बनानी होगी [28, 28, 3]. साथ ही, 128 कलर इमेज का बैच स्टोर करने के लिए, डाइमेंशन के साथ चार-डाइमेंशन वाली टेबल चाहिए [128, 28, 28, 3].
इन बहु-आयामी टेबल को "टेंसर" कहा जाता है और उनके डाइमेंशन की सूची उनका "आकार" होता है.
4. [जानकारी]: न्यूरल नेटवर्क 101
कम शब्दों में
अगर अगले पैराग्राफ़ में बोल्ड में दिए गए सभी शब्द पहले से ही आपके बारे में हैं, तो अगले अभ्यास पर जाएं. अगर आपने अभी डीप लर्निंग शुरू की है, तो आपका स्वागत है. कृपया आगे पढ़ें.
Keras लेयर के क्रम के तौर पर बनाए गए मॉडल के लिए, सिक्वेंशियल एपीआई उपलब्ध कराया जाता है. उदाहरण के लिए, तीन सघन लेयर वाले इमेज क्लासिफ़ायर को Keras में इस तरह लिखा जा सकता है:
model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=[28, 28, 1]),
tf.keras.layers.Dense(200, activation="relu"),
tf.keras.layers.Dense(60, activation="relu"),
tf.keras.layers.Dense(10, activation='softmax') # classifying into 10 classes
])
# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
optimizer='adam',
loss= 'categorical_crossentropy',
metrics=['accuracy']) # % of correct answers
# train the model
model.fit(dataset, ... )
एक सघन परत
MNIST डेटासेट में हाथ से लिखे गए अंक 28x28 पिक्सल वाली ग्रेस्केल इमेज होते हैं. उन्हें वर्गीकृत करने का सबसे आसान तरीका यह है कि एक लेयर वाले न्यूरल नेटवर्क के लिए इनपुट के तौर पर 28x28=784 पिक्सल का इस्तेमाल किया जाए.
न्यूरल नेटवर्क में हर "न्यूरॉन", अपने सभी इनपुट के वेटेज (महत्व) का योग करता है और "बायस" नाम का कॉन्स्टेंट जोड़ता है और फिर कुछ नॉन-लीनियर "ऐक्टिवेशन फ़ंक्शन" की मदद से नतीजे को फ़ीड करता है. "वेट" और "पक्षपात" ऐसे पैरामीटर हैं जिन्हें ट्रेनिंग के ज़रिए तय किया जाएगा. शुरुआत में, उन्हें किसी भी वैल्यू से शुरू किया जाता है.
ऊपर दिया गया चित्र 10 आउटपुट न्यूरॉन वाले 1-लेयर न्यूरल नेटवर्क को दिखाता है, क्योंकि हम अंकों को 10 क्लास (0 से 9) में बांटना चाहते हैं.
आव्यूहों के गुणा किए जाने पर
यहां बताया गया है कि कैसे न्यूरल नेटवर्क लेयर, इमेज के कलेक्शन को प्रोसेस करती है. इसे मैट्रिक्स गुणा करके दिखाया जा सकता है:
वज़न मैट्रिक्स W में वज़न के पहले कॉलम का इस्तेमाल करके, हम पहली इमेज के सभी पिक्सल के वेटेड योग का पता लगाते हैं. यह योग पहले न्यूरॉन से मेल खाता है. भार के दूसरे कॉलम का उपयोग करके, हम दूसरे न्यूरॉन के लिए यही प्रक्रिया करते हैं और यही क्रम 10वें न्यूरॉन के लिए भी करते हैं. फिर हम शेष 99 छवियों के लिए कार्रवाई दोहरा सकते हैं. यदि हम X को अपनी 100 छवियों वाला आव्यूह कहते हैं, तो 100 छवियों पर परिकलित, हमारे 10 न्यूरॉन के लिए सभी भारित योग केवल X.W होते हैं, जो एक आव्यूह गुणन है.
अब प्रत्येक न्यूरॉन को अपना पूर्वाग्रह (एक स्थिर) जोड़ना होगा. चूंकि हमारे पास 10 न्यूरॉन हैं, इसलिए हमारे 10 पूर्वाग्रह स्थिर हैं. हम 10 मानों b के इस वेक्टर को कॉल करेंगे. इसे पहले से कंप्यूट किए गए मैट्रिक्स की हर लाइन में जोड़ा जाना चाहिए. "ब्रॉडकास्ट करना" नाम के जादू का इस्तेमाल करना तो हम इसे एक सरल प्लस चिह्न के साथ लिखेंगे.
आखिर में, हम ऐक्टिवेशन फ़ंक्शन लागू करते हैं, जैसे कि "softmax" (नीचे बताया गया है) और 100 इमेज पर लागू 1-लेयर न्यूरल नेटवर्क का ब्यौरा देने वाला फ़ॉर्मूला पाएं:
Keras में
Keras जैसी हाई-लेवल न्यूरल नेटवर्क लाइब्रेरी के लिए, हमें यह फ़ॉर्मूला लागू करने की ज़रूरत नहीं है. हालांकि, यह समझना ज़रूरी है कि न्यूरल नेटवर्क लेयर, गुणा और योग का सिर्फ़ एक सेट है. Keras में, घनी लेयर को इस तरह लिखा जाएगा:
tf.keras.layers.Dense(10, activation='softmax')
ज़्यादा जानें
न्यूरल नेटवर्क लेयर की चेन बनाना आसान है. पहली लेयर, पिक्सल के वेटेड योग को कैलकुलेट करती है. बाद वाली लेयर, पिछली लेयर के आउटपुट के कुल योग का हिसाब लगाती हैं.
न्यूरॉन की संख्या के अलावा, अंतर सिर्फ़ ऐक्टिवेशन फ़ंक्शन के विकल्प में है.
ऐक्टिवेशन फ़ंक्शन: relu, softmax, और sigmoid
आम तौर पर, "relu" ऐक्टिवेशन फ़ंक्शन के अलावा सभी लेयर के लिए ऐक्टिवेशन फ़ंक्शन. क्लासिफ़ायर में आखिरी लेयर, "सॉफ़्टमैक्स" का इस्तेमाल करेगी चालू करना.
फिर से, एक "न्यूरॉन" अपने सभी इनपुट के भारित योग का पता लगाता है, और "बायस" नाम की एक वैल्यू जोड़ता है और ऐक्टिवेशन फ़ंक्शन से नतीजे को फ़ीड करता है.
सुधारी गई लीनियर यूनिट के लिए, ऐक्टिवेशन का सबसे लोकप्रिय फ़ंक्शन "RELU" है. यह एक बहुत ही आसान फ़ंक्शन है, जिसे ऊपर दिए गए ग्राफ़ में देखा जा सकता है.
न्यूरल नेटवर्क में, ऐक्टिवेशन का पारंपरिक फ़ंक्शन "sigmoid" था, लेकिन "relu" था करीब हर जगह पर बेहतर कनवर्जेंस प्रॉपर्टी दिखाई गई थी और अब इसे प्राथमिकता दी जाती है.
कैटगरी तय करने के लिए Softmax ऐक्टिवेशन
हमारे न्यूरल नेटवर्क की आखिरी लेयर में 10 न्यूरॉन हैं, क्योंकि हम हाथ से लिखे अंकों को 10 क्लास (0,..9) में बांटना चाहते हैं. इसमें 0 और 1 के बीच की 10 संख्याएं होनी चाहिए, जो इस अंक के 0, 1, 2 वगैरह होने की संभावना को दिखाती है. इसके लिए, आखिरी लेयर पर, हम "softmax" नाम के ऐक्टिवेशन फ़ंक्शन का इस्तेमाल करेंगे.
किसी वेक्टर पर सॉफ़्टमैक्स को लागू करने के लिए, हर एलिमेंट का एक्स्पोनेंशियल लिया जाता है और फिर वेक्टर को नॉर्मलाइज़ किया जाता है. आम तौर पर, वेक्टर को "L1" से भाग दिया जाता है नॉर्मल (यानी निरपेक्ष वैल्यू का योग) ताकि नॉर्मलाइज़ की गई वैल्यू में 1 जोड़ा जा सके और उन्हें प्रॉबबिलिटी के रूप में समझा जा सके.
ऐक्टिवेशन से पहले, आखिरी लेयर के आउटपुट को कभी-कभी "logits" कहा जाता है. अगर यह वेक्टर L = [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9] है, तो:
क्रॉस-एंट्रॉपी लॉस
अब जब हमारा न्यूरल नेटवर्क इनपुट इमेज से अनुमान लगाता है, तो हमें यह मापना होता है कि वे कितने अच्छे हैं, यानी कि नेटवर्क हमें जो जानकारी देता है और सही जवाबों के बीच की दूरी, उन्हें अक्सर "लेबल" कहा जाता है. याद रखें कि डेटासेट में मौजूद सभी इमेज के लिए, हमारे पास सही लेबल हैं.
किसी भी दूरी से काम किया जा सकता है. हालांकि, अलग-अलग कैटगरी में बांटने से जुड़ी समस्याओं के लिए, तथाकथित "क्रॉस-एंट्रॉपी दूरी" सबसे ज़्यादा असरदार है. हम इसे अपनी गड़बड़ी या "लॉस" कहेंगे फ़ंक्शन:
ग्रेडिएंट डिसेंट
"ट्रेनिंग" न्यूरल नेटवर्क का मतलब है, ट्रेनिंग इमेज और लेबल का इस्तेमाल करके वज़न और पक्षपात को अडजस्ट करना, ताकि क्रॉस-एंट्रॉपी लॉस फ़ंक्शन को कम किया जा सके. यह सुविधा इस तरह से काम करती है.
क्रॉस-एंट्रॉपी में वज़न, पक्षपात, ट्रेनिंग इमेज के पिक्सल, और उसकी क्लास की जानकारी होती है.
अगर हम सभी वेट और सभी पूर्वाग्रहों के सापेक्ष क्रॉस-एंट्रॉपी के आंशिक डेरिवेटिव का हिसाब लगाते हैं, तो हमें दी गई इमेज, लेबल, और भार और पक्षपात के मौजूदा मान के लिए एक "ग्रेडिएंट" मिलता है. याद रखें कि हमारे पास लाखों वज़न और पूर्वाग्रह हो सकते हैं, इसलिए ग्रेडिएंट की गणना करना बहुत बड़ा काम है. अच्छी बात यह है कि TensorFlow हमारे लिए है. ग्रेडिएंट की गणितीय प्रॉपर्टी यह है कि यह "ऊपर" को पॉइंट करता है. चूंकि हम वहां जाना चाहते हैं जहां क्रॉस-एंट्रॉपी कम है, इसलिए हम इसके विपरीत दिशा में जाते हैं. हम ग्रेडिएंट के एक अंश के द्वारा वज़न और पूर्वाग्रह अपडेट करते हैं. इसके बाद, हम ट्रेनिंग लूप में, ट्रेनिंग की इमेज और लेबल के अगले बैच का इस्तेमाल करके, इस काम को बार-बार करते हैं. उम्मीद है कि यह ऐसी जगह इकट्ठा होता है जहां क्रॉस-एंट्रॉपी बहुत कम होती है. हालांकि, इस बात की गारंटी नहीं है कि यह कम से कम यूनीक होगा.
मिनी बैचिंग और मोमेंटम
आप सिर्फ़ एक उदाहरण इमेज पर अपने ग्रेडिएंट का हिसाब लगा सकते हैं और महत्व और पक्षपात को तुरंत अपडेट कर सकते हैं, लेकिन उदाहरण के लिए, 128 इमेज के बैच पर ऐसा करने से ग्रेडिएंट मिलता है, जो अलग-अलग उदाहरण वाली इमेज के ज़रिए लागू किए गए कंस्ट्रेंट को बेहतर तरीके से दिखाता है और इससे समाधान ज़्यादा तेज़ी से जुड़ सकता है. मिनी-बैच के साइज़ में बदलाव किया जा सकता है.
इस तकनीक को "स्टोकैस्टिक ग्रेडिएंट डिसेंट" भी कहा जाता है इसका दूसरा और व्यावहारिक फ़ायदा है: बैच के साथ काम करने का मतलब है बड़े मैट्रिक्स पर काम करना. आम तौर पर, इन्हें जीपीयू और टीपीयू पर ऑप्टिमाइज़ करना आसान होता है.
हालांकि, अब भी कुछ गड़बड़ हो सकती है और ग्रेडिएंट वेक्टर के सभी शून्य होने पर यह रुक भी सकता है. क्या इसका मतलब यह है कि हमें कम से कम इतना डेटा मिल गया है? हमेशा नहीं. ग्रेडिएंट कॉम्पोनेंट, कम से कम या ज़्यादा से ज़्यादा शून्य हो सकता है. लाखों तत्वों वाले ग्रेडिएंट वेक्टर के साथ, अगर वे सभी शून्य हैं, तो इस बात की संभावना है कि हर शून्य एक न्यूनतम बिंदु से मेल खाता है और उनमें से कोई भी अधिकतम बिंदु से नहीं जुड़ा है. कई डाइमेंशन के क्षेत्र में, सैडल पॉइंट काफ़ी आम हो गए हैं और हम इन पर ही नहीं रुकना चाहते.
इलस्ट्रेशन: सैडल पॉइंट. ग्रेडिएंट 0 है लेकिन यह सभी दिशाओं में कम से कम नहीं है. (इमेज एट्रिब्यूशन Wikimedia: by Nicoguro - अपना काम, CC BY 3.0)
इसका समाधान है कि ऑप्टिमाइज़ेशन एल्गोरिदम में कुछ चीज़ें जोड़ी जाएं, ताकि यह बिना किसी रुकावट के सैडल पॉइंट से आगे बढ़ सके.
शब्दावली
बैच या मिनी-बैच: ट्रेनिंग, हमेशा ट्रेनिंग डेटा और लेबल के बैच पर की जाती है. ऐसा करने से एल्गोरिदम को एक जैसी चीज़ों के बारे में जानने में मदद मिलती है. "बैच" डाइमेंशन आम तौर पर, डेटा टेंसर का पहला डाइमेंशन होता है. उदाहरण के लिए, आकार के टेंसर [100, 192, 192, 3] में 192x192 पिक्सल की 100 इमेज होती हैं, जिनमें हर पिक्सल (RGB) में तीन वैल्यू होती हैं.
क्रॉस-एंट्रॉपी लॉस: एक खास लॉस फ़ंक्शन जिसका इस्तेमाल अक्सर क्लासिफ़ायर में किया जाता है.
गहन लेयर: न्यूरॉन की एक लेयर, जहां हर न्यूरॉन, पिछली लेयर में मौजूद सभी न्यूरॉन से जुड़ा होता है.
सुविधाएं: न्यूरल नेटवर्क के इनपुट को कभी-कभी "सुविधाएं" कहा जाता है. "फ़ीचर इंजीनियरिंग", यह पता लगाने की कला को "फ़ीचर इंजीनियरिंग" कहा जाता है. इसकी मदद से यह पता लगाया जा सकता है कि बेहतर अनुमान पाने के लिए, न्यूरल नेटवर्क में डेटासेट के किन हिस्सों या हिस्सों के कॉम्बिनेशन को फ़ीड किया जाए.
लेबल: "क्लास" के लिए एक और नाम या निगरानी में रखे गए क्लासिफ़िकेशन की समस्या में दिए गए जवाबों को सही करना
लर्निंग रेट: ग्रेडिएंट का वह हिस्सा जिसके हिसाब से ट्रेनिंग लूप में होने वाली हर प्रोसेस पर वेट और बायस को अपडेट किया जाता है.
logits: ऐक्टिवेशन फ़ंक्शन लागू होने से पहले, न्यूरॉन की एक लेयर के आउटपुट को "लॉगिट" कहा जाता है. यह शब्द "लॉजिस्टिक फ़ंक्शन" से आता है "सिगमॉइड फ़ंक्शन" जो सबसे लोकप्रिय ऐक्टिवेशन फ़ंक्शन हुआ करता था. "लॉजिस्टिक फ़ंक्शन से पहले न्यूरॉन आउटपुट" को छोटा करके "logits" कर दिया गया.
लॉस: गड़बड़ी का फ़ंक्शन, न्यूरल नेटवर्क आउटपुट की तुलना सही जवाबों से करता है
न्यूरॉन: यह अपने इनपुट के भारित योग का आकलन करता है, पूर्वाग्रह जोड़ता है और ऐक्टिवेशन फ़ंक्शन के ज़रिए नतीजे को फ़ीड करता है.
वन-हॉट एन्कोडिंग: 5 में से 3 क्लास को 5 एलिमेंट के वेक्टर के तौर पर एन्कोड किया जाता है. इसमें तीसरे एलिमेंट को छोड़कर, बाकी सभी शून्य होते हैं, यानी कि 1.
relu: सुधारी गई लीनियर यूनिट. न्यूरॉन के लिए एक लोकप्रिय ऐक्टिवेशन फ़ंक्शन.
sigmoid: ऐक्टिवेशन का एक और ऐसा फ़ंक्शन जो पहले लोकप्रिय हुआ था और खास मामलों में अब भी काम का है.
सॉफ़्टमैक्स: यह एक खास ऐक्टिवेशन फ़ंक्शन है, जो वेक्टर पर काम करता है. यह सबसे बड़े कॉम्पोनेंट और बाकी सभी के बीच के अंतर को बढ़ाता है. साथ ही, वेक्टर को 1 का योग करने के लिए नॉर्मलाइज़ करता है, ताकि इसे प्रॉबबिलिटी के वेक्टर के रूप में समझा जा सके. इसका इस्तेमाल क्लासिफ़ायर में आखिरी चरण के तौर पर किया जाता है.
टेन्सर: एक "टेंसर" आव्यूह की तरह होता है, लेकिन डाइमेंशन की संख्या आर्बिट्रेरी होती है. 1-डाइमेंशन वाला टेंसर एक वेक्टर होता है. 2-डाइमेंशन टेंसर एक मैट्रिक्स होता है. इसके बाद, आपके पास 3, 4, 5 या उससे ज़्यादा डाइमेंशन वाले टेंसर हो सकते हैं.
5. चलिए, सीधे कोड के बारे में जानते हैं
स्टडी नोटबुक पर वापस जाएं और इस बार, कोड को पढ़ें.
चलिए, इस notebook के सभी सेल देखते हैं.
सेल "पैरामीटर"
बैच का साइज़, ट्रेनिंग की अवधि की संख्या, और डेटा फ़ाइलों की जगह की जानकारी यहां दी गई है. डेटा फ़ाइलें Google Cloud Storage (GCS) बकेट में होस्ट की जाती हैं. इसलिए, उनका पता gs:// से शुरू होता है
सेल "इंपोर्ट"
यहां सभी ज़रूरी Python लाइब्रेरी इंपोर्ट की जाती हैं. इनमें TensorFlow और विज़ुअलाइज़ेशन के लिए matplotlib शामिल है.
सेल "विज़ुअलाइज़ेशन यूटिलिटी [RUN ME]****"
इस सेल में ऐसा विज़ुअलाइज़ेशन कोड है जिसमें दिलचस्पी नहीं है. यह डिफ़ॉल्ट रूप से छोटा हो जाता है. हालांकि, जब आपको समय मिले, तब कोड पर दो बार क्लिक करके इसे देखा जा सकता है.
सेल "tf.data.Dataset: फ़ाइलें पार्स करें और ट्रेनिंग और पुष्टि करने वाले डेटासेट तैयार करें"
MNIST डेटासेट को लोड करने के लिए, इस सेल ने tf.data.Dataset API का इस्तेमाल किया है. इससे डेटा फ़ाइलें बनाई जा सकती हैं. इस सेल पर ज़्यादा समय देने की ज़रूरत नहीं है. अगर आपकी tf.data.Dataset API में आपकी दिलचस्पी है, तो यहां एक ट्यूटोरियल दिया गया है. इसमें, इस बारे में जानकारी दी गई है: TPU-स्पीड डेटा पाइपलाइन. फ़िलहाल, बुनियादी बातें ये हैं:
एमएनआईएसटी डेटासेट से ली गई इमेज और लेबल (सही जवाब), चार फ़ाइलों में तय लंबाई के रिकॉर्ड में सेव किए जाते हैं. फ़ाइलों को फ़िक्स्ड रिकॉर्ड फ़ंक्शन के साथ लोड किया जा सकता है:
imagedataset = tf.data.FixedLengthRecordDataset(image_filename, 28*28, header_bytes=16)
अब हमारे पास इमेज बाइट का एक डेटासेट है. उन्हें इमेज में डिकोड करना ज़रूरी है. इसके लिए हम एक फ़ंक्शन तय करते हैं. इमेज को कंप्रेस नहीं किया गया है. इसलिए, फ़ंक्शन को कुछ भी डिकोड करने की ज़रूरत नहीं है (decode_raw बुनियादी तौर पर कुछ नहीं करता). इसके बाद, इमेज को 0 और 1 के बीच के फ़्लोटिंग-पॉइंट वैल्यू में बदल दिया जाता है. हम यहां इसे 2D इमेज के रूप में नया आकार दे सकते हैं. हालांकि, असल में हम इसे 28*28 साइज़ के पिक्सल के सपाट अरे के तौर पर रखते हैं, क्योंकि हमारी शुरुआती सघनता वाली लेयर यही उम्मीद करती है.
def read_image(tf_bytestring):
image = tf.io.decode_raw(tf_bytestring, tf.uint8)
image = tf.cast(image, tf.float32)/256.0
image = tf.reshape(image, [28*28])
return image
हम .map का इस्तेमाल करके, इस फ़ंक्शन को डेटासेट पर लागू करते हैं और इमेज का डेटासेट हासिल करते हैं:
imagedataset = imagedataset.map(read_image, num_parallel_calls=16)
हम लेबल को एक ही तरह से पढ़ने और डिकोड करने का काम करते हैं और हम इमेज और लेबल को एक साथ .zip करते हैं:
dataset = tf.data.Dataset.zip((imagedataset, labelsdataset))
अब हमारे पास पेयर (इमेज, लेबल) का डेटासेट है. हमारा मॉडल ऐसा ही उम्मीद करता है. हम अभी इसे ट्रेनिंग फ़ंक्शन में इस्तेमाल करने के लिए तैयार नहीं हैं:
dataset = dataset.cache()
dataset = dataset.shuffle(5000, reshuffle_each_iteration=True)
dataset = dataset.repeat()
dataset = dataset.batch(batch_size)
dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)
tf.data.Dataset API में डेटासेट तैयार करने के लिए सभी ज़रूरी यूटिलिटी फ़ंक्शन मौजूद हैं:
.cache, डेटासेट को रैम में कैश करता है. यह एक छोटा डेटासेट है. इसलिए, यह काम करेगा. .shuffle इसे 5000 एलिमेंट के बफ़र के साथ शफ़ल करता है. यह ज़रूरी है कि ट्रेनिंग डेटा अच्छी तरह से शफ़ल किया जा रहा हो. .repeat, डेटासेट को लूप करता है. हम इस पर कई बार ट्रेनिंग देंगे (कई युगों) .batch की मदद से, कई इमेज और लेबल को मिनी बैच में बनाया जा सकता है. आखिर में, जीपीयू पर मौजूदा बैच को ट्रेनिंग देने के दौरान, .prefetch अगला बैच तैयार करने के लिए, सीपीयू का इस्तेमाल कर सकता है.
पुष्टि करने वाला डेटासेट भी इसी तरह से तैयार किया जाता है. अब हम मॉडल बनाने और इसे ट्रेनिंग देने के लिए, इस डेटासेट का इस्तेमाल करने के लिए तैयार हैं.
सेल "Keras Model"
हमारे सभी मॉडल, लेयर के सीधे क्रम में होंगे, ताकि हम उन्हें बनाने के लिए tf.keras.Sequential स्टाइल का इस्तेमाल कर सकें. शुरुआत में यहां, यह एक सघन लेयर है. इसमें 10 न्यूरॉन हैं, क्योंकि हम हाथ से लिखे अंकों को 10 क्लास में बांट रहे हैं. यह "सॉफ़्टमैक्स" का इस्तेमाल करता है को ऐक्टिवेट करता है, क्योंकि यह क्लासिफ़ायर में आखिरी लेयर है.
Keras मॉडल के इनपुट का आकार जानने की भी ज़रूरत होती है. इसे तय करने के लिए, tf.keras.layers.Input का इस्तेमाल किया जा सकता है. यहां, इनपुट वेक्टर, 28*28 लंबाई वाले पिक्सल वैल्यू वाले फ़्लैट वेक्टर होते हैं.
model = tf.keras.Sequential(
[
tf.keras.layers.Input(shape=(28*28,)),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='sgd',
loss='categorical_crossentropy',
metrics=['accuracy'])
# print model layers
model.summary()
# utility callback that displays training curves
plot_training = PlotTraining(sample_rate=10, zoom=1)
मॉडल को कॉन्फ़िगर करने का काम, model.compile फ़ंक्शन का इस्तेमाल करके Keras में किया जाता है. यहां हम बेसिक ऑप्टिमाइज़र 'sgd' (स्टोकेस्टिक ग्रेडिएंट डिससेंट) का इस्तेमाल करते हैं. क्लासिफ़िकेशन मॉडल को क्रॉस-एंट्रॉपी लॉस फ़ंक्शन की ज़रूरत होती है, जिसे Keras में 'categorical_crossentropy' कहा जाता है. आखिर में, हम मॉडल को 'accuracy' मेट्रिक का हिसाब लगाने के लिए कहते हैं, जो कि सही कैटगरी में रखी गई इमेज का प्रतिशत है.
Keras एक बहुत अच्छी model.summary() सुविधा देता है जो आपके बनाए गए मॉडल की जानकारी को प्रिंट करती है. आपके शिक्षक ने PlotTraining सुविधा जोड़ी है. इस सुविधा के बारे में "विज़ुअलाइज़ेशन यूटिलिटी" सेल में बताया गया है. यह ट्रेनिंग के दौरान, अलग-अलग ट्रेनिंग कर्व दिखाएगा.
"मॉडल को ट्रेन करना और उसकी पुष्टि करना" सेल
यहां model.fit को कॉल करके ट्रेनिंग दी जाती है. इसके बाद, ट्रेनिंग और पुष्टि करने वाले डेटासेट, दोनों को पास किया जाता है. डिफ़ॉल्ट रूप से, Keras हर epoch के आखिर में पुष्टि करने का राउंड चलाता है.
model.fit(training_dataset, steps_per_epoch=steps_per_epoch, epochs=EPOCHS,
validation_data=validation_dataset, validation_steps=1,
callbacks=[plot_training])
Keras में कॉलबैक का इस्तेमाल करके, ट्रेनिंग के दौरान पसंद के मुताबिक व्यवहार जोड़ा जा सकता है. इस तरह, इस वर्कशॉप के लिए, डाइनैमिक तौर पर अपडेट होने वाले ट्रेनिंग प्लॉट को लागू किया गया था.
"विज़ुअलाइज़ करने के सुझाव" सेल
मॉडल तैयार हो जाने के बाद, हम model.predict() को कॉल करके इसका अनुमान लगा सकते हैं:
probabilities = model.predict(font_digits, steps=1)
predicted_labels = np.argmax(probabilities, axis=1)
यहां हमने टेस्ट के तौर पर, लोकल फ़ॉन्ट से रेंडर किए गए प्रिंट किए गए अंकों का एक सेट तैयार किया है. याद रखें कि न्यूरल नेटवर्क अपने आखिरी "सॉफ़्टमैक्स" से 10 प्रॉबबिलिटी का वेक्टर दिखाता है. लेबल पाने के लिए, हमें यह पता लगाना होगा कि कौनसी संभावना सबसे ज़्यादा है. np.argmax की मदद से ऐसा किया जा सकता है.
यह समझने के लिए कि axis=1 पैरामीटर की ज़रूरत क्यों है, कृपया याद रखें कि हमने 128 इमेज के बैच को प्रोसेस किया है. इसलिए, यह मॉडल प्रॉबबिलिटी के 128 वेक्टर दिखाता है. आउटपुट टेंसर का आकार [128, 10] है. हम हर इमेज के लिए दी गई 10 संभावनाओं के लिए, आर्गमैक्स का हिसाब लगा रहे हैं. इस तरह, axis=1 (पहला ऐक्सिस 0 है).
यह सरल मॉडल पहले से ही 90% अंकों को पहचानता है. अच्छा नहीं है, लेकिन अब आप इसमें काफ़ी सुधार करेंगे.
6. लेयर जोड़ना
हम न्यूरल नेटवर्क में ज़्यादा लेयर जोड़ेंगे, ताकि पहचानने को ज़्यादा सटीक बनाया जा सके.
हम सॉफ़्टमैक्स को आखिरी लेयर पर ऐक्टिवेशन फ़ंक्शन के तौर पर रखते हैं, क्योंकि डेटा की कैटगरी तय करने के लिए यही सबसे सही तरीका है. हालांकि, इंटरमीडिएट लेयर पर हम सबसे क्लासिकल ऐक्टिवेशन फ़ंक्शन का इस्तेमाल करेंगे: सिगमॉइड:
उदाहरण के लिए, आपका मॉडल ऐसा दिख सकता है (कॉमा न भूलें, tf.keras.Sequential कॉमा लगाकर अलग की गई लेयर की सूची लेता है):
model = tf.keras.Sequential(
[
tf.keras.layers.Input(shape=(28*28,)),
tf.keras.layers.Dense(200, activation='sigmoid'),
tf.keras.layers.Dense(60, activation='sigmoid'),
tf.keras.layers.Dense(10, activation='softmax')
])
"खास जानकारी" देखें मॉडल हो सकता है. अब इसमें कम से कम 10 गुना ज़्यादा पैरामीटर हैं. यह 10 गुना बेहतर होना चाहिए! हालांकि, किसी वजह से ऐसा नहीं होता है ...
ऐसा लगता है कि गला घोड़ा, छत से भी गया है. कुछ गड़बड़ है.
7. डीप नेटवर्क के लिए खास देखभाल
आपको अभी न्यूरल नेटवर्क का अनुभव हुआ है, जैसा कि 80 और 90 के दशक में लोग उन्हें डिज़ाइन करते थे. इसमें कोई हैरानी की बात नहीं है कि तथाकथित "एआई सर्दियों" की शुरुआत करने के बाद, उन्होंने इस विचार को छोड़ दिया. वाकई, जैसे-जैसे लेयर जोड़ी जाती हैं, न्यूरल नेटवर्क में एक जैसी मुश्किलें बढ़ती जाती हैं.
यह बात सच है कि कई लेयर वाले डीप न्यूरल नेटवर्क बहुत अच्छे से काम कर सकते हैं (आज 20, 50, यहां तक कि 100 भी) वे साथ मिलकर काम करने के लिए गणित के कुछ गंदे तरीके उपलब्ध कराते हैं. इन आसान तरीकों की खोज, 2010 के दशक में डीप लर्निंग को फिर से शुरू करने की वजहों में से एक है.
RELU ऐक्टिवेशन
डीप नेटवर्क में, सिगमॉइड ऐक्टिवेशन फ़ंक्शन असल में काफ़ी समस्या पैदा करता है. यह 0 से 1 के बीच की सभी वैल्यू को हटा देता है और जब ऐसा बार-बार किया जाता है, तो न्यूरॉन आउटपुट और उनके ग्रेडिएंट पूरी तरह से गायब हो सकते हैं. इसका ज़िक्र ऐतिहासिक वजहों से किया गया था, लेकिन मॉडर्न नेटवर्क, RELU (रेक्टिफ़ाइड लीनियर यूनिट) का इस्तेमाल करते हैं. यह इस तरह दिखता है:
दूसरी ओर, रेलू के दाईं ओर 1 का डेरिवेटिव होता है. RELU ऐक्टिवेशन के साथ, भले ही कुछ न्यूरॉन से आने वाले ग्रेडिएंट शून्य हों, लेकिन नॉन-ज़ीरो ग्रेडिएंट देने वाले अन्य लोग हमेशा अच्छी रफ़्तार से जारी रख सकते हैं.
बेहतर ऑप्टिमाइज़र
यहां जैसे बहुत ऊंचे डाइमेंशन वाले स्पेस में — "सैडल पॉइंट", 10 हज़ार वज़न और पक्षपात को ध्यान में रखकर बनाए गए हैं अक्सर होते हैं. ये ऐसे बिंदु होते हैं जो लोकल मिनिमा नहीं होते, लेकिन जहां ग्रेडिएंट फिर भी शून्य होता है और ग्रेडिएंट डिसेंट ऑप्टिमाइज़र वहां रहता है. TensorFlow के पास कई उपलब्ध ऑप्टिमाइज़र मौजूद हैं. इनमें कुछ ऐसे ऑप्टिमाइज़र भी शामिल हैं जो बहुत ज़्यादा इनर्शिया के साथ काम करते हैं और सैडल पॉइंट से आगे सुरक्षित रहते हैं.
किसी भी क्रम में लगाना
ट्रेनिंग से पहले, अलग-अलग मापदंडों के आधार पर भेदभाव न करने का तरीका भी रिसर्च का हिस्सा है. साथ ही, इस विषय पर कई पेपर पब्लिश किए गए हैं. Keras में उपलब्ध सभी शुरू करने वालों को यहां देखा जा सकता है. अच्छी बात यह है कि Keras डिफ़ॉल्ट रूप से सही काम करता है और 'glorot_uniform' शुरू करने वाले टूल का इस्तेमाल करता है, जो करीब सभी मामलों में सबसे बेहतर होता है.
आपको कुछ करने की ज़रूरत नहीं है, क्योंकि Keras पहले से ही सही काम कर रहे हैं.
नैन \
क्रॉस-एंट्रॉपी फ़ॉर्मूला में लॉगारिद्म (लघुगणक) और Log(0) कोई संख्या नहीं है (NaN, अगर आप चाहें तो एक संख्यात्मक क्रैश) है. क्या क्रॉस-एंट्रॉपी का इनपुट 0 हो सकता है? यह इनपुट, सॉफ़्टमैक्स से आता है, जो ज़रूरी तौर पर एक एक्स्पोनेंशियल होता है और एक्सपोनेन्शियल कभी भी शून्य नहीं होता. इसलिए, हम सुरक्षित हैं!
वाकई? गणित की इस सुंदर दुनिया में, हम सुरक्षित रहेंगे, लेकिन कंप्यूटर की दुनिया में, exp(-150), जो float32 प्रारूप में दिखाया जाता है, उतना ही शून्य है जितना इसे मिलता है और क्रॉस-एंट्रॉपी क्रैश हो जाता है.
अच्छी बात यह है कि यहाँ आपको कुछ करने की ज़रूरत नहीं है, क्योंकि Keras इस बात का ध्यान रखता है और क्रॉस-एंट्रॉपी के बाद सॉफ़्टमैक्स को कंप्यूट करता है. ऐसा, अंकों की स्थिरता पक्का करने और खतरनाक NaNs से बचने के लिए किया जाता है.
हो गया?
अब आपका लक्ष्य 97% सही है. इस वर्कशॉप का लक्ष्य 99% से ज़्यादा हासिल करना है, इसलिए आगे बढ़ना जारी रखें.
अगर आपको कोई समस्या आ रही है, तो उसका हल यहां दिया गया है:
8. लर्निंग रेट का नुकसान
शायद हम तेज़ी से ट्रेनिंग करने की कोशिश करें? ऐडम ऑप्टिमाइज़र में सीखने की डिफ़ॉल्ट दर 0.001 है. आइए, इसे बढ़ाने की कोशिश करते हैं.
ऐसा लगता है कि तेज़ी से आगे बढ़ने से ज़्यादा मदद नहीं मिल रही है और बस इतना ही शोर है?
ट्रेनिंग कर्व में बहुत शोर होता है और वे दोनों पुष्टि करने वाले कर्व को देखते हैं: वे धीरे-धीरे ऊपर-नीचे जा रहे हैं. इसका मतलब है कि हम बहुत तेज़ी से जा रहे हैं. हम अपनी पिछली स्पीड पर वापस जा सकते थे, लेकिन अब एक बेहतर तरीका है.
इसका सबसे अच्छा हल यह है कि आप तेज़ी से शुरुआत करें और सीखने की दर में तेज़ी से गिरावट लाएं. Keras में tf.keras.callbacks.LearningRateScheduler कॉलबैक की मदद से ऐसा किया जा सकता है.
कॉपी-पेस्ट करने के लिए उपयोगी कोड:
# lr decay function
def lr_decay(epoch):
return 0.01 * math.pow(0.6, epoch)
# lr schedule callback
lr_decay_callback = tf.keras.callbacks.LearningRateScheduler(lr_decay, verbose=True)
# important to see what you are doing
plot_learning_rate(lr_decay, EPOCHS)
बनाए गए lr_decay_callback का इस्तेमाल करना न भूलें. इसे model.fit में कॉलबैक की सूची में जोड़ें:
model.fit(..., callbacks=[plot_training, lr_decay_callback])
यह छोटा सा बदलाव शानदार है. आपको दिख रहा है कि ज़्यादातर गै़र-ज़रूरी चीज़ें हटा दी गई हैं. साथ ही, अब लंबे समय तक 98% से ज़्यादा सटीक जांच हो चुकी है.
9. ड्रॉपआउट, ओवरफ़िटिंग
ऐसा लगता है कि मॉडल अब बेहतर रूप से बदल रहा है. आइए, थोड़ा और समझने की कोशिश करते हैं.
क्या इससे मदद मिलेगी?
असल में, सटीक होने की संभावना अब भी 98% पर ही बनी रहती है और पुष्टि करने में होने वाली गड़बड़ियों को देखें. आपकी उम्मीद बढ़ती जा रही है! लर्निंग एल्गोरिदम, सिर्फ़ ट्रेनिंग के डेटा पर काम करता है और उसी हिसाब से ट्रेनिंग में होने वाले नुकसान को ऑप्टिमाइज़ करता है. यह कभी भी पुष्टि करने वाला डेटा नहीं देखता, इसलिए इसमें हैरानी की कोई बात नहीं है कि कुछ समय के बाद इसके काम से पुष्टि न हो पाने पर कोई असर नहीं पड़ता. यह पुष्टि होना बंद हो जाती है और कभी-कभी बैक अप भी चला जाती है.
इससे आपके मॉडल की वास्तविक दुनिया में पहचान करने की क्षमताओं पर तुरंत कोई असर नहीं पड़ता, लेकिन यह आपको कई बार दोहराने से रोक देगा और आम तौर पर इस बात का संकेत है कि अब प्रशिक्षण का सकारात्मक प्रभाव नहीं पड़ रहा है.
इस डिसकनेक्ट को आम तौर पर "ओवरफ़िटिंग" कहा जाता है और जब आपको वह दिखे, तो रेगुलराइज़ेशन तकनीक को लागू करने की कोशिश करें. इस तकनीक को "ड्रॉपआउट" कहते हैं. ड्रॉपआउट तकनीक हर ट्रेनिंग दोहराने पर रैंडम न्यूरॉन को शूट करती है.
क्या इसने काम किया?
शोर दोबारा दिखने लगता है (इस पर हैरानी की बात नहीं है कि ड्रॉपआउट कैसे काम करता है). ऐसा नहीं लगता कि पुष्टि की प्रोसेस आगे बढ़ रही है. हालांकि, यह संख्या पिछले 9 से 15 साल के बीच हुई है. साथ ही, पुष्टि करने की प्रोसेस थोड़ी कम हो गई है. यह बहुत ही निराशाजनक नतीजा है.
ऐसा लगता है कि ड्रॉप-आउट सही समाधान नहीं था या शायद "ओवरफ़िटिंग" हो रही थी ज़्यादा जटिल सिद्धांत है और इसकी कुछ वजहें "ड्रॉपआउट" के तौर पर स्वीकार नहीं की जा सकतीं ठीक करें?
"ओवरफ़िटिंग" क्या है? ओवरफ़िटिंग तब होती है, जब न्यूरल नेटवर्क "खराब तरीके से" सीखने में मदद करता है. यह ट्रेनिंग के उदाहरणों के लिए सही तरीके से काम करता है, लेकिन असल दुनिया के डेटा के मामले में ऐसा नहीं होता. नियमित तौर पर कुछ करने की कुछ तकनीकें हैं, जैसे कि ड्रॉप-आउट
बेसिक ओवरफ़िटिंग तब होती है, जब समस्या के लिए न्यूरल नेटवर्क में बहुत ज़्यादा इंडिपेंडेंट नेटवर्क होते हैं. कल्पना करें कि हमारे पास इतने सारे न्यूरॉन हैं कि नेटवर्क उनमें हमारी सभी ट्रेनिंग इमेज स्टोर कर सकता है और फिर पैटर्न मैचिंग की मदद से उनकी पहचान कर सकता है. यह कोड असल दुनिया के डेटा के साथ पूरी तरह से काम नहीं कर पाएगा. न्यूरल नेटवर्क कुछ हद तक सीमित होना चाहिए, ताकि वह ट्रेनिंग के दौरान सीखी जाने वाली चीज़ों को सामान्य तरीके से पेश कर सके.
अगर आपके पास ट्रेनिंग का बहुत कम डेटा है, तो एक छोटा नेटवर्क भी इसे पूरी तरह समझ सकता है और आपको "ओवरफ़िट हो रहा है" दिखेगा. आम तौर पर, न्यूरल नेटवर्क को ट्रेनिंग देने के लिए, आपको हमेशा बहुत सारे डेटा की ज़रूरत होती है.
अंत में, अगर आपने किताब के मुताबिक सब कुछ कर लिया है, तो अलग-अलग साइज़ के नेटवर्क के साथ प्रयोग करके यह पक्का किया है कि उसकी आज़ादी के स्तर सीमित हैं, उसे बीच में ही छोड़ दिया गया है, और बहुत सारे डेटा के लिए ट्रेन किया गया है. शायद आप अब भी उस परफ़ॉर्मेंस के स्तर पर अटक जाएं जिसे बेहतर बनाने की कोई उम्मीद नहीं है. इसका मतलब है कि आपका न्यूरल नेटवर्क अपने मौजूदा आकार में, आपके डेटा से ज़्यादा जानकारी नहीं निकाल सकता, जैसा कि हमारे मामले में है.
याद है कि हम किसी एक वेक्टर में अपनी इमेज का इस्तेमाल कैसे करते हैं? यह सच में बहुत बुरा आइडिया था. हाथ से लिखे गए अंक आकारों से बने होते हैं और पिक्सल को फ़्लैट करते समय हमने आकार की जानकारी को छोड़ दिया. हालांकि, एक ऐसा न्यूरल नेटवर्क है जो आकार की जानकारी का फ़ायदा ले सकता है: कॉन्वलूशनल नेटवर्क. आइए उन्हें आज़माने दें.
अगर आपको कोई समस्या आ रही है, तो उसका हल यहां दिया गया है:
10. [INFO] कॉन्वोलूशनल नेटवर्क
कम शब्दों में
अगर अगले पैराग्राफ़ में बोल्ड में दिए गए सभी शब्द पहले से ही आपके बारे में हैं, तो अगले अभ्यास पर जाएं. अगर आपने कॉन्वलूशनल न्यूरल नेटवर्क के साथ शुरुआत ही की है, तो कृपया आगे पढ़ें.
इलस्ट्रेशन: किसी इमेज को 4x4x3=48 सीखने लायक वज़न से बने दो फ़िल्टर के साथ फ़िल्टर करना.
Keras में ऐसा सिंपल कॉन्वलूशन न्यूरल नेटवर्क दिखता है:
model = tf.keras.Sequential([
tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1)),
tf.keras.layers.Conv2D(kernel_size=3, filters=12, activation='relu'),
tf.keras.layers.Conv2D(kernel_size=6, filters=24, strides=2, activation='relu'),
tf.keras.layers.Conv2D(kernel_size=6, filters=32, strides=2, activation='relu'),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(10, activation='softmax')
])
कॉन्वलूशनल नेटवर्क की लेयर में, एक "न्यूरॉन" सिर्फ़ इमेज के छोटे से क्षेत्र में, इसके ठीक ऊपर पिक्सल का वेटेड योग करता है. यह पूर्वाग्रह जोड़ता है और ऐक्टिवेशन फ़ंक्शन के ज़रिए योग को फ़ीड करता है, जैसा कि किसी नियमित सघन परत में मौजूद न्यूरॉन करता है. फिर यह कार्रवाई एक ही वेट का इस्तेमाल करके पूरी इमेज में दोहराई जाती है. याद रखें कि घनी लेयर में, हर एक न्यूरॉन का अपना वज़न होता है. यहाँ, एक "पैच" दोनों दिशाओं में इमेज पर वज़न की स्लाइड (एक "संकलन") का इस्तेमाल करें. आउटपुट में उतनी वैल्यू होती हैं जितनी इमेज में पिक्सल होती हैं. हालांकि, किनारों पर कुछ पैडिंग (जगह) ज़रूरी है. यह एक फ़िल्टर करने की कार्रवाई है. ऊपर दिए गए उदाहरण में, 4x4x3=48 मोटाई वाले फ़िल्टर का इस्तेमाल किया गया है.
हालांकि, 48 भार काफ़ी नहीं होंगे. ज़्यादा आज़ादी की कार्रवाई जोड़ने के लिए, हम इसी कार्रवाई को एक नए सेट के साथ दोहराते हैं. इससे, फ़िल्टर आउटपुट का एक नया सेट बनता है. इसे "चैनल" कहते हैं आउटपुट के लिए, इनपुट इमेज में R,G,B चैनल से जुड़े हैं.
कोई नया डाइमेंशन जोड़कर, वज़न के दो या उससे ज़्यादा सेट को एक टेंसर के तौर पर जोड़ा जा सकता है. इससे हमें कॉन्वलूशन लेयर के लिए, वेट टेंसर का सामान्य आकार मिलता है. इनपुट और आउटपुट चैनल की संख्या पैरामीटर हैं. इसलिए, हम कॉन्वोलूशनल लेयर को स्टैक और चेन करना शुरू कर सकते हैं.
इलस्ट्रेशन: कॉन्वलूशनल न्यूरल नेटवर्क, "क्यूब्स" को बदल देता है डेटा को दूसरे "क्यूब" में बदल देते हैं का डेटा इस्तेमाल किया जाता है.
स्टैंडेड कॉन्वोलूशन, ज़्यादा से ज़्यादा पूल करना
2 या 3 की चाल के साथ कन्वर्ज़न करने पर, हम मिलने वाले डेटा क्यूब को हॉरिज़ॉन्टल डाइमेंशन में छोटा भी कर सकते हैं. इसे करने के दो सामान्य तरीके हैं:
- स्ट्राइड कनवलूशन: ऊपर की तरह स्लाइडिंग फ़िल्टर, लेकिन स्ट्राइड >1 के साथ
- अधिकतम पूलिंग: MAX ऑपरेशन लागू करने वाली स्लाइड करने वाली विंडो (आम तौर पर 2x2 पैच पर, हर 2 पिक्सेल में दोहराया जाता है)
इलस्ट्रेशन: कंप्यूटिंग विंडो को तीन पिक्सल स्लाइड करने से आउटपुट वैल्यू कम हो जाती हैं. स्ट्राइड्ड कन्वर्ज़न या मैक्स पूलिंग, हॉरिज़ॉन्टल डाइमेंशन में डेटा क्यूब को छोटा करने का एक तरीका है. मैक्स पूलिंग का मतलब है कि विंडो को 2x2 वाली विंडो के एक हिस्से से दूसरे बार स्लाइड करना होगा.
आखिरी लेयर
आखिरी कॉन्वोलूशन लेयर के बाद, डेटा "क्यूब" के रूप में होता है. इस आखिरी लेयर में इसे दो तरीकों से फ़ीड किया जा सकता है.
पहला तरीका है, डेटा के क्यूब को किसी वेक्टर में फ़्लैट करना और फिर उसे सॉफ़्टमैक्स लेयर में फ़ीड करना. कभी-कभी, सॉफ़्टमैक्स लेयर से पहले, सघन लेयर भी जोड़ी जा सकती है. वज़न की संख्या के हिसाब से यह महंगा लग रहा है. कॉन्वलूशनल नेटवर्क के आखिर में एक सघन लेयर में, पूरे न्यूरल नेटवर्क का वज़न आधा हो सकता है.
एक महंगी लेयर का इस्तेमाल करने के बजाय, हम आने वाले डेटा "क्यूब" को भी अलग-अलग कर सकते हैं डेटा को कई हिस्सों में बांटा जा सकता है. साथ ही, उसकी वैल्यू का औसत किया जा सकता है और सॉफ़्टमैक्स ऐक्टिवेशन फ़ंक्शन की मदद से उन्हें फ़ीड किया जा सकता है. क्लासिफ़िकेशन हेड बनाने के इस तरीके में कोई वज़न नहीं होगा. Keras में, इसके लिए एक लेयर है: tf.keras.layers.GlobalAveragePooling2D().
अगले सेक्शन पर जाएं और अपनी समस्या से जुड़ा एक कॉन्वोलूशनल नेटवर्क बनाएं.
11. कॉन्वोलूशनल नेटवर्क
हमें हाथ से लिखे अंकों की पहचान के लिए कॉन्वोलूशनल नेटवर्क बनाने दें. हम सबसे ऊपर तीन कॉन्वोल्यूशन लेयर का इस्तेमाल करेंगे. सबसे नीचे दी गई हमारी परंपरागत सॉफ़्टमैक्स रीडआउट लेयर और उन्हें पूरी तरह से कनेक्ट की गई एक लेयर से कनेक्ट करेगा:
ध्यान दें कि दूसरी और तीसरी कॉन्वोल्यूशन लेयर में स्ट्राड की दो लाइन होती हैं. इसकी वजह से यह पता चलता है कि वे आउटपुट वैल्यू की संख्या को 28x28 से कम करके 14x14 और फिर 7x7 क्यों करती हैं.
चलिए, Keras कोड लिखते हैं.
पहली कॉन्वलूशनल लेयर से पहले, खास ध्यान देने की ज़रूरत होती है. वाकई, इसे 3D 'क्यूब' की उम्मीद है हालाँकि, हमारे डेटासेट को अब तक सघन लेयर के लिए सेट अप किया गया है और इमेज के सभी पिक्सल वेक्टर में फ़्लैट कर दिए गए हैं. हमें उन्हें 28x28x1 इमेज में फिर से आकार देना होगा (ग्रेस्केल इमेज के लिए 1 चैनल):
tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1))
अभी तक आपके पास मौजूद tf.keras.layers.Input लेयर के बजाय, इस लाइन का इस्तेमाल किया जा सकता है.
Keras में, 'relu'-चालू कॉन्वलूशनल लेयर के लिए सिंटैक्स है:
tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu')
अलग-अलग पहलुओं की समस्या से बचने के लिए, आपको यह लिखना होगा:
tf.keras.layers.Conv2D(kernel_size=6, filters=24, padding='same', activation='relu', strides=2)
डेटा के किसी घन को सदिश (वेक्टर) में फ़्लैट करने के लिए, ताकि उसे सघन परत के ज़रिए इस्तेमाल किया जा सके:
tf.keras.layers.Flatten()
और सघन लेयर के लिए, सिंटैक्स में बदलाव नहीं हुआ है:
tf.keras.layers.Dense(200, activation='relu')
क्या आपके मॉडल ने 99% सटीक जानकारी वाली रुकावट को तोड़ा? काफ़ी पास... लेकिन पुष्टि करने में होने वाले नुकसान का कर्व देखें. क्या यह घंटी बजती है?
अनुमानों पर भी नज़र डालें. पहली बार, आपको दिखेगा कि ज़्यादातर 10,000 टेस्ट अंकों की अब सही पहचान हो चुकी है. डेटा की गलत पहचान करने वाली लाइन में से करीब 41⁄2 लाइनें बची हैं (10,000 में से करीब 110 अंक)
अगर आपको कोई समस्या आ रही है, तो उसका हल यहां दिया गया है:
12. फिर से ड्रॉप आउट किया गया
पिछली ट्रेनिंग में ओवरफ़िटिंग के साफ़ लक्षण नज़र आए थे (और अभी भी 99% सटीक नहीं है). क्या हमें परीक्षा छोड़ने की फिर से कोशिश करनी चाहिए?
इस बार आपका अनुभव कैसा रहा?
ऐसा लगता है कि इस बार क्लास छोड़ने वाले लोगों ने काम किया. अब पुष्टि करने की प्रोसेस आगे नहीं बढ़ रही है और आखिर में ज़्यादा सटीक होने की संभावना 99% से ज़्यादा होनी चाहिए. बधाई हो!
जब पहली बार हमने ड्रॉपआउट लागू करने की कोशिश की, तो हमें लगा कि हम बहुत ज़्यादा बड़ी समस्या का सामना कर रहे हैं, जबकि असल में समस्या न्यूरल नेटवर्क की आर्किटेक्चर में थी. हम कॉन्वलूशनल लेयर के बिना और आगे नहीं बढ़ सकते. साथ ही, हम इस बारे में कुछ नहीं कर सकते.
इस बार, ऐसा लगता है कि ज़्यादा कसरत करना समस्या की वजह थी और स्कूल को बीच में छोड़ने वाले लोगों ने वाकई मदद की. याद रखें कि ऐसी कई चीज़ें हैं जिनकी वजह से, ट्रेनिंग और पुष्टि में अंतर आने की कई वजहें हो सकती हैं और पुष्टि करने की प्रोसेस में समय से ज़्यादा कमी आ सकती है. ओवरफ़िटिंग (बहुत ज़्यादा आज़ादी, जिसका नेटवर्क खराब तरीके से इस्तेमाल करता है) इनमें से एक है. अगर आपका डेटासेट बहुत छोटा है या आपके न्यूरल नेटवर्क का आर्किटेक्चर काफ़ी नहीं है, तो आपको लॉस कर्व पर ऐसा ही व्यवहार दिख सकता है. हालांकि, ड्रॉप-आउट से आपको मदद नहीं मिलेगी.
13. बैच नॉर्मलाइज़ेशन
आखिर में, बैच नॉर्मलाइज़ेशन जोड़ने की कोशिश करते हैं.
यही सिद्धांत है, व्यावहारिक रूप से, बस कुछ नियमों को याद रखें:
फ़िलहाल, किताब के हिसाब से कॉन्टेंट चलाएं और हर न्यूरल नेटवर्क लेयर पर बैच नॉर्म लेयर जोड़ें, लेकिन आखिरी लेयर. इसे आखिरी "सॉफ़्टमैक्स" में न जोड़ें लेयर. यह वहां उपयोगी नहीं होगा.
# Modify each layer: remove the activation from the layer itself.
# Set use_bias=False since batch norm will play the role of biases.
tf.keras.layers.Conv2D(..., use_bias=False),
# Batch norm goes between the layer and its activation.
# The scale factor can be turned off for Relu activation.
tf.keras.layers.BatchNormalization(scale=False, center=True),
# Finish with the activation.
tf.keras.layers.Activation('relu'),
अब वीडियो कितना सटीक है?
थोड़े-बहुत ट्वीट करके (BATCH_SIZE=64, लर्निंग रेट डिके पैरामीटर 0.666, सघन लेयर 0.3 पर ड्रॉपआउट रेट) और किस्मत की थोड़ी कोशिश करके, आप 99.5% तक पहुंच सकते हैं. लर्निंग रेट और स्कूल छोड़ने वाले लोगों की संख्या में बदलाव, "सबसे सही तरीकों" का पालन करके किए गए बैच मानदंड का इस्तेमाल करने के लिए:
- बैच मानदंड की मदद से, न्यूरल नेटवर्क को आपस में कनेक्ट करने में मदद मिलती है. साथ ही, आम तौर पर इसकी मदद से ज़्यादा तेज़ी से ट्रेनिंग की जा सकती है.
- बैच मानदंड एक रेगुलराइज़र है. आम तौर पर, स्कूल बीच में छोड़ने वाले लोगों की संख्या को कम किया जा सकता है या ज़रूरत पड़ने पर बिलकुल भी उनका इस्तेमाल नहीं किया जा सकता.
सलूशन नोटबुक में 99.5% ट्रेनिंग रन है:
14. बेहतरीन हार्डवेयर: AI Platform की मदद से, क्लाउड में ट्रेनिंग लें
आपको GitHub पर mlengine फ़ोल्डर में कोड का क्लाउड-रेडी वर्शन मिलेगा. साथ ही, आपको Google Cloud AI Platform पर कोड चलाने के निर्देश भी मिलेंगे. इस हिस्से को चलाने से पहले, आपको Google Cloud खाता बनाना होगा और बिलिंग की सुविधा चालू करनी होगी. लैब को पूरा करने के लिए ज़रूरी संसाधन कुछ डॉलर से कम होने चाहिए. यह मानते हुए कि एक जीपीयू पर ट्रेनिंग का समय एक घंटा है. अपना खाता तैयार करने के लिए:
- Google Cloud Platform प्रोजेक्ट बनाएं ( http://cloud.google.com/console).
- बिलिंग चालू करें.
- GCP कमांड लाइन टूल इंस्टॉल करें ( GCP SDK यहां देखें).
- Google Cloud Storage बकेट बनाएं (
us-central1क्षेत्र में डाला गया). इसका इस्तेमाल, ट्रेनिंग कोड को स्टेज करने और आपके प्रशिक्षित मॉडल को स्टोर करने के लिए किया जाएगा. - ज़रूरी एपीआई चालू करें और ज़रूरी कोटा पाने का अनुरोध करें (ट्रेनिंग कमांड को एक बार चलाएं. इससे आपको गड़बड़ी के मैसेज मिलेंगे, जिनमें बताया जाएगा कि क्या चालू करना है).
15. बधाई हो!
आपने अपना पहला न्यूरल नेटवर्क बना लिया है और इसे 99% सटीक बनाने की ट्रेनिंग दी है. इस दौरान सीखी गई तकनीकें, MNIST डेटासेट के लिए खास नहीं हैं. असल में, न्यूरल नेटवर्क के साथ काम करते समय इन तकनीकों का इस्तेमाल बड़े पैमाने पर किया जाता है. अलग-अलग उपहार के तौर पर, ये रहे "क्लिफ़ के नोट" लैब के लिए एक कार्ड है. इसका इस्तेमाल यह याद रखने के लिए किया जा सकता है कि आपने क्या सीखा:
अगले चरण
- पूरी तरह से कनेक्ट और कॉन्वोलूशनल नेटवर्क के बाद, आपको बार-बार चलने वाले न्यूरल नेटवर्क पर नज़र डालना चाहिए.
- डिस्ट्रिब्यूट किए गए इन्फ़्रास्ट्रक्चर पर क्लाउड में आपकी ट्रेनिंग या अनुमान लगाने के लिए, Google Cloud एआई प्लैटफ़ॉर्म उपलब्ध कराता है.
- आखिर में, हमें सुझाव, राय या शिकायत ज़रूर भेजें. अगर आपको इस लैब में कोई गड़बड़ी दिखती है या आपको लगता है कि इसमें सुधार किया जाना चाहिए, तो कृपया हमें बताएं. हम GitHub से जुड़ी समस्याओं के ज़रिए सुझाव, शिकायत या राय मैनेज करते हैं [ feedback link].
|
|
लेखक: मार्टिन गॉर्नरTwitter: 
इस लैब कॉपीराइट में मौजूद सभी कार्टून इमेज: alexpokusay / 123RF स्टॉक फ़ोटो