TensorFlow ANN उदाहरणों के साथ कृत्रिम तंत्रिका नेटवर्क ट्यूटोरियल

कृत्रिम तंत्रिका नेटवर्क क्या है?

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

एक कृत्रिम तंत्रिका नेटवर्क (एएनएन) चार प्रमुख वस्तुओं से बना होता है:

• परतें: सभी सीखना परतों में होता है। 3 परतें हैं 1) इनपुट 2) छिपा हुआ और 3) आउटपुट
• विशेषता और लेबलनेटवर्क में इनपुट डेटा (विशेषताएं) और नेटवर्क से आउटपुट (लेबल)
• लॉस फंकशन: सीखने के चरण के प्रदर्शन का अनुमान लगाने के लिए इस्तेमाल किया जाने वाला मीट्रिक
• अनुकूलक: नेटवर्क में ज्ञान को अद्यतन करके सीखने में सुधार करें

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

यदि आप ऊपर दिए गए चित्र पर नज़र डालें, तो आपको अंतर्निहित तंत्र समझ में आ जाएगा।

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

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

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

तंत्रिका नेटवर्क Archiटेक्चर

कृत्रिम तंत्रिका नेटवर्क Archiटेक्चर में निम्नलिखित घटक शामिल हैं:

• परतें
• सक्रियण फ़ंक्शन
• लॉस फंकशन
• अनुकूलक

परतें

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

एक सामान्य न्यूरल नेटवर्क इनपुट का एक वेक्टर और एक स्केलर लेता है जिसमें लेबल होते हैं। सबसे सुविधाजनक सेटअप बाइनरी वर्गीकरण है जिसमें केवल दो वर्ग होते हैं: 0 और 1.

नेटवर्क एक इनपुट लेता है, उसे सभी जुड़े हुए नोड्स को भेजता है और सिग्नल की गणना करता है सक्रियण समारोह.

ऊपर दिया गया चित्र इस विचार को दर्शाता है। पहली परत दूसरी परत के लिए इनपुट मान है, जिसे छिपी परत कहा जाता है, पिछली परत से भारित इनपुट प्राप्त करती है

1. पहला नोड इनपुट मान है
2. न्यूरॉन को इनपुट भाग और सक्रियण फ़ंक्शन में विघटित किया जाता है। बायाँ भाग पिछली परत से सभी इनपुट प्राप्त करता है। दायाँ भाग सक्रियण फ़ंक्शन में इनपुट पास का योग है।
3. छिपी हुई परतों से गणना की गई आउटपुट वैल्यू और भविष्यवाणी करने के लिए उपयोग किया जाता है। वर्गीकरण के लिए, यह वर्ग की संख्या के बराबर है। प्रतिगमन के लिए, केवल एक मान की भविष्यवाणी की जाती है।

सक्रियण फ़ंक्शन

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

अन्य सक्रियण कार्य इस प्रकार हैं:

• टुकड़े-टुकड़े रैखिक
• अवग्रह
• तनह
• लीकी रेलू

तंत्रिका नेटवर्क का निर्माण करते समय लिया जाने वाला महत्वपूर्ण निर्णय है:

• तंत्रिका नेटवर्क में कितनी परतें होती हैं
• प्रत्येक परत के लिए कितनी छुपी हुई इकाइयाँ

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

लॉस फंकशन

छिपी हुई परतों और सक्रियण फ़ंक्शन को परिभाषित करने के बाद, आपको हानि फ़ंक्शन और अनुकूलक को निर्दिष्ट करना होगा।

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

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

अनुकूलक

हानि फ़ंक्शन मॉडल के प्रदर्शन का एक माप है। ऑप्टिमाइज़र हानि को कम करने के लिए नेटवर्क के भार को बेहतर बनाने में मदद करेगा। विभिन्न ऑप्टिमाइज़र उपलब्ध हैं, लेकिन सबसे आम स्टोचैस्टिक ग्रेडिएंट डिसेंट है।

पारंपरिक अनुकूलक हैं:

• Momentum अनुकूलन,
• नेस्टरोव त्वरित ढाल,
• एडाग्रैड,
• एडम अनुकूलन

न्यूरल नेटवर्क की सीमाएँ

न्यूरल नेटवर्क की सीमाएँ निम्नलिखित हैं:

ओवरफिटिंग

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

मशीन लर्निंग में अनुकूलन और सामान्यीकरण के बीच एक समझौता होता है।

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

हालाँकि, सामान्यीकरण यह बताता है कि मॉडल अदृश्य डेटा के लिए कैसा व्यवहार करता है।

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

नेटवर्क का आकार

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

वजन नियमितीकरण

ओवरफिटिंग को रोकने के लिए एक मानक तकनीक नेटवर्क के भार में बाधाएँ जोड़ना है। बाधा नेटवर्क के आकार को केवल छोटे मान लेने के लिए बाध्य करती है। बाधा को त्रुटि के हानि फ़ंक्शन में जोड़ा जाता है। नियमितीकरण के दो प्रकार हैं:

L1: लैस्सो: लागत भार गुणांक के निरपेक्ष मान के समानुपाती होती है

L2: रिज: लागत भार गुणांक के मान के वर्ग के समानुपाती होती है

ड्रॉप आउट

ड्रॉपआउट एक अजीब लेकिन उपयोगी तकनीक है। ड्रॉपआउट वाले नेटवर्क का मतलब है कि कुछ वज़न बेतरतीब ढंग से शून्य पर सेट किए जाएँगे। कल्पना करें कि आपके पास वज़न की एक सरणी है [0.1, 1.7, 0.7, -0.9]। यदि न्यूरल नेटवर्क में ड्रॉपआउट है, तो यह बेतरतीब ढंग से वितरित 0.1 के साथ [0, 0, 0.9, -0] हो जाएगा। ड्रॉपआउट को नियंत्रित करने वाला पैरामीटर ड्रॉपआउट दर है। दर परिभाषित करती है कि कितने वज़न को शून्य पर सेट किया जाना है। 0.2 और 0.5 के बीच की दर होना आम बात है।

TensorFlow में न्यूरल नेटवर्क का उदाहरण

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

• दो छिपी हुई परतें
  • प्रथम परत में चार पूर्णतः जुड़े हुए न्यूरॉन होते हैं
  • दूसरी परत में दो पूर्णतः जुड़े हुए न्यूरॉन होते हैं
• सक्रियण फ़ंक्शन एक Relu है
• 2 की सीखने की दर के साथ एक L0.003 नियमितीकरण जोड़ें

यह नेटवर्क 10 के बैच आकार के साथ 180 युगों के दौरान भार को अनुकूलित करेगा। नीचे दिए गए ANN उदाहरण वीडियो में, आप देख सकते हैं कि भार कैसे विकसित होते हैं और नेटवर्क वर्गीकरण मानचित्र को कैसे बेहतर बनाता है।ping.

सबसे पहले, नेटवर्क सभी भारों को यादृच्छिक मान प्रदान करता है।

• यादृच्छिक भार के साथ, यानी अनुकूलन के बिना, आउटपुट हानि 0.453 है। नीचे दी गई तस्वीर अलग-अलग रंगों के साथ नेटवर्क का प्रतिनिधित्व करती है।
• सामान्यतः, नारंगी रंग नकारात्मक मूल्यों को दर्शाता है जबकि नीला रंग सकारात्मक मूल्यों को दर्शाता है।
• डेटा बिन्दुओं का प्रतिनिधित्व एक जैसा है; नीले वाले सकारात्मक लेबल हैं और नारंगी वाले नकारात्मक लेबल हैं।

दूसरी छिपी परत के अंदर, भार के चिह्न के अनुसार रेखाएँ रंगीन होती हैं। नारंगी रेखाएँ ऋणात्मक भार और नीली रेखाएँ धनात्मक भार निर्दिष्ट करती हैं

जैसा कि आप आउटपुट मैप में देख सकते हैंpingनेटवर्क में काफी गलतियाँ हो रही हैं। आइए देखते हैं कि ऑप्टिमाइज़ेशन के बाद नेटवर्क कैसा व्यवहार करता है।

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

इस विचार को अधिक छिपी हुई परतों और न्यूरॉन्स वाले नेटवर्क के लिए सामान्यीकृत किया जा सकता है। आप इसमें इधर-उधर खेल सकते हैं संपर्क.

TensorFlow के साथ न्यूरल नेटवर्क को कैसे प्रशिक्षित करें

यहां API के अनुमानक DNNClassifier का उपयोग करके TensorFlow ANN के साथ एक तंत्रिका नेटवर्क को प्रशिक्षित करने की चरण-दर-चरण प्रक्रिया दी गई है।

हम आपके पहले न्यूरल नेटवर्क को प्रशिक्षित करने के लिए MNIST डेटासेट का उपयोग करेंगे। न्यूरल नेटवर्क को प्रशिक्षित करना TensorFlow बहुत जटिल नहीं है। प्रीप्रोसेसिंग चरण ठीक वैसा ही दिखता है जैसा कि पिछले ट्यूटोरियल में था। आप निम्न प्रकार आगे बढ़ेंगे:

• चरण 1: डेटा आयात करें
• चरण 2: डेटा को रूपांतरित करें
• चरण 3: टेंसर का निर्माण करें
• चरण 4: मॉडल बनाएं
• चरण 5: मॉडल को प्रशिक्षित और मूल्यांकन करें
• चरण 6: मॉडल में सुधार करें

चरण 1) डेटा आयात करें

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

MNIST डेटासेट नई तकनीकों या एल्गोरिदम का परीक्षण करने के लिए आमतौर पर इस्तेमाल किया जाने वाला डेटासेट है। यह डेटासेट 28 से 28 तक हस्तलिखित अंकों के साथ 0×9 पिक्सेल छवि का संग्रह है। वर्तमान में, 0.27 कन्वोल्यूशनल न्यूरल नेटवर्क की समिति के साथ परीक्षण पर सबसे कम त्रुटि 7 प्रतिशत है।

import numpy as np
import tensorflow as tf
np.random.seed(1337)

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

from sklearn.datasets import fetch_mldata
mnist = fetch_mldata(' /Users/Thomas/Dropbox/Learning/Upwork/tuto_TF/data/mldata/MNIST original')
print(mnist.data.shape)
print(mnist.target.shape)

इसके बाद, आप डेटा आयात करते हैं और दोनों डेटासेट का आकार प्राप्त करते हैं।

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )

चरण 2) डेटा को रूपांतरित करें

पिछले ट्यूटोरियल में, आपने सीखा कि आउटलायर्स के प्रभाव को सीमित करने के लिए आपको डेटा को बदलने की आवश्यकता है। इस न्यूरल नेटवर्क ट्यूटोरियल में, आप मिन-मैक्स स्केलर का उपयोग करके डेटा को बदलेंगे। सूत्र है:

(X-min_x)/(max_x - min_x)

Scikit learns में इसके लिए पहले से ही एक फ़ंक्शन मौजूद है: MinMaxScaler()

## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))

चरण 3) टेंसर का निर्माण करें

अब आप Tensorflow में टेंसर बनाने के तरीके से परिचित हो चुके हैं। आप ट्रेन सेट को संख्यात्मक कॉलम में बदल सकते हैं।

feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]

चरण 4) मॉडल बनाएं

तंत्रिका नेटवर्क की वास्तुकला में 2 छिपी हुई परतें होती हैं, जिनमें पहली परत के लिए 300 इकाइयाँ और दूसरी परत के लिए 100 इकाइयाँ होती हैं। हम अपने अनुभव के आधार पर इन मूल्यों का उपयोग करते हैं। आप इन मूल्यों को ट्यून कर सकते हैं और देख सकते हैं कि यह नेटवर्क की सटीकता को कैसे प्रभावित करता है।

मॉडल बनाने के लिए, आप अनुमानक DNNClassifier का उपयोग करते हैं। आप फ़ीचर_कॉलम तर्कों में परतों की संख्या जोड़ सकते हैं। आपको कक्षाओं की संख्या 10 पर सेट करने की आवश्यकता है क्योंकि प्रशिक्षण सेट में दस कक्षाएं हैं। आप अनुमानक ऑब्जेक्ट के सिंटैक्स से पहले से ही परिचित हैं। तर्क फ़ीचर कॉलम, कक्षाओं की संख्या और मॉडल_डायरेक्टरी पिछले ट्यूटोरियल की तरह ही हैं। नया तर्क hidden_unit परतों की संख्या और तंत्रिका नेटवर्क से कनेक्ट करने के लिए कितने नोड्स को नियंत्रित करता है। नीचे दिए गए कोड में, दो छिपी हुई परतें हैं जिनमें से पहली 300 नोड्स को जोड़ती है और दूसरी 100 नोड्स को जोड़ती है।

अनुमानक बनाने के लिए, निम्नलिखित पैरामीटर के साथ tf.estimator.DNNClassifier का उपयोग करें:

• feature_columns: नेटवर्क में उपयोग किए जाने वाले कॉलम को परिभाषित करें
• hidden_units: छिपे हुए न्यूरॉन्स की संख्या निर्धारित करें
• n_classes: पूर्वानुमानित कक्षाओं की संख्या निर्धारित करें
• मॉडल_निर्देशिका: TensorBoard का पथ परिभाषित करें

estimator = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100], 
    n_classes=10, 
    model_dir = '/train/DNN')

चरण 5) मॉडल को प्रशिक्षित और मूल्यांकन करें

आप मॉडल को प्रशिक्षित करने और उसका मूल्यांकन करने के लिए numpy विधि का उपयोग कर सकते हैं

# Train the estimator
train_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=50,
    shuffle=False,
    num_epochs=None)
estimator.train(input_fn = train_input,steps=1000) 
eval_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test, 
    shuffle=False,
    batch_size=X_test_scaled.shape[0],
    num_epochs=1)
estimator.evaluate(eval_input,steps=None) 

आउटपुट:

{'accuracy': 0.9637143,
 'average_loss': 0.12014342,
 'loss': 1682.0079,
 'global_step': 1000}

वर्तमान वास्तुकला से मूल्यांकन सेट पर 96 प्रतिशत की सटीकता प्राप्त होती है।

चरण 6) मॉडल में सुधार करें

आप नियमितीकरण पैरामीटर जोड़कर मॉडल को बेहतर बनाने का प्रयास कर सकते हैं।

हम 0.3 की ड्रॉपआउट दर, X के L1 और y के L2 के साथ एडम ऑप्टिमाइज़र का उपयोग करेंगे। TensorFlow न्यूरल नेटवर्क में, आप ऑप्टिमाइज़र के नाम के बाद ऑब्जेक्ट ट्रेन का उपयोग करके ऑप्टिमाइज़र को नियंत्रित कर सकते हैं। TensorFlow प्रॉक्सिमल एडाग्रैड ऑप्टिमाइज़र के लिए एक अंतर्निहित एपीआई है।

डीप न्यूरल नेटवर्क में नियमितीकरण जोड़ने के लिए, आप निम्नलिखित पैरामीटर के साथ tf.train.ProximalAdagradOptimizer का उपयोग कर सकते हैं

• सीखने की दर: learning_rate
• L1 नियमितीकरण: l1_regularization_strength
• L2 नियमितीकरण: l2_regularization_strength

estimator_imp = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100],
    dropout=0.3, 
    n_classes = 10,
    optimizer=tf.train.ProximalAdagradOptimizer(
      learning_rate=0.01,
      l1_regularization_strength=0.01, 
      l2_regularization_strength=0.01
    ),
    model_dir = '/train/DNN1')
estimator_imp.train(input_fn = train_input,steps=1000) 
estimator_imp.evaluate(eval_input,steps=None) 

आउटपुट:

{'accuracy': 0.95057142,
 'average_loss': 0.17318928,
 'loss': 2424.6499,
 'global_step': 2000}

ओवर फिटिंग को कम करने के लिए चुने गए मानों ने मॉडल की सटीकता में सुधार नहीं किया। आपके पहले मॉडल की सटीकता 96% थी जबकि L2 रेगुलराइज़र वाले मॉडल की सटीकता 95% है। आप अलग-अलग मानों के साथ प्रयास कर सकते हैं और देख सकते हैं कि यह सटीकता को कैसे प्रभावित करता है।

सारांश

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

• छिपी हुई परतों की संख्या
• पूर्णतः जुड़े नोड की संख्या
• सक्रियण फ़ंक्शन
• अनुकूलक
• कक्षाओं की संख्या

TensorFlow ANN में, आप वर्गीकरण समस्या के लिए तंत्रिका नेटवर्क को प्रशिक्षित कर सकते हैं:

• tf.estimator.DNNक्लासिफायर

आकलनकर्ता को यह निर्दिष्ट करना आवश्यक है:

• फ़ीचर_कॉलम=फ़ीचर_कॉलम,
• hidden_units=[300, 100]
• n_क्लासेस=10
• मॉडल_निर्देशिका

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