वर्गीकरण के लिए आरबीएम का उपयोग कैसे करें?

12

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

मैंने जो मॉडल बनाया है, वह अब काफी फेमस जेनेरेटिव मॉडल है, लेकिन मुझे नहीं पता कि इसके साथ आगे कैसे जाना है।

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

क्या इसका मतलब यह है कि मुझे जो कुछ करना है वह छिपी हुई इकाइयों को इनपुट का प्रचार करना है और मेरे पास वर्गीकरण के लिए मेरी आरबीएम सुविधा है?

क्या कोई मुझे यह प्रक्रिया समझा सकता है?

classification rbm

— प्रदर्शित होने वाला नाम
स्रोत

प्रतिबंधित बोल्ट्जमैन मशीन गहन सीखने के लिए इस्तेमाल किए जाने वाले शुरुआती घटकों में से एक है। वास्तव में, डीएनएन में पहला महत्वपूर्ण काम हिंटन द्वारा किया गया था अधिक जानकारी के लिए RBM पर आधारित गहरा विश्वास नेटवर्क इस पेपर (गहन विश्वास नेटवर्क, 2007 के लिए खोज करें) पर आधारित था। उनकी वेबसाइट पर आप बहुत महत्वपूर्ण संसाधनों के साथ-साथ एक डेमो प्रयोग cs.toronto.edu/~hinton/digits.html

— बशर हदद

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

— M3tho5

15

प्रतिबंधित बोल्ट्जमान मशीनों की समीक्षा

एक प्रतिबंधित बोल्ट्ज़मन मशीन (आरबीएम) एक जेनेरेटिव मॉडल है, जो इनपुट पर संभाव्यता वितरण सीखता है। इसका मतलब है, प्रशिक्षित होने के बाद, आरबीएम सीखे गए संभाव्यता वितरण से नए नमूने उत्पन्न कर सकता है। दृश्य इकाइयों पर संभाव्यता वितरण द्वारा दिया गया है। जहां और फ़ंक्शन है, है दिखाई नोड के लिए पूर्वाग्रह , और से वजन है को $\mathbf{v}$

p (v ∣ h) = \prod_{i = 0}^{V} p (v_{i} ∣ h),

$p(\mathbf{v} \mid \mathbf{h}) = \prod_{i=0}^V p(v_i \mid \mathbf{h}),$

p (v_{i} ∣ h) = σ (a_{i} + \sum_{j = 0}^{H} w_{j i} h_{j})

$p(v_i \mid \mathbf{h}) = \sigma\left( a_i + \sum_{j=0}^H w_{ji} h_j \right)$

σ

$\sigma$

a_{i}

$a_i$

i

$i$

w_{j i}

$w_{ji}$

h_{j}

$h_j$

v_{i}

$v_i$ । इन दो समीकरणों से, यह इस प्रकार है कि केवल छिपे हुए राज्य पर निर्भर करता है । इसका अर्थ है कि एक दृश्य नमूना कैसे उत्पन्न होता है, इसकी जानकारी को छिपी इकाइयों, भार और पूर्वाग्रहों में संग्रहीत किया जाना है।

p (v ∣ h)

$p(\mathbf{v} \mid \mathbf{h})$

h

$\mathbf{h}$

v

$\mathbf{v}$

वर्गीकरण के लिए आरबीएम का उपयोग करना

वर्गीकरण कार्यों के लिए RBMs का उपयोग करते समय, आप निम्नलिखित विचार का उपयोग करते हैं: आपके प्रशिक्षण या परीक्षण डेटा को कैसे जनरेट किया जाता है, इस जानकारी के रूप में छिपी इकाइयों में सहेजा गया है , आप इन अंतर्निहित कारकों को एक प्रशिक्षण नमूना खिलाकर निकाल सकते हैं। RBM की दृश्य इकाइयाँ, इसे छिपी हुई इकाइयों के आगे प्रचारित करती हैं, और छिपी हुई इकाइयों के इस वेक्टर को फीचर वेक्टर के रूप में उपयोग करती हैं। अब आप किसी भी पीछे की ओर दृश्य इकाइयों को पास नहीं करते हैं। $\mathbf{h}$

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

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

— hbaderts
स्रोत

@ Seanny123 के संपादन के लिए धन्यवाद, इससे पढ़ने में बहुत आसानी होती है।

— हेबैडर्ट

5

@ हडर्ट्स ने पूरे वर्कफ़्लो को पूरी तरह से वर्णित किया। हालाँकि, यह इस मामले में कोई मतलब नहीं है कि आप इस विचार के लिए पूरी तरह से नए हैं। इसलिए, मैं इसे आम आदमी के तरीके से समझाने जा रहा हूं (इसलिए, मैं विवरणों को छोड़ दूंगा):

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

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

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

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

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

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

— नमक
स्रोत

0

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

— क्रिस्टिन एच
स्रोत