Come utilizzare l'apprendimento hebbiano?

Question

Desidero aggiornare il mio simulatore di evoluzione per utilizzare l'apprendimento Hebb, come this one. Fondamentalmente voglio che le piccole creature siano in grado di imparare come trovare cibo. L'ho raggiunto con le reti di feedforward di base, ma sono bloccato a capire come farlo con l'apprendimento di Hebb. Il principio base dell'apprendimento di Hebb è che, se due neuroni sparano insieme, si collegano.

Così, i pesi vengono aggiornati in questo modo:

weight_change = learning_rate * input * output 

Le informazioni che ho trovato su come questo può essere utile è piuttosto scarsa, e io non lo ottengono.

Nella mia versione corrente del simulatore, i pesi tra un'azione e un input (movimento, occhi) aumentano quando una creatura mangia un pezzo di cibo, e non riesco a vedere come ciò possa tradursi in questo nuovo modello. Semplicemente non c'è spazio per capire se ha fatto qualcosa di giusto o sbagliato qui, perché gli unici parametri sono input e output! Fondamentalmente, se un input attiva il movimento in una direzione, il peso continuerà ad aumentare, non importa se la creatura sta mangiando qualcosa o no!

Sto applicando l'apprendimento di Hebb in modo errato? Solo per riferimento, sto usando Python.

Answer 1

Hebbs law è una brillante intuizione per associative learning, ma è solo una parte dell'immagine. E hai ragione, implementato come hai fatto, e lasciato senza controllo un peso continuerà ad aumentare. La chiave è aggiungere una qualche forma di normalizzazione o processo di limitazione. Questo è illustrato abbastanza bene dalla pagina wiki per Oja's rule. Quello che ti suggerisco di fare è aggiungere un passo post-synaptic divisive normalisation, ciò significa che dividi attraverso un peso dalla somma di tutti i pesi che convergono sullo stesso neurone post-sinaptico (cioè la somma di tutti i pesi che convergono su un neurone è fissa a 1).

Ciò che si desidera fare può essere fatto creando una rete che utilizza Hebbian learning. Non sono abbastanza sicuro su cosa stai trasmettendo come input nel tuo sistema, o come hai impostato le cose. Ma si può guardare a LISSOM che è un'estensione hebbiana a SOM, (self-organising map).

In uno strato di questo tipo in genere tutti i neuroni possono essere interconnessi. Si passa nel vettore di input e si consente all'attività nella rete di stabilirsi, questo è un certo numero di passaggi di assestamento. Quindi aggiorni i pesi. Lo fai durante la fase di addestramento, al termine del quale gli elementi associati nello spazio di input tenderanno a formare patch di attività raggruppate nella mappa di output.

Vale anche la pena notare che il cervello è massicciamente interconnesso e altamente ricorsivo (vale a dire feedforward, feedback, interconnessione laterale, microcircuiti e anche molte altre cose ..).

Answer 2

Non conosco molto bene questo tipo di rete neurale, ma sembra che ti aspetti che funzioni come un metodo di aggiornamento supervisionato mentre non è sorvegliato. Ciò significa che non puoi insegnare ciò che è giusto, imparerà solo ciò che è diverso, per associazione. Cioè, alla fine associerà le azioni a particolari gruppi di input. Nella tua situazione in cui desideri migliorare il suo processo decisionale in base al feedback, non penso che gli aggiornamenti di Hebbian saranno sufficienti. Potresti combinarlo con una sorta di backpropagation.

Answer 3

Sebbene l'apprendimento hebbiano, come concetto generale, costituisca la base per molti algoritmi di apprendimento, inclusa la backpropagation, la formula semplice e lineare che si utilizza è molto limitata. Non solo i pesi aumentano all'infinito, anche quando la rete ha imparato tutti i modelli, ma la rete può imparare perfettamente solo schemi ortogonali (linearmente indipendenti).

L'apprendimento lineare di Hebbian non è nemmeno biologicamente plausibile. Le reti neurali biologiche sono molto più grandi delle tue e sono altamente non lineari, sia i neuroni che le sinapsi tra di loro. Nelle reti grandi e non lineari, le probabilità che i tuoi modelli siano vicini a quelli ortogonali sono più alte.

Quindi, se insisti a utilizzare una rete neurale, suggerisco di aggiungere strati nascosti di neuroni e introdurre non linearità, sia nei pesi, ad es. come proposto da fraxel, e in sparatoria di neuroni --- qui potresti usare una funzione sigmoide, come tanh (sì, usare valori negativi per "non-firing" è buono dato che può portare a ridurre i pesi). Nella sua forma generalizzata, regola Hebbian può essere espresso come

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

dove f1 e f2 sono alcune funzioni. Nel tuo caso, non c'è target_output, quindi f2 è libero di ignorarlo.

Per far sì che i neuroni dei livelli nascosti si attivino e quindi ottenere una connessione tra input e output, è possibile inizializzare i pesi su valori casuali.

Ma una rete neurale è davvero necessaria, o addirittura adatta al tuo problema? Hai considerato la correlazione semplice? Voglio dire, Hebb ha derivato la sua regola per spiegare come l'apprendimento potrebbe funzionare nei sistemi biologici, non come il miglior algoritmo di apprendimento automatico possibile.

Answer 4

Puoi provare con il mio codice.

/* 
 
* 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); 
 
     } 
 
    } 
 
}