पुस्तक "ग्रॉक डीप लर्निंग"

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

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

हम आपको अपने आप से परिचित कराते हैं कि "एक गहन शिक्षण ढांचा क्या है?"

अच्छे उपकरण त्रुटियों को कम करते हैं, गति विकास, और निष्पादन की गति बढ़ाते हैं।

यदि आप गहरी शिक्षा के बारे में बहुत कुछ पढ़ते हैं, तो आप शायद ऐसे प्रसिद्ध ढांचे जैसे PyTorch, TensorFlow, Theano (हाल ही में अप्रचलित घोषित), Keras, Lasagne और DyNet में आ गए। पिछले कुछ वर्षों में, फ्रेमवर्क बहुत तेज़ी से विकसित हुए हैं, और इस तथ्य के बावजूद कि इन सभी फ़्रेमवर्क को मुफ्त और खुला स्रोत वितरित किया गया है, उनमें से प्रत्येक में प्रतिस्पर्धा और ऊहापोह की भावना है।

अब तक, मैंने रूपरेखाओं पर चर्चा करने से परहेज किया है, क्योंकि, सबसे पहले, यह समझना आपके लिए बेहद ज़रूरी था कि पर्दे के पीछे क्या चल रहा था, एल्गोरिदम को मैन्युअल रूप से लागू करना (केवल NumPy लाइब्रेरी का उपयोग करके)। लेकिन अब हम ऐसे फ्रेमवर्क का उपयोग करना शुरू कर देंगे, क्योंकि हम जिस नेटवर्क को प्रशिक्षित करने जा रहे हैं, दीर्घकालिक अल्पकालिक मेमोरी (LSTM) के साथ नेटवर्क, बहुत जटिल हैं, और कोड जो कि उन्हें NumPy का उपयोग करते हुए लागू करता है, इस कोड को पढ़ना, उपयोग करना और डीबग करना मुश्किल है (ग्रेडर इस कोड में) सभी जगह पाए जाते हैं)।

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

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

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

टेन्सर्स का परिचय

सेंसर वैक्टर और मैट्रिस का एक अमूर्त रूप हैं

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

import numpy as np class Tensor (object): def __init__(self, data): self.data = np.array(data) def __add__(self, other): return Tensor(self.data + other.data) def __repr__(self): return str(self.data.__repr__()) def __str__(self): return str(self.data.__str__()) x = Tensor([1,2,3,4,5]) print(x) [1 2 3 4 5] y = x + x print(y) [2 4 6 8 10] 

यह हमारी बुनियादी डेटा संरचना का पहला संस्करण है। ध्यान दें कि यह सभी संख्यात्मक जानकारी को NumPy अरै (self.data) में संग्रहीत करता है और एक एकल टेंसर ऑपरेशन (जोड़) का समर्थन करता है। अतिरिक्त संचालन को जोड़ना बिल्कुल भी मुश्किल नहीं है, बस अतिरिक्त कार्यक्षमता के साथ अतिरिक्त कार्यों को Tensor वर्ग में जोड़ें।

स्वचालित ढाल गणना (ऑटोग्राद) का परिचय

इससे पहले, हमने मैनुअल बैक प्रचार किया। अब इसे स्वचालित बनाते हैं!

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

 import numpy as np class Tensor (object): def __init__(self, data, creators=None, creation_op=None): self.data = np.array(data) self.creation_op = creation_op self.creators = creators self.grad = None def backward(self, grad): self.grad = grad if(self.creation_op == "add"): self.creators[0].backward(grad) self.creators[1].backward(grad) def __add__(self, other): return Tensor(self.data + other.data, creators=[self,other], creation_op="add") def __repr__(self): return str(self.data.__repr__()) def __str__(self): return str(self.data.__str__()) x = Tensor([1,2,3,4,5]) y = Tensor([2,2,2,2,2]) z = x + y z.backward(Tensor(np.array([1,1,1,1,1]))) 

यह विधि दो नवाचारों का परिचय देती है। सबसे पहले, प्रत्येक टेंसर दो नई विशेषताओं को प्राप्त करता है। रचनाकार किसी भी टेंसरों की एक सूची है जिसका उपयोग वर्तमान टेंसर (कोई नहीं के लिए चूक) बनाने के लिए किया जाता है। यही है, अगर अन्य दो दसियों, x और y को जोड़कर टेंसर z प्राप्त किया जाता है, तो टेंसर z के रचनाकारों के गुण में टेनर्स x और y समाहित होंगे। creation_op एक साथी विशेषता है जो इस टेंसर को बनाने की प्रक्रिया में उपयोग किए जाने वाले संचालन को संग्रहीत करता है। यही है, निर्देश z = x + y तीन नोड्स (x, y और z) और दो किनारों (z -> x और z -> y) के साथ एक कम्प्यूटेशनल ग्राफ बनाएगा। प्रत्येक किनारे को रचना_ओप से ऑपरेशन द्वारा हस्ताक्षरित किया जाता है, अर्थात, जोड़ें। यह ग्राफ़ ग्रेडिएंट्स के पुनरावर्ती पिछड़े प्रसार को व्यवस्थित करने में मदद करेगा।


इस कार्यान्वयन में पहला नवाचार प्रत्येक गणितीय ऑपरेशन के दौरान एक ग्राफ का स्वचालित निर्माण है। यदि हम z लेते हैं और एक और ऑपरेशन करते हैं, तो ग्राफ को एक नए चर रेफरिंग z में जारी रखा जाएगा।

टेन्सर वर्ग के इस संस्करण में दूसरा नवाचार ग्रेडिएंट्स की गणना करने के लिए एक ग्राफ का उपयोग करने की क्षमता है। यदि आप z.backward () पद्धति को कॉल करते हैं, तो यह x और y के लिए ग्रेडिएंट पास करेगा, जिसमें उस फ़ंक्शन को ध्यान में रखा जाएगा जिसके साथ z (एड) टेंसर बनाया गया था। जैसा कि ऊपर के उदाहरण में दिखाया गया है, हम ढाल वेक्टर (np.array ([1,1,1,1,1]]) को z में पास करते हैं, और वह इसे अपने माता-पिता पर लागू करता है। जैसा कि आप शायद अध्याय 4 से याद करते हैं, इसके अलावा पिछड़े प्रसार के माध्यम से पिछड़े प्रचार को लागू करना है। इस मामले में, हमारे पास x और y में जोड़ने के लिए केवल एक ढाल है, इसलिए हम इसे z से x और y में कॉपी करते हैं:

 print(x.grad) print(y.grad) print(z.creators) print(z.creation_op) [1 1 1 1 1] [1 1 1 1 1] [array([1, 2, 3, 4, 5]), array([2, 2, 2, 2, 2])] add 

स्वचालित ढाल गणना के इस रूप की सबसे उल्लेखनीय विशेषता यह है कि यह पुनरावर्ती रूप से काम करता है - प्रत्येक वेक्टर अपने सभी माता-पिता की .backward () विधि को self.creators सूची से कहता है:


»पुस्तक की अधिक जानकारी प्रकाशक की वेबसाइट पर देखी जा सकती है
» सामग्री
» अंश

फेरीवालों के लिए कूपन पर 25% की छूट - डीप लर्निंग
पुस्तक के पेपर संस्करण के भुगतान पर, ई-मेल द्वारा एक इलेक्ट्रॉनिक पुस्तक भेजी जाती है।