इस कोडलैब (कोड बनाना सीखने के लिए ट्यूटोरियल) के बारे में जानकारी
1. शुरू करने से पहले
इस कोडलैब में, आप एमएल की बुनियादी बातें जानने के बजाय, नमस्ते, वर्ल्ड, और कोट जैसी बुनियादी जानकारी का इस्तेमाल करते हैं. यहां आपको Java या C++ जैसी भाषा में अश्लील नियम तय करने के बजाय, डेटा पर आधारित सिस्टम बनाना होता है. इससे, आपको ऐसे नियम बनाने में मदद मिलती है जो संख्याओं के बीच संबंध तय करते हैं.
नीचे दी गई समस्या पर ध्यान दें: आप एक ऐसा सिस्टम बना रहे हैं जो फ़िटनेस ट्रैकिंग के लिए गतिविधि की पहचान करता है. हो सकता है कि आपके पास किसी व्यक्ति के पैदल चलने की रफ़्तार का ऐक्सेस हो और आप कंडीशनल का इस्तेमाल करके उसकी रफ़्तार का अनुमान लगाने की कोशिश करें.
if(speed<4){
status=WALKING;
}
आप इसे दूसरी शर्तों के साथ चलाने के लिए बढ़ा सकते हैं.
if(speed<4){
status=WALKING;
} else {
status=RUNNING;
}
ऐसी ही स्थिति में, आप इसी तरह साइकल चला सकते हैं.
if(speed<4){
status=WALKING;
} else if(speed<12){
status=RUNNING;
} else {
status=BIKING;
}
अब, सोचें कि जब आप गोल्फ़ जैसी कोई गतिविधि शामिल करना चाहते हैं, तो क्या होता है. गतिविधि को तय करने के लिए, कोई नियम नहीं बनाया जा सकता.
// Now what?
यह एक ऐसा कार्यक्रम लिखना बहुत मुश्किल है जो गोल्फ़ की गतिविधि को पहचान लेगा. इसलिए, आपको क्या करना चाहिए? आप समस्या को हल करने के लिए एमएल का इस्तेमाल कर सकते हैं!
ज़रूरी शर्तें
इस कोडलैब के इस्तेमाल से पहले, आपके पास ये होना चाहिए:
- Python की पूरी जानकारी
- प्रोग्रामिंग की बुनियादी जानकारी
आप क्या #39;जानेंगे
- मशीन लर्निंग की बुनियादी बातें
आप क्या बनाते हैं
- आपका पहला मशीन लर्निंग मॉडल
आपको क्या चाहिए
अगर आपने TensorFlow का इस्तेमाल करके कभी भी ML का मॉडल नहीं बनाया है, तो आप ब्राउज़र पर आधारित Colaboratory का इस्तेमाल कर सकते हैं. इस एनवायरमेंट में सभी ज़रूरी चीज़ें शामिल होती हैं. आप Colab में चल रहे कोडलैब के बाकी कोड के लिए कोड देख सकते हैं.
अगर आप किसी दूसरे आईडीई का इस्तेमाल कर रहे हैं{0}, तो पक्का करें कि आपने Python इंस्टॉल किया है. आपको#39; TensorFlow और NumPy लाइब्रेरी की भी ज़रूरत होगी. आप TensorFlow यहां जाकर, इसके बारे में ज़्यादा जानें और इसे इंस्टॉल करें. NumPy को यहां इंस्टॉल करें.
2. एमएल क्या है?
नीचे दिए डायग्राम में दिखाए गए ऐप्लिकेशन बनाने के पारंपरिक तरीके को ध्यान में रखें:
आप प्रोग्रामिंग भाषा में अपने नियम दिखाते हैं. वे डेटा पर काम करते हैं और आपका प्रोग्राम जवाब** देता है.** गतिविधि की पहचान करने के मामले में, नियम (जो कोड आपने गतिविधि टाइप के बारे में बताने के लिए लिखा है) पर जवाब देने के लिए डेटा (व्यक्ति और #39; की हलचल से जुड़ी रफ़्तार) पर काम किया: उपयोगकर्ता की गतिविधि की स्थिति तय करने के लिए फ़ंक्शन से रिटर्न वैल्यू (चाहे वे चल रहे हों, दौड़ रहे हों, बाइकिंग कर रहे हों या कोई और काम कर रहे हों).
एमएल के ज़रिए गतिविधि की स्थिति का पता लगाने का तरीका काफ़ी हद तक एक जैसा है. सिर्फ़ अक्षों की स्थिति अलग होती है.
नियमों को तय करने और उन्हें किसी प्रोग्रामिंग भाषा में दिखाने के बजाय, आप डेटा के साथ जवाब (आम तौर पर लेबल) देते हैं और मशीन उन नियमों का अनुमान लगाती है जो जवाबों और डेटा के बीच संबंध तय करते हैं. उदाहरण के लिए, आपकी गतिविधि की पहचान करने वाली स्थिति, एमएल फ़ॉर्मैट में ऐसी दिख सकती है:
आप बहुत सारा डेटा इकट्ठा करते हैं और उसे असरदार ढंग से 'कोट' करने के लिए लेबल करते हैं;{0}ये ऐसा दिखता है जो && कोट/या कोट हो सकता है;यह ऐसा दिखता है.&कोटेशन; इसके बाद, कंप्यूटर डेटा से यह तय करने वाले नियमों का अनुमान लगा सकता है कि किसी खास गतिविधि को दिखाने वाले अलग-अलग पैटर्न क्या हैं.
उस परिस्थिति के अनुसार प्रोग्रामिंग के वैकल्पिक तरीके के अलावा, आपको उस नई स्थिति को खोलने की सुविधा भी मिलती है, जैसे गोल्फ़ का ऐसा कोई तरीका जो नियम-आधारित परंपरागत प्रोग्रामिंग के तहत नहीं होता.
पारंपरिक प्रोग्रामिंग में, आपका कोड एक बाइनरी में इकट्ठा होता है, जिसे आम तौर पर प्रोग्राम कहा जाता है. एमएल में, डेटा और लेबल से जो आइटम बनाया जाता है उसे मॉडल कहा जाता है.
इसलिए, अगर आप इस डायग्राम पर वापस जाते हैं, तो:
इसके नतीजे को एक मॉडल के तौर पर देखें, जिसका इस्तेमाल रनटाइम के समय इस तरह किया जाता है:
जब आप मॉडल को कुछ डेटा पास करते हैं और मॉडल ट्रेनिंग के आधार पर अनुमान लगाने के लिए नियमों का इस्तेमाल करता है, जैसे कि &डेटा, वह डेटा पैदल चलने का रास्ता लगता है या &कोटेशन का डेटा है.
3. अपना पहला एमएल मॉडल बनाएं
नंबरों के इन सेट पर ध्यान दें. क्या आप उनके बीच का संबंध देख सकते हैं?
गुना: | -1 | 0 | 1 | 2 | 3 | 4 |
हां: | -2 | 1 | 4 | 7 | 10 | 13 |
अगर आप इन शब्दों पर गौर करें, तो आपको दिखेगा कि X की वैल्यू 1 बढ़ रही है. इसकी वजह यह है कि आपने बाईं से दाईं ओर पढ़ा और Y की वैल्यू को 3 बढ़ाया गया है. शायद आपको लगता है कि Y के बराबर 3X प्लस या कम है. फिर, आप X
यह बिल्कुल वैसा ही है जैसा आप डेटा में पैटर्न को पहचानने के लिए मॉडल को ट्रेनिंग देने के लिए कोड का इस्तेमाल करते हैं!
अब, कोड को देखकर ऐसा करें.
आप किसी मिलते-जुलते काम के लिए, न्यूरल नेटवर्क को कैसे ट्रेनिंग देंगे? डेटा का इस्तेमाल करना! X's और Y's के सेट के साथ इसे फ़ीड करके, यह उनके बीच के संबंध का पता लगा सकता है.
इंपोर्ट
इंपोर्ट करने से शुरू करें. यहां, आप आसानी से इस्तेमाल करने के लिए TensorFlow इंपोर्ट कर रहे हैं और उसे tf कह रहे हैं.
इसके बाद, numpy नाम की एक लाइब्रेरी इंपोर्ट करें, जो आपके डेटा को सूचियों के तौर पर आसानी और तेज़ी से दिखाती है.
न्यूरल नेटवर्क को, क्रम में चलने वाले लेयर के सेट के तौर पर तय करने वाले फ़्रेमवर्क को keras कहा जाता है, इसलिए उसे भी इंपोर्ट करें.
import tensorflow as tf
import numpy as np
from tensorflow import keras
न्यूरल नेटवर्क को तय करना और कंपाइल करना
इसके बाद, सबसे आसान न्यूरल नेटवर्क बनाएं. इसमें एक परत होती है, इस परत में एक न्यूरॉन होती है और इनपुट आकार इसका सिर्फ़ एक मान होता है.
model = tf.keras.Sequential([keras.layers.Dense(units=1, input_shape=[1])])
इसके बाद, अपने न्यूरल नेटवर्क को कंपाइल करने के लिए कोड लिखें. ऐसा करने पर, आपको दो फ़ंक्शन तय करने होंगे — loss और optimizer.
इस उदाहरण में, आप जानते हैं कि संख्याओं के बीच का संबंध Y=3X+1 है.
जब कंप्यूटर यह पता लगाने की कोशिश करता है, तो यह अनुमान लगाता है कि शायद Y=10X+10 है. loss फ़ंक्शन, अनुमानित जवाबों का अंदाज़ा लगाता है और पता लगाता है कि कौनसे जवाब जाने-पहचाने हैं या नहीं.
आगे, मॉडल एक और अनुमान लगाने के लिए optimizer फ़ंक्शन का इस्तेमाल करता है. नुकसान की संभावना को कम करने वाले फ़ंक्शन के आधार पर, यह कोशिश करता है कि #39; नतीजा. इस पॉइंट पर, हो सकता है कि यह Y=5X+5 जैसा कुछ मिले. हालांकि यह बहुत खराब है, लेकिन यह सही नतीजे के करीब है. नुकसान कम है.
मॉडल इसे epoch की संख्या के लिए दोहराता है. इसे आपको जल्द ही दिखेगा.
सबसे पहले, यहां बताया गया है कि नुकसान के लिए mean_squared_error का इस्तेमाल कैसे करना है और ऑप्टिमाइज़र के लिए स्टोकैस्टिक ग्रेडिएंट डिसेंडेंट (sgd) का इस्तेमाल करना है. आपको अभी तक उनका गणित समझना ज़रूरी नहीं है, लेकिन आप देख सकते हैं कि वे काम करते हैं!
समय के साथ, आप अलग-अलग स्थितियों के हिसाब से, अलग-अलग और सही नुकसान और ऑप्टिमाइज़र फ़ंक्शन के बारे में जानेंगे.
model.compile(optimizer='sgd', loss='mean_squared_error')
डेटा दें
इसके बाद, कुछ डेटा फ़ीड करें. इस मामले में, आप पहले के छह X और छह Y वैरिएबल लेते हैं. आप देख सकते हैं कि उनके बीच का संबंध Y=3X+1 है, इसलिए X -1 है और Y -2 है.
NumPy नाम की एक Python लाइब्रेरी ऐसा करने के लिए कई सारणी प्रकार डेटा संरचना देती है. np.array[] के साथ NumPy में एक श्रेणी के रूप में मान तय करें.
xs = np.array([-1.0, 0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-2.0, 1.0, 4.0, 7.0, 10.0, 13.0], dtype=float)
अब आपके पास न्यूरल नेटवर्क तय करने के लिए ज़रूरी सभी कोड हैं. अगला कदम यह पता करना है कि इन नंबरों के पैटर्न का अंदाज़ा लगाना या नहीं और उनका इस्तेमाल करके मॉडल बनाना है या नहीं.
4. न्यूरल नेटवर्क को ट्रेनिंग दें
न्यूरल नेटवर्क को ट्रेनिंग देने की प्रक्रिया, model.fit कॉल में X's और Y's के बीच संबंध सीखती है. इसका मतलब है कि अनुमान लगाने से पहले, यह लूप में चलेगा या यह बताता है कि यह कितना अच्छा या खराब है (नुकसान पहुंचाने वाला) या कोई दूसरा अनुमान लगाने के लिए ऑप्टिमाइज़र का इस्तेमाल करता है. ऐसा करने से, आपकी तय की गई epoch की संख्या के लिए ऐसा किया जाएगा. जब आप उस कोड को चलाएंगे, तो आप देख पाएंगे कि खोए हुए समय को हर epoch के लिए प्रिंट कर दिया जाएगा.
model.fit(xs, ys, epochs=500)
उदाहरण के लिए, आप देख सकते हैं कि पहले कुछ बिंदुओं के लिए, हानि मान बहुत बड़ा होता है, लेकिन हर चरण के साथ यह कम होता जाता है.
जैसे-जैसे ट्रेनिंग उपलब्ध होती है, वैसे-वैसे यह नुकसान बहुत कम होता जाता है.
ट्रेनिंग के दौरान, डेटा का नुकसान बहुत कम होता है. इससे पता चलता है कि हमारा मॉडल दोनों के बीच के रिश्ते को बेहतर तरीके से समझ रहा है.
शायद आपको सभी 500 ईमेल पतों की ज़रूरत नहीं है और आप अलग-अलग रकम के साथ प्रयोग कर सकते हैं. जैसा कि आप उदाहरण से देख सकते हैं, नुकसान सिर्फ़ 50 epoch के बाद काफ़ी कम होता है, इसलिए यह काफ़ी हो सकता है!
5. मॉडल का इस्तेमाल करना
आपके पास एक ऐसा मॉडल है जिसे X और Y के बीच संबंध सीखने के लिए ट्रेनिंग दी गई है. आप model.predict तरीके का इस्तेमाल करके, पहले एक अज्ञात X का Y पता लगा सकते हैं. उदाहरण के लिए, अगर X 10 है, तो आपके हिसाब से Y क्या होगा? इस कोड को चलाने से पहले अनुमान लगाएं:
print(model.predict([10.0]))
हो सकता है कि आपने 31 सोच लिया हो, लेकिन शायद यह थोड़ा सा बढ़ गया हो. आपको ऐसा क्यों लगता है?
न्यूरल नेटवर्क, संभावना से जुड़े हैं. इसलिए, इसकी गिनती करने की संभावना बहुत ज़्यादा है कि X और Y के बीच का संबंध Y=3X+1 है, लेकिन यह सिर्फ़ छह डेटा पॉइंट से ही तय नहीं हो सकता. नतीजा 31 के करीब है, लेकिन 31 के बराबर नहीं है.
न्यूरल नेटवर्क के साथ काम करने पर, आपको वह #39;बार-बार दिखेगा. आप हमेशा संभावनाओं के बारे में बात करेंगे, न कि कुछ खास बातों के बारे में. साथ ही, थोड़ा सा कोडिंग करेंगे, ताकि यह पता चल सके कि नतीजों को संभावना के आधार पर क्या बनाया जाएगा, खास तौर पर क्लासिफ़िकेशन के बारे में.
6. बधाई हो
मान लें कि आपने एमएल के ज़्यादातर कॉन्सेप्ट को शामिल किया है जिसका इस्तेमाल आप बहुत मुश्किल हालातों में करेंगे. आपने एक न्यूरल नेटवर्क को ट्रेनिंग देने का तरीका सीखा. इसके लिए, नेटवर्क को परिभाषित करके, नंबरों के दो सेट के बीच के संबंध का पता लगाया जाता है. आपने लेयर का एक सेट परिभाषित किया है (इस मामले में सिर्फ़ एक) जिसमें न्यूरॉन शामिल हैं (इस मामले में, सिर्फ़ एक) जिसमें आपने उसके बाद फ़ंक्शन और ऑप्टिमाइज़र को कंपाइल किया है.
किसी नेटवर्क, हानि फ़ंक्शन, और ऑप्टिमाइज़र का संग्रह, आंकड़ों के बीच संबंध का अनुमान लगाने, उनके काम करने की क्षमता को मापने, और फिर नए अनुमानों के लिए नए पैरामीटर जनरेट करने की प्रक्रिया को संभालता है. ज़्यादा जानकारी के लिए, TensorFlow.org पर जाएं.
ज़्यादा जानें
यह जानने के लिए कि एमएल और TensorFlow आपके कंप्यूटर के दृष्टि मॉडल में कैसे मदद कर सकते हैं, TensORFlow की मदद से कंप्यूटर दृष्टि वाला मॉडल बनाएं पर जाएं.