Threads Neuronales Netz - Perzeptron

[minzee]

Hi

Heute habe ich das erste mal etwas über neuronale Netze gelesen. Wird in meinem Buch nur kurz das Grundprinzip vom Perzeptron erklärt. Es gibt keinen Algorithmus oder ein Programm dazu.

Jetzt hab ich mal folgendes programmiert:

class Neuron
{
   private double[] weights;
   private double threshold;
   /**
    * @param double[] weights
    * @param double threshold
    */
   public Neuron(double[] weights, double threshold)
   {
      this.weights = weights;
      this.threshold = threshold;
   }
   /**
    * @param double[] values Anzahl weights == Anzahl values
    * @return int {0, 1}
    */
   public int fire(double[] values)
   {
      double sum = 0.0;
      int length = weights.length;
      for(int i = 0; i < length; ++i)
      {
         sum += values[i] * weights[i];
      }
      if(sum >= threshold)
      {
         return 1;
      }
      return 0;
   }
}
public class Main
{
   public static void main(String[] args)
   {
      // Perzeptron für logische UND-Verknüpfung:
      
      double[] weights = {2.0, 2.0};
      double threshold = 3.0;
      Neuron neuron = new Neuron(weights, threshold);

      double[] values = {0.0, 1.0};
      int result = neuron.fire(values);

      System.out.println(result);
   }
}

Jetzt habe ich aber auch gelesen, dass neuronale Netze massiv parallele Systeme sind. Darum gehe ich stark davon aus, dass ich bei meinem Programm noch mit Threads arbeiten muss. Allerdings kann ich wirklich nur raten, da im Buch nicht weiter darauf eingegangen wird.

Habt ihr eine Idee, wie das mit Threads aussehen könnte?

 

[minzee]

Gemäß der obigen Klasse Neuron würde meine XOR-Verknüpfung übrigens folgendermaßen aussehen:

public class Main
{
   public static void main(String[] args)
   {
      // Perzeptron für logische XOR-Verknüpfung:
      
      double[] weights0 = {1.0, 1.0};
      Neuron neuron0 = new Neuron(weights0, 1.5);
      // -------|
      //        |1
      //     -------
      //     | 1.5 |-------
      //     -------
      //        |1
      // -------|
      
      double[] weights1 = {1.0, -2.0, 1.0};
      Neuron neuron1 = new Neuron(weights1, 0.5);
      // -------|
      //        |1
      //  -2 -------
      // ----| 0.5 |-------
      //     -------
      //        |1
      // -------|

      double[] values0 = {0.0, 0.0};
      double[] values1 = {values0[0], neuron0.fire(values0), values0[1]};
      int result = neuron1.fire(values1);
      // values0[0]
      // -------+-------------|
      //        |1            |1
      //     -------    -2 ------- result
      //     | 1.5 |-------| 0.5 |-------
      //     -------       -------
      //        |1            |1
      // -------+-------------|
      // values0[1]
      
      System.out.println(result);
   }
}

Aber ich glaube nicht, dass hier viel parallel ablaufen kann. Zumindest neuron1 muss auf das Ergebnis von neuron0 warten.

 

[minzee]

Sucht man im Google nach "class Neuron extends thread", werden 2 chinesische Seiten aufgelistet. Auf http://www.paper.edu.cn/scholar/downpaper/zhangyunong109232-201007-26 findet sich scheinbar eine PFD, die so eine Klasse definiert. Leider kann ich die Seite nicht aufrufen. Leider bekomme ich nur:

Fehler: Verbindung unterbrochen

Die Verbindung zum Server wurde zurückgesetzt, während die Seite geladen wurde.

Könnt ihr diese PDF aufrufen?

 

[Gucky]

Also ich bekomme ungefähr 13.200.000 Ergebnisse. Ich weiß nicht, womit du gesucht hast. Google war es nicht

Ich kann die Seite runterladen. Ein PDF hab ich so schnell aber nicht gefunden.

Vielleicht hilft dir diese Seite weiter: Football Neural Network Source Code
Oder vielleicht auch diese hier. Ist aber leider auf Chinesisch. Mit Google Chrome oder dem Google Übersetzer kannst du dir die Seite aber übersetzen lassen: Erste Papier - Rechnen neuronale Netzwerke

 

[minzee]

Ich kann kein chinesisch. Chinesische Seiten besuche ich nur, wenn es dort ein für mich lesbares Programm gibt

 

[Gucky]

Wie gesagt: URL beim Google Übersetzer eingeben, auf den Link rechts klicken und übersetzen lassen und schon kannst du es lesen. Die Sprache ist zwar nicht the yellow of the egg but it goes.
Zumal der erste Link auf einen Quellcode zeigt.

 

[nvidia]

[...]
Habt ihr eine Idee, wie das mit Threads aussehen könnte?

Wozu? Diese Art von Modell lässt sich als normale Vektor-Matrix-Multiplikation darstellen, die praktisch stufenweise in der Anzahl der Layer fortgeführt wird. Das was sich parallalelisieren lässt ist für große Perzeptrone ist die VMM innherhalb einer Stufe. Das Neuron als Neuron zu modellieren lohnt IMHO bei Modellen wie den Spiking Networks, da dort eine Zeitkomponente abgedeckt werden muss.

 

[minzee]

Oh, du scheinst dich ja damit auszukennen. Hast du das studiert?

Kennst du zufällig auch das Buch Bücher: Neuronale Netze von Karl F. Wender, Günter Daniel Rey ? Ich habe das gestern gefunden und überlege, ob ich es kaufen soll.

Vektor-Matrix-Multiplikation

Hast du zufällig ein kleines Beispiel bei der Hand? Grundsätzlich kenne ich mich mit solchen Sachen aus. Aber müsste natürlich mal ein Beispiel sehen. Nicht überall, wo man das einsetzen kann, zahlt sich das auch wirklich aus.

 

[nvidia]

Nein das Buch kenne ich nicht und das mit den KNN ist auch schon sehr lange her. Mit einem direkten Beispiel kann ich auch nicht dienen aber das sollte sich von dir schnell konstruieren lassen. Normalerweise hat man von den Input-Neuronen gewichtete Kanten zu den Output-Neuronen, diese Gewichte kann man in einer Gewichtsmatrix darstellen. Dann wird diese Matrix von rechts mit dem Input-Vektor multipliziert. Das ergibt dann diese typische Summenformel für ein Neuron in dem die Summe über das Produkt des Inputs über alle gewichteten Kanten die zu Ausgabeneuronen verbunden sind gebildet wird. Danach schiebt man diesen Vektor elementweise durch die Transferfunktion um den endgültigen Ausgabevektor zu erhalten. Es gibt da noch Variationen bzgl. des Schwellenwerts, der lässt sich auch aber auch direkt in dieses Modell integrieren.