मशीन लर्निंग का परिचय

रूसी में पूर्ण पाठ्यक्रम इस लिंक पर पाया जा सकता है।
इस लिंक पर मूल अंग्रेजी पाठ्यक्रम उपलब्ध है।



हर 2-3 दिनों में नए व्याख्यान निर्धारित होते हैं।

सेबस्टियन ट्रून, सीईओ उडेसिटी के साथ साक्षात्कार

"नमस्कार फिर, मैं Paige हूं और आप आज मेरे मेहमान हैं, सेबेस्टियन।"
- हाय, मैं सेबस्टियन हूँ!
- ... एक ऐसा व्यक्ति जिसके पास एक अविश्वसनीय कैरियर है, जो बहुत सारी अद्भुत चीजें करने में कामयाब रहा! आप उडेसिटी के सह-संस्थापक हैं, आपने Google X की स्थापना की, आप स्टैनफोर्ड में प्रोफेसर हैं। आप अपने पूरे करियर में अविश्वसनीय शोध और गहन शिक्षा प्राप्त करते रहे हैं। आपको सबसे अधिक संतुष्टि मिली और किन क्षेत्रों में आपको किए गए कार्यों के लिए सबसे अधिक पुरस्कार मिले?
- सच कहूं, मुझे सिलिकॉन वैली में रहना बहुत पसंद है! मुझे ऐसे लोगों के पास रहना पसंद है जो मुझसे ज्यादा होशियार हैं, और मैंने हमेशा प्रौद्योगिकी को एक उपकरण के रूप में माना है जो खेल के नियमों को विभिन्न तरीकों से बदलता है - शिक्षा से लेकर रसद, स्वास्थ्य देखभाल आदि। यह सब इतनी जल्दी बदल जाता है, और इन परिवर्तनों को देखने के लिए इन परिवर्तनों में भागीदार बनने की एक अविश्वसनीय इच्छा है। आप अपने परिवेश को देखें और समझें कि आपके आस-पास जो भी आप देखते हैं उनमें से अधिकांश काम नहीं करता है जैसा कि आपको करना चाहिए - आप हमेशा कुछ नया आविष्कार कर सकते हैं!
- ठीक है, यह प्रौद्योगिकी का एक बहुत ही आशावादी दृष्टिकोण है! आपके पूरे करियर में सबसे बड़ा यूरेका क्या था?
- भगवान, बहुत सारे थे! मुझे उन दिनों में से एक याद है जब लैरी पेज ने मुझे फोन किया और ऑटोपायलट कार बनाने का सुझाव दिया जो कैलिफोर्निया की सभी सड़कों के माध्यम से ड्राइव कर सकती थी। उस समय मुझे एक विशेषज्ञ माना जाता था, मुझे उन लोगों में स्थान दिया गया था और, मैं बहुत ही ऐसा व्यक्ति था जिसने कहा "नहीं, यह नहीं किया जा सकता है।" उसके बाद, लैरी ने मुझे आश्वस्त किया कि, सिद्धांत रूप में, ऐसा करना संभव है, आपको बस शुरुआत और कोशिश करनी होगी। और हमने यह किया! यह वह क्षण था जब मुझे महसूस हुआ कि विशेषज्ञ भी गलत हैं और "नहीं" कह रहे हैं कि हम 100% निराशावादी हैं। मुझे लगता है कि हमें नए से ज्यादा खुला होना चाहिए।
- या, उदाहरण के लिए, अगर लैरी पेज आपको कॉल करता है और कहता है, "अरे, Google एक्स की तरह एक शांत काम करें" और आपको कुछ बहुत अच्छा मिलता है!
- हाँ, यह सुनिश्चित करने के लिए, कोई शिकायत करने की जरूरत है! मेरा मतलब है, यह सब एक प्रक्रिया है जिसे लागू करने के तरीके पर बहुत चर्चा होती है। मैं काम करने के लिए वास्तव में भाग्यशाली हूं और मुझे इस पर गर्व है, Google X और अन्य परियोजनाओं पर।
- बहुत बढ़िया! तो, यह कोर्स TensorFlow के साथ काम करने के बारे में है। क्या आपके पास TensorFlow का उपयोग करने का अनुभव है या हो सकता है कि आप इसके साथ परिचित (सुने हुए) हों?
- हाँ! मैं सचमुच TensorFlow प्यार करता हूँ, ज़ाहिर है! मेरी अपनी प्रयोगशाला में, हम अक्सर और बहुत से उपयोग करते हैं, लगभग दो साल पहले TensorFlow पर आधारित सबसे महत्वपूर्ण कार्यों में से एक को जारी किया गया था। हमने सीखा कि दुनिया के सर्वश्रेष्ठ त्वचा विशेषज्ञों की तुलना में iPhone और Android त्वचा कैंसर का पता लगाने में अधिक प्रभावी हो सकते हैं। हमने नेचर में अपना शोध प्रकाशित किया और इसने चिकित्सा में एक तरह की हलचल पैदा की।
- यह अद्भुत लगता है! तो आप जानते हैं और TensorFlow से प्यार करते हैं, जो अपने आप में महान है! क्या आपने पहले से ही TensorFlow 2.0 के साथ काम किया है?
- नहीं, दुर्भाग्य से मेरे पास अभी तक समय नहीं है।
- वह सिर्फ अद्भुत होगा! इस पाठ्यक्रम के सभी छात्र इस संस्करण के साथ काम करेंगे।
- मैं उनसे ईर्ष्या करता हूं! मैं इसे जरूर आजमाऊंगा!
- बढ़िया! हमारे पाठ्यक्रम में बहुत सारे छात्र हैं जो अपने जीवन में "पूरी तरह से" शब्द से कभी मशीन सीखने में नहीं लगे हैं। उनके लिए, क्षेत्र नया हो सकता है, शायद किसी प्रोग्रामिंग के लिए खुद नया होगा। उनके लिए आपके पास क्या सलाह है?
- मैं उन्हें नए विचारों, तकनीकों, समाधानों, पदों के लिए खुला रहना चाहूंगा। मशीन लर्निंग वास्तव में प्रोग्रामिंग की तुलना में आसान है। प्रोग्रामिंग प्रक्रिया में, आपको स्रोत डेटा में प्रत्येक मामले को ध्यान में रखना होगा, इसके लिए प्रोग्राम लॉजिक और नियमों को अनुकूलित करना होगा। इस समय, TensorFlow और मशीन लर्निंग का उपयोग करते हुए, आप अनिवार्य रूप से उदाहरणों का उपयोग करते हुए कंप्यूटर को प्रशिक्षित करते हैं, जिससे कंप्यूटर को खुद ही नियम मिल जाते हैं।
- यह अविश्वसनीय रूप से दिलचस्प है! मैं इस पाठ्यक्रम में छात्रों को मशीन लर्निंग के बारे में कुछ और बताने का इंतजार नहीं कर सकता! सेबेस्टियन, आज हमारे पास आने के लिए समय निकालने के लिए धन्यवाद!
- धन्यवाद! संपर्क में रहें!

मशीन लर्निंग क्या है?

तो, चलिए निम्नलिखित कार्य के साथ शुरू करते हैं - दिए गए इनपुट और आउटपुट मान।



जब आपके पास इनपुट मान के रूप में मान 0 होता है, तो आउटपुट मान के रूप में 32। जब आपके पास इनपुट मूल्य के रूप में 8 होता है, तो आउटपुट मूल्य के रूप में 46.4 होता है। जब आपके पास इनपुट मूल्य के रूप में 15 है, तो आउटपुट मूल्य के रूप में 59, और इसी तरह।

इन मूल्यों पर एक करीब से नज़र डालें और मुझे आपसे एक प्रश्न पूछना चाहिए। क्या आप निर्धारित कर सकते हैं कि इनपुट पर 38 मिलने पर आउटपुट क्या होगा?



अगर आपने १००.४ का उत्तर दिया, तो आप सही थे!



तो, हम इस समस्या को कैसे हल कर सकते हैं? यदि आप मूल्यों को करीब से देखते हैं, तो आप देख सकते हैं कि वे अभिव्यक्ति से संबंधित हैं:



जहां सी - डिग्री सेल्सियस (इनपुट मान), एफ - फारेनहाइट (आउटपुट मान)।

आपके मस्तिष्क ने अभी क्या किया है - इनपुट मूल्यों और आउटपुट मानों की तुलना की और उनके बीच एक सामान्य मॉडल (कनेक्शन, निर्भरता) पाया - यह वही है जो सीखने योग्य बनाता है।

इनपुट और आउटपुट मानों के आधार पर, मशीन लर्निंग एल्गोरिदम आउटपुट मानों के लिए इनपुट मानों को परिवर्तित करने के लिए एक उपयुक्त एल्गोरिदम पाएंगे। इसे निम्नानुसार दर्शाया जा सकता है:



आइए एक उदाहरण देखें। कल्पना करें कि हम एक प्रोग्राम विकसित करना चाहते हैं जो डिग्री सेल्सियस को डिग्री Fahrenheit में सूत्र F = C * 1.8 + 32 का उपयोग करके परिवर्तित करेगा।



समाधान, जब पारंपरिक सॉफ्टवेयर विकास के दृष्टिकोण से आ रहा है, तो फ़ंक्शन का उपयोग करके किसी भी प्रोग्रामिंग भाषा में लागू किया जा सकता है:



तो हमारे पास क्या है? फ़ंक्शन सी का एक इनपुट मूल्य लेता है, फिर एक स्पष्ट एल्गोरिथ्म का उपयोग करके एफ के आउटपुट मूल्य की गणना करता है, और फिर गणना किए गए मूल्य को वापस करता है।



दूसरी ओर, मशीन सीखने के दृष्टिकोण में, हमारे पास केवल इनपुट और आउटपुट मान हैं, लेकिन एल्गोरिथ्म ही नहीं:



मशीन लर्निंग दृष्टिकोण इनपुट और आउटपुट मानों के बीच संबंध खोजने के लिए तंत्रिका नेटवर्क के उपयोग पर निर्भर करता है।



आप तंत्रिका नेटवर्क को परतों के ढेर के रूप में सोच सकते हैं, जिनमें से प्रत्येक में पहले से ज्ञात गणित (सूत्र) और आंतरिक चर शामिल हैं। इनपुट मान तंत्रिका नेटवर्क में प्रवेश करता है और न्यूरॉन्स की परतों के ढेर से गुजरता है। परतों से गुजरते समय, इनपुट मान को गणित (दिए गए सूत्र) और परतों के आंतरिक चर के मूल्यों के अनुसार परिवर्तित किया जाता है, एक आउटपुट मूल्य का उत्पादन करता है।

तंत्रिका नेटवर्क को इनपुट और आउटपुट मानों के बीच सही संबंध जानने और निर्धारित करने में सक्षम होने के लिए, हमें इसे प्रशिक्षित करने की आवश्यकता है - प्रशिक्षित करने के लिए।

हम आउटपुट मानों से इनपुट मानों के मिलान के लिए बार-बार प्रयास के माध्यम से तंत्रिका नेटवर्क को प्रशिक्षित करते हैं।



प्रशिक्षण की प्रक्रिया में, तंत्रिका नेटवर्क की परतों में आंतरिक चर के मूल्यों का "फिटिंग" (चयन) तब तक होता है जब तक नेटवर्क संबंधित आउटपुट मानों को संबंधित इनपुट मानों को उत्पन्न करने के लिए नहीं सीखता।

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



मशीन सीखने को समझने के सरलीकृत संस्करण के रूप में, आप मशीन लर्निंग एल्गोरिदम को उन कार्यों के रूप में कल्पना कर सकते हैं जो आंतरिक चर के मूल्यों का चयन करते हैं ताकि सही इनपुट मान सही आउटपुट मानों के अनुरूप हों।

कई प्रकार के तंत्रिका नेटवर्क आर्किटेक्चर हैं। हालांकि, कोई फर्क नहीं पड़ता कि आप किस आर्किटेक्चर को चुनते हैं, प्रशिक्षण के दौरान अंदर गणित (जो गणना की जाती है और किस क्रम में) अपरिवर्तित रहेगी। बदलते गणित के बजाय, आंतरिक चर (वजन और ऑफसेट) प्रशिक्षण के दौरान बदलते हैं।

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

लेकिन एक अच्छी बात सोचने वाली है! यदि आपने डिग्री सेल्सियस को फ़ारेनहाइट में परिवर्तित करने की समस्या को हल किया है, जो वीडियो में और नीचे दिए गए पाठ में इंगित किया गया है, तो आपने शायद इसे हल किया है क्योंकि आपके पास डिग्री सेल्सियस से फ़ारेनहाइट तक इस तरह के रूपांतरण को करने के बारे में कुछ पिछला अनुभव या ज्ञान था। उदाहरण के लिए, आप बस यह जान सकते हैं कि 0 डिग्री सेल्सियस 32 डिग्री फ़ारेनहाइट से मेल खाता है। दूसरी ओर, मशीन लर्निंग पर आधारित सिस्टम में समस्या को हल करने के लिए पिछला सहायक ज्ञान नहीं होता है। वे ऐसी समस्याओं को हल करना सीखते हैं जो पिछले ज्ञान पर आधारित न हों और उनकी पूर्ण अनुपस्थिति में हों।

पर्याप्त बात - व्याख्यान के व्यावहारिक भाग पर आगे बढ़ें!

कोलैब: डिग्री सेल्सियस को डिग्री फ़ारेनहाइट में परिवर्तित करें

CoLab स्रोत कोड का रूसी संस्करण और CoLab स्रोत कोड का अंग्रेजी संस्करण ।

मूल बातें: पहला मॉडल सीखना

CoLab में आपका स्वागत है, जहाँ हम अपने पहले मशीन लर्निंग मॉडल को प्रशिक्षित करेंगे!

हम प्रस्तुत सामग्री की सादगी को बनाए रखने और काम के लिए आवश्यक केवल मूल अवधारणाओं को पेश करने की कोशिश करेंगे। बाद के CoLabs में अधिक उन्नत तकनीकें होंगी।

जो कार्य हम हल करेंगे, वह डिग्री सेल्सियस से डिग्री फ़ारेनहाइट में परिवर्तित होता है। रूपांतरण सूत्र इस प्रकार है:

$$

$$f = c \ टाइम्स 1.8 + 32$$

बेशक, पाइथन या किसी अन्य प्रोग्रामिंग भाषा में रूपांतरण फ़ंक्शन लिखना आसान होगा, जो प्रत्यक्ष गणना करेगा, लेकिन इस मामले में यह मशीन सीखना नहीं होगा :)

इसके बजाय, हम TensorFlow इनपुट में हमारे उपलब्ध इनपुट डिग्री सेल्सियस (0, 8, 15, 22, 38) और उनके संगत फ़ारेनहाइट डिग्री (32, 46, 59, 72, 100) में फ़ीड करते हैं। फिर हम मॉडल को इस तरह से प्रशिक्षित करेंगे कि यह लगभग उपरोक्त सूत्र से मेल खाता है।

आयात निर्भरताएँ

पहली चीज जो हम आयात करते हैं वह है TensorFlow । यहाँ और निम्नलिखित में हम संक्षेप में इसे tf कहते हैं। हम लॉगिंग के स्तर को भी कॉन्फ़िगर करते हैं - केवल त्रुटियां।

अगला, NumPy को np रूप में आयात करें। Numpy हमें अपने डेटा को उच्च-प्रदर्शन लिस्टिंग के रूप में प्रस्तुत करने में मदद करता है।

 from __future__ import absolute_import, division, print_function, unicode_literals import tensorflow as tf tf.logging.set_verbosity(tf.logging.ERROR) import numpy as np 

प्रशिक्षण डेटा तैयार करना

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

 celsius_q = np.array([-40, -10, 0, 8, 15, 22, 38], dtype=float) fahrenheit_a = np.array([-40, 14, 32, 46, 59, 72, 100], dtype=float) for i,c in enumerate(celsius_q): print("{}   = {}  ".format(c, fahrenheit_a[i])) 

-40.0 = -40.0
-10.0 = 14.0
0.0 = 32.0
8.0 = 46.0
15.0 = 59.0
22.0 = 72.0
38.0 = 100.0

कुछ मशीन सीखने की शब्दावली:

• संपत्ति हमारे मॉडल का इनपुट मूल्य है। इस मामले में, इकाई मूल्य डिग्री सेल्सियस है।
• लेबल आउटपुट मान हैं जो हमारे मॉडल की भविष्यवाणी करते हैं। इस मामले में, इकाई मूल्य डिग्री फ़ारेनहाइट है।
• एक उदाहरण प्रशिक्षण के लिए उपयोग किए जाने वाले इनपुट-आउटपुट मानों की एक जोड़ी है। इस मामले में, यह एक निश्चित सूचकांक के तहत celsius_q और fahrenheit_a से मूल्यों की एक जोड़ी है, उदाहरण के लिए, (22,72)।

एक मॉडल बनाएं

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

एक नेटवर्क का निर्माण

हम लेयर l0 ( l अय्यर और ज़ीरो) को नाम देंगे और इसे tf.keras.layers.Dense को इनिशियलाइज़ करके tf.keras.layers.Dense । निम्न मापदंडों के साथ:

• input_shape=[1] - यह पैरामीटर इनपुट पैरामीटर के आयाम को निर्धारित करता है - एक एकल मान। एक मूल्य के साथ 1 × 1 मैट्रिक्स। चूंकि यह पहली (और केवल) परत है, इनपुट डेटा का आयाम पूरे मॉडल के आयाम से मेल खाता है। एकमात्र मान एक अस्थायी बिंदु मान है जो डिग्री सेल्सियस का प्रतिनिधित्व करता है।
• units=1 - यह पैरामीटर परत में न्यूरॉन्स की संख्या निर्धारित करता है। न्यूरॉन्स की संख्या निर्धारित करती है कि समस्या का हल खोजने के लिए प्रशिक्षण के लिए कितने आंतरिक परत चर का उपयोग किया जाएगा। चूंकि यह अंतिम परत है, इसलिए इसका आयाम परिणाम के आयाम के बराबर है - मॉडल का आउटपुट मूल्य - एक एकल फ़्लोटिंग-पॉइंट संख्या फ़ारेनहाइट का प्रतिनिधित्व करता है। (एक बहुपरत नेटवर्क में, input_shape परत का आकार और आकार, अगली परत के आकार और आकार से मेल खाना चाहिए)।

 l0 = tf.keras.layers.Dense(units=1, input_shape=[1]) 

परतों को मॉडल में बदलें

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

हमारे मॉडल में केवल एक परत है - l0 ।

 model = tf.keras.Sequential([l0]) 

टिप्पणी
अक्सर, आप अपने प्रारंभिक विवरण और उसके बाद के उपयोग के बजाय सीधे मॉडल फ़ंक्शन में परतों की परिभाषा का सामना करेंगे।

 model = tf.keras.Sequential([ tf.keras.layers.Dense(units=1, input_shape=[1]) ]) 

हम एक मॉडल को नुकसान और अनुकूलन फ़ंक्शन के साथ संकलित करते हैं

प्रशिक्षण से पहले, मॉडल को संकलित (इकट्ठा) किया जाना चाहिए। प्रशिक्षण के लिए संकलन करते समय, आपको आवश्यकता है:

• हानि फ़ंक्शन - यह मापने का एक तरीका है कि वांछित आउटपुट मूल्य से कितनी दूर की भविष्यवाणी की गई है (एक औसत दर्जे का अंतर "नुकसान" कहा जाता है)।
• अनुकूलन फ़ंक्शन - नुकसान को कम करने के लिए आंतरिक चर को समायोजित करने का एक तरीका।

 model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(0.1)) 

प्रत्येक फ़ंक्शन पर प्रारंभिक गणना करने के लिए हानि फ़ंक्शन और ऑप्टिमाइज़ेशन फ़ंक्शन का उपयोग मॉडल प्रशिक्षण ( model.fit(...) नीचे उल्लेख किया गया है) के दौरान किया जाता है और फिर मानों का अनुकूलन किया जाता है।

मौजूदा नुकसान की गणना और मॉडल में इन मूल्यों के बाद के सुधार की कार्रवाई वास्तव में प्रशिक्षण (एक पुनरावृत्ति) क्या है।

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

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

इन विकल्पों के बारे में जानने के लिए क्या उपयोगी है:

इस उदाहरण में उपयोग किए जाने वाले नुकसान फ़ंक्शन (मानक त्रुटि) और अनुकूलन फ़ंक्शन (एडम) ऐसे सरल मॉडल के लिए मानक हैं, लेकिन उनके अलावा कई अन्य उपलब्ध हैं। इस स्तर पर, हमें परवाह नहीं है कि ये कार्य कैसे करते हैं।

आपको अनुकूलन फ़ंक्शन पर ध्यान देना चाहिए और पैरामीटर learning rate गुणांक है, जो हमारे उदाहरण में 0.1 । चरों के आंतरिक मानों को समायोजित करते समय यह प्रयोग किया गया चरण आकार है। यदि मान बहुत छोटा है, तो मॉडल को प्रशिक्षित करने के लिए बहुत सारे प्रशिक्षण पुनरावृत्तियां लेंगे। बहुत अधिक - सटीकता बूँदें। सीखने की दर गुणांक के लिए एक अच्छा मूल्य खोजने के लिए कुछ परीक्षण और त्रुटि की आवश्यकता होती है, यह आमतौर पर 0.01 (डिफ़ॉल्ट रूप से) से 0.1 ।

हम मॉडल को प्रशिक्षित करते हैं

मॉडल का प्रशिक्षण fit विधि द्वारा किया जाता है।

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

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

 history = model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False) print("  ") 

निम्नलिखित वीडियो में, हम इस विवरण में डुबकी लगाएंगे कि यह सब कैसे काम करता है और पूरी तरह से जुड़े परतों ( Dense परतें) "हुड के नीचे" कैसे।

प्रशिक्षण आँकड़े प्रदर्शित करें

fit विधि एक ऐसी वस्तु लौटाती है जिसमें प्रत्येक बाद के पुनरावृत्ति के साथ नुकसान के बारे में जानकारी होती है। हम इस ऑब्जेक्ट का उपयोग एक उपयुक्त नुकसान शेड्यूल बनाने के लिए कर सकते हैं। उच्च हानि का मतलब है कि मॉडल द्वारा भविष्यवाणी की गई फ़ारेनहाइट डिग्री fahrenheit_a सरणी में सही मूल्यों से बहुत दूर हैं।

विज़ुअलाइज़ेशन के लिए, हम Matplotlib उपयोग Matplotlib । जैसा कि आप देख सकते हैं, हमारे मॉडल में बहुत शुरुआत में बहुत जल्दी सुधार होता है, और तब तक एक स्थिर और धीमी गति से सुधार आता है जब तक कि परिणाम प्रशिक्षण के बहुत अंत में "निकट" नहीं हो जाते।

 import matplotlib.pyplot as plt plt.xlabel('Epoch') plt.ylabel('Loss') plt.plot(history.history['loss']) 

हम भविष्यवाणियों के लिए मॉडल का उपयोग करते हैं।

अब हमारे पास एक मॉडल है जिसे उनके बीच के संबंधों को निर्धारित करने के लिए इनपुट वैल्यू celsius_q और आउटपुट वैल्यू fahrenheit_a पर प्रशिक्षित किया गया है। हम फारेनहाइट डिग्री की गणना करने के लिए भविष्यवाणी पद्धति का उपयोग कर सकते हैं जिसके द्वारा हम पहले संबंधित डिग्री सेल्सियस नहीं जानते थे।

उदाहरण के लिए, 100.0 डिग्री सेल्सियस फ़ारेनहाइट कितना है? नीचे दिए गए कोड को चलाने से पहले अनुमान लगाने का प्रयास करें।

 print(model.predict([100.0])) 

निष्कर्ष:

[[211.29639]]


सही उत्तर 100 × 1.8 + 32 = 212 है, इसलिए हमारे मॉडल ने बहुत अच्छा किया!

समीक्षा

• हमने Dense परत का उपयोग करके एक मॉडल बनाया।
• हमने उसे 3,500 उदाहरणों (7 जोड़े मूल्यों, 500 प्रशिक्षण पुनरावृत्तियों) के साथ प्रशिक्षित किया

हमारे मॉडल ने Dense परत में आंतरिक चर (भार) के मूल्यों को इस तरह समायोजित किया कि फारेनहाइट डिग्री के सही मानों को डिग्री सेल्सियस के मनमाने इनपुट मान पर वापस लौटाया जाए।

हम वजन को देखते हैं

चलो Dense परत के आंतरिक चर के मूल्यों को प्रदर्शित करते हैं।

 print("   : {}".format(l0.get_weights())) 

निष्कर्ष:

    : [array([[1.8261501]], dtype=float32), array([28.681389], dtype=float32)] 

पहले चर का मान ~ 1.8 और दूसरा ~ 32 के करीब है। ये मान (1.8 और 32) डिग्री सेल्सियस को डिग्री फ़ारेनहाइट में बदलने के सूत्र में प्रत्यक्ष मूल्य हैं।

यह वास्तव में सूत्र में वास्तविक मूल्यों के बहुत करीब है! हम बाद के वीडियो में इस बिंदु पर अधिक विस्तार से विचार करेंगे, जहां हम दिखाते हैं कि Dense परत कैसे काम करती है, लेकिन अब आपको केवल यह जानना होगा कि एकल इनपुट और आउटपुट वाले एक न्यूरॉन में सरल गणित होता है - y = mx + b (एक समीकरण के रूप में प्रत्यक्ष), जो डिग्री सेल्सियस को डिग्री फ़ारेनहाइट में बदलने के लिए हमारे सूत्र से ज्यादा कुछ नहीं है, f = 1.8c + 32 ।

चूंकि अभ्यावेदन समान हैं, इसलिए मॉडल के आंतरिक चर के मूल्यों को वास्तविक सूत्र में प्रस्तुत किए गए उन लोगों में परिवर्तित करना चाहिए, जो अंत में हुआ।

अतिरिक्त न्यूरॉन्स, अतिरिक्त इनपुट मूल्यों और आउटपुट मानों की उपस्थिति के साथ, सूत्र थोड़ा अधिक जटिल हो जाता है, लेकिन सार एक ही रहता है।

थोड़ा सा प्रयोग

मनोरंजन के लिए! यदि हम अधिक न्यूरॉन्स के साथ अधिक Dense परत बनाते हैं, तो बदले में अधिक आंतरिक चर शामिल होंगे तो क्या होगा?

 l0 = tf.keras.layers.Dense(units=4, input_shape=[1]) l1 = tf.keras.layers.Dense(units=4) l2 = tf.keras.layers.Dense(units=1) model = tf.keras.Sequential([l0, l1, l2]) model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(0.1)) model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False) print("  ") print(model.predict([100.0])) print(" ,  100    {}  ".format(model.predict([100.0]))) print("    l0: {}".format(l0.get_weights())) print("    l1: {}".format(l1.get_weights())) print("    l2: {}".format(l2.get_weights())) 

निष्कर्ष:

    [[211.74748]]  ,  100    [[211.74748]]       l0: [array([[-0.5972079 , -0.05531882, -0.00833384, -0.10636603]], dtype=float32), array([-3.0981746, -1.8776944, 2.4708805, -2.9092448], dtype=float32)]     l1: [array([[ 0.09127654, 1.1659832 , -0.61909443, 0.3422218 ], [-0.7377194 , 0.20082018, -0.47870865, 0.30302727], [-0.1370897 , -0.0667181 , -0.39285263, -1.1399261 ], [-0.1576551 , 1.1161333 , -0.15552482, 0.39256814]], dtype=float32), array([-0.94946504, -2.9903848 , 2.9848468 , -2.9061244 ], dtype=float32)]     l2: [array([[-0.13567649], [-1.4634581 ], [ 0.68370366], [-1.2069695 ]], dtype=float32), array([2.9170544], dtype=float32)] 

जैसा कि आपने देखा होगा कि वर्तमान मॉडल भी फ़ारेनहाइट की संगत डिग्री की भविष्यवाणी करने में सक्षम है। हालांकि, अगर हम परतों द्वारा न्यूरॉन्स के आंतरिक चर (भार) के मूल्यों को देखते हैं, तो हम 1.8 और 32 के समान कोई भी मान नहीं देखेंगे। मॉडल की अतिरिक्त जटिलता डिग्री सेल्सियस को डिग्री फ़ारेनहाइट में परिवर्तित करने के "सरल" रूप को छुपाती है।

जुड़े रहें और अगले भाग में हम देखेंगे कि घने परतें "हुड के नीचे" कैसे काम करती हैं।

संक्षिप्त सारांश

बधाई! आपने अभी-अभी अपना पहला मॉडल प्रशिक्षित किया है। व्यवहार में, हमने देखा कि कैसे इनपुट और आउटपुट मानों से, मॉडल ने इनपुट मूल्य को 1.8 से गुणा करना और सही परिणाम प्राप्त करने के लिए 32 को जोड़ना सीखा।



यह वास्तव में प्रभावशाली था, यह देखते हुए कि हमें लिखने के लिए कोड की कितनी लाइनें चाहिए:

 l0 = tf.keras.layers.Dense(units=1, input_shape=[1]) model = tf.keras.Sequential([l0]) model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(0.1)) history = model.fit(celsius_q, fahrenheit_a, epochs=500, verbose=False) model.predict([100.0]) 

उपरोक्त उदाहरण सभी मशीन लर्निंग प्रोग्राम के लिए एक सामान्य योजना है। आप तंत्रिका नेटवर्क बनाने और प्रशिक्षित करने और बाद की समस्याओं को हल करने के लिए समान निर्माण का उपयोग करेंगे।

प्रशिक्षण प्रक्रिया

प्रशिक्षण प्रक्रिया (विधि में जगह ले रही है model.fit(...)) में कार्यों का एक बहुत ही सरल अनुक्रम होता है, जिसके परिणाम मूल के जितना संभव हो सके परिणाम देने वाले आंतरिक चर के मूल्य होने चाहिए। अनुकूलन प्रक्रिया जिसके द्वारा ऐसे परिणाम प्राप्त किए जाते हैं, जिसे ढाल वंश कहा जाता है , मॉडल के आंतरिक चर के लिए सबसे उपयुक्त मूल्यों को खोजने के लिए संख्यात्मक विश्लेषण का उपयोग करता है।

मशीन लर्निंग में संलग्न होने के लिए, आपको, सिद्धांत रूप में, इन विवरणों को समझने की आवश्यकता नहीं है। लेकिन उन लोगों के लिए जो अभी भी अधिक सीखने में रुचि रखते हैं: पुनरावृत्तियों के माध्यम से ढाल वंशज मानों को थोड़ा बदल देता है, जब तक कि सर्वोत्तम परिणाम प्राप्त न हो, उन्हें सही दिशा में "खींच"। इस मामले में, "सर्वश्रेष्ठ परिणाम" (सर्वोत्तम मूल्य) का मतलब है कि पैरामीटर में कोई भी बाद में परिवर्तन केवल मॉडल के परिणाम को खराब करेगा। एक फ़ंक्शन जो मापता है कि प्रत्येक पुनरावृत्ति पर एक मॉडल कितना अच्छा या बुरा है, उसे "नुकसान फ़ंक्शन" कहा जाता है, और प्रत्येक "पुल" (आंतरिक मूल्यों का समायोजन) का लक्ष्य नुकसान फ़ंक्शन के मूल्य को कम करना है।

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

हमारे उदाहरण में, इनपुट मूल्य डिग्री सेल्सियस में तापमान है और मॉडल ने डिग्री फ़ारेनहाइट में इसी मूल्य की भविष्यवाणी की है।



जैसे ही मूल्य की भविष्यवाणी की जाती है, अनुमानित मूल्य और सही के बीच अंतर की गणना की जाती है। अंतर को "नुकसान" कहा जाता है और यह मापने का एक रूप है कि मॉडल ने कितनी अच्छी तरह काम किया। नुकसान मूल्य की गणना हानि फ़ंक्शन द्वारा की जाती है, जिसे हमने विधि को कॉल करते समय एक तर्क द्वारा निर्धारित किया था model.compile(...)।

नुकसान के मूल्य की गणना करने के बाद, तंत्रिका नेटवर्क की सभी परतों के आंतरिक चर (वजन और विस्थापन) को नुकसान के मूल्य को कम करने के लिए समायोजित किया जाता है ताकि आउटपुट मूल्य को सही प्रारंभिक संदर्भ मूल्य पर अनुमानित किया जा सके।



इस अनुकूलन प्रक्रिया को ग्रेडिएंट डिसेंट कहा जाता है । एक विशिष्ट अनुकूलन एल्गोरिथ्म का उपयोग प्रत्येक आंतरिक चर के लिए एक नए मूल्य की गणना करने के लिए किया जाता है जब विधि कहा जाता है model.compile(...)। उपरोक्त उदाहरण में, हमने एक अनुकूलन एल्गोरिथ्म का उपयोग किया Adam।

इस प्रक्रिया के लिए प्रशिक्षण प्रक्रिया के सिद्धांतों को समझना आवश्यक नहीं है, लेकिन यदि आप पर्याप्त उत्सुक हैं तो आप Google क्रैश कोर्स के बारे में अधिक जानकारी प्राप्त कर सकते हैं।(प्रकाशन के लिए लेखक की योजनाओं में अनुवाद और पूरे पाठ्यक्रम का व्यावहारिक हिस्सा निर्धारित किया गया है)।

इस बिंदु से, आपको पहले से ही निम्नलिखित शर्तों से परिचित होना चाहिए:

• संपत्ति : हमारे मॉडल का इनपुट मूल्य;
• उदाहरण : इनपुट + आउटपुट जोड़े;
• टैग : मॉडल आउटपुट मान;
• परतें : एक तंत्रिका नेटवर्क के भीतर नोड्स का एक संग्रह एक साथ शामिल हो गया;
• मॉडल : आपके तंत्रिका नेटवर्क का प्रतिनिधित्व;
• सघन और पूरी तरह से जुड़ा हुआ : एक परत में प्रत्येक नोड पिछली परत से प्रत्येक नोड से जुड़ा होता है।
• वज़न और ऑफ़सेट : मॉडल आंतरिक चर;
• नुकसान : वांछित आउटपुट मूल्य और मॉडल के वास्तविक आउटपुट मूल्य के बीच का अंतर;
• MSE : , , , .
• : , - ;
• : ;
• : «» ;
• : ;
• : ;
• : ;
• वापस प्रसार : आउटपुट परत से शुरू होने वाले अनुकूलन एल्गोरिथम के अनुसार आंतरिक चर के मूल्यों की गणना करना और सभी मध्यवर्ती परतों के माध्यम से इनपुट परत की ओर।

संवेदना की परतें

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

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



याद रखें कि एक तंत्रिका नेटवर्क को परतों के एक सेट के रूप में कल्पना की जा सकती है, जिनमें से प्रत्येक में न्यूरॉन्स नामक नोड्स होते हैं। प्रत्येक स्तर पर न्यूरॉन्स को प्रत्येक बाद की परत के न्यूरॉन्स से जोड़ा जा सकता है। परतों का प्रकार जिसमें एक परत का प्रत्येक न्यूरॉन अगली परत के एक-दूसरे न्यूरॉन से जुड़ा होता है, पूरी तरह से जुड़ा हुआ (पूरी तरह से जुड़ा हुआ) या घने परत ( Dense-लेयर) कहलाता है ।



इस प्रकार, जब हम पूरी तरह से कनेक्ट की गई परतों का उपयोग करते हैं, तो हम इस kerasतरह की सूचना देते हैं कि इस परत के न्यूरॉन्स को पिछली परत के सभी न्यूरॉन्स से जोड़ा जाना चाहिए।

उपरोक्त तंत्रिका नेटवर्क बनाने के लिए, निम्नलिखित अभिव्यक्तियाँ हमारे लिए पर्याप्त हैं:

 hidden = tf.keras.layers.Dense(units=2, input_shape=[3]) output = tf.keras.layers.Dense(units=1) model = tf.keras.Sequential([hidden, output]) 

इसलिए, हमें पता चला कि न्यूरॉन्स क्या हैं और वे कैसे संबंधित हैं। लेकिन पूरी तरह से जुड़ी हुई परतें वास्तव में कैसे काम करती हैं?

यह समझने के लिए कि वास्तव में वहां क्या हो रहा है और वे क्या कर रहे हैं, हमें "हुड के नीचे" देखने और न्यूरॉन्स के आंतरिक गणित को अलग करने की आवश्यकता है।



कल्पना कीजिए कि हमारे मॉडल को तीन पैरामीटर मिलते हैं - 1, 2, 3और 1, 2 3- हमारे नेटवर्क के न्यूरॉन्स। याद रखें कि हमने कहा था कि एक न्यूरॉन में आंतरिक चर होते हैं? तो, w * और b * एक न्यूरॉन के समान आंतरिक चर हैं, जिन्हें वज़न और विस्थापन के रूप में भी जाना जाता है। यह इन चरों के मान हैं जिन्हें इनपुट प्रक्रिया की आउटपुट से तुलना करने के सबसे सटीक परिणाम प्राप्त करने के लिए सीखने की प्रक्रिया में समायोजित किया जाता है।



आपको निश्चित रूप से ध्यान रखना चाहिए कि न्यूरॉन का आंतरिक गणित अपरिवर्तित रहता है । दूसरे शब्दों में, प्रशिक्षण प्रक्रिया के दौरान, केवल वजन और विस्थापन बदलते हैं ।

जब आप मशीन सीखना सीखना शुरू करते हैं, तो यह अजीब लग सकता है - यह तथ्य कि यह वास्तव में काम करता है, लेकिन यह है कि मशीन सीखना कैसे काम करता है!

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



एक एकल न्यूरॉन के साथ, हमारे पास केवल एक वजन और एक विस्थापन है। जानते हो क्या?यह वही है जो डिग्री सेल्सियस को डिग्री फ़ारेनहाइट में बदलने का सूत्र दिखता है। यदि हम w11मूल्य को प्रतिस्थापित करते हैं 1.8, और इसके बजाय b1- 32, हम अंतिम परिवर्तन मॉडल प्राप्त करते हैं!

यदि हम व्यावहारिक भाग से अपने मॉडल के परिणामों पर लौटते हैं, तो हम इस तथ्य पर ध्यान देते हैं कि वजन और विस्थापन के संकेतक इस तरह से "कैलिब्रेटेड" थे कि लगभग सूत्र से मूल्यों के अनुरूप हैं।

हमने स्पष्ट रूप से वजन और ऑफसेट के बीच सटीक तुलना दिखाने के लिए सिर्फ ऐसे व्यावहारिक उदाहरण का निर्माण किया। मशीन सीखने को अभ्यास में लाना, हम कभी भी इस तरह से लक्ष्य एल्गोरिथ्म के साथ चर के मूल्यों की तुलना नहीं कर सकते हैं, जैसा कि ऊपर दिए गए उदाहरण में किया गया है। हम यह कैसे कर सकते हैं? कोई रास्ता नहीं, क्योंकि हम लक्ष्य एल्गोरिथ्म भी नहीं जानते हैं!

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

संपर्क में रहें, क्योंकि अब मज़ा शुरू होता है!

परिणाम

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

... और मानक कॉल-टू-एक्शन - साइन अप करें, एक प्लस लगाएं और शेयर करें :)


YouTube: https://youtube.com/channel/ashmig
टेलीग्राम: https://t.me/ashmig
VK: https : // vkashashig