informatics4kids.de

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
ein_neuronales_netz_fuer_den_nxt_roboter

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
ein_neuronales_netz_fuer_den_nxt_roboter [2024/01/26 11:02] – [Der Backpropagation-Algorithmus] torsten.roehlein_neuronales_netz_fuer_den_nxt_roboter [2024/01/26 11:20] (aktuell) – [Quellcode] torsten.roehl
Zeile 71: Zeile 71:
 </WRAP>| </WRAP>|
 |9.|<WRAP>Justieren der Gewichte zwischen Input- und Hidden-Layer: |9.|<WRAP>Justieren der Gewichte zwischen Input- und Hidden-Layer:
-  * Δw$1_{ij}$= ηδ$1_jh_i$ für alle i=0, ..., A, j=1, ..., B+\begin{equation} \Delta w1_{ij} = \eta \delta 1_jh_i \end{equation} 
 +  * für alle i=0, ..., A, j=1, ..., B
 </WRAP>| </WRAP>|
 |10.|<WRAP>Ab Schritt 4 alles wiederholen, bis alle Input-Output-Paare dem Netzwerk "präsentiert" worden sind. Dann ist eine //"Epoche"// vervollständigt.  Die Schritte 4-10 für eine gewünschte Zahl an Epochen wiederholen. |10.|<WRAP>Ab Schritt 4 alles wiederholen, bis alle Input-Output-Paare dem Netzwerk "präsentiert" worden sind. Dann ist eine //"Epoche"// vervollständigt.  Die Schritte 4-10 für eine gewünschte Zahl an Epochen wiederholen.
Zeile 87: Zeile 88:
 |Abb. 4 Der Aufbau des Lego NXT Roboters| |Abb. 4 Der Aufbau des Lego NXT Roboters|
  
-|{{ :inf:msr:nn_7.png? |}}|+|{{ :inf:msr:nn_6.png? |}}|
 |Abb. 5:Das Backpropagation-Netzwerk | |Abb. 5:Das Backpropagation-Netzwerk |
 +
 +{{:inf:hinweis.gif?|}}Dass hier ein 3-Layer-Netzwerk mit 3 Neuronen im Hidden-Layer verwendet wird, ist im Grunde eine willkürliche Entscheidung. Allerdings ist ein einfaches Netzwerk für den Lerneffekt sinnvoll. 
 +
 +Die Input-Output-Vektor-Paare (Ziel-Outputs) können nicht willkürlich festgelegt werden, da sie von den Input- und Output-Möglichkeiten des Roboters abhängen. 
 +
 +
 +Grundlegende Bewegungsregeln:
 +  - **Vorwärtsbewegung**: Sensor 1 aus, Sensor 2 auf weißer Oberflächte, Sensor 3 aus → Motoren A und C laufen vorwärts
 +  - **Rechtskurve**: Sensor 3 an → Motor A läuft vorwärts, Motor B läuft rückwärts
 +  - **Linkskurve**: Sensor 1 an → Motor A läuft rückwärts, Motor B läuft vorwärts
 +  - **Rückwärtsbewegung**: Sensor 2 auf schwarzer Oberfläche→ Motoren A und B laufen rückwärts
 +Diese Regeln werden in Trainingsmuster übersetzt. 
 +
 +|{{ :inf:msr:nn_4.png? |}}|
 +|Abb. 6 Lernregeln|
 +
 +|{{ :inf:msr:nn_5.png? |}}|
 +|Abb. 7 Input-Output-Vektoren|
 +
 +Die Input-Output-Vektorpaare sind diese Trainigsmuster, anhand derer das Netzwerk lernt. Abhängig von den Zuständen seiner Input-Sensoren wird der Roboter also lernen, sich vorwärts zu bewegen, eine Rechtskurve zu machen, usw. Doch was würde zum Beispiel passieren, wenn beide Touch-Sensoren aktiviert sind? Für diesen Fall hat der Roboter kein Lernmuster, doch würde das Netzwerk ein bestimmtes Verhalten berechnen.
 +
 +
 +
 ====  Quellcode==== ====  Quellcode====
 +Abschließend noch der vollständige Quellcode um mit dem Experimentieren anzufangen zu können. Das Programm ist in zwei Java-Klassen aufgeteilt, eine Klasse für die Berechnungen (//Methods//) und eine für die Ausführung (Main).
 === Quellen === === Quellen ===
  
  
 +<Code Java linenums:1 | Listing 1: Die Main-Klasse>
 +import lejos.nxt.*;
 +import lejos.nxt.LCD;
 + 
 +public class Main {
 +   public static Methods bpn = new Methods();
 + 
 +   public static void main(String args[]) throws InterruptedException {
 + 
 +   //Initialisieren der Sensoren
 +  
 +   TouchSensor s1 = new TouchSensor(SensorPort.S1);
 +   LightSensor s2 = new LightSensor(SensorPort.S2);
 +   TouchSensor s3 = new TouchSensor(SensorPort.S3);
 + 
 +   //Initialisieren der Zählvariable i, des Weißstandarts
 +   // und des Input- und Output-Vektors
 +  
 +   int i, white;
 +   int inp[] = { 0, 0, 0 };
 +   int out[] = { 0, 0 };
 + 
 +   Sound.beep();
 +   System.out.println("Train");
 + 
 +   // Trainieren des bpn (Backpropagation-Netzwerks) in 500 Epochen
 +   for (i = 0; i < 500; i++) {
 +      bpn.train(1);
 +      System.out.println(bpn.trainedEpochs);
 +   }
 + 
 +   Sound.twoBeeps();
 +  
 +   //Definieren des Weißstandards und der Motorgeschwindigkeiten
 +  
 +   white = s2.readValue();
 + 
 +   Motor.A.setSpeed(300);
 +   Motor.C.setSpeed(300); 
 +   Sound.twoBeeps();
 + 
 +   while (!Button.ENTER.isPressed()) {
 + 
 +       System.out.println(s2.readValue());
 + 
 +       if (s1.isPressed()==true)
 +          inp[0] = 1; // Sensor 1 an
 +       else
 +          inp[0] = 0; // Sensor 1 aus
 + 
 +       if (s2.readValue() > white + 15)
 +           inp[1] = 1; // Sensor 2 schwarz
 +       else
 +           inp[1] = 0; // Sensor 2 weiß
 + 
 +       if (s3.isPressed()==true)
 +           inp[2] = 1; // Sensor 3 an
 +       else
 +           inp[2] = 0; // Sensor 3 aus
 + 
 +       bpn.test(inp, out);
 + 
 +       if (out[0] == 1)
 +           Motor.A.forward();
 +       else
 +          Motor.A.backward();
 + 
 +      if (out[1] == 1)
 +          Motor.C.forward();
 +      else
 +          Motor.C.backward();
 + 
 +      Thread.sleep(500);
 + 
 +   } 
 +  
 + 
 + 
 +   Motor.A.stop();
 +   Motor.C.stop();
 +   Sound.beep();
 +  
 +   Button.ESCAPE.addButtonListener(new ButtonListener() {
 +      public void buttonPressed(Button b) {
 +           LCD.drawString("Program stop", 0, 3);
 +      }
 +      
 +      public void buttonReleased(Button b) {
 +         System.exit(0);
 +      }
 +   });
 + 
 + } 
 + 
 +}
 +
 +
 +</Code>
 +
 +<Code Java linenums:1 | Listing 1: Die Methods-Klasse>
 +class Methods {
 + public static int data1[][] = {{0,0,0}, {1,1}};
 + public static int data2[][] = {{1,0,0}, {1,0}};
 + public static int data3[][] = {{0,0,1}, {0,1}};
 + public static int data4[][] = {{0,1,0}, {0,0}};
 +  
 + public static double input[] = {0,0,0,1};
 + public static double w1[][] = {{0,0,0}, {0,0,0}, {0,0,0}, {0,0,0}};
 + public static double hidden[] = {0,0,1};
 + public static double w2[][] = {{0,0}, {0,0}, {0,0}};
 + public static double output[] = {0,0};
 + public static double delta2[] = {0,0};
 + public static double delta1[] = {0,0,0};
 + 
 + public static int trainedEpochs = 0;
 +   
 + public Methods() {
 + byte i, j;
 + // Initialisieren der zufälligen Gewichte zwischen 0.1 und 0.9
 + for(i=0; i
 + 
 + for(i=0; i 
 + }
 + 
 + 
 + public static void train(int e) {
 +    for(int i=0; i
 +      learn( data1[0], data1[1] );
 +      learn( data2[0], data2[1] );
 +      learn( data3[0], data3[1] );
 +      learn( data4[0], data4[1] );
 +      trainedEpochs++;
 +      }
 + }
 + 
 + 
 + public static void learn( int inp[], int out[] ) {
 + int i, j;
 + double sum, out_j; 
 + 
 + // Initialisieren der Input-Vekoren
 + for(i=0; i
 + 
 + // Berechnen der Werte im Hidden-Layer
 + for(j=0; j for(i=0; i
 + 
 + 
 + hidden[j] = 1 / ( 1 + Math.exp(-sum));
 + } 
 + 
 + // Berechnen der Output-Werte
 + for(j=0; j for(i=0; i
 + 
 + 
 + output[j] = 1 / (1 + Math.exp(-sum));
 + }
 + 
 + 
 + // Berechnen der delta2 Fehler
 + for(j=0; j
 + out_j = 0.1;
 + else if( out[j] == 1 )
 + out_j = 0.9;
 + else
 + out_j = out[j];
 + delta2[j] = output[j]*(1-output[j])*(out_j-output[j]);
 + }
 + 
 + 
 + // Berechnen der delta1 Fehler
 + for(j=0; j for(i=0; i
 + 
 + 
 + delta1[j] = hidden[j]*(1-hidden[j])*sum;
 + }
 + 
 + 
 + // Anpassen der Gewichte w2
 + for(i=0; i
 + 
 + 
 + // Anpassen der Gewichte w1
 + for(i=0; i
 + } 
 + 
 + public static void test(int inp[], int out[]) {
 + int i, j;
 + double sum;
 + 
 + 
 + // Initialisieren der Input-Werte
 + for(i=0; i
 + 
 + // Berechnen der Wete im Hidden-Layer
 + for(j=0; j for(i=0; i
 + 
 + 
 + hidden[j] = 1 / ( 1 + Math.exp(-sum));
 + }
 + 
 + 
 + // Berechnen der Output-Werte
 + for(j=0; j
 + sum = 0;
 + for(i=0; i
 + 
 + output[j] = 1 / (1 + Math.exp(-sum));
 + }
 + 
 + 
 + // Übertragen des Outputs auf das Array out[]
 +     for(i=0; i= 0.5 )
 +         out[i] = 1;
 +     else
 +         out[i] = 0;
 + }
 +    
 + 
 +}
 +
 +
 +
 +</Code>
 +
 +<WRAP center round info 60%>
 +FIXME Der Quellcode enthält noch Fehler 
 +</WRAP>
  
  
 +==== Quellen ====
 +  * Download des orginales Artikels erschienen in JavaWorld 2005
 +          * [[https://www.informatics4kids.de/addons-i4k/doc/article/neural_network_lego.pdf|A neural network for Java Lego robots]]
  
ein_neuronales_netz_fuer_den_nxt_roboter.1706266976.txt.gz · Zuletzt geändert: von torsten.roehl