इस कोडलैब में, आप न्यूरल नेटवर्क को बनाने और ट्रेनिंग देने का तरीका जानेंगे. इस नेटवर्क पर, हाथ से लिखे गए अंकों को पहचानना आसान होता है. इस प्रक्रिया के दौरान, आप अपने न्यूरल नेटवर्क को 99% सटीक बनाने के लिए बेहतर बनाते हैं. साथ ही, आपको उस कारोबार के टूल की जानकारी भी मिलती है जिसका इस्तेमाल डीप लर्निंग प्रोफ़ेशनल अपने मॉडल को बेहतर तरीके से ट्रेनिंग देने के लिए करते हैं.
यह कोडलैब MNIST डेटासेट का इस्तेमाल करता है. यह 60, 000 लेबल वाले अंकों का संग्रह है,जिसकी वजह से पीएचडी की जनरेशन करीब दो दशकों से व्यस्त है. आप Python / TensorFlow कोड की 100 से कम लाइन वाली समस्या को ठीक करेंगे.
आप इन चीज़ों के बारे में जानेंगे
- न्यूरल नेटवर्क क्या है और इसे ट्रेनिंग कैसे दें
- tf.keras का इस्तेमाल करके, एक लेयर वाला सामान्य न्यूरल नेटवर्क बनाने का तरीका
- और ज़्यादा लेयर जोड़ने का तरीका
- लर्निंग रेट शेड्यूल सेट अप करने का तरीका
- कंवेंशनल न्यूरल नेटवर्क बनाने का तरीका
- रेगुलराइज़ेशन की तकनीकों का इस्तेमाल करने का तरीका: ड्रॉप-आउट, बैच नॉर्मलाइज़ेशन
- ओवरफ़िटिंग क्या है
आपको इनकी ज़रूरत होगी
सिर्फ़ एक ब्राउज़र. यह वर्कशॉप, पूरी तरह से Google Colaboratory के साथ चलाई जा सकती है.
सुझाव, शिकायत या राय
अगर आपको इस लैब में कुछ समस्या आती है या आपको लगता है कि इसे बेहतर बनाना है, तो हमें बताएं. हम GitHub से जुड़ी समस्याओं को हल करने के लिए, [feedback link] का इस्तेमाल करते हैं.
इस लैब में Google Colaboratory का इस्तेमाल किया जाता है. इसके लिए, आपको किसी सेट अप की ज़रूरत नहीं होती. आप इसे Chromebook से चला सकते हैं. कृपया नीचे दी गई फ़ाइल खोलें और सेल चालू करें, ताकि आप Colab नोटबुक के बारे में जान सकें.
नीचे कुछ और निर्देश दिए गए हैं:
जीपीयू बैकएंड चुनें
Colab मेन्यू में, रनटाइम > रनटाइम टाइप बदलें को चुनें और फिर जीपीयू चुनें. रनटाइम पर पहली बार एक्ज़ीक्यूशन होने पर कनेक्शन अपने-आप आ जाएगा या आप ऊपर दाएं कोने में मौजूद "कनेक्ट करें" बटन का इस्तेमाल कर सकते हैं.
notebook को लागू करना
सेल पर क्लिक करके और Shift-ENTER का इस्तेमाल करके, एक बार में एक सेल चलाएं. आप पूरी रनटाइम को Runtime > all Run के साथ भी चला सकते हैं
विषय-सूची
सभी नोटबुक में कॉन्टेंट की टेबल होती है. आप बाईं ओर मौजूद काले तीर के निशान का इस्तेमाल करके, इसे खोल सकते हैं.
छिपाए गए सेल
कुछ सेल में सिर्फ़ उनका शीर्षक दिखेगा. यह Colab के लिए खास notebook की सुविधा है. उनके अंदर कोड देखने के लिए आप उन पर दो बार क्लिक कर सकते हैं, लेकिन यह आम तौर पर बहुत दिलचस्प नहीं होता. आम तौर पर, सपोर्ट या विज़ुअलाइज़ेशन फ़ंक्शन. आपको इन फ़ंक्शन को अंदर से ही फ़ंक्शन के लिए चलाना होगा.
हम सबसे पहले एक न्यूरल नेटवर्क ट्रेन देखेंगे. कृपया नीचे दी गई नोटबुक खोलें और सभी सेल देखें. कोड पर अभी ध्यान न दें, हम इसके बारे में बाद में जानकारी देंगे.
notebook को लागू करते समय, विज़ुअलाइज़ेशन पर फ़ोकस करें. ज़्यादा जानकारी के लिए नीचे देखें.
ट्रेनिंग का डेटा
हमारे पास हाथ से लिखे गए अंकों का डेटासेट है, जिसे लेबल किया गया है, ताकि हमें पता चल सके कि हर तस्वीर क्या दिखाती है. जैसे, 0 और 9 के बीच की कोई संख्या. नोटबुक में, आपको एक अंश दिखेगा:
न्यूरल नेटवर्क हम हाथ से लिखे हुए अंकों को 10 क्लास (0, .., 9) में बांट देंगे. ऐसा उन अंदरूनी पैरामीटर के आधार पर किया जाता है जिन्हें सही तरीके से कैटगरी तय करने के लिए सही वैल्यू की ज़रूरत होती है. यह &कोटेशन कोड सही है. इसे ऐसी ट्रेनिंग प्रोसेस से सीखा जाता है जिसके लिए इमेज और उससे जुड़े सही जवाबों के साथ &कोटेशन को लेबल करने वाले डेटासेट की ज़रूरत होती है.
हम कैसे पता करेंगे कि प्रशिक्षित न्यूरल नेटवर्क अच्छा परफ़ॉर्म कर रहा है या नहीं? नेटवर्क को धोखाधड़ी से बचाने के लिए, ट्रेनिंग डेटासेट का इस्तेमाल करना. हमने पहले ही देखा है कि ट्रेनिंग के दौरान डेटासेट को कई बार देखा जा चुका है और यह बहुत अच्छा परफ़ॉर्म करता है. नेटवर्क के परफ़ॉर्मेंस का मूल्यांकन करने के लिए हमें एक और डेटासेट की ज़रूरत है, जो कभी ट्रेनिंग के दौरान नहीं दिखता. इसे &कोटेशन;पुष्टि करने का डेटासेट&कोटेशन कहा जाता है;
ट्रेनिंग
जैसे-जैसे ट्रेनिंग आगे बढ़ती है, एक-एक करके ट्रेनिंग डेटा का एक बैच तैयार होता जाता है, इंटरनल मॉडल पैरामीटर अपडेट होते जाते हैं और मॉडल, हाथ से लिखे हुए अंकों को पहचानने के लिए बेहतर और बेहतर होता जाता है. इसे ट्रेनिंग ग्राफ़ पर देखा जा सकता है:
दाईं ओर, "सटीक&कोटेशन; सही रूप से पहचाने गए अंकों का प्रतिशत है. जैसे-जैसे ट्रेनिंग बेहतर होती है, यह आगे बढ़ता जाता है, जो अच्छी बात है.
बाईं ओर, हम "लॉस&कोटेशन देख सकते हैं. ट्रेनिंग के लिए, हम &&tt>लॉस &कोटेशन फ़ंक्शन तय करेंगे, जो यह दिखाता है कि सिस्टम, पॉइंट की पहचान कितनी अच्छी तरह करता है और उन्हें कम करने की कोशिश करता है. आप यहां देख सकते हैं कि ट्रेनिंग के दौरान, ट्रेनिंग और पुष्टि वाले डेटा, दोनों में कमी आती है: अच्छा है. इसका मतलब है कि न्यूरल नेटवर्क सीख रहा है.
X-एक्सिस, पूरे डेटासेट की मदद से "epochs&kot; या की संख्या दिखाता है.
अनुमान
मॉडल को ट्रेनिंग देने के बाद, हम इसका इस्तेमाल हैंडराइट किए गए अंकों की पहचान करने के लिए कर सकते हैं. अगला विज़ुअलाइज़ेशन दिखाता है कि स्थानीय फ़ॉन्ट (पहली लाइन) से मिले कुछ अंकों की परफ़ॉर्मेंस कैसी है. इसके बाद, पुष्टि करने वाले डेटासेट के 10,000 अंकों पर यह कैसा परफ़ॉर्म करता है. अनुमानित क्लास हर अंक के नीचे दिखेगा. अगर यह गलत था, तो लाल रंग में.
जैसा कि आप देख सकते हैं, यह शुरुआती मॉडल बहुत अच्छा नहीं है, लेकिन अब भी कुछ अंकों को सही तरीके से पहचान रहा है. इसके लिए, पुष्टि की सटीक जानकारी 90% है. इस मॉडल के आसान मॉडल के लिए यह इतना खराब नहीं है, लेकिन इसका मतलब यह भी है कि 10,000 से पुष्टि करने पर यह 1,000 तक पहुंच नहीं सकता. इस पेज पर दिखाने के लिए काफ़ी कुछ है, इसलिए हो सकता है कि सभी जवाब गलत (लाल) हों.
सेंसर
डेटा को मैट्रिक्स में सेव किया जाता है. 28x28 पिक्सल की ग्रेस्केल इमेज, 28x28 पिक्सल के दो डाइमेंशन वाले मैट्रिक्स में फ़िट हो जाती है. हालांकि, रंग की इमेज के लिए हमें और डाइमेंशन की ज़रूरत होती है. हर पिक्सल के लिए तीन रंग की वैल्यू होती हैं (लाल, हरा, नीला), इसलिए डाइमेंशन [28, 28, 3] के साथ तीन डाइमेंशन वाली टेबल की ज़रूरत होती है. और 128 रंग वाली इमेज के बैच को स्टोर करने के लिए, डाइमेंशन [128, 28, 28, 3] के साथ चार डाइमेंशन वाली टेबल चाहिए.
कई डाइमेंशन वाली इन टेबल को "tensor&kot; कहा जाता है और इनके डाइमेंशन की सूची उनका &kot;Shap&kot; है.
खास जानकारी में
अगर अगले पैराग्राफ़ में दिए गए सभी शब्द, बोल्ड में पहले से जानते हैं, तो आप अगली कसरत पर जा सकते हैं. अगर आप अभी डीप लर्निंग शुरू कर रहे हैं, तो आपका स्वागत है. कृपया आगे पढ़ें.
कीवर्ड के क्रम से बनाए गए मॉडल के लिए Keras, क्रम में चलने वाले एपीआई का ऑफ़र देता है. उदाहरण के लिए, तीन सघन लेयर का इस्तेमाल करके इमेज की कैटगरी तय करने वाले टूल को Kerberos में लिखा जा सकता है:
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, ... )
एक घनी लेयर
एमएनआईएस डेटासेट में हाथ से लिखे गए अंक, 28x28 पिक्सल की ग्रेस्केल इमेज होते हैं. उन्हें कैटगरी में बांटने का सबसे आसान तरीका, 1-लेयर न्यूरल नेटवर्क के लिए इनपुट के तौर पर 28x28=784 पिक्सल का इस्तेमाल करना है.
न्यूरल नेटवर्क में मौजूद हर "neuron&कोटेशन, सभी इनपुट को कुल मिलाकर इस्तेमाल करता है. इसके बाद, &tort&bias&quat नाम का एक कॉन्सटेंट जोड़ता है और कुछ नतीजों को कुछ &वह &quat;weights" और &kot;biases&quat; ऐसे पैरामीटर हैं जिन्हें ट्रेनिंग के ज़रिए तय किया जाएगा. शुरुआत में ये किसी भी क्रम में वैल्यू के साथ शुरू किए जाते हैं.
ऊपर दी गई तस्वीर, 10-न्यूरल नेटवर्क को 10 आउटपुट न्यूरॉन के साथ दिखाती है, क्योंकि हम अंकों को 10 क्लास (0 से 9) में बांटना चाहते हैं.
मैट्रिक गुणा के साथ
यहां बताया गया है कि कैसे न्यूरल नेटवर्क लेयर, इमेज के संग्रह को प्रोसेस करता है, जिसे मैट्रिक्स गुणा से दिखाया जा सकता है:
वज़न के मैट्रिक्स W में वज़न के पहले कॉलम का इस्तेमाल करके, हम पहली इमेज के सभी पिक्सल के वेटेड योग की गिनती करते हैं. यह योग पहले न्यूरॉन से मेल खाता है. वेट के दूसरे कॉलम का इस्तेमाल करके, हम दूसरे न्यूरॉन के लिए भी ऐसा ही करते हैं और इसी तरह 10वें न्यूरॉन तक करते हैं. फिर हम बाकी 99 इमेज के लिए यह कार्रवाई दोहरा सकते हैं. अगर हम {0/} को मैट्रिक्स कहते हैं, जिसमें हमारी 100 इमेज शामिल हैं, तो 100 न्यूरॉन के लिए वेटेड योग की गिनती, सिर्फ़ X.W होती है. यह एक मैट्रिक्स गुणा है.
हर न्यूरॉन को अब अपनी झुकाव (एक कॉन्सटेंट) जोड़नी होगी. हमें 10 न्यूरॉन दिखते हैं, इसलिए इसमें 10 मापदंड हैं. हम इस वेक्टर को 10 वैल्यू b कहेंगे. इसे पहले तय किए गए मैट्रिक्स की हर लाइन में जोड़ना होगा. & बताना</a>ब्रॉडकास्टिंग&कोटेशन नाम के थोड़ा जादू का इस्तेमाल करके; हम इसे एक आसान प्लस चिह्न के साथ लिखेंगे.
हम आखिर में एक ऐक्टिवेशन फ़ंक्शन लागू करते हैं, जैसे कि "softmax&कोटेशन; नीचे दिया गया है) और 100 इमेज पर लागू की गई 1-लेयर न्यूरल नेटवर्क के बारे में बताने वाला फ़ॉर्मूला मिलता है:
Keras में
केरास जैसे ऊंचे स्तर के न्यूरल नेटवर्क लाइब्रेरी होने पर, हमें इस फ़ॉर्मूला को लागू करने की ज़रूरत नहीं होगी. हालांकि, यह समझना ज़रूरी है कि न्यूरल नेटवर्क लेयर में गुणा और अंक शामिल होते हैं. केरेस में, एक घनी लेयर इस तरह लिखी जाएगी:
tf.keras.layers.Dense(10, activation='softmax')गहरे काम करें
न्यूरल नेटवर्क लेयर को चेन करना बेहद आसान है. पहली लेयर पिक्सल के कुल योग का हिसाब लगाती है. बाद की परत, पिछली परत के आउटपुट के शुद्ध योग की गणना करती हैं.
न्यूरोन की संख्या के अलावा, सिर्फ़ एक अंतर सिर्फ़ ऐक्टिवेशन फ़ंक्शन है.
ऐक्टिवेशन फ़ंक्शन: रेलू, सॉफ़्टमैक्स और सिग्मॉइड
आम तौर पर, आप आखिरी लेयर को छोड़कर सभी लेयर के लिए &kot;relu&kot; फ़ंक्शन का इस्तेमाल करेंगे. क्लासीफ़ायर में आखिरी लेयर, &chromes&softmax&kot; ऐक्टिवेशन का इस्तेमाल करेगी.
फिर से & &kot;neuron&kot;; अपने सभी इनपुट के कुल योग की गणना करता है, "bias&quat; नाम का मान जोड़ता है; और नतीजे को ऐक्टिवेशन फ़ंक्शन के ज़रिए फ़ीड करता है.
सुधारी गई लीनियर यूनिट के लिए, सबसे लोकप्रिय ऐक्टिवेशन फ़ंक्शन को "RELU" कहा जाता है. यह एक बहुत ही आसान फ़ंक्शन है, जैसा कि आप ऊपर दिए गए ग्राफ़ में देख सकते हैं.
न्यूरल नेटवर्क में पारंपरिक ऐक्टिवेशन फ़ंक्शन "sigmoid&कोटेशन था, लेकिन "relu&kot; को करीब-करीब हर जगह बेहतर कन्वर्ज़न ट्रैकिंग प्रॉपर्टी दिखाने के लिए दिखाया गया था और अब इसे प्राथमिकता दी जाती है.
कैटगरी के लिए सॉफ़्टमैक्स ऐक्टिवेशन
हमारे न्यूरल नेटवर्क की आखिरी लेयर में 10 न्यूरॉन होते हैं, क्योंकि हम हाथ से लिखे गए अंकों को 10 क्लास (0,.9) में बांटना चाहते हैं. इसे 0 और 1 के बीच में 10 संख्याएं देनी चाहिए, जो 0, 1, 2, वगैरह होने की संभावना का संकेत देता है. इसके लिए, आखिरी लेयर में, &kot;softmax&kot; नाम के ऐक्टिवेशन फ़ंक्शन का इस्तेमाल किया जाएगा.
किसी वेक्टर पर सॉफ़्टमैक्स लागू करना हर एलिमेंट के घातांक को निकालकर और फिर वेक्टर को सामान्य बनाने के लिए किया जाता है, आम तौर पर इसे अपने &kot;L1&कोटेशन;
चालू करने से पहले, आखिरी लेयर का आउटपुट कभी-कभी &kot;logits&kot; कहा जाता है. अगर यह वेक्टर L = [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9] है, तो:
क्रॉस-एंट्रॉपी नुकसान
अब हमारा न्यूरल नेटवर्क, इनपुट इमेज से सुझाव तैयार करता है, इसलिए हमें यह आकलन करना होता है कि नेटवर्क कितना अच्छा है. इसका मतलब है कि नेटवर्क की सटीक जानकारी और सही जवाबों के बीच की दूरी, जिसे अक्सर "labels और कोटेशन कहा जाता है;. याद रखें कि हमारे पास डेटासेट में मौजूद सभी इमेज के लिए सही लेबल हैं.
कोई भी दूरी काम करेगी, लेकिन वर्गीकरण की समस्याओं के लिए एक, &कोटेशन, क्रॉस-एंट्रॉपी दूरी और कोट सबसे असरदार होते हैं. हम इसे अपनी गड़बड़ी या &कमीन&कमीना नाम का फ़ंक्शन बताएंगे:
नीचे की ओर ग्रेडिएंट
न्यूट्रल नेटवर्क का मतलब है ट्रेनिंग और कोटेशन; वज़न और झुकाव को कम करने के लिए इमेज और लेबल को ट्रेनिंग देना. इससे, क्रॉस-एंट्रॉपी लॉस फ़ंक्शन को कम करने में मदद मिलती है. यह इस तरह से काम करता है.
क्रॉस-एंट्रॉपी, महत्व, मापदंड, ट्रेनिंग की इमेज के पिक्सल, और पहले से मालूम क्लास का फ़ंक्शन है.
अगर हम सभी वज़न और सभी झुकावों के मुकाबले क्रॉस-एंट्रीज़ी के कुछ हिस्से का पता लगाते हैं, तो हमें दी गई इमेज, लेबल, और महत्व और झुकावों के मौजूदा मान के लिए आकलन की जाने वाली &quatentgradient&quat; याद रखें कि हम लाखों वज़न और पक्षपात कर सकते हैं, इसलिए ग्रेडिएंट साउंड को कंपाइल करने को लेकर बहुत मेहनत करते हैं. सबसे अच्छी बात यह है कि TensorFlow हमारे लिए काम करता है. ग्रेडिएंट का गणित संबंधी तरीका यह है कि यह & &t</up; &कोटेशन;. क्योंकि हम उस जगह पर जाना चाहते हैं जहां क्रॉस-एंट्रॉपी कम है, इसलिए हम उलटी दिशा में जाते हैं. हम ग्रेडिएंट के एक हिस्से के हिसाब से वज़न और झुकाव अपडेट करते हैं. फिर हम ट्रेनिंग लूप में, ट्रेनिंग की इमेज और लेबल के अगले बैच का इस्तेमाल करके, बार-बार एक ही काम करते हैं. उम्मीद है कि ऐसा करने से वह जगह बदल जाएगी जहां क्रॉस-एंट्रॉपी बहुत कम है. हालांकि, इस बात की कोई गारंटी नहीं है कि यह सबसे कम यूनीक होगी.
मिनी बैचिंग और मोशन
आप सिर्फ़ एक उदाहरण वाली इमेज पर अपने ग्रेडिएंट की गणना कर सकते हैं और महत्व और झुकावों को तुरंत अपडेट कर सकते हैं, लेकिन उदाहरण के लिए, बैच के लिए 128 इमेज का इस्तेमाल करने से अलग-अलग उदाहरण इमेज से लागू किए गए प्रतिबंधों को बेहतर तरीके से दिखाया जा सकता है और इसलिए समाधान के लिए तेज़ी से समाधान किया जा सकता है. मिनी-बैच का साइज़, बदलाव किया जा सकने वाला पैरामीटर है.
इस तकनीक को कभी-कभी &tottostochastic gradients Dडिस" भी कहा जाता है. इसका एक और फ़ायदा है. ज़्यादा बैच के साथ काम करने का मतलब है कि ज़्यादा बड़े मैट्रिक्स के साथ काम करना और आम तौर पर जीपीयू और टीपीयू को ऑप्टिमाइज़ करना आसान होता है.
कन्वर्ज़न अब भी थोड़ा अव्यवस्थित हो सकता है और भले ही ग्रेडिएंट वेक्टर शून्य हो. क्या इसका मतलब है कि हमें कम से कम क्वेरी मिली है? हमेशा नहीं. ग्रेडिएंट कॉम्पोनेंट को कम से कम या ज़्यादा से ज़्यादा शून्य रखा जा सकता है. लाखों एलिमेंट वाले ग्रेडिएंट वेक्टर के साथ, अगर ये सभी ज़ीरो हैं, तो इस बात की संभावना है कि हर ज़ीरो, कम से कम वैल्यू से मेल खाता हो और उनमें से कोई भी पॉइंट सबसे कम पॉइंट न हो. कई डाइमेंशन के मामले में, सैडल पॉइंट बहुत आम हैं और हम उन्हें रोकना नहीं चाहेंगे.
इलस्ट्रेशन: सैडल पॉइंट. ग्रेडिएंट 0 है, लेकिन यह सभी दिशाओं में कम से कम नहीं है. (इमेज एट्रिब्यूशन विकिमीडिया: Nicoguaro - अपने काम, CC BY 3.0)
इसका हल, ऑप्टिमाइज़ेशन एल्गोरिदम में कुछ तेज़ी लाना है, ताकि यह सैडल पॉइंट से होते हुए भी पिछला सफ़र चलाना जारी रखे.
शब्दावली
बैच या मिनी-बैच: ट्रेनिंग हमेशा डेटा के बैच और लेबल के बैच पर की जाती है. ऐसा करने से एल्गोरिदम को बदलने में मदद मिलती है. &कोटेशन;बैच; डाइमेंशन आम तौर पर डेटा ट्यूनर का पहला डाइमेंशन है. उदाहरण के लिए, [100, 192, 192, 3] के टेंसर में 192x192 पिक्सल की 100 इमेज हैं. हर पिक्सल के हिसाब से ये तीन वैल्यू होती हैं.
क्रॉस-एंट्रॉपी नुकसान: यह एक खास फ़ंक्शन है, जिसका इस्तेमाल अक्सर कैटगरी तय करने वाली तकनीक में किया जाता है.
डेंस लेयर: न्यूरॉन की एक लेयर, जहां हर न्यूरॉन पिछली लेयर में सभी न्यूरॉन से कनेक्ट होता है.
सुविधाएं: न्यूरल नेटवर्क के इनपुट को कभी-कभी "सुविधाएं&कोटेशन; कहा जाता है. यह बताने की कला कि डेटासेट के किन हिस्सों (या हिस्सों के कॉम्बिनेशन) को न्यूरल नेटवर्क में फ़ीड करना है, ताकि ये अनुमान सही तरीके से लगाए जा सकें, इन्हें "फ़ीचर इंजीनियरिंग&कोटेशन" कहा जाता है.
लेबल: 'निगरानी में रखे गए कैटगरी' की समस्या में &kot;classes&kot; का कोई दूसरा नाम या सही जवाब
लर्निंग रेट: ग्रेडिएंट का वह हिस्सा जिससे ट्रेनिंग लूप के हर इटरेशन पर वज़न और मापदंड अपडेट किए जाते हैं.
लॉगिट: ऐक्टिवेशन फ़ंक्शन लागू किए जाने से पहले न्यूरॉन की एक परत के आउटपुट को &kot;logits&kot; कहा जाता है. यह शब्द & वोकलॉजिकल लॉजिस्टिक फ़ंक्शन &कोटेशन (ऊपरी कोट) नाम से आता है, जिसका इस्तेमाल सबसे ज़्यादा इस्तेमाल किया जाने वाला ऐक्टिवेशन फ़ंक्शन किया जाता था. & सुझाए गए लॉजिस्टिक फ़ंक्शन से पहले न्यूरॉन के आउटपुट &कोटेशन को छोटा किया गया था.
गड़बड़ी: न्यूरल नेटवर्क आउटपुट की तुलना सही जवाबों से करने वाली गड़बड़ी का फ़ंक्शन
न्यूरॉन: अपने इनपुट के वेटेड कुल योग की गिनती करता है, झुकाव को जोड़ता है और ऐक्टिवेशन फ़ंक्शन के ज़रिए नतीजे को फ़ीड करता है.
एक-हॉट एन्कोडिंग: 5 में से तीसरी श्रेणी, 5 एलिमेंट के वेक्टर के रूप में एन्कोड की जाती है, जो तीसरी एलिमेंट को छोड़कर शून्य होती है, जो कि 1 होती है.
relu: सुधारी गई लीनियर यूनिट. न्यूरॉन के लिए लोकप्रिय ऐक्टिवेशन फ़ंक्शन.
sigmoid: ऐक्टिवेशन का एक और फ़ंक्शन जो लोकप्रिय था और खास मामलों में अब भी इस्तेमाल किया जा रहा है.
softmax: यह एक ऐक्टिवेशन फ़ंक्शन है, जो वेक्टर पर काम करता है, सबसे बड़े कॉम्पोनेंट और अन्य सभी के बीच का अंतर बढ़ाता है, और वेक्टर के योग को 1 के बराबर भी बनाता है, ताकि इसकी संभावना के वेक्टर के रूप में समझा जा सके. डेटा की कैटगरी तय करने वाले प्रोग्राम में आखिरी चरण के तौर पर इस्तेमाल किया जाता है.
tensor: एक "tensor&quat; एक मैट्रिक्स जैसा है, लेकिन डाइमेंशन की आर्बिट्रेरी संख्या के साथ है. 1-डाइमेंशन टेंसर एक वेक्टर है. दो डाइमेंशन वाला टेंसर एक मैट्रिक्स है. इसके बाद, आपके पास 3, 4, 5 या इससे ज़्यादा डाइमेंशन वाले टेंसर हो सकते हैं.
अध्ययन notebook पर वापस जाएं और इस बार, कोड को पढ़ने दें.
इस नोटबुक में सभी सेल के बारे में जानने दें.
Cell &कोटेशन;पैरामीटर&कोटेशन
बैच के आकार, ट्रेनिंग की जगहों की संख्या, और डेटा फ़ाइलों की जगह की जानकारी यहां दी गई है. डेटा फ़ाइलें, Google Cloud Storage (जीसीएस) बकेट में होस्ट की जाती हैं, इसलिए उनका पता gs:// से शुरू होता है
सेल &कोटेशन/इंपोर्ट;
सभी ज़रूरी Python लाइब्रेरी यहां इंपोर्ट की जाती हैं. इनमें TensorFlow और विज़ुअलाइज़ेशन के लिए catplotlib भी शामिल है.
सेल &कोट[विज़ुअलाइज़ेशन सुविधाएं [RUN ME]&quat;
इस सेल में दिलचस्पी दिखाने वाला विज़ुअलाइज़ेशन कोड मौजूद है. यह डिफ़ॉल्ट रूप से छोटा हो जाता है, लेकिन जब आप समय पर दो बार क्लिक करें, तब उसे खोल सकते हैं और कोड देख सकते हैं.
Cell "tf.data.Dataset: फ़ाइलें पार्स करें और ट्रेनिंग और पुष्टि के डेटासेट तैयार करें&kot;
इस सेल में, MNIST डेटासेट को लोड करने के लिए, tf.data.Dataset API का इस्तेमाल किया गया है. इस सेल पर बहुत ज़्यादा समय बिताना ज़रूरी नहीं है. अगर आपकी दिलचस्पी tf.data.Dataset API में है, तो यहां एक ट्यूटोरियल दिखाया गया है जिसमें यह बताया गया है: TPU-speed डेटा पाइपलाइन. फ़िलहाल, बुनियादी बातें नीचे दी गई हैं:
एमएनआईएस डेटासेट के इमेज और लेबल (सही जवाब), चार फ़ाइलों में तय लंबाई वाले रिकॉर्ड में सेव किए जाते हैं. फ़ाइलों को तय किए गए तय रिकॉर्ड फ़ंक्शन के साथ लोड किया जा सकता है:
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.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 डेटासेट को लूप में चलाता है. हम इस पर कई बार प्रशिक्षण देंगे (कई epoch). .batch एक से ज़्यादा इमेज और लेबल को एक छोटे नैशनल खाते में ले आता है. आखिर में, जीपीयू पर मौजूदा बैच की ट्रेनिंग के दौरान, .prefetch सीपीयू का इस्तेमाल कर सकता है.
पुष्टि करने वाला डेटासेट उसी तरह तैयार किया जाता है. अब हम एक मॉडल तय करने और उसे ट्रेनिंग देने के लिए इस डेटासेट का इस्तेमाल करने के लिए तैयार हैं.
सेल &कोट्स;करेस मॉडल&कोटेशन
हमारे सभी मॉडल में, इस्तेमाल होने वाली लेयर को सीधे तौर पर दिखाया जाएगा, ताकि हम उन्हें बनाने के लिए tf.keras.Sequential स्टाइल का इस्तेमाल कर सकें. शुरुआत में, यह एक # घनी लेयर है. इसमें 10 न्यूरॉन होते हैं, क्योंकि हम हाथ से लिखे गए अंकों को 10 कक्षाओं में बांटते हैं. यह &soft</soft>&कोटेशन को चालू करता है, क्योंकि यह किसी क्लासीफ़ायर में आखिरी लेयर होता है.
केरास मॉडल को अपने इनपुट के आकार को जानने की ज़रूरत होती है. इसे तय करने के लिए, 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' (स्टोकैस्टिक ग्रेडिएंट वंश) का इस्तेमाल करते हैं. क्लासिफ़िकेशन मॉडल के लिए, क्रॉस-एंट्रॉपी लॉस फ़ंक्शन की ज़रूरत होती है, जिसे 'categorical_crossentropy' में कहते हैं. आखिर में, हम मॉडल से 'accuracy' मेट्रिक का हिसाब लगाने के लिए कहते हैं. यह सही कैटगरी में रखी गई इमेज का प्रतिशत होता है.
Keras बहुत ही बढ़िया model.summary() सुविधा देता है जिससे आपके बनाए गए मॉडल की जानकारी प्रिंट होती है. आपके शिक्षक ने ट्रेनिंग के दौरान PlotTraining यूटिलिटी (&view>उपयोगिता&कोटेशन सेल में तय किया गया) जोड़ी है. इसमें ट्रेनिंग के दौरान कई तरह के ट्रेनिंग कर्व दिखेंगे.
सेल &कोटेशन; कोटेशन और मॉडल की पुष्टि करना
यहां 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)हमने स्थानीय फ़ॉन्ट से प्रिंट किए गए अंकों का एक सेट, टेस्ट के तौर पर तैयार किया है. याद रखें कि न्यूरल नेटवर्क अपने अंतिम "softmax&kot; से 10 संभावना का वेक्टर दिखाता है. लेबल पाने के लिए, हमें यह पता लगाना होता है कि सबसे ज़्यादा संभावना कौनसी है. नंबर की लाइब्रेरी की np.argmax से ऐसा होता है.
यह समझने के लिए कि axis=1 पैरामीटर की ज़रूरत क्यों है, कृपया याद रखें कि हमने 128 इमेज का बैच प्रोसेस कर दिया है. इसलिए, यह मॉडल प्रॉबेबिलिटी के 128 वेक्टर दिखाता है. आउटपुट टेंसर का आकार [128, 10] है. हम हर इमेज के लिए दी गई 10 संभावना का पता लगाने के लिए, argmax का हिसाब लगा रहे हैं. इस तरह, axis=1 का पहला अक्ष 0 हो सकता है.
यह आसान मॉडल पहले ही 90% अंकों को पहचान लेता है. बुरा नहीं है, लेकिन अब आप इसे और बेहतर बना सकते हैं.
पहचान सटीक बनाने के लिए, हम न्यूरल नेटवर्क में ज़्यादा लेयर जोड़ेंगे.
हम सॉफ़्टमैक्स को आखिरी लेयर पर ऐक्टिवेशन फ़ंक्शन के तौर पर रखते हैं, क्योंकि यह क्लासिफ़िकेशन के लिए सबसे अच्छा काम करता है. मध्यवर्ती लेयर पर हालांकि हम सबसे क्लासिकल ऐक्टिवेशन फ़ंक्शन का इस्तेमाल करेंगे: सिग्मॉइड:
उदाहरण के लिए, आपका मॉडल इस तरह दिखाई दे सकता है (कॉमा का इस्तेमाल करना न भूलें, 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 गुना बेहतर होना चाहिए! लेकिन किसी वजह से, यह't है ...
ऐसा लगता है कि वे छत पर भी शॉट कर रहे हैं. कुछ गड़बड़ है.
आपको न्यूरल नेटवर्क का अनुभव हुआ है, क्योंकि लोग 80' और 90's में उन्हें डिज़ाइन करते थे. इस बात पर कोई शक नहीं कि उन्होंने इस आइडिया को खारिज कर दिया, और नाम है &कोटेशन; वास्तव में, जैसे-जैसे आप लेयर जोड़ते हैं, न्यूरल नेटवर्क को मुश्किलों के हिसाब से ढालने में ज़्यादा से ज़्यादा मुश्किल होती है.
हमें पता चला कि कई लेयर वाले डीप न्यूरल नेटवर्क, (20, 50, यहां तक कि 100 आज भी) काम कर सकते हैं, बशर्ते उन्हें गणित के कुछ गंदे ट्रिक दिए जाएं, ताकि वे आपस में तालमेल बैठा सकें. इन आसान तरकीबों के मिलने की वजह से, 2010 और #39 के दशक में डीप लर्निंग की शुरुआत हुई.
RELU ऐक्टिवेशन
सिग्मॉइड ऐक्टिवेशन फ़ंक्शन, डीप नेटवर्क में असल में काफ़ी समस्या वाला है. यह 0 और 1 के बीच की सभी वैल्यू को बराबर कर देता है और जब आप ऐसा बार-बार करते हैं, तो न्यूरॉन के आउटपुट और उनके ग्रेडिएंट पूरी तरह से गायब हो सकते हैं. इसका ऐतिहासिक कारणों से उल्लेख किया गया था, लेकिन आधुनिक नेटवर्क RELU (रिक्टिफ़ाइड लीनियर यूनिट) का इस्तेमाल करते हैं, जो कुछ इस तरह दिखता है:
दूसरी ओर के रेलू का डेरिवेटिव 1 होता है, जो दाईं ओर होता है. आरईएलयू ऐक्टिवेशन की मदद से, भले ही कुछ न्यूरॉन से आने वाले ग्रेडिएंट शून्य हो सकते हैं, लेकिन कभी-कभी उन्हें साफ़ तौर पर गैर-शून्य ग्रेडिएंट और ट्रेनिंग देने वाला कॉन्टेंट भी मिल जाता है.
बेहतर ऑप्टिमाइज़र
यहां बहुत ज़्यादा डाइमेंशन वाली जगहों पर — हम 10 हज़ार वज़न और झुकावों के क्रम में हैं—और कोटेशन अक्सर मिलते हैं. ये ऐसे पॉइंट हैं जो स्थानीय छोटी मिनिम नहीं होते, लेकिन ग्रेडिएंट फिर भी शून्य नहीं होता और ग्रेडिएंट का डाउनग्रेड करने वाला वहीं रुक जाता है. TensorFlow में कई तरह के ऑप्टिमाइज़र मौजूद हैं. इनमें कुछ ऐसे इंटर्नल भी हैं जो इंटर्निया की मात्रा के साथ काम करते हैं और सुरक्षित रूप से सैडल पॉइंट से गुज़रते हैं.
किसी भी क्रम में शुरू करना
प्रशिक्षण से पहले वेटेज शुरू करने की कला, रिसर्च का एक हिस्सा है. इस विषय पर कई पेपर प्रकाशित हो चुके हैं. आप यहां Keras में उपलब्ध सभी शुरुआती टूल देख सकते हैं. अच्छी बात यह है कि डिफ़ाॅल्ट तरीके से Keras, सही तरीके से काम करते हैं और 'glorot_uniform' अडैप्टर का इस्तेमाल करते हैं. यह करीब-करीब सभी मामलों में सबसे अच्छा होता है.
आपको कुछ करने की ज़रूरत नहीं है, क्योंकि केरास पहले से ही सही काम करता है.
NaN !!!
क्रॉस-एंट्रॉपी फ़ॉर्मूला में एक लॉगारिद्म (लघुगणक) और लॉग (0) एक संख्या नहीं (NAN, संख्या वाला क्रैश, अगर आप चाहें तो) है. क्या क्रॉस-एंट्रॉपी को इनपुट 0 हो सकता है? इनपुट softmax से आता है, जो खास तौर से एक्सपोनेंशियल होता है और एक्सपोनेंशियल कभी भी शून्य नहीं होता. इसलिए हम सुरक्षित हैं!
वाकई? गणित की खूबसूरत दुनिया में, हम सुरक्षित होंगे, लेकिन कंप्यूटर की दुनिया में, exp3-150, फ़्लोट 32 फ़ॉर्मैट में दिखाया जाता है. यह, शून्य होने के साथ-साथ क्रॉस-एंट्रॉपी क्रैश जैसा भी होता है.
सबसे अच्छी बात यह है कि आपको यहां कुछ करने की ज़रूरत नहीं है, क्योंकि केरास इसका ध्यान रखते हैं और सॉफ़्टमैक्स के बाद आने वाली संख्या को स्थिरता का खास तरीका अपनाते हैं.
पूरा हो गया?
अब आपको 97% सटीक जानकारी मिलेगी. इस वर्कशॉप में 99% से ज़्यादा बढ़ोतरी करनी है, इसलिए लगातार आगे बढ़ते रहें.
अगर आपको कोई समस्या है, तो यहां इसका हल दिया गया है:
हो सकता है कि हम ज़्यादा तेज़ी से ट्रेनिंग देने की कोशिश करें? एडम ऑप्टिमाइज़र में डिफ़ॉल्ट लर्निंग रेट 0.001 है. चलिए, इसे बढ़ाने की कोशिश करते हैं.
तेज़ी से ऐसा होने से आपको ज़्यादा मदद नहीं मिलती और यह सब क्या होता है?
ट्रेनिंग कर्व असल में शोर वाले होते हैं और पुष्टि करने वाले कर्व पर नज़र रखते हैं: वे ऊपर या नीचे जा रहे हैं. इसका मतलब है कि हम बहुत तेज़ी से आगे बढ़ रहे हैं. हम अपनी पिछली रफ़्तार पर वापस जा सकते हैं, लेकिन यह एक बेहतर तरीका है.
बेहतर समाधान है कि तेज़ी से शुरुआत की जाए और सीखने की दर को तेज़ी से कम हो. Kerberos में, आप 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% से ज़्यादा हो रही है.
ऐसा लगता है कि मॉडल अब ठीक से काम कर रहा है. आइए, पहले से ज़्यादा बेहतर जानकारी पाएं.
क्या इससे मदद मिलेगी?
दरअसल, सही जानकारी अब भी 98% पर रुक गई है और पुष्टि की संख्या में हुई कमी को देखें. यह चल रहा है! सीखने वाला एल्गोरिदम, सिर्फ़ ट्रेनिंग डेटा पर काम करता है और ट्रेनिंग के दौरान होने वाले नुकसान को ऑप्टिमाइज़ करता है. इसमें कभी भी पुष्टि करने वाला डेटा नहीं दिखता है. इसलिए, इसमें हैरानी की बात होती है कि कुछ समय बाद इसके काम करने की सुविधा के असर की वजह से, पुष्टि की प्रोसेस के नतीजों पर असर नहीं पड़ता है. कभी-कभी डेटा लीक होने की समस्या से भी बचा जा सकता है.
यह आपके मॉडल की वास्तविक दुनिया की पहचान की क्षमताओं को तुरंत प्रभावित नहीं करता है, लेकिन यह आपको कई बार चलने से रोकेगा. आम तौर पर, यह इस बात का संकेत है कि ट्रेनिंग का असर अब अच्छा नहीं हो रहा है.
इस डिसकनेक्ट को आम तौर पर "overfit&कोटेशन; कहा जाता है; और जब आपको यह दिखता है, तो आप &kot;dropout&kot; नाम की एक रेगुलराइज़ेशन तकनीक लागू करने की कोशिश कर सकते हैं. ड्रॉपआउट तकनीक हर प्रशिक्षण प्रशिक्षण के दौरान रैंडम न्यूरॉन को शूट करती है.
क्या इसने काम किया?
शोर फिर से दिखता है (इसमें कोई शक नहीं कि ड्रॉप आउट कैसे काम करता है). ऐसा लगता है कि पुष्टि की प्रोसेस के दौरान पेजों से ज़्यादा टारगेटिंग नहीं की जा रही है, लेकिन ड्रॉप-डाउन की तुलना में पुष्टि की दर ज़्यादा है. साथ ही, पुष्टि करने की प्रक्रिया में सटीक बदलाव नहीं हुए. यह काफ़ी बेकार नतीजा है.
ऐसा लगता है कि ड्रॉप-आउट सही हल नहीं था या हो सकता है कि यह ज़्यादा जटिल &कोटेशन है; एक ज़्यादा मुश्किल कॉन्सेप्ट है और इसकी कुछ वजहें "ड्रॉपआउट&कोटेशन; के लिए सक्षम नहीं हैं?
&कोटेशन क्या है? ओवरफ़िटिंग तब होती है, जब न्यूरल नेटवर्क इस तरह से सीखता है; ट्रेनिंग के उदाहरणों के लिए काम करता है, लेकिन असल में मौजूद डेटा पर यह ठीक से काम नहीं करता. आम तौर पर, इस्तेमाल में आने वाली ऐसी तकनीकें जो ड्रॉप-डाउन जैसी हैं. इनका इस्तेमाल करने वालों को बेहतर तरीके से सीखने के लिए प्रेरित किया जा सकता है. हालांकि, ज़रूरत से ज़्यादा फ़िट होने की वजहें भी ज़्यादा होती हैं.
बुनियादी ओवरफ़िट तब होता है, जब किसी न्यूरल नेटवर्क में समस्या के लिए बहुत ज़्यादा आज़ादी हो. मान लें कि हमारे पास इतने न्यूरॉन हैं कि नेटवर्क हमारी सभी ट्रेनिंग इमेज को स्टोर कर सकता है और फिर उन्हें पैटर्न मैचिंग से पहचान सकता है. इससे असल डेटा पर पूरी तरह से रोक नहीं लगेगी. न्यूरल नेटवर्क को कुछ हद तक सीमित होना चाहिए, ताकि ट्रेनिंग के दौरान उससे जुड़ी जानकारी इकट्ठा की जा सके.
अगर आपके पास ट्रेनिंग का डेटा बहुत कम है, तब भी एक छोटा नेटवर्क इसे दिल का निशान लगाकर सीख सकता है. आप चाहें, तो " &fiting" के साथ कोटेशन भी देख सकते हैं. आम तौर पर, न्यूरल नेटवर्क को ट्रेनिंग देने के लिए आपके पास काफ़ी डेटा होना चाहिए.
आखिर में, अगर आपने किताब पूरी तरह से तैयार की है, तो अलग-अलग साइज़ के नेटवर्क के साथ प्रयोग करके यह पक्का किया जाएगा कि स्वतंत्र मानों की संख्या सीमित है, ड्रॉप-डाउन लागू की गई है, और बहुत सारे डेटा के लिए आपको ट्रेनिंग दी गई है. हालांकि, शायद आप अब भी परफ़ॉर्मेंस के ऐसे लेवल पर हैं जिसमें कोई सुधार नहीं हो रहा. इसका मतलब है कि आपके न्यूरल नेटवर्क, अपने मौजूदा आकार में, आपके डेटा से ज़्यादा जानकारी नहीं ले सकते. जैसा कि यहां दिखाया गया है.
याद रखें कि हम अपनी इमेज का इस्तेमाल किस तरह करते हैं, एक वेक्टर में सपाट होना? यह तो बहुत बुरा था. हाथ से लिखे हुए अंक, आकार के होते हैं और पिक्सल को फ़्लैट करने के बाद आकार की जानकारी को खारिज कर दिया जाता है. हालांकि, एक प्रकार का न्यूरल नेटवर्क होता है जो आकार की जानकारी का फ़ायदा ले सकता है: कॉन्वोल्यूशनल नेटवर्क. आइए, इसे आज़माकर देखते हैं.
अगर आपको कोई समस्या है, तो यहां इसका हल दिया गया है:
खास जानकारी में
अगर अगले पैराग्राफ़ में दिए गए सभी शब्द, बोल्ड में पहले से जानते हैं, तो आप अगली कसरत पर जा सकते हैं. अगर आपने नए न्यूरल नेटवर्क का इस्तेमाल शुरू किया है, तो कृपया आगे पढ़ें.
उदाहरण: हर इमेज को 4x4x3=48 के हिसाब से वज़न के हिसाब से फ़िल्टर करना.
केरस में एक सामान्य कॉन्वोल्यूशनल न्यूरल नेटवर्क ऐसा दिखता है:
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')
])
कंवोल्यूशन नेटवर्क की एक लेयर में, एक &व्यंजन&कोटेशन; इमेज के छोटे से हिस्से में, इसके ठीक ऊपर पिक्सल का भारित योग करता है. यह एक झुकाव को जोड़ता है और एक्टिवेशन फ़ंक्शन के ज़रिए योग को फ़ीड करता है, जैसा कि किसी सामान्य सघन परत में एक न्यूरॉन को करता है. इसके बाद, यह तरीका पूरी इमेज में एक जैसे वेट का इस्तेमाल करके दोहराया जाता है. याद रखें कि घनी लेयर में, हर न्यूरॉन का अपना वज़न होता है. यहां, दोनों दिशाओं में इमेज में एक सिंगल कोट (पैच)</ot;(कोटेशन और कोटेशन); आउटपुट में इमेज में पिक्सल जैसे ही ज़्यादा मान हैं (हालांकि, किनारों पर कुछ पैडिंग ज़रूरी है). यह फ़िल्टर करने की कार्रवाई है. ऊपर दिए गए उदाहरण में, यह 4x4x3=48 वज़न के फ़िल्टर का इस्तेमाल करता है.
हालांकि, सिर्फ़ 48 पेजों की मोटाई काफ़ी नहीं होगी. स्वतंत्रता की और डिग्री जोड़ने के लिए, हम इसी ऑपरेशन को वेट के एक नए सेट के साथ दोहराते हैं. इससे फ़िल्टर आउटपुट का एक नया सेट बन जाता है. आइए, इसे "&channel" की मदद से इनपुट इमेज में मौजूद R,G,B चैनलों की मदद से आउटपुट दें.
वेट के दो (या ज़्यादा) सेट को नया डाइमेंशन जोड़कर, एक टेंसर के तौर पर जोड़ा जा सकता है. इससे हम एक बड़ी लेयर के लिए, टेंशनर के सामान्य साइज़ का पता लगाते हैं. इनपुट और आउटपुट चैनल की संख्या पैरामीटर है, इसलिए हम कॉन्वोल्यूशन लेयर को स्टैक और चेन करना शुरू कर सकते हैं.
साफ़ तौर पर बताना: एक कॉन्वोल्यूशनल न्यूरल नेटवर्क, डेटा के अन्य कोटेशन में कोटेशन लेता है.
स्टडी कन्वोल्यूशन, ज़्यादा से ज़्यादा पूलिंग
2 या 3 के स्ट्राइडो के साथ कनवोलेशन करने से, हम नतीजे के क्यूब को हॉरिज़ॉन्टल डाइमेंशन में भी छोटा कर सकते हैं. ऐसा करने के दो सामान्य तरीके हैं:
- बेहतर रिज़ॉल्यूशन: ऊपर की ओर स्लाइड करने वाला ऐसा फ़िल्टर जो स्ट्रोड और ग्रास के साथ है
- मैक्स पूलिंग: मैक्स ऑपरेशन लागू करने वाली एक स्लाइडिंग विंडो (आम तौर पर 2x2 पैच पर, हर दो पिक्सल में दोहराया जाता है)
उदाहरण: कंप्यूटिंग विंडो को 3 पिक्सल तक स्लाइड करने से आउटपुट वैल्यू कम होती हैं. बेहतर कॉन्फ़िगरेशन या ज़्यादा से ज़्यादा पूलिंग (ज़्यादा से ज़्यादा दो के बीच 2x2 की विंडो पर, दो तक स्क्रोल करना) हॉरिज़ॉन्टल डाइमेंशन में डेटा क्यूब को छोटा करने का तरीका है.
फ़ाइनल लेयर
आखिरी कॉन्वोल्यूशन लेयर के बाद, डेटा & के कोटेशन और कोटेशन के तौर पर होता है. आखिरी घने परत से इसे खाना देने के दो तरीके हैं.
पहला है, डेटा के क्यूब को वेक्टर में फ़्लैट करना और फिर उसे सॉफ़्टमैक्स लेयर में फ़ीड करना. कभी-कभी, आप सॉफ़्टमैक्स लेयर से पहले भी एक सघन लेयर जोड़ सकते हैं. यह वज़न की संख्या के हिसाब से महंगा होता है. कंवोल्यूशन नेटवर्क के आखिर में घनी लेयर है, जिसमें पूरे न्यूरल नेटवर्क का आधा से ज़्यादा वज़न हो सकता है.
महंगी सघन परत का इस्तेमाल करने के बजाय, हम आने वाले डेटा को कोटेशन में बांट सकते हैं और उसे कई सेक्शन में बांट सकते हैं. साथ ही, सॉफ़्टमैक्स ऐक्टिवेशन फ़ंक्शन की मदद से उनकी वैल्यू का औसत निकाल सकते हैं और उन्हें फ़ीड कर सकते हैं. कैटगरी तय करने वाले इस तरीके को बनाने का शुल्क शून्य होता है. Keras में, इसके लिए लेयर है: tf.keras.layers.GlobalAveragePooling2D().
समस्या के लिए कंवोल्यूशन नेटवर्क बनाने के लिए, अगले सेक्शन पर जाएं.
हमें हाथ से लिखे हुए अंकों की पहचान करने के लिए, एक कॉन्फ़िगरेशन नेटवर्क बनाएं. हम सबसे ऊपर तीन कन्वर्ज़न वाली लेयर इस्तेमाल करेंगे. सबसे नीचे, सॉफ़्टmax रीडआउट लेयर की लेयर को जोड़कर, हम उन्हें पूरी तरह से कनेक्ट की गई एक लेयर के साथ कनेक्ट करेंगे:
ध्यान दें कि दूसरी और तीसरी कॉन्वोल्यूशन लेयर में दो का स्ट्राइड होता है, जो बताता है कि आउटपुट वैल्यू की संख्या को 28x28 से घटाकर 14x14 और फिर 7x7 क्यों किया जाता है.
चलिए कीरास कोड लिखते हैं.
पहली कन्वर्ज़न लेयर से पहले खास ध्यान देने की ज़रूरत है. दरअसल, इसके 3D क्यूब' डेटा की उम्मीद होती है, लेकिन अभी तक हमारे डेटासेट को घनी लेयर के लिए सेट अप कर लिया गया है और सभी पिक्सल वेक्टर में फ़्लैट हो गई हैं. हमें उन्हें 28x28x1 आकार की इमेज में बदलना होगा (स्लेटी इमेज के लिए एक चैनल):
tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1))आपके पास अभी तक tf.keras.layers.Input लेयर के बजाय इस लाइन का इस्तेमाल हो सकता है.
Keras में, "relu'-activated Convutation की लेयर का सिंटैक्स यह है:
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 अंक)
अगर आपको कोई समस्या है, तो यहां इसका हल दिया गया है:
पिछली ट्रेनिंग में, साफ़ तौर पर दिखने वाले निशान के बारे में साफ़ तौर पर बताया गया था (हालांकि, यह 99% सटीक नहीं है). क्या हम फिर से कोशिश करें?
यह समय कैसा लगा?
ऐसा लगता है कि इस समय ड्रॉपआउट की सुविधा ने काम कर लिया है. पुष्टि करने की प्रक्रिया का दायरा अब कम नहीं हो रहा है और फ़ाइनल स्कोर 99% से ज़्यादा होना चाहिए. बधाई हो!
जब हमने पहली बार ड्रॉप-आउट लागू करने की कोशिश की, तब हमें लगा कि हमें ओवरफ़िटिंग की समस्या आ रही है, जबकि असल में समस्या न्यूरल नेटवर्क की वास्तुकला में ही थी. हम ग़ैर-ज़रूरी लेयर के बिना आगे नहीं बढ़ सके. साथ ही, इसके बारे में कुछ भी नहीं किया जा सकता.
ऐसा लगता है कि समस्या ज़्यादा होने की वजह से ही ज़रूरत से ज़्यादा काम हो गया था और ड्रॉप-आउट से असल में मदद मिली. याद रखें कि कई वजहों से ट्रेनिंग और पुष्टि के नुकसान वाले कर्व के बीच डिसकनेक्ट हो जाता है और पुष्टि कम हो जाती है. ज़रूरत से ज़्यादा फ़िटिंग करना (बहुत ज़्यादा आज़ादी, जिसे नेटवर्क बहुत गलत तरीके से इस्तेमाल करता है) उनमें से एक है. अगर आपका डेटासेट बहुत छोटा है या आपके न्यूरल नेटवर्क का आर्किटेक्चर काफ़ी नहीं है, तो आपको कमी वाले कर्व पर मिलता-जुलता व्यवहार दिख सकता है, लेकिन ड्रॉप आउट से कोई मदद नहीं मिलेगी.
अंत में, आइए बैच को सामान्य बनाने का प्रयास करें.
सिद्धांत के तौर पर, कुछ बातों को याद रखें:
अभी के लिए, किताब के मुताबिक खेलें. न्यूरल नेटवर्क लेयर के अलावा, हर न्यूरल नेटवर्क लेयर पर बैच नॉर्म लेयर जोड़ें. इसे आखिरी &कोटेशन, सॉफ़्टमैक्स&कोटेशन की लेयर में न जोड़ें. यह वहां काम का नहीं होगा.
# 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% ट्रेनिंग उपलब्ध है:
आपको कोड का एक क्लाउड-रेडी वर्शन GitHub पर ml Engine फ़ोल्डर में मिलेगा. साथ ही, इसे Google Cloud AI Platform पर चलाने के निर्देश भी मिलेंगे. इस हिस्से को चलाने से पहले, आपको Google Cloud खाता बनाना होगा और बिलिंग चालू करनी होगी. लैब को पूरा करने के लिए ज़रूरी संसाधन, दो डॉलर से कम के होने चाहिए. इसे एक जीपीयू पर एक घंटे के लिए ट्रेनिंग माना जाता है. अपना खाता तैयार करने के लिए:
- Google Cloud Platform प्रोजेक्ट (http://cloud.google.com/console) बनाएं.
- बिलिंग चालू करें.
- GCP कमांड लाइन टूल (GCP SDK टूल यहां) इंस्टॉल करें.
- Google Cloud Storage बकेट (
us-central1क्षेत्र में रखें) बनाएं. इसका इस्तेमाल ट्रेनिंग कोड को स्टेज करने और आपके प्रशिक्षित मॉडल को सेव करने के लिए किया जाएगा. - ज़रूरी एपीआई चालू करें और ज़रूरी कोटा बढ़ाने का अनुरोध करें. एक बार ट्रेनिंग निर्देश चलाएं और आपको गड़बड़ी के मैसेज में यह जानकारी दी जाएगी कि आपको क्या चालू करना है.
आपने अपना पहला न्यूरल नेटवर्क बना लिया है और उसे 99% सटीक बनाने की ट्रेनिंग दे दी है. इसमें इस्तेमाल होने वाली तकनीकें एमएनआईएस डेटासेट के लिए खास नहीं हैं. असल में, न्यूरल नेटवर्क के साथ काम करते समय इनका इस्तेमाल बड़े पैमाने पर किया जाता है. आपको एक खास उपहार मिलेगा. यह कार्टून संग्रह में लैब वाला कार्ड है. आप इसका इस्तेमाल करके यह याद रख सकते हैं कि आपने क्या सीखा है:
अगले कदम
- पूरी तरह से कनेक्ट और गुमराह करने वाले नेटवर्क के बाद, आपको बार-बार होने वाले न्यूरल नेटवर्क पर एक नज़र डालनी चाहिए.
- डिस्ट्रिब्यूटेड इंफ़्रास्ट्रक्चर पर क्लाउड में अपनी ट्रेनिंग या अनुमान चलाने के लिए, Google Cloud AI Platform उपलब्ध कराता है.
- आखिरकार, हमें सुझाव पाकर खुशी होती है. अगर आपको इस लैब में कुछ समस्या आती है या आपको लगता है कि इसे बेहतर बनाना है, तो हमें बताएं. हम GitHub से जुड़ी समस्याओं को हल करने के लिए, [feedback link] का इस्तेमाल करते हैं.
लेखक: मार्टिन गॉर्नर Twitter: @martin_gorner |
|
इस लैब में सभी कॉपीराइट इमेज मौजूद हैं: alexpokusay / 123RF स्टॉक फ़ोटो