हेबियन सीखने का उपयोग कैसे करें?

Question

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

तो, वजन इस तरह अपडेट किया जाता है:

weight_change = learning_rate * input * output 

जानकारी मैं यह कैसे उपयोगी हो सकता है पर मिल गया है बहुत दुर्लभ है, और मैं इसे नहीं मिलता है।

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

क्या मैं गलत तरीके से हेब सीख रहा हूं? बस संदर्भ के लिए, मैं पायथन का उपयोग कर रहा हूँ।

Answer 1

Hebbs lawassociative learning के लिए एक शानदार अंतर्दृष्टि है, लेकिन तस्वीर का इसका एकमात्र हिस्सा है। और आप सही हैं, जैसा आपने किया है, लागू किया गया है, और एक वजन अनचेक छोड़ दिया गया है बस बढ़ते रहेंगे। कुंजी सामान्यीकरण या सीमित प्रक्रिया के कुछ रूपों में जोड़ना है। यह Oja's rule के लिए विकी पेज का काफी अच्छा चित्रित किया गया है। क्या मैं सुझाव है कि आप कर एक post-synaptic divisive normalisation कदम में जोड़ने के लिए, क्या इसका मतलब है कि आप (सभी भार एक ही पोस्ट अन्तर्ग्रथनी न्यूरॉन पर converging की राशि से एक वजन के माध्यम से विभाजित यानी एक न्यूरॉन पर converging सभी वजन की राशि ठीक हो गई है है 1 पर)।

आप जो करना चाहते हैं वह Hebbian learning का उपयोग करने वाले नेटवर्क के निर्माण द्वारा किया जा सकता है। मुझे इस बात पर पूरा यकीन नहीं है कि आप अपने सिस्टम में इनपुट के रूप में क्या गुजर रहे हैं, या आपने चीजों को कैसे सेट किया है। लेकिन आप LISSOM देख सकते हैं जो SOM, (self-organising map) पर एक हेबियन एक्सटेंशन है।

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

यह भी ध्यान देने योग्य है कि मस्तिष्क बड़े पैमाने पर एक दूसरे से जुड़ा हुआ है, और अत्यधिक रिकर्सिव (यानी फीडफोर्ड, फीडबैक, पार्श्व इंटरकनेक्टिविटी, माइक्रोक्रिकिट्स और कई अन्य सामान भी हैं ..)।

Answer 2

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

Answer 3

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

रैखिक हेबियन सीखना भी जैविक रूप से व्यावहारिक नहीं है। जैविक तंत्रिका नेटवर्क आपके से बहुत बड़े हैं और न्यूरॉन्स और उनके बीच synapses दोनों, अत्यधिक गैर रेखीय हैं। बड़े, गैर-रैखिक नेटवर्क में, संभावना है कि आपके पैटर्न ऑर्थोगोनल के करीब हैं।

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

weight_change = learning_rate * f1(input, weight) * f2(output, target_output) 

जहां f1 और f2 कुछ कार्य हैं व्यक्त किया जा सकता। आपके मामले में, target_output नहीं है, इसलिए f2 इसे अनदेखा करने के लिए स्वतंत्र है।

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

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

Answer 4

आप मेरे कोड के साथ प्रयास कर सकते हैं।

/* 
 
* To change this license header, choose License Headers in Project Properties. 
 
* To change this template file, choose Tools | Templates 
 
* and open the template in the editor. 
 
*/ 
 
package modelhebb; 
 

 
/** 
 
* 
 
* @author Raka 
 
*/ 
 
public class ModelHebb { 
 
    public static void main(String[] args) { 
 
     Integer xinput[][] = new Integer[][]{ 
 
      {1, 1}, 
 
      {1, -1}, 
 
      {-1, 1}, 
 
      {-1, -1} 
 
     }; 
 
     Integer xtarget[] = new Integer[]{ 
 
      1, 
 
      -1, 
 
      -1, 
 
      -1 
 
     }; 
 
     Integer xweight[] = new Integer[xinput[0].length]; 
 
     System.out.println("\t Iterasi \t"); 
 
     Integer bayes = 0; 
 
     for (int i = 0; i < xtarget.length; i++) { 
 
      for (int j = 0; j < xinput[i].length; j++) { 
 
       int temp = xweight[j]==null?0:xweight[j]; 
 
       xweight[j] = temp + (xinput[i][j] * xtarget[i]); 
 
       System.out.print("W"+j+": "+xweight[j]+"\t"); 
 
      } 
 
      bayes = bayes + xtarget[i]; 
 
      System.out.println("Bobot : " + bayes); 
 
     } 
 
    } 
 
}