वास्तविक छवि मान्यता के लिए सीमित बोल्ट्जमन मशीनों के साथ पूर्व प्रशिक्षण

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

C # में प्रतिबंधित बोल्ट्जमान मशीन को लागू करना ,
एक सीमित बोल्ट्जमान मशीन का उपयोग करके तंत्रिका नेटवर्क प्रशिक्षण

सब कुछ खराब क्यों है?

लिमिटेड बोल्ट्जमान मशीनों को मूल रूप से स्टोकेस्टिक बाइनरी न्यूरॉन्स का उपयोग करके विकसित किया गया था, जो दृश्य और छिपे हुए दोनों हैं। बाइनरी डेटा के साथ काम करने के लिए इस तरह के एक मॉडल का उपयोग काफी स्पष्ट है। हालाँकि, अधिकांश वास्तविक चित्र बाइनरी नहीं हैं, लेकिन कम से कम ग्रे के रंगों में प्रतिनिधित्व करते हैं, प्रत्येक पिक्सेल का पूर्णांक चमक मान 0 से 255 तक होता है। समस्या के संभावित समाधानों में से एक है चमक मूल्यों को बदलना ताकि वे रेंज -1.1 में विभाजित हों (255 से विभाजित करें) ), और हम मानते हैं कि पिक्सेल वास्तव में द्विआधारी हैं, और प्राप्त मान प्रत्येक विशिष्ट पिक्सेल को एक में स्थापित करने की संभावना का प्रतिनिधित्व करते हैं। चलो लिखावट मान्यता ( MNIST ) और वॉइला के लिए इस दृष्टिकोण का उपयोग करने की कोशिश करें - सब कुछ शानदार ढंग से काम करता है और काम करता है! सब कुछ बुरा क्यों है?

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

इसे अच्छा कैसे बनाया जाए ...

हमें दृश्यमान न्यूरॉन्स का प्रतिनिधित्व करने का एक तरीका चाहिए जो कह सकता है कि तीव्रता सबसे अधिक संभावना के बराबर है, कहते हैं, 0.61, कम संभावना 0.59 या 0.63, और बहुत, बहुत कम 0.5 या 0.72। संभावना घनत्व समारोह कुछ इस तरह दिखना चाहिए:

हाँ, यह एक सामान्य वितरण है ! कम से कम इसका उपयोग ऐसे न्यूरॉन व्यवहार को अनुकरण करने के लिए किया जा सकता है, जिसे हम बर्नौली वितरण के बजाय सामान्य वितरण के साथ दृश्यमान न्यूरॉन्स के यादृच्छिक चर के मान से करेंगे। यह ध्यान दिया जाना चाहिए कि सामान्य वितरण न केवल वास्तविक छवियों के साथ काम करने के लिए उपयोग करने के लिए सुविधाजनक है, बल्कि रेंज [-noted; + ∞] से वास्तविक संख्याओं द्वारा दर्शाए गए कई अन्य डेटा के साथ, जिसके लिए यह सीमा से द्विआधारी रूप या संभावनाओं के मूल्यों को कम करने का कोई मतलब नहीं है। [०; १] ^[२] । इस मामले में, छिपे हुए न्यूरॉन बाइनरी रहते हैं और हमें तथाकथित गाऊसी-बाइनरी आरबीएम मिलता है, जिसके लिए न्यूरॉन्स के मूल्यों का वितरण सूत्र ^[3] द्वारा दिया जाता है।






और बोल्ट्जमैन मशीन की ऊर्जा के बराबर है



जहां छिपा हुआ न्यूरॉन्स के सूचकांकों का समूह है,
दृष्टि - दृश्यमान न्यूरॉन्स के कई सूचकांक,
बी - पूर्वाग्रह (ऑफसेट),
σ _{मैं ith} दृश्यमान न्यूरॉन के लिए मानक विचलन है,
w _{i, j,} i-th और j-th न्यूरॉन के बीच संबंध का वजन है,
N (x | μ,) ² ) प्रत्याहार μ और फैलाव normal ^{2 के} साथ एक सामान्य वितरण के साथ चर के लिए x के मूल्य की संभावना है।

विचार करें कि v के साथ RBM ऊर्जा कैसे बदलती है। घटक b _i (पूर्वाग्रह) ith दृश्यमान न्यूरॉन (संबंधित छवि पिक्सेल की तीव्रता) के वांछित मूल्य के लिए जिम्मेदार है, और ऊर्जा स्वयं इस मान से विचलन के साथ द्विघात रूप से बढ़ जाती है:

सूत्र का अंतिम घटक, v _i और h _i पर निर्भर करता है, और उनकी सहभागिता का प्रतिनिधित्व करते हुए, _{मैं i} पर रैखिक रूप से निर्भर करता है:

लाल पेराबोला के साथ सुमीलिंग, यह घटक एक दिशा या किसी अन्य में न्यूनतम ऊर्जा को स्थानांतरित करता है। इस प्रकार, हमें वह व्यवहार मिलता है जिसकी हमें आवश्यकता होती है: लाल पेराबोला एक निश्चित मूल्य से मजबूत दूरी देकर न्यूरॉन के मूल्य को सीमित करने की कोशिश करता है, और वायलेट लाइन आरबीएम की अव्यक्त स्थिति के आधार पर इस मूल्य को स्थानांतरित करता है।

हालांकि, यहां कठिनाइयां पैदा होती हैं। सबसे पहले, प्रत्येक दृश्यमान न्यूरॉन के लिए, प्रशिक्षण के परिणामस्वरूप उपयुक्त पैरामीटर a _i चुनना आवश्यक है। दूसरे, अपने आप में to _{i के} छोटे मूल्य सीखने की कठिनाइयों को जन्म देते हैं, जिससे छिपे हुए न्यूरॉन्स के मजबूत प्रभाव और छिपे हुए न्यूरॉन्स के कमजोर प्रभाव दिखाई देते हैं:


तीसरा, दृश्यमान न्यूरॉन का मान अब अनिश्चित काल तक बढ़ सकता है, जिससे ऊर्जा अनिश्चित काल तक गिर सकती है, जो सीखने को बहुत कम स्थिर बनाती है। पहली दो समस्याओं को हल करने के लिए, जेफरी हिंटन ने प्रशिक्षण शुरू करने से पहले सभी प्रशिक्षण डेटा को सामान्य करने का प्रस्ताव रखा, ताकि उनके पास शून्य उम्मीद और इकाई भिन्नता हो, और फिर एकता के लिए उपरोक्त समीकरणों में पैरामीटर parameter _i सेट करें ^[4] । इसके अलावा, यह दृष्टिकोण आपको आँकड़े एकत्र करने और सामान्य स्थिति में (केवल बाइनरी न्यूरॉन्स का उपयोग करके) सीडी-एन पद्धति का उपयोग करके आरबीएम का प्रशिक्षण लेने के लिए ठीक उसी फॉर्मूले का उपयोग करने की अनुमति देता है। तीसरी समस्या को केवल परिमाण के 1-2 आदेशों द्वारा सीखने की दर को कम करके हल किया जाता है।

... और बेहतर भी

नतीजतन, हमने सीमित बोल्ट्जमान मशीन के दृश्यमान न्यूरॉन्स के साथ अच्छी तरह से वास्तविक-मूल्यवान डेटा का प्रतिनिधित्व करना सीखा है, लेकिन आंतरिक, अव्यक्त स्थिति अभी भी द्विआधारी है। क्या किसी तरह छिपे हुए न्यूरॉन्स में सुधार करना संभव है, जिससे उन्हें अधिक जानकारी मिल सके? यह आप कर सकते हैं पता चला है। यह बहुत आसान है, छिपे हुए न्यूरॉन्स को बाइनरी छोड़कर, उन्हें 1 से अधिक प्राकृतिक संख्याओं को प्रदर्शित करने के लिए। ऐसा करने के लिए, एक छिपे हुए न्यूरॉन को लें और दिखाई देने वाले न्यूरॉन्स (वीजिथ शेयरिंग) और एक प्रशिक्षित बाइस बाय से बिल्कुल समान वजन के साथ इसकी कई प्रतियां बनाएं। जब संभावनाओं की गणना करते हैं, तो हम प्रत्येक न्यूरॉन के विस्थापन से निश्चित मानों को घटा देंगे, विस्थापन के साथ समान रूप से समान न्यूरॉन्स के बहुत सारे प्राप्त कर रहे हैं b _i -0.5, b _i -1.5, b _i -2.5, b _i -3.5 ... परिणामस्वरूप, हमें सुधारा हुआ रैखिक इकाई का पूर्णांक संस्करण मिलता है। फैलाव के साथ शोर जोड़कर σ (x) = (1 + ऍक्स्प (-x)) ^-1 (न्यूरॉन्स की संभाव्य प्रकृति के कारण)। सीधे शब्दों में कहें, तो बड़ा मूल्य x = b _i + wv _j w _{i, j} इस तरह के न्यूरॉन के इनपुट पर, अधिक से अधिक इसकी प्रतियां एक साथ सक्रिय हो जाती हैं, जबकि सभी सक्रिय प्रतियों की संख्या एक प्राकृतिक संख्या के रूप में प्रदर्शित की जाएगी:



हालांकि, वास्तव में, प्रत्येक न्यूरॉन के लिए बड़ी संख्या में प्रतियां बनाना महंगा है, क्योंकि यह आरबीएम प्रशिक्षण / कार्य के प्रत्येक पुनरावृत्ति पर सिग्मोइड फ़ंक्शन की गणना की संख्या को उसी समय की संख्या से बढ़ाता है। इसलिए, हम नाटकीय रूप से कार्य करेंगे - हम तुरंत प्रत्येक न्यूरॉन के लिए अनंत संख्या में प्रतियां बनाएंगे! अब हमारे पास एक सरल सन्निकटन है जो हमें एक एकल सरल सूत्र ^[1,5] का उपयोग करके प्रत्येक न्यूरॉन के लिए परिणामी मूल्य की गणना करने की अनुमति देता है:



इस प्रकार, हमारे छिपे हुए न्यूरॉन्स गॉसियन शोर के साथ बाइनरी से रेक्टिफाइड रैखिक इकाइयों में बदल गए, जबकि लर्निंग एल्गोरिथ्म अछूता रहा (आखिरकार, हम मानते हैं कि ये वास्तव में एक ही बाइनरी न्यूरॉन्स हैं, ऊपर वर्णित केवल अनंत संख्या में प्रतियां हैं)। अब वे न केवल 0 और 1 का प्रतिनिधित्व कर सकते हैं, और न केवल प्राकृतिक, बल्कि सभी गैर-नकारात्मक वास्तविक संख्या भी! फैलाव 1 (x) ersion [0; 1] यह सुनिश्चित करता है कि पूरी तरह से निष्क्रिय न्यूरॉन्स शोर उत्पन्न नहीं करेगा और बढ़ते एक्स के साथ शोर बहुत बड़ा नहीं होगा। इसके अलावा, एक अच्छा बोनस: इस तरह के न्यूरॉन्स का उपयोग प्रत्येक न्यूरॉन के लिए पैरामीटर parameter _i सीखने की अनुमति देता है, यदि डेटा का प्रारंभिक सामान्यीकरण किसी कारण से असंभव या अवांछनीय है ^[1,2] , लेकिन हम इस पर विस्तार से ध्यान नहीं देंगे।

प्रशिक्षण कार्यान्वयन

सामान्य वितरण सूत्र से अपेक्षा को हटाकर, दृश्यमान न्यूरॉन के मूल्य की गणना सूत्र द्वारा की जा सकती है


जहां N (μ,) ² ) एक सामान्य वितरण, अपेक्षा μ और फैलाव। ^{2 के} साथ एक यादृच्छिक चर है।

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



छिपे हुए न्यूरॉन के मूल्य की गणना सूत्र द्वारा की जाती है



प्रशिक्षण को लागू करने के लिए, हम सीडी-एन में साधारण बाइनरी न्यूरॉन्स के लिए ठीक उसी फॉर्मूले का उपयोग करते हैं।

प्रयोग

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

सभी आधारों में, हम केवल एक विशिष्ट भावना के साथ चिह्नित छवियों का चयन करते हैं (आठ में से एक: तटस्थ अभिव्यक्ति, क्रोध, भय, घृणा, खुशी, आश्चर्य, अवमानना, उदासी)। हमें 719 चित्र मिले हैं। हम प्रशिक्षण के रूप में 70% बेतरतीब ढंग से चयनित छवियों (500 टुकड़े) का उपयोग करते हैं, और शेष 30% (219 टुकड़े) सत्यापन डेटा के रूप में (हमारे मामले में, वे परीक्षण वाले के रूप में उपयोग किए जा सकते हैं, क्योंकि हम उनकी मदद से किसी भी पैरामीटर का चयन नहीं करते हैं) । कार्यान्वयन के लिए हम MATLAB 2012 बी का उपयोग करेंगे। प्रत्येक छवि पर, मानक दृष्टि का उपयोग करके चेहरे का चयन करें। कैसकेडऑबजेक्टडाइक्टर, परिणामी वर्ग क्षेत्र को 10% तक बढ़ाएं ताकि ठुड्डी पूरी तरह से संसाधित छवि में फिट हो जाए। चेहरे की परिणामी छवि को 70x64 के आकार में संपीड़ित करें, इसे ग्रे के रंगों में तब्दील करें और सभी छवियों पर इसके विपरीत को बराबर करने के लिए हिस्टोग्राम समीकरण लागू करें। उसके बाद, हम प्रत्येक छवि को 1x4480 वेक्टर में विस्तारित करते हैं और ट्रेन_x और val_x मैट्रिक्स में संबंधित वैक्टर को बचाते हैं। Train_y और val_y मैट्रिसेस में, हम संबंधित वांछित क्लासिफायरियर आउटपुट वैक्टर (आकार 1x8, 1 को इनपुट वेक्टर द्वारा दर्शाए गए भाव की स्थिति में, शेष पदों में 0) को संग्रहीत करते हैं। डेटा तैयार है, यह प्रयोग शुरू करने का समय है।

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

हमारे तंत्रिका नेटवर्क की प्रत्येक परत में न्यूरॉन्स की संख्या: 4480 - 200 - 300 - 500 - 8. छिपी हुई परतों में न्यूरॉन्स की इतनी छोटी संख्या को सभी इनपुट छवियों के ओवरफिटिंग और सरल नेटवर्क मेमोराइजेशन को बाहर करने के लिए चुना जाता है, क्योंकि उनकी संख्या छोटी है। सबसे पहले, हम एक तंत्रिका नेटवर्क को सिग्मोइडल सक्रियण फ़ंक्शन के साथ प्रशिक्षित करते हैं, और पूर्व-प्रशिक्षण के लिए हम साधारण बाइनरी आरबीएम का उपयोग करते हैं।

tx = double(train_x)/255; ty = double(train_y); vx = double(val_x)/255; vy = double(val_y); % train DBN (stack of RBMs) dbn.sizes = [200 300 500]; opts.numepochs = 100; opts.batchsize = 25; opts.momentum = 0.5; opts.alpha = 0.02; opts.vis_units = 'sigm'; % Sigmoid visible and hidden units opts.hid_units = 'sigm'; dbn = dbnsetup(dbn, tx, opts); dbn = dbntrain(dbn, tx, opts); % train NN nn = dbnunfoldtonn(dbn, 8); nn.activation_function = 'sigm'; % Sigmoid hidden units nn.learningRate = 0.05; nn.momentum = 0.5; nn.output = 'softmax'; % Softmax output to get probabilities nn.errfun = @nntest; % Error function to use with plotting % calculates misclassification rate opts.numepochs = 550; opts.batchsize = 100; opts.plot = 1; opts.plotfun = @nnplotnntest; % Plotting function nn = nntrain(nn, tx, ty, opts,vx,vy); 

तंत्रिका नेटवर्क प्रशिक्षण अनुसूची:


10 के बीच सत्यापन डेटा पर औसत त्रुटि हर बार प्रशिक्षण और सत्यापन डेटा का एक नया यादृच्छिक नमूना 36.26% के साथ शुरू होता है।

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

 tx = double(train_x)/255; ty = double(train_y); normMean = mean(tx); normStd = std(tx); vx = double(val_x)/255; vy = double(val_y); tx = normalize(tx, normMean, normStd); %normalize data to have mean 0 and variance 1 vx = normalize(vx, normMean, normStd); % train DBN (stack of RBMs) dbn.sizes = [200 300 500]; opts.numepochs = 100; opts.batchsize = 25; opts.momentum = 0.5; opts.alpha = 0.0001; % 2 orders of magnitude lower learning rate opts.vis_units = 'linear'; % Linear visible units opts.hid_units = 'NReLU'; % Noisy rectified linear hidden units dbn = dbnsetup(dbn, tx, opts); dbn = dbntrain(dbn, tx, opts); % train NN nn = dbnunfoldtonn(dbn, 8); nn.activation_function = 'ReLU'; % Rectified linear units nn.learningRate = 0.05; nn.momentum = 0.5; nn.output = 'softmax'; % Softmax output to get probabilities nn.errfun = @nntest; % Error function to use with plotting % calculates misclassification rate opts.numepochs = 50; opts.batchsize = 100; opts.plot = 1; opts.plotfun = @nnplotnntest; % Plotting function nn = nntrain(nn, tx, ty, opts,vx,vy); 

तंत्रिका नेटवर्क प्रशिक्षण अनुसूची:



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

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

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

संदर्भ

1. मशीन लर्निंग के लिए तंत्रिका नेटवर्क (वीडियो कोर्स)
2. गौसियन-बाइनरी प्रतिबंधित बोल्ट्जमैन मशीनों के साथ प्राकृतिक छवि सांख्यिकी सीखना
3. छोटे छवियों से सुविधाओं के कई परतों सीखना
4. प्रतिबंधित बोल्ट्जमान मशीनों को प्रशिक्षण देने के लिए एक व्यावहारिक मार्गदर्शिका
5. रेक्टी Lin एड रैखिक इकाइयां प्रतिबंधित बोल्ट्जमैन मशीनों में सुधार करती हैं