TensorFlow - त्वरित गाइड

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

TensorFlow की आधिकारिक वेबसाइट नीचे उल्लिखित है -

www.tensorflow.org

आइये अब TensorFlow की निम्नलिखित महत्वपूर्ण विशेषताओं पर विचार करते हैं -

  • इसमें उन विशेषताओं को शामिल किया गया है, जो टेनर्स नामक बहु-आयामी सरणियों की सहायता से गणितीय अभिव्यक्तियों को आसानी से परिभाषित और अनुकूलित करते हैं।

  • इसमें गहरे तंत्रिका नेटवर्क और मशीन सीखने की तकनीकों का प्रोग्रामिंग समर्थन शामिल है।

  • इसमें विभिन्न डेटा सेटों के साथ गणना की एक उच्च मापनीय सुविधा शामिल है।

  • TensorFlow GPU कंप्यूटिंग का उपयोग करता है, स्वचालित प्रबंधन। इसमें समान मेमोरी और उपयोग किए गए डेटा के अनुकूलन की एक अनूठी विशेषता भी शामिल है।

TensorFlow इतना लोकप्रिय क्यों है?

TensorFlow अच्छी तरह से प्रलेखित है और इसमें बहुत सारे मशीन लर्निंग लाइब्रेरी शामिल हैं। यह उसी के लिए कुछ महत्वपूर्ण कार्यात्मकता और तरीके प्रदान करता है।

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

TensorFlow स्थापित करने के लिए, आपके सिस्टम में "पायथन" स्थापित होना महत्वपूर्ण है। पायथन संस्करण 3.4+ को TensorFlow स्थापना के साथ शुरू करने के लिए सबसे अच्छा माना जाता है।

विंडोज ऑपरेटिंग सिस्टम में TensorFlow स्थापित करने के लिए निम्नलिखित चरणों पर विचार करें।

Step 1 - स्थापित किया जा रहा अजगर संस्करण सत्यापित करें।

Step 2- एक उपयोगकर्ता सिस्टम में TensorFlow स्थापित करने के लिए किसी भी तंत्र को चुन सकता है। हम "पाइप" और "एनाकोंडा" की सलाह देते हैं। पिप एक कमांड है जिसे पायथन में मॉड्यूल को निष्पादित करने और स्थापित करने के लिए उपयोग किया जाता है।

TensorFlow स्थापित करने से पहले, हमें अपने सिस्टम में एनाकोंडा फ्रेमवर्क स्थापित करना होगा।

सफल इंस्टॉलेशन के बाद, "कॉन्डा" कमांड के माध्यम से कमांड प्रॉम्प्ट में जांच करें। कमांड का निष्पादन नीचे प्रदर्शित किया गया है -

Step 3 - TensorFlow की स्थापना को आरंभ करने के लिए निम्नलिखित आदेश का पालन करें -

conda create --name tensorflow python = 3.5

यह TensorFlow सेटअप के लिए आवश्यक आवश्यक संकुल डाउनलोड करता है।

Step 4 - सफल पर्यावरण सेटअप के बाद, TensorFlow मॉड्यूल को सक्रिय करना महत्वपूर्ण है।

activate tensorflow

Step 5- सिस्टम में "Tensorflow" स्थापित करने के लिए पाइप का उपयोग करें। स्थापना के लिए उपयोग की जाने वाली कमांड निम्नानुसार है -

pip install tensorflow

तथा,

pip install tensorflow-gpu

सफल स्थापना के बाद, TensorFlow के नमूना कार्यक्रम के निष्पादन को जानना महत्वपूर्ण है।

निम्न उदाहरण हमें TensorFlow में "हैलो वर्ल्ड" के मूल कार्यक्रम निर्माण को समझने में मदद करता है।

पहले कार्यक्रम कार्यान्वयन के लिए कोड नीचे उल्लिखित है -

>> activate tensorflow
>> python (activating python shell)
>> import tensorflow as tf
>> hello = tf.constant(‘Hello, Tensorflow!’)
>> sess = tf.Session()
>> print(sess.run(hello))

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

मशीन लर्निंग आर्टिफिशियल इंटेलिजेंस की शाखा है, जो सिस्टम और एल्गोरिदम से संबंधित है जो किसी भी नए डेटा और डेटा पैटर्न को सीख सकते हैं।

आइए मशीन सीखने और गहरी सीखने की अवधारणाओं को समझने के लिए नीचे दिए गए Venn आरेख पर ध्यान दें।

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

उत्पादन को वांछनीय तरीके से दिखाने के लिए पैटर्न को प्रशिक्षित किया जाना चाहिए।

मशीन लर्निंग को दो अलग-अलग तरीकों से प्रशिक्षित किया जा सकता है -

  • प्रशिक्षण प्राप्त किया
  • अनसुनी प्रशिक्षण

पर्यवेक्षित अध्ययन

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

प्रशिक्षण पूरा होने के बाद, प्रत्येक मॉडल की सटीकता को प्रशिक्षण सेट से उदाहरणों को खारिज करने के संबंध में मापा जाता है, जिसे सत्यापन सेट भी कहा जाता है।

"सुपरवाइज्ड लर्निंग" को चित्रित करने के लिए सबसे अच्छा उदाहरण उन में शामिल जानकारी के साथ दी गई तस्वीरों का एक समूह है। यहां, उपयोगकर्ता नई तस्वीरों को पहचानने के लिए एक मॉडल को प्रशिक्षित कर सकता है।

अनसुचित शिक्षा

बिना पढ़े-लिखे सीखने या अनुपयोगी प्रशिक्षण में, प्रशिक्षण के उदाहरण शामिल हैं, जो सिस्टम द्वारा लेबल नहीं किए जाते हैं कि वे किस वर्ग के हैं। सिस्टम डेटा की तलाश करता है, जो सामान्य विशेषताओं को साझा करते हैं, और उन्हें आंतरिक ज्ञान सुविधाओं के आधार पर बदलते हैं। यह सीखने के एल्गोरिदम के प्रकार मूल रूप से क्लस्टरिंग समस्याओं में उपयोग किए जाते हैं।

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

TensorFlow में मूल एप्लिकेशन बनाने से पहले TensorFlow के लिए आवश्यक गणितीय अवधारणाओं को समझना महत्वपूर्ण है। गणित को किसी भी मशीन लर्निंग एल्गोरिदम का दिल माना जाता है। यह गणित की मुख्य अवधारणाओं की मदद से है, विशिष्ट मशीन लर्निंग एल्गोरिदम के लिए एक समाधान परिभाषित किया गया है।

वेक्टर

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

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

वेक्टर मॉडल का सचित्र प्रतिनिधित्व नीचे दिखाया गया है -

अदिश

स्केलर को एक आयामी वेक्टर के रूप में परिभाषित किया जा सकता है। स्केलर वे होते हैं, जिनमें केवल परिमाण और कोई दिशा नहीं होती है। स्केलर के साथ, हम केवल परिमाण के साथ चिंतित हैं।

स्केलर के उदाहरणों में बच्चों का वजन और ऊंचाई पैरामीटर शामिल हैं।

आव्यूह

मैट्रिक्स को बहुआयामी सरणियों के रूप में परिभाषित किया जा सकता है, जिन्हें पंक्तियों और स्तंभों के प्रारूप में व्यवस्थित किया जाता है। मैट्रिक्स का आकार पंक्ति की लंबाई और स्तंभ की लंबाई से परिभाषित होता है। निम्नलिखित आंकड़ा किसी भी निर्दिष्ट मैट्रिक्स का प्रतिनिधित्व दर्शाता है।

मैट्रिक्स का उल्लेख "m" ​​पंक्तियों और "n" कॉलम के साथ करें जैसा कि ऊपर उल्लेख किया गया है, मैट्रिक्स प्रतिनिधित्व "m * n मैट्रिक्स" के रूप में निर्दिष्ट किया जाएगा जो मैट्रिक्स की लंबाई को भी परिभाषित करता है।

गणितीय संगणना

इस खंड में, हम TensorFlow में विभिन्न गणितीय संगणनाओं के बारे में जानेंगे।

मेट्रिसेस का जोड़

दो या अधिक मेट्रिसेस का जुड़ाव संभव है अगर मैट्रिस एक ही आयाम के हों। इसके अलावा दिए गए स्थान के अनुसार प्रत्येक तत्व का जोड़ शामिल है।

मैट्रिस कैसे काम करता है, यह समझने के लिए निम्नलिखित उदाहरण पर विचार करें -

$$ उदाहरण: A = \ start {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B = \ start {bmatrix} 5 और 6 \\ 7 & 8 \ अंत {bmatrix} \: फिर \ _ A + B = \ start {bmatrix} 1 + 5 & 2 + 6 \\ 3 + 7 और 4 + 8 \ अंत {bmatrix} = \ start {bmatrix} 6 & 8 \\ 10 & 12 \ end {bmatrix}}

मेट्रिसेस का घटाव

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

$$ उदाहरण: A- \ start {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B- \ start {bmatrix} 5 & 6 \\ 7 & 8 \ अंत {bmatrix} \: तत्कालीन \ _: AB - शुरू करें {bmatrix} 1-5 & 2-6 \\ 3-7 & 4-8 \ end {bmatrix} - \ start {bmatrix} -4 & -4 \\ - 4 & -4 \ end {bmatrix} $$

मैट्रिस का गुणन

दो मेट्रिसेस के लिए एक m * n और B p * q को गुणा करने के लिए, n के बराबर होना चाहिए p। परिणामी मैट्रिक्स है -

सी एम * क्यू

$$ A = \ start {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} B = \ start {bmatrix} 5 और 6 \\ 7 & 8 \ अंत {bmatrix} $$

$$ c_ {11} = \ start {bmatrix} 1 & 2 \ end {bmatrix} \ start {bmatrix} 5 \\ 7 \ end {bmatrix} = 1 \ times5 + 2 \ times7 = 19 \ _ c_ {12} = \ start {bmatrix} 1 & 2 \ end {bmatrix} \ start {bmatrix} 6 \\ 8 \ अंत {bmatrix} = 1 \ times6 + 2 \ times8 = 22 $ $

$$ c_ {21} = \ start {bmatrix} 3 & 4 \ end {bmatrix} \ start {bmatrix} 5 \\ 7 \ end {bmatrix} = 3 \ times5 + 4 \ times7 = 43 \ _ c_ {22} = \ start {bmatrix} 3 & 4 \ end {bmatrix} \ start {bmatrix} 6 \\ 8 \ अंत {bmatrix} = 3 \ times6 + 4 \ times8 = 50 $ $

$ $ C = \ start {bmatrix} c_ {11} & c_ {12} \\ c_ {21} & c_ {22} \ end {bmatrix} = \ start {bmatrix} 19 & 22 \\ 43 और 50 \ अंत {} bmatrix $$

मैट्रिक्स का संक्रमण

मैट्रिक्स A, m * n का संक्रमण आमतौर पर AT (transpose) n * m द्वारा दर्शाया जाता है और स्तंभ वैक्टर को पंक्ति वैक्टर के रूप में स्थानांतरित करके प्राप्त किया जाता है।

$$ उदाहरण: A = \ start {bmatrix} 1 & 2 \\ 3 & 4 \ end {bmatrix} \: तत्पश्चात \ _ A ^ {T} \ start {bmatrix} 1 & 3 \\ 2 & 4 \ end { bmatrix} $$

वैक्टर के डॉट उत्पाद

आयाम n के किसी भी वेक्टर को मैट्रिक्स v = R ^ n * 1 के रूप में दर्शाया जा सकता है।

$$ v_ {1} = \ start {bmatrix} v_ {11} \\ v_ {12} \\ cdot \\\ cdot \\\ cdot \\ v_ {1n} \ end {bmatrix, v_ {2} = = \ start {bmatrix} v_ {21} \\ v_ {22} \\\ cdot \\\ cdot \\\ cdot \\ vdot {END 2 \ _n} \ end {bmatrix} $ $

दो वैक्टर का डॉट उत्पाद संगत घटकों के उत्पाद का योग है - समान आयाम के साथ घटक और के रूप में व्यक्त किया जा सकता है

$ $ v_ {1} \ cdot v_ {2} = v_1 ^ Tv_ {2} = v_2 ^ Tv_ {1} = v_ {11} v_ {21} + v_ {12} v_ {22 = + \ _ cdot + cdot + v_ {1n} v_ {2n} = \ displaystyle \ sum \ limit_ {k = 1} ^ n v_ {1k} v_ {2k} $ $

वैक्टर के डॉट उत्पाद का उदाहरण नीचे दिया गया है -

$$ उदाहरण: v_ {1} = \ start {bmatrix} 1 \\ 2 \\ 3 \ end {bmatrix} v_ {2} = \ start {bmatrix} 3 \\ 5 \\ - 1 \ end {bmatrix} v_ {1} \ cdot v_ {2} = v_1 ^ Tv_ {2} = 1 \ times3 + 2 \ times5-3 \ times1 = १० $

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

मशीन लर्निंग

मशीन लर्निंग, डिजाइन और प्रोग्राम किए गए एल्गोरिदम के अनुसार कंप्यूटर को प्राप्त करने की विज्ञान की कला है। कई शोधकर्ता सोचते हैं कि मशीन लर्निंग मानव-स्तरीय AI की दिशा में प्रगति करने का सबसे अच्छा तरीका है। मशीन लर्निंग में निम्न प्रकार के पैटर्न शामिल हैं

  • सुपरवाइज्ड लर्निंग पैटर्न
  • अनसुचित शिक्षण पैटर्न

ध्यान लगा के पढ़ना या सीखना

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

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

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

मशीन लर्निंग प्रक्रिया को परिभाषित करने वाले निम्नलिखित चरणों पर विचार करें

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

मशीन लर्निंग और डीप लर्निंग में अंतर

इस खंड में, हम मशीन लर्निंग और डीप लर्निंग के बीच अंतर के बारे में जानेंगे।

डाटा की मात्रा

मशीन लर्निंग बड़ी मात्रा में डेटा के साथ काम करता है। यह छोटी मात्रा में डेटा के लिए भी उपयोगी है। दूसरी ओर डीप लर्निंग कुशलता से काम करता है अगर डेटा की मात्रा तेजी से बढ़ती है। निम्नलिखित आरेख मशीन सीखने और डेटा की मात्रा के साथ गहन सीखने का काम दिखाता है -

हार्डवेयर निर्भरताएँ

डीप लर्निंग एल्गोरिदम को पारंपरिक मशीन लर्निंग एल्गोरिदम के विपरीत उच्च अंत मशीनों पर बहुत अधिक निर्भर करने के लिए डिज़ाइन किया गया है। डीप लर्निंग एल्गोरिदम कई मैट्रिक्स गुणा ऑपरेशन करते हैं, जिसमें बड़ी मात्रा में हार्डवेयर समर्थन की आवश्यकता होती है।

फ़ीचर इंजीनियरिंग

फ़ीचर इंजीनियरिंग डेटा की जटिलता को कम करने के लिए निर्दिष्ट ज्ञान में डोमेन ज्ञान डालने की प्रक्रिया है और यह काम करने वाले एल्गोरिदम सीखने के लिए दिखाई देने वाले पैटर्न बनाते हैं।

उदाहरण - पारंपरिक मशीन लर्निंग पैटर्न पिक्सेल और अन्य विशेषताओं पर ध्यान केंद्रित करते हैं जो कि फीचर इंजीनियरिंग प्रक्रिया के लिए आवश्यक हैं। डीप लर्निंग एल्गोरिदम डेटा से उच्च-स्तरीय सुविधाओं पर ध्यान केंद्रित करता है। यह हर नई समस्या के नए फीचर एक्सट्रैक्टर को विकसित करने के कार्य को कम करता है।

समस्या का समाधान दृष्टिकोण

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

निष्पादन समय

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

विवेचनीयता

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

मशीन लर्निंग और डीप लर्निंग के अनुप्रयोग

इस खंड में, हम मशीन लर्निंग और डीप लर्निंग के विभिन्न अनुप्रयोगों के बारे में जानेंगे।

  • कंप्यूटर दृष्टि जिसका उपयोग चेहरे की पहचान और उपस्थिति चिह्न के लिए उंगलियों के निशान या वाहन पहचान के माध्यम से नंबर प्लेट के माध्यम से किया जाता है।

  • छवि खोज के लिए पाठ खोज जैसे खोज इंजन से सूचना पुनर्प्राप्ति।

  • निर्दिष्ट लक्ष्य पहचान के साथ स्वचालित ईमेल विपणन।

  • किसी भी पुरानी बीमारी के कैंसर के ट्यूमर या विसंगति की चिकित्सा निदान।

  • फोटो टैगिंग जैसे अनुप्रयोगों के लिए प्राकृतिक भाषा प्रसंस्करण। इस परिदृश्य को समझाने के लिए सबसे अच्छा उदाहरण फेसबुक में उपयोग किया जाता है।

  • ऑनलाइन प्रचार।

भविष्य के रुझान

  • उद्योग में डेटा विज्ञान और मशीन सीखने का उपयोग करने की बढ़ती प्रवृत्ति के साथ, प्रत्येक संगठन के लिए अपने व्यवसायों में मशीन सीखने को प्रोत्साहित करना महत्वपूर्ण हो जाएगा।

  • डीप लर्निंग मशीन लर्निंग की तुलना में अधिक महत्व प्राप्त कर रहा है। डीप लर्निंग अत्याधुनिक प्रदर्शन में सर्वश्रेष्ठ तकनीकों में से एक साबित हो रही है।

  • मशीन लर्निंग और डीप लर्निंग अनुसंधान और शिक्षाविदों के क्षेत्र में फायदेमंद साबित होगी।

निष्कर्ष

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

इस अध्याय में, हम TensorFlow की मूल बातों के बारे में जानेंगे। हम टेंसर की डेटा संरचना को समझने के द्वारा शुरू करेंगे।

टेंसर डेटा स्ट्रक्चर

TensorFlow भाषा में मूल डेटा संरचनाओं के रूप में Tensors का उपयोग किया जाता है। सेंसर डेटा फ्लो ग्राफ नामक किसी भी प्रवाह आरेख में कनेक्टिंग किनारों का प्रतिनिधित्व करते हैं। सेंसर को बहुआयामी सरणी या सूची के रूप में परिभाषित किया गया है।

सेंसर की पहचान निम्नलिखित तीन मापदंडों से होती है -

पद

टेंसर के भीतर वर्णित आयामीता की इकाई को रैंक कहा जाता है। यह टेंसर के आयामों की संख्या की पहचान करता है। किसी टेंसर की एक रैंक को एक टेंसर परिभाषित के क्रम या एन-आयाम के रूप में वर्णित किया जा सकता है।

आकार

पंक्तियों और स्तंभों की संख्या एक साथ Tensor के आकार को परिभाषित करते हैं।

प्रकार

प्रकार Tensor के तत्वों को निर्दिष्ट डेटा प्रकार का वर्णन करता है।

एक उपयोगकर्ता को Tensor के निर्माण के लिए निम्नलिखित गतिविधियों पर विचार करने की आवश्यकता है -

  • एक एन-आयामी सरणी बनाएँ
  • एन-आयामी सरणी में कनवर्ट करें।

TensorFlow के विभिन्न आयाम

TensorFlow में विभिन्न आयाम शामिल हैं। आयाम नीचे दिए गए हैं -

एक आयामी टेन्सर

एक आयामी टेंसर एक सामान्य सरणी संरचना है जिसमें समान डेटा प्रकार के मूल्यों का एक सेट शामिल है।

Declaration

>>> import numpy as np
>>> tensor_1d = np.array([1.3, 1, 4.0, 23.99])
>>> print tensor_1d

आउटपुट के साथ कार्यान्वयन नीचे स्क्रीनशॉट में दिखाया गया है -

तत्वों की अनुक्रमणिका पायथन सूची के समान है। पहला तत्व 0 के सूचकांक से शुरू होता है; सूचकांक के माध्यम से मूल्यों को मुद्रित करने के लिए, आपको केवल सूचकांक संख्या का उल्लेख करना होगा।

>>> print tensor_1d[0]
1.3
>>> print tensor_1d[2]
4.0

दो आयामी सेंसर

सरणियों का अनुक्रम "दो आयामी टेनर्स" बनाने के लिए उपयोग किया जाता है।

द्वि-आयामी टेंसरों का निर्माण नीचे वर्णित है -

निम्नलिखित दो आयामी सरणियों के निर्माण का पूरा सिंटैक्स है -

>>> import numpy as np
>>> tensor_2d = np.array([(1,2,3,4),(4,5,6,7),(8,9,10,11),(12,13,14,15)])
>>> print(tensor_2d)
[[ 1 2 3 4]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
>>>

दो आयामी टेंसरों के विशिष्ट तत्वों को सूचकांक संख्या के रूप में निर्दिष्ट पंक्ति संख्या और स्तंभ संख्या की सहायता से ट्रैक किया जा सकता है।

>>> tensor_2d[3][2]
14

टेंसर हैंडलिंग और जोड़तोड़

इस खंड में, हम Tensor हैंडलिंग और जोड़तोड़ के बारे में जानेंगे।

शुरू करने के लिए, हमें निम्नलिखित कोड पर विचार करना चाहिए -

import tensorflow as tf
import numpy as np

matrix1 = np.array([(2,2,2),(2,2,2),(2,2,2)],dtype = 'int32')
matrix2 = np.array([(1,1,1),(1,1,1),(1,1,1)],dtype = 'int32')

print (matrix1)
print (matrix2)

matrix1 = tf.constant(matrix1)
matrix2 = tf.constant(matrix2)
matrix_product = tf.matmul(matrix1, matrix2)
matrix_sum = tf.add(matrix1,matrix2)
matrix_3 = np.array([(2,7,2),(1,4,2),(9,0,2)],dtype = 'float32')
print (matrix_3)

matrix_det = tf.matrix_determinant(matrix_3)
with tf.Session() as sess:
   result1 = sess.run(matrix_product)
   result2 = sess.run(matrix_sum)
   result3 = sess.run(matrix_det)

print (result1)
print (result2)
print (result3)

Output

उपरोक्त कोड निम्नलिखित आउटपुट उत्पन्न करेगा -

व्याख्या

हमने उपरोक्त स्रोत कोड में बहुआयामी सरणियाँ बनाई हैं। अब, यह समझना महत्वपूर्ण है कि हमने ग्राफ़ और सत्र बनाए, जो कि सेंसर का प्रबंधन करते हैं और उचित आउटपुट उत्पन्न करते हैं। ग्राफ की मदद से, हमारे पास Tensors के बीच गणितीय गणना को निर्दिष्ट करने वाला आउटपुट है।

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

निम्नलिखित दो महत्वपूर्ण प्रकार के गहरे तंत्रिका नेटवर्क हैं -

  • संवादी तंत्रिका नेटवर्क
  • आवर्तक तंत्रिका नेटवर्क

इस अध्याय में, हम सीएनएन, कन्वेंशनल न्यूरल नेटवर्क्स पर ध्यान केंद्रित करेंगे।

संवादी तंत्रिका नेटवर्क

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

सीएनएन के प्रमुख दृष्टिकोण में मान्यता की समस्याओं के समाधान शामिल हैं। Google और Facebook जैसी शीर्ष कंपनियों ने मान्यता परियोजनाओं के लिए अनुसंधान और विकास में निवेश किया है ताकि अधिक गति के साथ गतिविधियां हो सकें।

एक दृढ़ तंत्रिका नेटवर्क तीन बुनियादी विचारों का उपयोग करता है -

  • स्थानीय संबंधित क्षेत्र
  • Convolution
  • Pooling

आइये इन विचारों को विस्तार से समझते हैं।

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

निम्नलिखित स्थानीय संबंधित क्षेत्रों को उत्पन्न करने का एक आरेखीय प्रतिनिधित्व है -

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

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

CNN या कन्वेन्शनल न्यूरल नेटवर्क पूलिंग लेयर्स का उपयोग करते हैं, जो कि लेयर हैं, CNN डिक्लेरेशन के तुरंत बाद पोस्ट की जाती हैं। यह उपयोगकर्ता से इनपुट को एक फ़ीचर मैप के रूप में लेता है जो कनवल्शन नेटवर्क से निकलता है और एक कंडेंस्ड फ़ीचर मैप तैयार करता है। पूलिंग परतें पिछली परतों के न्यूरॉन्स के साथ परत बनाने में मदद करती हैं।

TensorFlow CNN का कार्यान्वयन

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

Step 1 - TensorFlow के लिए आवश्यक मॉड्यूल और डेटा सेट मॉड्यूल शामिल करें, जिन्हें CNN मॉडल की गणना करने की आवश्यकता होती है।

import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

Step 2 - नामक एक समारोह की घोषणा run_cnn(), जिसमें डेटा प्लेसहोल्डर की घोषणा के साथ विभिन्न पैरामीटर और अनुकूलन चर शामिल हैं। ये अनुकूलन चर प्रशिक्षण पैटर्न की घोषणा करेंगे।

def run_cnn():
   mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)
   learning_rate = 0.0001
   epochs = 10
   batch_size = 50

Step 3 - इस चरण में, हम इनपुट मापदंडों के साथ प्रशिक्षण डेटा प्लेसहोल्डर्स की घोषणा करेंगे - 28 x 28 पिक्सल = 784 के लिए। यह चपटा छवि डेटा है जो इससे खींचा गया है mnist.train.nextbatch()।

हम अपनी आवश्यकताओं के अनुसार टेंसर को फिर से खोल सकते हैं। पहला मान (-1) फ़ंक्शन को गतिशील रूप से आकार देने के लिए कहता है जो कि उस पर दिए गए डेटा की मात्रा के आधार पर आयाम है। दो मध्य आयाम छवि आकार (यानी 28 x 28) पर सेट हैं।

x = tf.placeholder(tf.float32, [None, 784])
x_shaped = tf.reshape(x, [-1, 28, 28, 1])
y = tf.placeholder(tf.float32, [None, 10])

Step 4 - अब कुछ महत्वपूर्ण परतें बनाना महत्वपूर्ण है -

layer1 = create_new_conv_layer(x_shaped, 1, 32, [5, 5], [2, 2], name = 'layer1')
layer2 = create_new_conv_layer(layer1, 32, 64, [5, 5], [2, 2], name = 'layer2')

Step 5- हम पूरी तरह से जुड़े आउटपुट चरण के लिए तैयार आउटपुट को समतल करते हैं - 28 x 28 के आयामों के साथ 2 पूलिंग की दो परतों के बाद, 14 x 14 या न्यूनतम 7 x 7 x के आयाम के लिए, y सह-निर्देशांक, लेकिन 64 के साथ आउटपुट चैनल। "घने" परत के साथ पूरी तरह से जुड़ा हुआ बनाने के लिए, नए आकार को [-1, 7 x 7 x 64] होना चाहिए। हम इस परत के लिए कुछ वज़न और पूर्वाग्रह मान सेट कर सकते हैं, फिर ReLU के साथ सक्रिय कर सकते हैं।

flattened = tf.reshape(layer2, [-1, 7 * 7 * 64])

wd1 = tf.Variable(tf.truncated_normal([7 * 7 * 64, 1000], stddev = 0.03), name = 'wd1')
bd1 = tf.Variable(tf.truncated_normal([1000], stddev = 0.01), name = 'bd1')

dense_layer1 = tf.matmul(flattened, wd1) + bd1
dense_layer1 = tf.nn.relu(dense_layer1)

Step 6 - आवश्यक ऑप्टिमाइज़र के साथ विशिष्ट सॉफ्टमैक्स सक्रियण के साथ एक और परत सटीकता मूल्यांकन को परिभाषित करती है, जो आरंभीकरण ऑपरेटर का सेटअप बनाती है।

wd2 = tf.Variable(tf.truncated_normal([1000, 10], stddev = 0.03), name = 'wd2')
bd2 = tf.Variable(tf.truncated_normal([10], stddev = 0.01), name = 'bd2')

dense_layer2 = tf.matmul(dense_layer1, wd2) + bd2
y_ = tf.nn.softmax(dense_layer2)

cross_entropy = tf.reduce_mean(
   tf.nn.softmax_cross_entropy_with_logits(logits = dense_layer2, labels = y))

optimiser = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

init_op = tf.global_variables_initializer()

Step 7- हमें रिकॉर्डिंग चर सेट करना चाहिए। यह डेटा की सटीकता को संग्रहीत करने के लिए एक सारांश जोड़ता है।

tf.summary.scalar('accuracy', accuracy)
   merged = tf.summary.merge_all()
   writer = tf.summary.FileWriter('E:\TensorFlowProject')
   
   with tf.Session() as sess:
      sess.run(init_op)
      total_batch = int(len(mnist.train.labels) / batch_size)
      
      for epoch in range(epochs):
         avg_cost = 0
      for i in range(total_batch):
         batch_x, batch_y = mnist.train.next_batch(batch_size = batch_size)
            _, c = sess.run([optimiser, cross_entropy], feed_dict = {
            x:batch_x, y: batch_y})
            avg_cost += c / total_batch
         test_acc = sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
            summary = sess.run(merged, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
         writer.add_summary(summary, epoch)

   print("\nTraining complete!")
   writer.add_graph(sess.graph)
   print(sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
      mnist.test.labels}))

def create_new_conv_layer(
   input_data, num_input_channels, num_filters,filter_shape, pool_shape, name):

   conv_filt_shape = [
      filter_shape[0], filter_shape[1], num_input_channels, num_filters]

   weights = tf.Variable(
      tf.truncated_normal(conv_filt_shape, stddev = 0.03), name = name+'_W')
   bias = tf.Variable(tf.truncated_normal([num_filters]), name = name+'_b')

#Out layer defines the output
   out_layer =
      tf.nn.conv2d(input_data, weights, [1, 1, 1, 1], padding = 'SAME')

   out_layer += bias
   out_layer = tf.nn.relu(out_layer)
   ksize = [1, pool_shape[0], pool_shape[1], 1]
   strides = [1, 2, 2, 1]
   out_layer = tf.nn.max_pool(
      out_layer, ksize = ksize, strides = strides, padding = 'SAME')

   return out_layer

if __name__ == "__main__":
run_cnn()

निम्नलिखित कोड द्वारा उत्पन्न आउटपुट है -

See @{tf.nn.softmax_cross_entropy_with_logits_v2}.

2018-09-19 17:22:58.802268: I
T:\src\github\tensorflow\tensorflow\core\platform\cpu_feature_guard.cc:140]
Your CPU supports instructions that this TensorFlow binary was not compiled to
use: AVX2

2018-09-19 17:25:41.522845: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

2018-09-19 17:25:44.630941: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 501760000 exceeds 10% of system memory.

Epoch: 1 cost = 0.676 test accuracy: 0.940

2018-09-19 17:26:51.987554: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

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

एक आवर्ती तंत्रिका नेटवर्क को प्रशिक्षित करने के लिए निम्नलिखित चरणों पर विचार करें -

Step 1 - डेटासेट से एक विशिष्ट उदाहरण इनपुट करें।

Step 2 - नेटवर्क एक उदाहरण लेगा और बेतरतीब ढंग से आरंभिक चर का उपयोग करके कुछ गणनाओं की गणना करेगा।

Step 3 - एक अनुमानित परिणाम तब गणना की जाती है।

Step 4 - अपेक्षित मूल्य के साथ उत्पन्न वास्तविक परिणाम की तुलना एक त्रुटि पैदा करेगी।

Step 5 - त्रुटि का पता लगाने के लिए, इसे उसी पथ के माध्यम से प्रचारित किया जाता है जहां चर भी समायोजित किए जाते हैं।

Step 6 - 1 से 5 तक के चरणों को दोहराया जाता है जब तक हम आश्वस्त नहीं होते कि आउटपुट प्राप्त करने के लिए घोषित चर ठीक से परिभाषित हैं।

Step 7 - नया अनदेखा इनपुट प्राप्त करने के लिए इन चर को लागू करके एक व्यवस्थित भविष्यवाणी की जाती है।

आवर्तक तंत्रिका नेटवर्क का प्रतिनिधित्व करने का योजनाबद्ध तरीका नीचे वर्णित है -

TensorFlow के साथ आवर्तक तंत्रिका नेटवर्क कार्यान्वयन

इस खंड में, हम सीखेंगे कि TensorFlow के साथ आवर्तक तंत्रिका नेटवर्क को कैसे लागू किया जाए।

Step 1 - TensorFlow में आवर्तक तंत्रिका नेटवर्क मॉड्यूल के विशिष्ट कार्यान्वयन के लिए विभिन्न पुस्तकालय शामिल हैं।

#Import necessary modules
from __future__ import print_function

import tensorflow as tf
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)

जैसा कि ऊपर उल्लेख किया गया है, पुस्तकालय इनपुट डेटा को परिभाषित करने में मदद करते हैं, जो आवर्तक तंत्रिका नेटवर्क कार्यान्वयन का प्राथमिक हिस्सा बनता है।

Step 2- हमारा प्राथमिक उद्देश्य एक आवर्तक तंत्रिका नेटवर्क का उपयोग करके छवियों को वर्गीकृत करना है, जहां हम प्रत्येक छवि पंक्ति को पिक्सेल के अनुक्रम के रूप में मानते हैं। MNIST छवि आकृति को विशेष रूप से 28 * 28 px के रूप में परिभाषित किया गया है। अब हम प्रत्येक नमूने के लिए 28 चरणों के 28 अनुक्रमों का उल्लेख करेंगे। हम अनुक्रमिक पैटर्न को पूरा करने के लिए इनपुट मापदंडों को परिभाषित करेंगे।

n_input = 28 # MNIST data input with img shape 28*28
n_steps = 28
n_hidden = 128
n_classes = 10

# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_classes]
weights = {
   'out': tf.Variable(tf.random_normal([n_hidden, n_classes]))
}
biases = {
   'out': tf.Variable(tf.random_normal([n_classes]))
}

Step 3- सर्वोत्तम परिणाम प्राप्त करने के लिए RNN में परिभाषित फ़ंक्शन का उपयोग करके परिणामों की गणना करें। यहां, प्रत्येक डेटा आकार की वर्तमान इनपुट आकार के साथ तुलना की जाती है और सटीकता दर को बनाए रखने के लिए परिणामों की गणना की जाती है।

def RNN(x, weights, biases):
   x = tf.unstack(x, n_steps, 1)

   # Define a lstm cell with tensorflow
   lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)

   # Get lstm cell output
   outputs, states = rnn.static_rnn(lstm_cell, x, dtype = tf.float32)

   # Linear activation, using rnn inner loop last output
   return tf.matmul(outputs[-1], weights['out']) + biases['out']

pred = RNN(x, weights, biases)

# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = pred, labels = y))
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)

# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# Initializing the variables
init = tf.global_variables_initializer()

Step 4- इस चरण में, हम कम्प्यूटेशनल परिणाम प्राप्त करने के लिए ग्राफ लॉन्च करेंगे। यह परीक्षण परिणामों के लिए सटीकता की गणना करने में भी मदद करता है।

with tf.Session() as sess:
   sess.run(init)
   step = 1
   # Keep training until reach max iterations
   
   while step * batch_size < training_iters:
      batch_x, batch_y = mnist.train.next_batch(batch_size)
      batch_x = batch_x.reshape((batch_size, n_steps, n_input))
      sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
      
      if step % display_step == 0:
         # Calculate batch accuracy
         acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})
         
         # Calculate batch loss
         loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})
         
         print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
            "{:.6f}".format(loss) + ", Training Accuracy= " + \
            "{:.5f}".format(acc))
      step += 1
   print("Optimization Finished!")
      test_len = 128
   test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
   
   test_label = mnist.test.labels[:test_len]
   print("Testing Accuracy:", \
      sess.run(accuracy, feed_dict={x: test_data, y: test_label}))

नीचे दिए गए स्क्रीनशॉट से उत्पन्न आउटपुट दिखाते हैं -

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

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

निम्न योजनाबद्ध आरेख प्रतिनिधित्व, TensorBoard विज़ुअलाइज़ेशन के पूर्ण कार्य को दर्शाता है -

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

हमें निम्न कोड की मदद से TensorBoard विज़ुअलाइज़ेशन के डेमो उदाहरण पर ध्यान दें -

import tensorflow as tf 

# Constants creation for TensorBoard visualization 
a = tf.constant(10,name = "a") 
b = tf.constant(90,name = "b") 
y = tf.Variable(a+b*2,name = 'y') 
model = tf.initialize_all_variables() #Creation of model 

with tf.Session() as session: 
   merged = tf.merge_all_summaries() 
   writer = tf.train.SummaryWriter("/tmp/tensorflowlogs",session.graph) 
   session.run(model) 
   print(session.run(y))

निम्न तालिका नोड प्रतिनिधित्व के लिए इस्तेमाल किए गए TensorBoard विज़ुअलाइज़ेशन के विभिन्न प्रतीकों को दिखाती है -

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

शब्द एम्बेडिंग के इनपुट का नमूना चित्रण नीचे दिखाया गया है -

blue: (0.01359, 0.00075997, 0.24608, ..., -0.2524, 1.0048, 0.06259)
blues: (0.01396, 0.11887, -0.48963, ..., 0.033483, -0.10007, 0.1158)
orange: (-0.24776, -0.12359, 0.20986, ..., 0.079717, 0.23865, -0.014213)
oranges: (-0.35609, 0.21854, 0.080944, ..., -0.35413, 0.38511, -0.070976)

Word2vec

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

TensorFlow इस तरह के मॉडल को परिष्कार और अनुकूलन के बढ़ते स्तर और मल्टीथ्रेडिंग अवधारणाओं और उच्च-स्तरीय अमूर्तताओं का उपयोग करने के साथ कई तरह से लागू करने में सक्षम बनाता है।

import os 
import math 
import numpy as np 
import tensorflow as tf 

from tensorflow.contrib.tensorboard.plugins import projector 
batch_size = 64 
embedding_dimension = 5 
negative_samples = 8 
LOG_DIR = "logs/word2vec_intro" 

digit_to_word_map = {
   1: "One", 
   2: "Two", 
   3: "Three", 
   4: "Four", 
   5: "Five", 
   6: "Six", 
   7: "Seven", 
   8: "Eight", 
   9: "Nine"} 
sentences = [] 

# Create two kinds of sentences - sequences of odd and even digits. 
   for i in range(10000): 
   rand_odd_ints = np.random.choice(range(1, 10, 2), 3) 
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_odd_ints])) 
   rand_even_ints = np.random.choice(range(2, 10, 2), 3) 
      sentences.append(" ".join([digit_to_word_map[r] for r in rand_even_ints])) 
   
# Map words to indices
word2index_map = {} 
index = 0 

for sent in sentences: 
   for word in sent.lower().split(): 
   
   if word not in word2index_map: 
      word2index_map[word] = index 
      index += 1 
index2word_map = {index: word for word, index in word2index_map.items()} 

vocabulary_size = len(index2word_map) 

# Generate skip-gram pairs 
skip_gram_pairs = [] 

for sent in sentences: 
   tokenized_sent = sent.lower().split() 
   
   for i in range(1, len(tokenized_sent)-1):        
      word_context_pair = [[word2index_map[tokenized_sent[i-1]], 
         word2index_map[tokenized_sent[i+1]]], word2index_map[tokenized_sent[i]]] 
      
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][0]]) 
      skip_gram_pairs.append([word_context_pair[1], word_context_pair[0][1]]) 

def get_skipgram_batch(batch_size): 
   instance_indices = list(range(len(skip_gram_pairs))) 
      np.random.shuffle(instance_indices)
   batch = instance_indices[:batch_size] 
   x = [skip_gram_pairs[i][0] for i in batch] 
   y = [[skip_gram_pairs[i][1]] for i in batch] 
   return x, y 
   
# batch example 
x_batch, y_batch = get_skipgram_batch(8) 
x_batch 
y_batch 
[index2word_map[word] for word in x_batch] [index2word_map[word[0]] for word in y_batch] 

# Input data, labels train_inputs = tf.placeholder(tf.int32, shape = [batch_size]) 
   train_labels = tf.placeholder(tf.int32, shape = [batch_size, 1]) 

# Embedding lookup table currently only implemented in CPU with 
   tf.name_scope("embeddings"): 
   embeddings = tf.Variable(    
      tf.random_uniform([vocabulary_size, embedding_dimension], -1.0, 1.0), 
         name = 'embedding') 
   # This is essentialy a lookup table 
   embed = tf.nn.embedding_lookup(embeddings, train_inputs) 
   
# Create variables for the NCE loss
nce_weights = tf.Variable(     
   tf.truncated_normal([vocabulary_size, embedding_dimension], stddev = 1.0 / 
      math.sqrt(embedding_dimension))) 
   
nce_biases = tf.Variable(tf.zeros([vocabulary_size])) 

loss = tf.reduce_mean(     
   tf.nn.nce_loss(weights = nce_weights, biases = nce_biases, inputs = embed, 
   labels = train_labels,num_sampled = negative_samples, 
   num_classes = vocabulary_size)) tf.summary.scalar("NCE_loss", loss) 
   
# Learning rate decay 
global_step = tf.Variable(0, trainable = False) 
   learningRate = tf.train.exponential_decay(learning_rate = 0.1, 
   global_step = global_step, decay_steps = 1000, decay_rate = 0.95, staircase = True) 

train_step = tf.train.GradientDescentOptimizer(learningRate).minimize(loss) 
   merged = tf.summary.merge_all() 
with tf.Session() as sess: 
   train_writer = tf.summary.FileWriter(LOG_DIR,    
      graph = tf.get_default_graph()) 
   saver = tf.train.Saver() 
   
   with open(os.path.join(LOG_DIR, 'metadata.tsv'), "w") as metadata: 
      metadata.write('Name\tClass\n') for k, v in index2word_map.items(): 
      metadata.write('%s\t%d\n' % (v, k)) 
   
   config = projector.ProjectorConfig() 
   embedding = config.embeddings.add() embedding.tensor_name = embeddings.name 
   
   # Link this tensor to its metadata file (e.g. labels). 
   embedding.metadata_path = os.path.join(LOG_DIR, 'metadata.tsv') 
      projector.visualize_embeddings(train_writer, config) 
   
   tf.global_variables_initializer().run() 
   
   for step in range(1000): 
      x_batch, y_batch = get_skipgram_batch(batch_size) summary, _ = sess.run(
         [merged, train_step], feed_dict = {train_inputs: x_batch, train_labels: y_batch})
      train_writer.add_summary(summary, step)
      
      if step % 100 == 0:
         saver.save(sess, os.path.join(LOG_DIR, "w2v_model.ckpt"), step)
         loss_value = sess.run(loss, feed_dict = {
            train_inputs: x_batch, train_labels: y_batch})
         print("Loss at %d: %.5f" % (step, loss_value))

   # Normalize embeddings before using
   norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims = True))
   normalized_embeddings = embeddings /
      norm normalized_embeddings_matrix = sess.run(normalized_embeddings)
   
ref_word = normalized_embeddings_matrix[word2index_map["one"]]

cosine_dists = np.dot(normalized_embeddings_matrix, ref_word)
ff = np.argsort(cosine_dists)[::-1][1:10] for f in ff: print(index2word_map[f])
print(cosine_dists[f])

उत्पादन

उपरोक्त कोड निम्नलिखित आउटपुट उत्पन्न करता है -

सिंगल लेयर परसेप्ट्रॉन को समझने के लिए आर्टिफिशियल न्यूरल नेटवर्क्स (ANN) को समझना जरूरी है। कृत्रिम तंत्रिका नेटवर्क सूचना प्रसंस्करण प्रणाली है जिसका तंत्र जैविक तंत्रिका सर्किट की कार्यक्षमता से प्रेरित है। एक कृत्रिम तंत्रिका नेटवर्क में एक दूसरे से जुड़ी कई प्रसंस्करण इकाइयाँ होती हैं। निम्नलिखित कृत्रिम तंत्रिका नेटवर्क का योजनाबद्ध प्रतिनिधित्व है -

आरेख दिखाता है कि छिपी हुई इकाइयाँ बाहरी परत के साथ संचार करती हैं। जबकि इनपुट और आउटपुट यूनिट नेटवर्क की छिपी हुई परत के माध्यम से ही संवाद करते हैं।

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

वास्तुकला दो प्रकार की होती है। इस प्रकार की कार्यक्षमता कृत्रिम तंत्रिका नेटवर्क पर केंद्रित है -

  • सिंगल लेयर परसेप्ट्रॉन
  • मल्टी-लेयर पर्सेप्ट्रॉन

सिंगल लेयर परसेप्ट्रॉन

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

आइए हम TensorFlow का उपयोग करके एक छवि वर्गीकरण समस्या के लिए सिंगल लेयर परसेप्ट्रॉन के कार्यान्वयन पर ध्यान दें। सिंगल लेयर परसेप्ट्रान का वर्णन करने के लिए सबसे अच्छा उदाहरण "लॉजिस्टिक रिग्रेशन" का प्रतिनिधित्व है।

अब, आइए हम लॉजिस्टिक प्रतिगमन प्रशिक्षण के निम्नलिखित बुनियादी चरणों पर विचार करें -

  • प्रशिक्षण की शुरुआत में वजन को यादृच्छिक मूल्यों के साथ आरंभ किया जाता है।

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

  • यह प्रक्रिया तब तक दोहराई जाती है जब तक कि पूरे प्रशिक्षण सेट पर की गई त्रुटि निर्दिष्ट सीमा से कम न हो, जब तक कि पुनरावृत्तियों की अधिकतम संख्या नहीं पहुँच जाती।

लॉजिस्टिक प्रतिगमन के मूल्यांकन के लिए पूरा कोड नीचे उल्लिखित है -

# Import MINST data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True) 

import tensorflow as tf 
import matplotlib.pyplot as plt 

# Parameters 
learning_rate = 0.01 
training_epochs = 25 
batch_size = 100 
display_step = 1 

# tf Graph Input 
x = tf.placeholder("float", [None, 784]) # mnist data image of shape 28*28 = 784 
y = tf.placeholder("float", [None, 10]) # 0-9 digits recognition => 10 classes 

# Create model 
# Set model weights 
W = tf.Variable(tf.zeros([784, 10])) 
b = tf.Variable(tf.zeros([10])) 

# Construct model 
activation = tf.nn.softmax(tf.matmul(x, W) + b) # Softmax 

# Minimize error using cross entropy 
cross_entropy = y*tf.log(activation) 
cost = tf.reduce_mean\ (-tf.reduce_sum\ (cross_entropy,reduction_indices = 1)) 

optimizer = tf.train.\ GradientDescentOptimizer(learning_rate).minimize(cost) 

#Plot settings 
avg_set = [] 
epoch_set = [] 

# Initializing the variables init = tf.initialize_all_variables()
# Launch the graph 
with tf.Session() as sess:
   sess.run(init)
   
   # Training cycle
   for epoch in range(training_epochs):
      avg_cost = 0.
      total_batch = int(mnist.train.num_examples/batch_size)
      
      # Loop over all batches
      for i in range(total_batch):
         batch_xs, batch_ys = \ mnist.train.next_batch(batch_size)
         # Fit training using batch data sess.run(optimizer, \ feed_dict = {
            x: batch_xs, y: batch_ys}) 
         # Compute average loss avg_cost += sess.run(cost, \ feed_dict = {
            x: batch_xs, \ y: batch_ys})/total_batch
      # Display logs per epoch step
      if epoch % display_step == 0:
         print ("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(avg_cost))
            avg_set.append(avg_cost) epoch_set.append(epoch+1)
   print ("Training phase finished")
    
   plt.plot(epoch_set,avg_set, 'o', label = 'Logistic Regression Training phase') 
   plt.ylabel('cost') 
   plt.xlabel('epoch') 
   plt.legend() 
   plt.show() 
    
   # Test model 
   correct_prediction = tf.equal(tf.argmax(activation, 1), tf.argmax(y, 1)) 
   
   # Calculate accuracy 
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) print 
      ("Model accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels}))

उत्पादन

उपरोक्त कोड निम्नलिखित आउटपुट उत्पन्न करता है -

लॉजिस्टिक रिग्रेशन को प्रेडिक्टिव एनालिसिस माना जाता है। लॉजिस्टिक रिग्रेशन का उपयोग डेटा का वर्णन करने और एक आश्रित बाइनरी चर और एक या अधिक नाममात्र या स्वतंत्र चर के बीच संबंधों को समझाने के लिए किया जाता है।

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

इन दो चर के बीच संबंध है considered रैखिक। यदि y आश्रित चर है और x को स्वतंत्र चर माना जाता है, तो दो चरों के रैखिक प्रतिगमन संबंध निम्न प्रकार दिखाई देंगे -

Y = Ax+b

हम रैखिक प्रतिगमन के लिए एक एल्गोरिथ्म डिजाइन करेंगे। यह हमें निम्नलिखित दो महत्वपूर्ण अवधारणाओं को समझने की अनुमति देगा -

  • लागत कार्य
  • धीरे-धीरे वंश एल्गोरिदम

रैखिक प्रतिगमन का योजनाबद्ध प्रतिनिधित्व नीचे दिया गया है -

रेखीय प्रतिगमन के समीकरण का ग्राफिकल दृश्य नीचे उल्लिखित है -

रैखिक प्रतिगमन के लिए एक एल्गोरिथ्म डिजाइन करने के लिए कदम

अब हम उन चरणों के बारे में जानेंगे जो रैखिक प्रतिगमन के लिए एक एल्गोरिथ्म को डिजाइन करने में मदद करते हैं।

चरण 1

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

import numpy as np 
import matplotlib.pyplot as plt

चरण 2

लॉजिस्टिक रिग्रेशन के लिए आवश्यक गुणांक की संख्या निर्धारित करें।

number_of_points = 500 
x_point = [] 
y_point = [] 
a = 0.22 
b = 0.78

चरण 3

प्रतिगमन समीकरण के चारों ओर 300 यादृच्छिक बिंदुओं को उत्पन्न करने के लिए चर को मिटाएँ -

Y = 0.22x + 0.78

for i in range(number_of_points): 
   x = np.random.normal(0.0,0.5) 
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) 
   y_point.append([y])

चरण 4

Matplotlib का उपयोग करके उत्पन्न अंक देखें।

fplt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() plt.show()

लॉजिस्टिक रिग्रेशन का पूरा कोड इस प्रकार है -

import numpy as np 
import matplotlib.pyplot as plt 

number_of_points = 500 
x_point = [] 
y_point = [] 
a = 0.22 
b = 0.78 

for i in range(number_of_points): 
   x = np.random.normal(0.0,0.5) 
   y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) 
   y_point.append([y]) 
   
plt.plot(x_point,y_point, 'o', label = 'Input Data') plt.legend() 
plt.show()

इनपुट के रूप में लिए जाने वाले अंकों की संख्या को इनपुट डेटा माना जाता है।

TFLearn को TensorFlow ढांचे में उपयोग किए जाने वाले एक मॉड्यूलर और पारदर्शी गहरे सीखने के पहलू के रूप में परिभाषित किया जा सकता है। TFLearn का मुख्य उद्देश्य नए प्रयोगों को सुविधाजनक बनाने और दिखाने के लिए TensorFlow को एक उच्च स्तरीय एपीआई प्रदान करना है।

TFLearn की निम्नलिखित महत्वपूर्ण विशेषताओं पर विचार करें -

  • TFLearn का उपयोग करना और समझना आसान है।

  • इसमें उच्च मॉड्यूलर नेटवर्क परतों, ऑप्टिमाइज़र और उनके भीतर एम्बेडेड विभिन्न मैट्रिक्स का निर्माण करना आसान अवधारणाएं शामिल हैं।

  • इसमें TensorFlow कार्य प्रणाली के साथ पूर्ण पारदर्शिता शामिल है।

  • इसमें उन शक्तिशाली सहायक कार्यों को शामिल किया गया है जो बिल्ट इन टेनर्स को प्रशिक्षित करते हैं जो कई इनपुट, आउटपुट और ऑप्टिमाइज़र को स्वीकार करते हैं।

  • इसमें आसान और सुंदर ग्राफ़ विज़ुअलाइज़ेशन शामिल है।

  • ग्राफ विज़ुअलाइज़ेशन में वज़न, ग्रेडिएंट और सक्रियण के विभिन्न विवरण शामिल हैं।

निम्नलिखित कमांड निष्पादित करके TFLearn स्थापित करें -

pip install tflearn

उपरोक्त कोड के निष्पादन पर, निम्नलिखित आउटपुट उत्पन्न होगा -

निम्नलिखित चित्रण रैंडम फ़ॉरेस्ट क्लासिफ़ायर के साथ TFLearn के कार्यान्वयन को दर्शाता है -

from __future__ import division, print_function, absolute_import

#TFLearn module implementation
import tflearn
from tflearn.estimators import RandomForestClassifier

# Data loading and pre-processing with respect to dataset
import tflearn.datasets.mnist as mnist
X, Y, testX, testY = mnist.load_data(one_hot = False)

m = RandomForestClassifier(n_estimators = 100, max_nodes = 1000)
m.fit(X, Y, batch_size = 10000, display_step = 10)

print("Compute the accuracy on train data:")
print(m.evaluate(X, Y, tflearn.accuracy_op))

print("Compute the accuracy on test set:")
print(m.evaluate(testX, testY, tflearn.accuracy_op))

print("Digits for test images id 0 to 5:")
print(m.predict(testX[:5]))

print("True digits:")
print(testY[:5])

इस अध्याय में, हम सीएनएन और आरएनएन के बीच अंतर पर ध्यान केंद्रित करेंगे -

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

निम्नलिखित चित्रण सीएनएन और आरएनएन के योजनाबद्ध प्रतिनिधित्व को दर्शाता है -

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

  • अनुक्रमिक एपीआई
  • कार्यात्मक एपीआई

केरस में गहन शिक्षण मॉडल बनाने के लिए निम्नलिखित आठ चरणों पर विचार करें -

  • डेटा लोड हो रहा है
  • लोड किए गए डेटा को रोकें
  • मॉडल की परिभाषा
  • मॉडल का संकलन
  • निर्दिष्ट मॉडल को फिट करें
  • इसका मूल्यांकन करें
  • आवश्यक भविष्यवाणी करें
  • मॉडल को सहेजें

हम नीचे दिखाए गए अनुसार आउटपुट के निष्पादन और प्रदर्शन के लिए Jupyter नोटबुक का उपयोग करेंगे -

Step 1 - डेटा लोड करना और लोड किए गए डेटा को प्रीप्रोसेस करना सबसे पहले डीप लर्निंग मॉडल को निष्पादित करने के लिए कार्यान्वित किया जाता है।

import warnings
warnings.filterwarnings('ignore')

import numpy as np
np.random.seed(123) # for reproducibility

from keras.models import Sequential
from keras.layers import Flatten, MaxPool2D, Conv2D, Dense, Reshape, Dropout
from keras.utils import np_utils
Using TensorFlow backend.
from keras.datasets import mnist

# Load pre-shuffled MNIST data into train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)

इस कदम को "आयात पुस्तकालयों और मॉड्यूल" के रूप में परिभाषित किया जा सकता है, जिसका अर्थ है कि सभी पुस्तकालय और मॉड्यूल एक प्रारंभिक चरण के रूप में आयात किए जाते हैं।

Step 2 - इस चरण में, हम मॉडल वास्तुकला को परिभाषित करेंगे -

model = Sequential()
model.add(Conv2D(32, 3, 3, activation = 'relu', input_shape = (28,28,1)))
model.add(Conv2D(32, 3, 3, activation = 'relu'))
model.add(MaxPool2D(pool_size = (2,2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation = 'softmax'))

Step 3 - अब हम निर्दिष्ट मॉडल संकलित करते हैं -

model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])

Step 4 - अब हम प्रशिक्षण डेटा का उपयोग करके मॉडल फिट करेंगे -

model.fit(X_train, Y_train, batch_size = 32, epochs = 10, verbose = 1)

निर्मित पुनरावृत्तियों का उत्पादन निम्नानुसार है -

Epoch 1/10 60000/60000 [==============================] - 65s - 
loss: 0.2124 - 
acc: 0.9345 
Epoch 2/10 60000/60000 [==============================] - 62s - 
loss: 0.0893 - 
acc: 0.9740 
Epoch 3/10 60000/60000 [==============================] - 58s - 
loss: 0.0665 - 
acc: 0.9802 
Epoch 4/10 60000/60000 [==============================] - 62s - 
loss: 0.0571 - 
acc: 0.9830 
Epoch 5/10 60000/60000 [==============================] - 62s - 
loss: 0.0474 - 
acc: 0.9855 
Epoch 6/10 60000/60000 [==============================] - 59s -
loss: 0.0416 - 
acc: 0.9871 
Epoch 7/10 60000/60000 [==============================] - 61s - 
loss: 0.0380 - 
acc: 0.9877 
Epoch 8/10 60000/60000 [==============================] - 63s - 
loss: 0.0333 - 
acc: 0.9895 
Epoch 9/10 60000/60000 [==============================] - 64s - 
loss: 0.0325 - 
acc: 0.9898 
Epoch 10/10 60000/60000 [==============================] - 60s - 
loss: 0.0284 - 
acc: 0.9910

यह अध्याय वितरित TensorFlow के साथ आरंभ करने पर ध्यान देगा। उद्देश्य डेवलपर्स को मूल वितरित टीएफ अवधारणाओं को समझने में मदद करना है जो कि टीएफ सर्वर जैसे reoccurring हैं। हम वितरित TensorFlow के मूल्यांकन के लिए Jupyter नोटबुक का उपयोग करेंगे। TensorFlow के साथ वितरित कंप्यूटिंग का कार्यान्वयन नीचे उल्लिखित है -

Step 1 - वितरित कंप्यूटिंग के लिए अनिवार्य आवश्यक मॉड्यूल आयात करें -

import tensorflow as tf

Step 2- एक नोड के साथ एक TensorFlow क्लस्टर बनाएं। इस नोड को एक ऐसे काम के लिए ज़िम्मेदार होने दें जिसका नाम "कार्यकर्ता" है और जो लोकलहोस्ट: 2222 पर एक टेक संचालित करेगा।

cluster_spec = tf.train.ClusterSpec({'worker' : ['localhost:2222']})
server = tf.train.Server(cluster_spec)
server.target

उपरोक्त स्क्रिप्ट निम्नलिखित आउटपुट उत्पन्न करते हैं -

'grpc://localhost:2222'
The server is currently running.

Step 3 - संबंधित सत्र के साथ सर्वर कॉन्फ़िगरेशन की गणना निम्न कमांड को निष्पादित करके की जा सकती है -

server.server_def

उपरोक्त कमांड निम्नलिखित आउटपुट उत्पन्न करता है -

cluster {
   job {
      name: "worker"
      tasks {
         value: "localhost:2222"
      }
   }
}
job_name: "worker"
protocol: "grpc"

Step 4- निष्पादन इंजन के सर्वर के साथ एक TensorFlow सत्र लॉन्च करें। स्थानीय सर्वर बनाने और उपयोग करने के लिए TensorFlow का उपयोग करेंlsof सर्वर के स्थान का पता लगाने के लिए।

sess = tf.Session(target = server.target)
server = tf.train.Server.create_local_server()

Step 5 - इस सत्र में उपलब्ध उपकरणों को देखें और संबंधित सत्र को बंद कर दें।

devices = sess.list_devices()
for d in devices:
   print(d.name)
sess.close()

उपरोक्त कमांड निम्नलिखित आउटपुट उत्पन्न करता है -

/job:worker/replica:0/task:0/device:CPU:0

यहां, हम TensorFlow में मेटाग्राफ गठन पर ध्यान देंगे। यह हमें TensorFlow में निर्यात मॉड्यूल को समझने में मदद करेगा। मेटाग्राफ में मूल जानकारी होती है, जिसे पहले प्रशिक्षित ग्राफ पर प्रशिक्षित करना, मूल्यांकन करना या निष्कर्ष निकालना आवश्यक होता है।

इसके लिए कोड स्निपेट निम्नलिखित है -

def export_meta_graph(filename = None, collection_list = None, as_text = False): 
   """this code writes `MetaGraphDef` to save_path/filename. 
   
   Arguments: 
   filename: Optional meta_graph filename including the path. collection_list: 
      List of string keys to collect. as_text: If `True`, 
      writes the meta_graph as an ASCII proto. 
   
   Returns: 
   A `MetaGraphDef` proto. """

उसी के लिए विशिष्ट उपयोग मॉडल में से एक नीचे उल्लिखित है -

# Build the model ... 
with tf.Session() as sess: 
   # Use the model ... 
# Export the model to /tmp/my-model.meta. 
meta_graph_def = tf.train.export_meta_graph(filename = '/tmp/my-model.meta')

मल्टी लेयर परसेप्ट्रॉन कृत्रिम तंत्रिका नेटवर्क की सबसे जटिल वास्तुकला को परिभाषित करता है। यह काफी हद तक अवधारणात्मक की कई परतों से बनता है।

मल्टी-लेयर परसेप्ट्रॉन लर्निंग का डायग्रामेटिक प्रतिनिधित्व नीचे दिखाया गया है -

एमएलपी नेटवर्क आमतौर पर पर्यवेक्षित शिक्षण प्रारूप के लिए उपयोग किया जाता है। एमएलपी नेटवर्क के लिए एक विशिष्ट शिक्षण एल्गोरिथ्म को वापस प्रचार का एल्गोरिथ्म भी कहा जाता है।

अब, हम एक छवि वर्गीकरण समस्या के लिए MLP के साथ कार्यान्वयन पर ध्यान केंद्रित करेंगे।

# Import MINST data 
from tensorflow.examples.tutorials.mnist import input_data 
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True) 

import tensorflow as tf 
import matplotlib.pyplot as plt 

# Parameters 
learning_rate = 0.001 
training_epochs = 20 
batch_size = 100 
display_step = 1 

# Network Parameters 
n_hidden_1 = 256 

# 1st layer num features
n_hidden_2 = 256 # 2nd layer num features 
n_input = 784 # MNIST data input (img shape: 28*28) n_classes = 10 
# MNIST total classes (0-9 digits) 

# tf Graph input 
x = tf.placeholder("float", [None, n_input]) 
y = tf.placeholder("float", [None, n_classes]) 

# weights layer 1 
h = tf.Variable(tf.random_normal([n_input, n_hidden_1])) # bias layer 1 
bias_layer_1 = tf.Variable(tf.random_normal([n_hidden_1])) 
# layer 1 layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, h), bias_layer_1)) 

# weights layer 2 
w = tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2])) 

# bias layer 2 
bias_layer_2 = tf.Variable(tf.random_normal([n_hidden_2])) 

# layer 2 
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, w), bias_layer_2)) 

# weights output layer 
output = tf.Variable(tf.random_normal([n_hidden_2, n_classes])) 

# biar output layer 
bias_output = tf.Variable(tf.random_normal([n_classes])) # output layer 
output_layer = tf.matmul(layer_2, output) + bias_output

# cost function 
cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(
   logits = output_layer, labels = y)) 

#cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(output_layer, y)) 
# optimizer 
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost) 

# optimizer = tf.train.GradientDescentOptimizer(
   learning_rate = learning_rate).minimize(cost) 

# Plot settings 
avg_set = [] 
epoch_set = [] 

# Initializing the variables 
init = tf.global_variables_initializer() 

# Launch the graph 
with tf.Session() as sess: 
   sess.run(init) 
   
   # Training cycle
   for epoch in range(training_epochs): 
      avg_cost = 0. 
      total_batch = int(mnist.train.num_examples / batch_size) 
      
      # Loop over all batches 
      for i in range(total_batch): 
         batch_xs, batch_ys = mnist.train.next_batch(batch_size) 
         # Fit training using batch data sess.run(optimizer, feed_dict = {
            x: batch_xs, y: batch_ys}) 
         # Compute average loss 
         avg_cost += sess.run(cost, feed_dict = {x: batch_xs, y: batch_ys}) / total_batch
      # Display logs per epoch step 
      if epoch % display_step == 0: 
         print 
         Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost)
      avg_set.append(avg_cost) 
      epoch_set.append(epoch + 1)
   print 
   "Training phase finished" 
   
   plt.plot(epoch_set, avg_set, 'o', label = 'MLP Training phase') 
   plt.ylabel('cost') 
   plt.xlabel('epoch') 
   plt.legend() 
   plt.show() 
   
   # Test model 
   correct_prediction = tf.equal(tf.argmax(output_layer, 1), tf.argmax(y, 1)) 
   
   # Calculate accuracy 
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 
   print 
   "Model Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels})

कोड की उपरोक्त लाइन निम्नलिखित आउटपुट उत्पन्न करती है -

इस अध्याय में, हम उस नेटवर्क पर ध्यान केंद्रित करेंगे, जिसे हमें x और f (x) नामक बिंदुओं के ज्ञात सेट से सीखना होगा। एक छिपी हुई परत इस सरल नेटवर्क का निर्माण करेगी।

परसेप्ट्रॉन की छिपी हुई परतों की व्याख्या के लिए कोड नीचे दिखाया गया है -

#Importing the necessary modules 
import tensorflow as tf 
import numpy as np 
import math, random 
import matplotlib.pyplot as plt 

np.random.seed(1000) 
function_to_learn = lambda x: np.cos(x) + 0.1*np.random.randn(*x.shape) 
layer_1_neurons = 10 
NUM_points = 1000 

#Training the parameters 
batch_size = 100 
NUM_EPOCHS = 1500 

all_x = np.float32(np.random.uniform(-2*math.pi, 2*math.pi, (1, NUM_points))).T 
   np.random.shuffle(all_x) 

train_size = int(900) 
#Training the first 700 points in the given set x_training = all_x[:train_size] 
y_training = function_to_learn(x_training)

#Training the last 300 points in the given set x_validation = all_x[train_size:] 
y_validation = function_to_learn(x_validation) 

plt.figure(1) 
plt.scatter(x_training, y_training, c = 'blue', label = 'train') 
plt.scatter(x_validation, y_validation, c = 'pink', label = 'validation') 
plt.legend() 
plt.show()

X = tf.placeholder(tf.float32, [None, 1], name = "X")
Y = tf.placeholder(tf.float32, [None, 1], name = "Y")

#first layer 
#Number of neurons = 10 
w_h = tf.Variable(
   tf.random_uniform([1, layer_1_neurons],\ minval = -1, maxval = 1, dtype = tf.float32)) 
b_h = tf.Variable(tf.zeros([1, layer_1_neurons], dtype = tf.float32)) 
h = tf.nn.sigmoid(tf.matmul(X, w_h) + b_h)

#output layer 
#Number of neurons = 10 
w_o = tf.Variable(
   tf.random_uniform([layer_1_neurons, 1],\ minval = -1, maxval = 1, dtype = tf.float32)) 
b_o = tf.Variable(tf.zeros([1, 1], dtype = tf.float32)) 

#build the model 
model = tf.matmul(h, w_o) + b_o 

#minimize the cost function (model - Y) 
train_op = tf.train.AdamOptimizer().minimize(tf.nn.l2_loss(model - Y)) 

#Start the Learning phase 
sess = tf.Session() sess.run(tf.initialize_all_variables()) 

errors = [] 
for i in range(NUM_EPOCHS): 
   for start, end in zip(range(0, len(x_training), batch_size),\ 
      range(batch_size, len(x_training), batch_size)): 
      sess.run(train_op, feed_dict = {X: x_training[start:end],\ Y: y_training[start:end]})
   cost = sess.run(tf.nn.l2_loss(model - y_validation),\ feed_dict = {X:x_validation}) 
   errors.append(cost) 
   
   if i%100 == 0: 
      print("epoch %d, cost = %g" % (i, cost)) 
      
plt.plot(errors,label='MLP Function Approximation') plt.xlabel('epochs') 
plt.ylabel('cost') 
plt.legend() 
plt.show()

उत्पादन

समारोह परत सन्निकटन का प्रतिनिधित्व निम्नलिखित है -

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

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

TensorFlow का मूल आशावादी है -

tf.train.Optimizer

यह वर्ग टेंसोफ़्लो / अजगर / प्रशिक्षण / ऑप्टिमाइज़रहोम के निर्दिष्ट पथ में परिभाषित किया गया है।

Tensorflow में कुछ आशावादी निम्नलिखित हैं -

  • स्टोचैस्टिक ग्रेडिएंट वंश
  • स्टोकेस्टिक क्रमिक ढाल के साथ ढाल वंश
  • Momentum
  • नेस्टरोव गति
  • Adagrad
  • Adadelta
  • RMSProp
  • Adam
  • Adamax
  • SMORMS3

हम स्टोचस्टिक ग्रेडिएंट वंश पर ध्यान केंद्रित करेंगे। उसी के लिए ऑप्टिमाइज़र बनाने का चित्रण नीचे दिया गया है -

def sgd(cost, params, lr = np.float32(0.01)):
   g_params = tf.gradients(cost, params)
   updates = []
   
   for param, g_param in zip(params, g_params):
      updates.append(param.assign(param - lr*g_param))
   return updates

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

इस अध्याय में, हम XOR कार्यान्वयन के बारे में TensorFlow का उपयोग करके सीखेंगे। TensorFlow में XOR के कार्यान्वयन से शुरू करने से पहले, हमें XOR तालिका मान देखें। यह हमें एन्क्रिप्शन और डिक्रिप्शन प्रक्रिया को समझने में मदद करेगा।

ए ख ए XOR ख
0 0 0
0 1 1
1 0 1
1 1 0

XOR सिफर एन्क्रिप्शन विधि मूल रूप से डेटा को एन्क्रिप्ट करने के लिए उपयोग की जाती है जो कि ब्रूट फोर्स विधि के साथ क्रैक करना मुश्किल है, अर्थात, यादृच्छिक एन्क्रिप्शन कुंजियों को उत्पन्न करके जो उपयुक्त कुंजी से मेल खाती है।

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

#Declaring necessary modules
import tensorflow as tf
import numpy as np
"""
A simple numpy implementation of a XOR gate to understand the backpropagation
algorithm
"""

x = tf.placeholder(tf.float64,shape = [4,2],name = "x")
#declaring a place holder for input x
y = tf.placeholder(tf.float64,shape = [4,1],name = "y")
#declaring a place holder for desired output y

m = np.shape(x)[0]#number of training examples
n = np.shape(x)[1]#number of features
hidden_s = 2 #number of nodes in the hidden layer
l_r = 1#learning rate initialization

theta1 = tf.cast(tf.Variable(tf.random_normal([3,hidden_s]),name = "theta1"),tf.float64)
theta2 = tf.cast(tf.Variable(tf.random_normal([hidden_s+1,1]),name = "theta2"),tf.float64)

#conducting forward propagation
a1 = tf.concat([np.c_[np.ones(x.shape[0])],x],1)
#the weights of the first layer are multiplied by the input of the first layer

z1 = tf.matmul(a1,theta1)
#the input of the second layer is the output of the first layer, passed through the 
   activation function and column of biases is added

a2 = tf.concat([np.c_[np.ones(x.shape[0])],tf.sigmoid(z1)],1)
#the input of the second layer is multiplied by the weights

z3 = tf.matmul(a2,theta2)
#the output is passed through the activation function to obtain the final probability

h3 = tf.sigmoid(z3)
cost_func = -tf.reduce_sum(y*tf.log(h3)+(1-y)*tf.log(1-h3),axis = 1)

#built in tensorflow optimizer that conducts gradient descent using specified 
   learning rate to obtain theta values

optimiser = tf.train.GradientDescentOptimizer(learning_rate = l_r).minimize(cost_func)

#setting required X and Y values to perform XOR operation
X = [[0,0],[0,1],[1,0],[1,1]]
Y = [[0],[1],[1],[0]]

#initializing all variables, creating a session and running a tensorflow session
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

#running gradient descent for each iteration and printing the hypothesis 
   obtained using the updated theta values
for i in range(100000):
   sess.run(optimiser, feed_dict = {x:X,y:Y})#setting place holder values using feed_dict
   if i%100==0:
      print("Epoch:",i)
      print("Hyp:",sess.run(h3,feed_dict = {x:X,y:Y}))

कोड की उपरोक्त पंक्ति नीचे स्क्रीनशॉट में दिखाए अनुसार आउटपुट उत्पन्न करती है -

डेटा साइंस में ग्रेजुएशन डिसेंट ऑप्टिमाइज़ेशन को एक महत्वपूर्ण अवधारणा माना जाता है।

क्रमिक वंश अनुकूलन के कार्यान्वयन को समझने के लिए नीचे दिए गए चरणों पर विचार करें -

चरण 1

आवश्यक मॉड्यूल और एक्स और वाई चर की घोषणा शामिल करें जिसके माध्यम से हम ढाल वंश अनुकूलन को परिभाषित करने जा रहे हैं।

import tensorflow as tf

x = tf.Variable(2, name = 'x', dtype = tf.float32)
log_x = tf.log(x)
log_x_squared = tf.square(log_x)

optimizer = tf.train.GradientDescentOptimizer(0.5)
train = optimizer.minimize(log_x_squared)

चरण 2

आवश्यक चर आरंभ करें और संबंधित फ़ंक्शन के साथ इसे परिभाषित करने और कॉल करने के लिए ऑप्टिमाइज़र को कॉल करें।

init = tf.initialize_all_variables()

def optimize():
   with tf.Session() as session:
      session.run(init)
      print("starting at", "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
      
      for step in range(10):
         session.run(train)
         print("step", step, "x:", session.run(x), "log(x)^2:", session.run(log_x_squared))
optimize()

कोड की उपरोक्त पंक्ति नीचे स्क्रीनशॉट में दिखाए अनुसार आउटपुट उत्पन्न करती है -

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

एक आंशिक अंतर समीकरण (PDE) एक अंतर समीकरण है, जिसमें कई स्वतंत्र चर के अज्ञात फ़ंक्शन के साथ आंशिक व्युत्पन्न शामिल है। आंशिक अंतर समीकरणों के संदर्भ में, हम नए रेखांकन बनाने पर ध्यान केंद्रित करेंगे।

मान लें कि वहाँ एक तालाब है जिसका आयाम 500 * 500 वर्ग है -

N = 500

अब, हम आंशिक अंतर समीकरण की गणना करेंगे और इसका उपयोग करके संबंधित ग्राफ बनाएंगे। कंप्यूटिंग ग्राफ के लिए नीचे दिए गए चरणों पर विचार करें।

Step 1 - सिमुलेशन के लिए आयात पुस्तकालयों।

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

Step 2 - 2 डी सरणी को एक कन्वेक्शन कर्नेल और सरलीकृत 2D कनवल्शन ऑपरेशन में बदलने के लिए कार्य शामिल करें।

def make_kernel(a):
   a = np.asarray(a)
   a = a.reshape(list(a.shape) + [1,1])
   return tf.constant(a, dtype=1)

def simple_conv(x, k):
   """A simplified 2D convolution operation"""
   x = tf.expand_dims(tf.expand_dims(x, 0), -1)
   y = tf.nn.depthwise_conv2d(x, k, [1, 1, 1, 1], padding = 'SAME')
   return y[0, :, :, 0]

def laplace(x):
   """Compute the 2D laplacian of an array"""
   laplace_k = make_kernel([[0.5, 1.0, 0.5], [1.0, -6., 1.0], [0.5, 1.0, 0.5]])
   return simple_conv(x, laplace_k)
   
sess = tf.InteractiveSession()

Step 3 - पुनरावृत्तियों की संख्या शामिल करें और तदनुसार रिकॉर्ड प्रदर्शित करने के लिए ग्राफ़ की गणना करें।

N = 500

# Initial Conditions -- some rain drops hit a pond

# Set everything to zero
u_init = np.zeros([N, N], dtype = np.float32)
ut_init = np.zeros([N, N], dtype = np.float32)

# Some rain drops hit a pond at random points
for n in range(100):
   a,b = np.random.randint(0, N, 2)
   u_init[a,b] = np.random.uniform()

plt.imshow(u_init)
plt.show()

# Parameters:
# eps -- time resolution
# damping -- wave damping
eps = tf.placeholder(tf.float32, shape = ())
damping = tf.placeholder(tf.float32, shape = ())

# Create variables for simulation state
U = tf.Variable(u_init)
Ut = tf.Variable(ut_init)

# Discretized PDE update rules
U_ = U + eps * Ut
Ut_ = Ut + eps * (laplace(U) - damping * Ut)

# Operation to update the state
step = tf.group(U.assign(U_), Ut.assign(Ut_))

# Initialize state to initial conditions
tf.initialize_all_variables().run()

# Run 1000 steps of PDE
for i in range(1000):
   # Step simulation
   step.run({eps: 0.03, damping: 0.04})
   
   # Visualize every 50 steps
   if i % 500 == 0:
      plt.imshow(U.eval())
      plt.show()

नीचे दिए गए अनुसार ग्राफ को प्लॉट किया गया है -

TensorFlow में छवि पहचान की एक विशेष विशेषता शामिल है और ये चित्र एक विशिष्ट फ़ोल्डर में संग्रहीत हैं। अपेक्षाकृत समान छवियों के साथ, सुरक्षा उद्देश्यों के लिए इस तर्क को लागू करना आसान होगा।

छवि मान्यता कोड कार्यान्वयन की फ़ोल्डर संरचना निम्नानुसार है -

डेटासेट_मेज में संबंधित चित्र शामिल हैं, जिन्हें लोड करने की आवश्यकता है। हम इसमें परिभाषित हमारे लोगो के साथ छवि पहचान पर ध्यान केंद्रित करेंगे। छवियों को "load_data.py" स्क्रिप्ट के साथ लोड किया गया है, जो उनके भीतर विभिन्न छवि मान्यता मॉड्यूल पर एक नोट रखने में मदद करता है।

import pickle
from sklearn.model_selection import train_test_split
from scipy import misc

import numpy as np
import os

label = os.listdir("dataset_image")
label = label[1:]
dataset = []

for image_label in label:
   images = os.listdir("dataset_image/"+image_label)
   
   for image in images:
      img = misc.imread("dataset_image/"+image_label+"/"+image)
      img = misc.imresize(img, (64, 64))
      dataset.append((img,image_label))
X = []
Y = []

for input,image_label in dataset:
   X.append(input)
   Y.append(label.index(image_label))

X = np.array(X)
Y = np.array(Y)

X_train,y_train, = X,Y

data_set = (X_train,y_train)

save_label = open("int_to_word_out.pickle","wb")
pickle.dump(label, save_label)
save_label.close()

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

import numpy
import matplotlib.pyplot as plt

from keras.layers import Dropout
from keras.layers import Flatten
from keras.constraints import maxnorm
from keras.optimizers import SGD
from keras.layers import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.utils import np_utils
from keras import backend as K

import load_data
from keras.models import Sequential
from keras.layers import Dense

import keras
K.set_image_dim_ordering('tf')

# fix random seed for reproducibility
seed = 7
numpy.random.seed(seed)

# load data
(X_train,y_train) = load_data.data_set

# normalize inputs from 0-255 to 0.0-1.0
X_train = X_train.astype('float32')

#X_test = X_test.astype('float32')
X_train = X_train / 255.0

#X_test = X_test / 255.0
# one hot encode outputs
y_train = np_utils.to_categorical(y_train)

#y_test = np_utils.to_categorical(y_test)
num_classes = y_train.shape[1]

# Create the model
model = Sequential()
model.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), padding = 'same', 
   activation = 'relu', kernel_constraint = maxnorm(3)))

model.add(Dropout(0.2))
model.add(Conv2D(32, (3, 3), activation = 'relu', padding = 'same', 
   kernel_constraint = maxnorm(3)))

model.add(MaxPooling2D(pool_size = (2, 2)))
model.add(Flatten())
model.add(Dense(512, activation = 'relu', kernel_constraint = maxnorm(3)))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation = 'softmax'))

# Compile model
epochs = 10
lrate = 0.01
decay = lrate/epochs
sgd = SGD(lr = lrate, momentum = 0.9, decay = decay, nesterov = False)
model.compile(loss = 'categorical_crossentropy', optimizer = sgd, metrics = ['accuracy'])
print(model.summary())

#callbacks = [keras.callbacks.EarlyStopping(
   monitor = 'val_loss', min_delta = 0, patience = 0, verbose = 0, mode = 'auto')]
callbacks = [keras.callbacks.TensorBoard(log_dir='./logs', 
   histogram_freq = 0, batch_size = 32, write_graph = True, write_grads = False, 
   write_images = True, embeddings_freq = 0, embeddings_layer_names = None, 
   embeddings_metadata = None)]

# Fit the model

model.fit(X_train, y_train, epochs = epochs, 
   batch_size = 32,shuffle = True,callbacks = callbacks)

# Final evaluation of the model
scores = model.evaluate(X_train, y_train, verbose = 0)
print("Accuracy: %.2f%%" % (scores[1]*100))

# serialize model to JSONx
model_json = model.to_json()
with open("model_face.json", "w") as json_file:
   json_file.write(model_json)

# serialize weights to HDF5
model.save_weights("model_face.h5")
print("Saved model to disk")

कोड की उपरोक्त रेखा नीचे दिखाए अनुसार आउटपुट उत्पन्न करती है -

इस अध्याय में, हम तंत्रिका नेटवर्क प्रशिक्षण के विभिन्न पहलुओं को समझेंगे, जिसे TensorFlow ढांचे का उपयोग करके लागू किया जा सकता है।

निम्नलिखित दस सिफारिशें हैं, जिनका मूल्यांकन किया जा सकता है -

वापस प्रचार

आंशिक प्रसार की गणना करने के लिए बैक प्रचार एक सरल विधि है, जिसमें तंत्रिका जाल के लिए सबसे उपयुक्त रचना का मूल रूप शामिल है।

स्टोचैस्टिक ग्रेडिएंट डिसेंट

स्टोकेस्टिक क्रमिक वंश में, ए batchउदाहरणों की कुल संख्या है, जो उपयोगकर्ता एक एकल पुनरावृत्ति में ढाल की गणना करने के लिए उपयोग करता है। अब तक, यह माना जाता है कि बैच संपूर्ण डेटा सेट है। सबसे अच्छा चित्रण Google के पैमाने पर काम कर रहा है; डेटा सेट में अक्सर अरबों या सैकड़ों अरबों उदाहरण होते हैं।

सीखना दर क्षय

अधिगम दर को अपनाना ग्रेडिएंट डिसेंट ऑप्टिमाइज़ेशन की सबसे महत्वपूर्ण विशेषताओं में से एक है। यह TensorFlow कार्यान्वयन के लिए महत्वपूर्ण है।

ड्रॉप आउट

बड़ी संख्या में मापदंडों के साथ गहरे तंत्रिका जाल शक्तिशाली मशीन लर्निंग सिस्टम बनाते हैं। हालाँकि, इस तरह के नेटवर्क में ओवर फिटिंग एक गंभीर समस्या है।

मैक्स पूलिंग

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

लंबी अवधि की मेमोरी (LSTM)

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

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved