पदानुक्रमित टेम्पोरल मेमोरी कोर लर्निंग एल्गोरिदम

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

कार्यान्वयन का आधार यहाँ उपलब्ध दस्तावेज था। आप वहां एक रूसी अनुवाद भी पा सकते हैं, लेकिन पूर्णता के लिए, मैं व्यक्तिगत रूप से मूल का उपयोग करने की सलाह दूंगा।

एचटीएम वास्तुकला

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


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

स्थानिक ग्रूपर

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

1. सार्वजनिक शून्य SOverlap ( ) {
2. for ( int i = 0 ; मैं < xDimension * yDimension ; i ++ ) {
3. ओवरलैप [ i ] = 0.0 ;
4. के लिए ( Synapse सिनैप्स : कनेक्टसिनैप्स ( i ) ) {
5. ओवरलैप [ i ] + = इनपुट ( समय, synapse; c , synapse। i ) ;
6. }
7. अगर ( ओवरलैप [ i ] < minOverlap )
8. ओवरलैप [ i ] = 0.0 ;
9. अन्यथा
10. ओवरलैप [ i ] * = बूस्ट [ i ] ;
11. }
12. }

दमन चरण में, सक्रिय स्तंभों की एक सूची की गणना की जाती है। अधिकतम "कवरेज" वाले कॉलम अपने पड़ोसियों को दबाते हैं, उपयोगकर्ता द्वारा परिभाषित पैरामीटर द्वारा क्षेत्र में सक्रिय स्तंभों की संख्या को विनियमित किया जाता है।

1. सार्वजनिक शून्य निषेध ( ) {
2. activeColumns। add ( नया ArrayList < Integer > ( ) ) ;
3. for ( int i = 0 ; मैं < xDimension * yDimension ; i ++ ) {
4. डबल minLocalActivity = kthScore ( पड़ोसी ( i ) , वांछितLocalActivity ) ;
6. अगर ( ओवरलैप [ i ] > 0.0 && ओवरलैप [ i ] > = minLocalActivity ) {
7. activeColumns। मिल ( समय ) । जोड़ें ( i ) ;
8. }
9. }
10. }

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

1. सार्वजनिक शून्य SLearning ( ) {
2. के लिए ( पूर्णांक c : ActiveColumns। प्राप्त करें ( समय ) ) {
3. के लिए ( Synapse s : potentialSynapses। get ( c ) ) {
4. अगर ( इनपुट ( समय, s। c , s। i ) > 0 ) {
5. रों। स्थायित्व + = स्थायित्व ;
6. रों। स्थायित्व = मठ । मिनट ( s। स्थायित्व , 1.0 ) ;
7. } {
8. रों। स्थायित्व - = permanentenceDec ;
9. रों। स्थायित्व = मठ । अधिकतम ( s। स्थायित्व , 0.0 ) ;
10. }
11. }
12. }
14. for ( int i = 0 ; मैं < xDimension * yDimension ; i ++ ) {
15. minDutyCycle [ i ] = 0.01 * maxDutyCycle ( पड़ोसी ( i ) ) ;
16. activeDutyCycle [ i ] = updateActiveDutyCycle ( i ) ;
17. बूस्ट [ i ] = बूस्टरफंक्शन ( सक्रियडूट साइकिल [ i ] , minDutyCycle [ i ] ) ;
18. ओवरलैपडुटचाइकल [ i ] = updateOverlapDutyCycle ( i ) ;
20. अगर ( ओवरलैपडुट साइकल [ i ] < minDutyCycle [ i ] ) {
21. वृद्धिमान ( i, 0.1 * कनेक्टपर्म ) ;
22. }
23. }
25. inhibitionRadius = averageReceptiveFieldSize ( ) ;
26. }

इस स्तर पर, स्थानिक ग्रॉपर समाप्त होता है। परिणामस्वरूप, हमारे पास सक्रिय स्तंभों की एक सूची है, जिनकी हमें अभी भी आवश्यकता है।

अस्थायी ग्रूपर

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

1. सार्वजनिक शून्य संग्रह ( ) {
2. ( int c = 0 ; c < xDimension * yDimension ; c ++ ) {
3. for ( int i = 0 ; मैं < cellsPolumn ; i ++ ) {
4. if ( learnState। get ( time ) । get ( c ) । get ( i ) ) {
5. adaptSegments ( खंडUpdateList। get ( c ) । get ( i ) , true ) ;
6. // सेगमेंटवेटलिस्ट .get © .get (i) .clear ();
7. } और अगर ( ? भविष्य कहनेवाला। मिलता है । ( समय ) । get ( c ) । get ( i ) && predictiveState। प्राप्त करें ( समय - 1 > 0; समय - 1 : 0 ) । get ( c ) । get ( i ) ) {
8. adaptSegments ( खंडUpdateList। get ( c ) । get ( i ) , false ) ;
9. // सेगमेंटवेटलिस्ट .get © .get (i) .clear ();
10. }
11. segmentUpdateList। get ( c ) । मिल ( i ) । स्पष्ट ( ) ;
12. }
13. }
14. }

निष्कर्ष

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