दीप लर्निंग विथ पायथन: बिगिनर्स गाइड टू डीप लर्निंग

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

• डेटा विज्ञान और इसके घटक
• डीप लर्निंग की जरूरत
• डीप लर्निंग क्या है?
• परसेप्ट्रान और कृत्रिम तंत्रिका नेटवर्क
• डीप लर्निंग के अनुप्रयोग
• क्यों डीप लर्निंग के लिए पायथन?
• दीप लर्निंग विथ पाइथन: परसेप्ट्रॉन उदाहरण
• दीप लर्निंग विथ पायथन: एक डीप न्यूरल नेटवर्क बनाना

डेटा विज्ञान और इसके घटक

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

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

खैर, वापस तो हमारे पास पर्याप्त डेटा और गणना शक्ति नहीं थी, लेकिन अब साथ है बड़ा डेटा अस्तित्व में आने और GPU के आगमन के साथ, आर्टिफिशियल इंटेलिजेंस संभव है।

एआई तकनीक का एक सबसेट है जो मशीनों को अनुभव के साथ बेहतर बनाने में सक्षम बनाता है।

ध्यान लगा के पढ़ना या सीखना एमएल का एक सबसेट है जो बहु-परत तंत्रिका नेटवर्क की गणना को संभव बनाता है। यह मानव जैसे निर्णय लेने का अनुकरण करने के लिए तंत्रिका नेटवर्क का उपयोग करता है।

डीप लर्निंग की जरूरत

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

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

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

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

डीप लर्निंग क्या है?

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

जैसा कि आप जानते हैं,हमारा मस्तिष्क बना हुआ है अरबों न्यूरॉन्स जो हमें आश्चर्यजनक चीजें करने की अनुमति देता है। यहां तक ​​कि एक छोटे बच्चे का मस्तिष्क जटिल समस्याओं को हल करने में सक्षम है जो सुपर-कंप्यूटर का उपयोग करके भी हल करना बहुत मुश्किल है। तो, हम एक कार्यक्रम में समान कार्यक्षमता कैसे प्राप्त कर सकते हैं? अब, यह वह जगह है जहाँ हम समझते हैं कृत्रिम न्यूरॉन (परसेप्ट्रॉन) तथा कृत्रिम तंत्रिका नेटवर्क।

परसेप्ट्रान और कृत्रिम तंत्रिका नेटवर्क

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

• डेंड्राइट: अन्य न्यूरॉन्स से संकेत प्राप्त करता है
• कोशिका - पिण्ड: सभी इनपुट्स को गाया
• Axon: इसका उपयोग सिग्नल को अन्य कोशिकाओं तक पहुंचाने के लिए किया जाता है

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

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

• संक्षेप
• परिवर्तन (सक्रियण)

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

सक्रियण कार्य आउटपुट में इनपुट का अनुवाद करता है। यह आउटपुट उत्पन्न करने के लिए थ्रेशोल्ड का उपयोग करता है। कई कार्य हैं जिन्हें सक्रियण क्रियाओं के रूप में उपयोग किया जाता है, जैसे:

• रैखिक या पहचान
• यूनिट या बाइनरी स्टेप
• सिग्मॉइड या लॉजिस्टिक
• तन्ह
• ReLU
• सॉफ्टमैक्स

कुंआ। अगर आपको लगता है कि पेसेप्ट्रॉन समस्या को हल करता है, तो आप गलत हैं। दो प्रमुख समस्याएं थीं:

• सिंगल-लेयर पेसेप्ट्रॉन गैर-रेखीय रूप से वियोज्य डेटा बिंदुओं को वर्गीकृत नहीं कर सकता ।
• जटिल समस्याएं, जिसमें शामिल है बहुत सारे पैरामीटर सिंगल-लेयर पेसेप्ट्रॉन द्वारा हल नहीं किया जा सकता है।

मार्केटिंग टीम द्वारा निर्णय लेने के लिए इसमें शामिल मापदंडों के साथ यहाँ और जटिलता पर विचार करें।

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

jquery और जावास्क्रिप्ट के बीच क्या अंतर है

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

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

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

उद्योग में डीप लर्निंग के विभिन्न अनुप्रयोग हैं, यहाँ कुछ महत्वपूर्ण हैं जो हमारे दिन-प्रतिदिन के कार्यों में मौजूद हैं।

• वाक् पहचान

• मशीन अनुवाद

• चेहरे की पहचान और स्वचालित टैगिंग

• वर्चुअल पर्सनल असिस्टेंट

• सेल्फ ड्राइविंग कार

• चटबट

क्यों डीप लर्निंग के लिए पायथन?

• एक ऐसा उपकरण है जिसमें एक विशिष्ट गुण है, एक होने का सामान्य प्रयोजन प्रोग्रामिंग भाषा जैसा हो रहा है प्रयोग करने में आसान जब यह विश्लेषणात्मक और मात्रात्मक कंप्यूटिंग की बात आती है।
• ये तो बहुत समझने में आसान
• अजगर है डायनामिक रूप से टाइप किया हुआ
• विशाल
• विभिन्न उद्देश्यों के लिए पुस्तकालयों की एक विशाल श्रृंखला Numpy, Seaborn, Matplotlib, Pandas और Scikit-learn

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

दीप लर्निंग विथ पाइथन: पेरीसेप्टन उदाहरण

अब मुझे यकीन है कि आप लोग “के काम से परिचित होंगे या ' द्वार। आउटपुट है एक यदि कोई इनपुट भी है एक।

इसलिए, एक पेसेप्ट्रॉन को विभाजक या एक निर्णय रेखा के रूप में इस्तेमाल किया जा सकता है जो OR गेट के इनपुट सेट को दो वर्गों में विभाजित करता है:

वर्ग 1: इनपुट 0 के रूप में आउटपुट है जो निर्णय रेखा के नीचे स्थित है।
कक्षा 2: आउटपुट 1 के रूप में इनपुट जो निर्णय रेखा या विभाजक के ऊपर स्थित है।

अब तक, हम यह समझते थे कि इनपुट डेटा को दो वर्गों में वर्गीकृत करने के लिए एक रेखीय पर्सेप्ट्रॉन का उपयोग किया जा सकता है। लेकिन, यह वास्तव में डेटा को कैसे वर्गीकृत करता है?

गणितीय रूप से एक अवधारणात्मक भार, भार, इनपुट और पूर्वाग्रह के समीकरण की तरह सोचा जा सकता है।

चरण 1: सभी आवश्यक पुस्तकालय आयात करें

यहाँ मैं केवल एक पुस्तकालय आयात करने जा रहा हूँ, अर्थात। TensorFlow

tf के रूप में आयात स्पर्शरेखा

चरण 2: इनपुट और आउटपुट के लिए वेक्टर चर को परिभाषित करें

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

train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1] [१]]

चरण 3: वजन चर को परिभाषित करें

यहाँ हम अपने वज़न के लिए आकार 3 × 1 के टेंसर वेरिएबल को परिभाषित करेंगे और इसे शुरू में कुछ यादृच्छिक मान प्रदान करेंगे।

w = tf.Variable (tf.random_normal ([3, 1], बीज = 15))

चरण 4: इनपुट और आउटपुट के लिए प्लेसहोल्डर्स को परिभाषित करें

हमें प्लेसहोल्डर्स को परिभाषित करने की आवश्यकता है ताकि वे रन पर बाहरी आदानों को स्वीकार कर सकें।

x = tf.placeholder (tf.float32, [कोई नहीं, 3]) y = tf.placeholder (tf.float32, [कोई नहीं, 1])

चरण 5: आउटपुट और सक्रियण फ़ंक्शन की गणना करें

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

आउटपुट = tf.nn.relu (tf.matmul (x, w))

नोट: इस मामले में, मैंने उपयोग किया है relu मेरे सक्रियण समारोह के रूप में। आप अपनी आवश्यकता के अनुसार किसी भी सक्रियण कार्य का उपयोग करने के लिए स्वतंत्र हैं।

चरण 6: लागत या त्रुटि की गणना करें

हमें लागत = मीन चुकता त्रुटि की गणना करने की आवश्यकता है जो कि अवधारणात्मक आउटपुट और वांछित आउटपुट के अंतर के अलावा कुछ भी नहीं है।

हानि = tf.reduce_sum (tf.square (आउटपुट - y))

चरण 7: त्रुटि को कम करें

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

अनुकूलक = tf.train.GradientDescentOptimizer (0.01) ट्रेन = optimizer.minimize (हानि)

चरण 8: सभी चर को प्रारंभ करें

चर केवल के साथ परिभाषित किए गए हैं tf.Variable। इसलिए, हमें परिभाषित चर को आरंभ करने की आवश्यकता है।

init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)

चरण 9: Iterations में प्रशिक्षण परसेप्ट्रॉन

हमें त्रुटि या हानि को कम करने के लिए अपने अवधारणात्मक यानी वजन और पूर्वाग्रह के मूल्यों को क्रमिक पुनरावृत्ति में प्रशिक्षित करने की आवश्यकता है। यहाँ, हम 100 युगों में हमारे अवधारणात्मक को प्रशिक्षित करेंगे।

i for रेंज (100): sess.run (ट्रेन, {x: train_in, y: train_out}) लागत = sess.run (हानि, feed_dict = {x: train_in, y: train_out}) प्रिंट ('युग) ', i,' - हानि - ', लागत)

चरण 10: आउटपुट

……

……

जैसा कि आप यहां देख सकते हैं, नुकसान की शुरुआत हुई 2.07 और पर समाप्त हुआ 0.27

।

दीप लर्निंग विथ पायथन: एक डीप न्यूरल नेटवर्क बनाना

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

हम MNIST डेटा-सेट का उपयोग करने जा रहे हैं। MNIST डेटा-सेट के होते हैं 60,000 का प्रशिक्षण नमूने और 10,000 परीक्षण हस्तलिखित अंकों की छवियों के नमूने। चित्र आकार के हैं 28 × 28 पिक्सेल और आउटपुट के बीच झूठ हो सकता है 0-9 ।

यहां कार्य एक मॉडल को प्रशिक्षित करना है जो छवि पर मौजूद अंकों की सटीक पहचान कर सकता है

सबसे पहले, हम पायथन 3 से पायथन 2.6+ में प्रिंट फ़ंक्शन लाने के लिए नीचे के आयात का उपयोग करने जा रहे हैं। __future__ स्टेटमेंट्स को फ़ाइल के शीर्ष के पास होना चाहिए क्योंकि वे भाषा के बारे में मूलभूत चीजों को बदलते हैं, और इसलिए कंपाइलर को उनके बारे में शुरुआत से जानना चाहिए

__future__ से प्रिंट_फंक्शन आयात करें

निम्नलिखित हर कदम पर टिप्पणियों के साथ कोड है

# आयात MNIST डेटा को टेनसॉरफ़्लो.एक्सटामैंट्स.टाइरेसिस्ट। इंमनिस्ट इम्पोर्ट input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True: ts आयात matplotl.pyplot के रूप में plt # Parameters learning_rate = 0. प्रशिक्षण = 0. प्रशिक्षण / प्रशिक्षण में आयात करें। बैच_साइज = 100 डिस्प्ले_स्टेप = 1 # नेटवर्क पैरामीटर्स n_hidden_1 = 256 # पहली परत की संख्या n_hidden_2 = 256 # 2 परत की संख्या सुविधाओं n_input = 784 # MNIST डेटा इनपुट (img आकार: 28 * 28) n_classes = 10 # MNIST कुल कक्षाएं ( 0-9 अंक) # tf ग्राफ़ इनपुट x = tf.placeholder ('फ़्लोट', [कोई नहीं, n_input]) y = tf.placeholder ('फ़्लोट', [कोई नहीं, n_classes]) 'मॉडल डीफ़ मल्टीलेयर_पेसेप्ट्रॉन (x, वज़न) बनाएँ , biases): # RELU सक्रियण परत के साथ छिपी परत = tf.add (tf.matmul (x, weights ['h1']), biases ['b1']) layer_1 = tf.nn.relu (layer_1) # हिडन परत RELU सक्रियण लेयर के साथ_2 = tf.add (tf.matmul (layer_1, weights ['h2']), biases ['b2']) layer_2 = tf.nn.relu (layer_2) # रेखीय सक्रियण out_layer = tf के साथ आउटपुट परत। मटमूल (परत) _2, वेट ['आउट'] + बायसेस ['आउट'] रिटर्न आउट_लेयर # स्टोर लेयर्स व बायस वेट्स = {'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])), 'h2' : tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_hidden_2, n_classes])}} biases = {'b1': tf.Variable। random_normal ([n_hidden_1])), 'b2': tf.Variable (tf.random_normal ([n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_classes])}} # कंस्ट्रक्शन मॉडल पूर्व = Multilayer_ (x, वज़न, पूर्वाग्रह) # घाटा और आशावादी लागत को परिभाषित करें = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, label = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) का निर्धारण करें। # वैरिएबल init की शुरुआत करना = tf.global_variables_initializer () # लागत इतिहास और सटीकता इतिहास cost_history = [] सटीकता_history = [] को संग्रहीत करने के लिए एक खाली सूची बनाएं # tf.Session () sess: sess.run (init) के रूप में ग्राफ लॉन्च करें। ) # रेंज में युग के लिए प्रशिक्षण चक्र (training_epochs): avg_cost = 0. Total_batch = int (mnist.train.num_examples / batch_size) # मैं रेंज में सभी बैचों के लिए लूप (Total_batch): बैच_x, बैच_x = mnist.train.next_batch (बैच_साइज़) # रन ऑप्टिमाइज़ेशन सेशन (बैकप्रॉप) op (हानि मान प्राप्त करने के लिए) _, c = sess.run ([ऑप्टिमाइज़र, लागत], feed_dict = {x: बैच_x, y: बैच_y}) # गणना औसत हानि avg_cost + = c / total_batch # प्रदर्शन लॉग प्रति युग चरण यदि। epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (पूर्व, 1), tf.argmax (y, 1)) # सटीकता की गणना सटीकता = tf.reduce_mean (tf.cast (correct_prediction, 'float')। ) acu_temp = सटीकता.वैल ({x: mnist.test.images, y: mnist.test.labels}) # सटीकता को सूची सटीकता के लिए भेजें_history.append (acu_pemp) # लागत इतिहास की लागत_हाइस्टर .append (avg_cost) प्रिंट ('युग:', '% 04d'% (युग + 1), '- लागत =', '{: .9f}'। स्वरूप (avg_cost), '- सटीकता =', acu_temp: प्रिंट ('अनुकूलन समाप्त)! ') # प्लॉट द कॉस्ट हिस्ट्री plt.plot (cost_history) plt.show () # सटीकता का इतिहास plt.plot (सटीकता) _history) plt.show () # टेस्ट मॉडल correct_prediction = tf.equal (tf.argmax (पूर्व, 1), tf.argmax (y, 1)) # सटीकता की गणना करें = tf.reduce_mean (tf.cast (correct_prediction, ') फ्लोट ')) प्रिंट (' सटीकता: ', सटीकता.वैल ({x: mnist.test.images, y: mnist.test.labels}))

आउटपुट:

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

एडुर्का की उद्योग की आवश्यकताओं और मांगों के अनुसार उद्योग के पेशेवरों द्वारा क्यूरेट किया जाता है। आप SoftMax फ़ंक्शन, Autoencoder Neural Networks, Restricted Boltzmann मशीन (RBM) और कासेर और TFLearn जैसे पुस्तकालयों के साथ काम करते हैं। पाठ्यक्रम को विशेष रूप से उद्योग के विशेषज्ञों द्वारा वास्तविक समय के मामले के अध्ययन के साथ क्यूरेट किया गया है।

जावा में स्कैनर क्या है

क्या आप हमसे कोई प्रश्न पूछना चाहते हैं? कृपया इसे 'दीप लर्निंग विथ पायथन' के टिप्पणी अनुभाग में उल्लेख करें और हम आपके पास वापस आ जाएंगे।