Inkas Anfrage bezüglich Code, im Thema Linienfolger

[Moppi]

Das Problem an dem Beispiel, das von MXT ursprünglich verlinkt hatte, ist einfach, dass es nicht ganz für Einsteiger ist. Steht in dem Text auf der Seite.
Dennoch ist so einfach, dass man damit zurechtkommen kann.

Um es mal mit dem Auto zu vergleichen, so sind in dem Beispielcode Einstellungen enthalten, welche die Motorsteuerung betreffen, dafür benötigt man etwas mehr Verständnis des Motors. Um das Auto zu fahren, brauchst Du aber nur ein paar Parameter verändern, Lenkung, Gas ...

Ich hatte das versucht etwas abzusetzen, um auf die wichtigen Werte aufmerksam zu machen, nämlich diese:

const int InputNodes = 2;
const int HiddenNodes = 2;
const int OutputNodes = 2;
const int PatternCount = 4;  //zu trainierende Muster

const byte Input[PatternCount][InputNodes] =
{
  { 0, 0 },
  { 1, 0 },
  { 0, 1 },
  { 1, 1 } 
}; 



const byte Target[PatternCount][OutputNodes] =
{
  { 1, 1 },  
  { 0, 1 }, 
  { 1, 0 }, 
  { 1, 0 } };

Auf diese Werte bin ich beispielhaft eingegangen.
Und wie gesagt, wenn Du Werte zur Laufzeit ändern willst, die mit "const" bezeichnet sind, wird das nicht funktionieren, weil die eben so geschützt sind vor Änderung.
Dann muss das "const" weg.



MfG


- - - Aktualisiert - - -

Inka, ich verstehe was Du willst.
Ich weiß aber nicht, in wie weit Du bis jetzt etwas von der Materie verstanden hast.

Weil ich gerne helfen will, versuche ich das noch mal von vorne, immer bezogen auf das Beispiel, wie oben.
Ich hatte das schon mal am Anfang des Themas erklärt, aber ich mach das gerne noch mal. Ist kein Problem.

1. Logikgatter sind bekannt?

Ganz einfach ausgedrückt, hast Du hier ein Gatter, von dem Du die Eingänge und Ausgänge in der Anzahl und in der Logik selber bestimmen kannst.

Die Zahl der Eingänge und die Logik legst Du hier fest:

const byte Input[PatternCount][InputNodes] =
{
  { 0, 0 },
  { 1, 0 },
  { 0, 1 },
  { 1, 1 } 
};

Die Zahl der Ausgänge und deren Logik legst Du hier fest:

const byte Target[PatternCount][OutputNodes] =
{
  { 1, 1 },  
  { 0, 1 }, 
  { 1, 0 }, 
  { 1, 0 } 
};

Im Code musst Du außerdem berücksichtigen:

int InputNodes = 2;    //Die Zahl der Eingänge
int HiddenNodes = 2;   //Die Zahl der verdeckten Neurone (Knoten)
int OutputNodes = 2;   //Die Zahl der Ausgänge
int PatternCount = 4;  //zu trainierende Eingangsmuster

Diese Werte: Zahl der Eingänge, Zahl der Ausgänge und die Zahl der Muster muss angegeben werden und mit den Daten in Input[PatternCount][InputNodes] und Target[PatternCount][OutputNodes] übereinstimmen.
Am Anfang bin ich beispielhaft auf die Änderung dieser Werte und Arrays eingegangen.

Damit dies Auto - jetzt ein Prototyp - für Dich einfach fahrbar wird, kann man eine Karosserie drum herum bauen, Knöpfe für Einstellungen zugänglich machen/lassen und andere verdecken (im Motorraum) und Türen als Zugang einbauen. Außerdem musst Du noch wissen, wo der Zündschlüssel rein gehört und Du bräuchtest einen. Zurzeit sind da, im übertragenen Sinn, überwiegend nur farbige Drähte.




MfG

[inka]

Lieber Moppi,

ich glaube nicht, dass Du wirklich verstehst worum es mir geht. Ich versuche - wie Du auch schon oft - (oder war's doch der Rumgucker?) hier einfach einen anderen zugang zu der materie zu finden. Und nicht nur für mich...

btw: Gatter kenne ich nur vom namen her und ehrlich gesagt, interessieren sie mich nur am rande - ich will autofahren...

Als ich 1971 meinen führerschein gemacht habe, hat mir mein fahrlehrer den zündschlüssel in die hand gedrückt und gesagt - fahr mal...

Ich fand das loch, wo der schlüssel reinpasste, habe gedreht, das auto sprang an, aber weil ich zu lange draufgehalten habe, hat's gekratzt und vor lauter schreck habe ich den motor wieder abgestellt. Dass es das anlassergetriebe war, erfuhr ich erst viel später. Aber beim nächsten anlassen passierte es nicht mehr!

Das gleiche beim anfahren: 2x abgewürgt, dann mit heuledem motor und schleifender kupplung endlich mal im 2.ten gang angefahren. Auch das ist aber nur einmal passiert, beim nächsten mal nahm ich die gände der reihe nach. Und wie gings weiter? Naja, als ich im 2ten gang dann 80 fuhr und es wurde laut, hat er gefragt wann ich denn höher schalten wollte. Tja, beim käfer ging das alles noch

Moppi,

was ich, und sicher einige mehr, haben möchte sind keine theoretischen erklärungen über gatter, bunte drähte und ähnliches. Und ob das KI-auto binär, oktal oder hexa fährt ist auch egal...

Wenn's geht, und nicht zu viel verlangt ist, möchte ich ein fahrbereites KI-auto, einen zündschlüssel und eine startseite, auf der ich nach belieben (wenn ich auch gerne vorschläge entgegen nehme) in den parametern schalten und walten kann. Was kann schon passieren?

[Moppi]

Hallo inka,

Copy & Paste, um irgendwas zum funktionieren zu bekommen,
bläht aber den Code womöglich um unnötige Zeilen auf.
Kann man zur Not machen.

Einfach mal ein Menü einbauen, wo Du ganze Datensätze eingeben kannst,
ist so schnell auch nicht gemacht. Zumal die Datensätze (Arrays) im Quelltext
vom Compiler übersetzt werden. Das sind feste Größen, die sich später nicht
einfach per Menü ändern lassen.

Die Vorgehensweise bei dem Quelltext würde ich so sehen:

1. Überlegen, was ich damit machen will.
2. Die Eingangszustände definieren.
3. Die Ausgangszustände definieren.
4. Den Quelltext für Deine Zwecke anpassen.

Dann wäre Dein Auto fertig, mit den Eigenschaften, die Du benötigst.
Ein Universalauto, das alles kann und nur eingestellt werden müsste,
ist es leider nicht. Bis dahin ist es ein weiter Weg.



MfG

[inka]

hallo Moppi,
zunächst, nichts liegt mir ferner als hier irgendwelche forderungen zu stellen, ich versuche nur zu erreichen, dass wir die KI endlich von dem podest - ich bin nur was für absolute korypheen - runterstossen - wir müssen reden...

ich habs mal ein bischen aufgedröselt:

Copy & Paste, um irgendwas zum funktionieren zu bekommen, bläht aber den Code womöglich um unnötige Zeilen auf. Kann man zur Not machen.

In der reinen lehre hast du natürlich recht, früher hatten die autos noch eine vernünftige karroserie, unter 1mm dicke war da nix. Heute spart man. Und optimiert. Kostet zeit, nerven, ressourcen, klima...

Einfach mal ein Menü einbauen, wo Du ganze Datensätze eingeben kannst, ist so schnell auch nicht gemacht. Zumal die Datensätze (Arrays) im Quelltext vom Compiler übersetzt werden. Das sind feste Größen, die sich später nicht einfach per Menü ändern lassen.

Ich wollte nur einzelne werte eingeben. Da wo es nicht geht gibt es standardeinstellungen - zunächst, bis man die ersten probefahrten hinter sich hat...

1. Überlegen, was ich damit machen will.

ich denke damit kann man alles machen? Jetzt aber im ernst: ich wollte nur testen, was z.b. eine änderung an einem wert für konsequenzen für das ergebnis und die laufzteit hat...

2. Die Eingangszustände definieren.

sind die nicht zufällig?

3. Die Ausgangszustände definieren.

das geht, denke ich.

4. Den Quelltext für Deine Zwecke anpassen.

und da sind wir beim problem: für das testen möchte ich eigentlich am quelltext nix anfassen - wenn Du mit quelltext das allerheiligste des Ki-systems meinst...

Dann wäre Dein Auto fertig, mit den Eigenschaften, die Du benötigst.
Ein Universalauto, das alles kann und nur eingestellt werden müsste, ist es leider nicht. Bis dahin ist es ein weiter Weg.

Ich kenne ja die eigenschaften nicht. siehe punkt 1. Es soll im prinzip nur ein simples "spielzeug" sein mit dem ich verständnis für abhängigkeiten von bestimmten eingans- und ausgangs- werten, von laufzeitabhängigkeit usw. bekomme...

ich sehe schon, das wird nicht einfach sein...

[Moppi]

ich versuche nur zu erreichen, dass wir die KI endlich von dem podest - ich bin nur was für absolute korypheen - runterstossen

Da bin ich ja bei Dir, deshalb erkläre ich das schon so, dass es verständlich ist.
Ich denke, "Künstliche Intelligenz" muss man zuerst mal durch so was wie "einstellbares Logikgatter" ersetzen. Um der Sache und der Grundfunktion dieses Quelltextes irgendwie gerecht zu werden.

Jetzt aber im ernst: ich wollte nur testen, was z.b. eine änderung an einem wert für konsequenzen für das ergebnis und die laufzteit hat...

Das hatte ich so auch etwa verstanden.

sind die nicht zufällig?

Die Eingangszustände nein. Die Ausgangszustände: nein.
Diese Zustände sind vorgegeben.



Für die Eingabe kannst Du digitale Signale verwenden "0" oder "1".

Eingang#1: Umgebungslichtsensor (Licht da: ja / nein)
Eingang#2: Endschalter an der Fahrzeugfront (an Hindernis gestoßen: ja / nein)

Für die Ausgabe kommt im Grunde auch "0" oder "1" raus:

Ausgang#1: Fahren oder Anhalten (Fahren = 1, Anhalten = 0)
Ausgang#2: Scheinwerfer (Licht an = 1, Licht aus = 0)

Mit einer Wahrheitstabelle kann man nun die Regeln aufstellen, wie zum Beispiel:

Wenn kein Umgebungslicht da ist und das Fahrzeug angestoßen ist, dann mache am Scheinwerfer das Licht aus und halte das Fahrzeug an.
Tabelle dafür:

Eingang#1,Eingang#2,Ausgang#1,Ausgang#2
----0------,----1------,------0------,----0------

Das entspräche einem Trainingsmuster (Pattern). Davon kannst Du so viele erstellen, wie der Speicher am Ende her gibt.
Das Programm lernt dann diese Regeln auswendig.
Später reagiert es auf die Eingangszustände mit den eingeübten Ausgangszuständen.

Falls Eingangszustände nicht definiert wurden, sie aber dennoch auftreten können, kann das KNN auch darauf reagieren, womöglich sogar "richtig", in unserm Verständnis, obwohl es diese Zustände nie trainiert hat. Erst hier zeigt sich dann die wirkliche Intelligenz, bis dahin kann man davon eigentlich noch nicht so recht sprechen (finde ich). Um das letztere Verhalten auszunutzen und das Netz möglichst intelligent zu machen, benötigt man mehr Schichten, u.U. einige Schichten mehr. Hier gibt es nur eine Zwischenschicht. Ohne diese eine Zwischenschicht würde das noch trauriger aussehen, mit der Intelligenz. Dann könnte das Netz sich noch nicht einmal eine XOR-Wahrheitstabelle "merken".



MfG


- - - Aktualisiert - - -

Mal kurz geschaut:

const int InputNodes = 2;
const int HiddenNodes = 2;
const int OutputNodes = 2;
const int PatternCount = 4:


Können zur Laufzeit nicht geändert werden, da der Compiler Speicherplatz für Arrays, aufgrund dieser Werte, organisiert.
Diese Werte sollten mit der Wahrheitstabelle übereinstimmen und dann muss neu kompiliert werden.






Gruß

- - - Aktualisiert - - -

den Quelltext mit den Eingabemöglichkeiten habe ich einmal angepasst, damit er wenigstens ein wenig funktioniert:

/******************************************************************
   ArduinoANN - An artificial neural network for the Arduino
   All basic settings can be controlled via the Network Configuration
   section.
   See robotics.hobbizine.com/arduinoann.html for details.
 ******************************************************************/




#include <math.h>




/******************************************************************
   Network Configuration - customized per network
 ******************************************************************/




float LearningRate = 0.3;
float Momentum = 0.9;
float InitialWeightMax = 0.5;
float Success = 0.0004;




const int InputNodes = 2;
const int HiddenNodes = 2;
const int OutputNodes = 2;
const int PatternCount = 4;  //zu trainierende Muster


const byte Input[PatternCount][InputNodes] =
{
  { 0, 0 },
  { 1, 0 },
  { 0, 1 },
  { 1, 1 }
};
//};




const byte Target[PatternCount][OutputNodes] =
{
  { 1, 1 },
  { 0, 1 },
  { 1, 0 },
  { 1, 0 }
};




/******************************************************************
   End Network Configuration
 ******************************************************************/








int i, j, p, q, r;
int ReportEvery1000;
int RandomizedIndex[PatternCount];
long  TrainingCycle;
float Rando;
float Error;
float Accum;








float Hidden[HiddenNodes];
float Output[OutputNodes];
float HiddenWeights[InputNodes + 1][HiddenNodes];
float OutputWeights[HiddenNodes + 1][OutputNodes];
float HiddenDelta[HiddenNodes];
float OutputDelta[OutputNodes];
float ChangeHiddenWeights[InputNodes + 1][HiddenNodes];
float ChangeOutputWeights[HiddenNodes + 1][OutputNodes];




void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(3));
  ReportEvery1000 = 1;
  for ( p = 0 ; p < PatternCount ; p++ )
  {
    RandomizedIndex[p] = p ;
  }
}




void loop ()
{


    input_NN();


    calculation();
}




/******************************************************************
  Input
******************************************************************/
  char str[10];
  int charcount;
float intInput()
{
  for(int i=0;i<10;i++)str[i]=0; // String-Puffer löschen
  charcount = 0;
  //memset(str, 0, sizeof(str)); // String-Puffer löschen
  while (!Serial.available()); // Warten bis 1. Zeichen im Eingangspuffer
  delay(100); // Warten auf weitere Zeichen im Eigangspuffer
  while (Serial.available() && charcount < 10)
  {
    str[charcount] = Serial.read(); // Zeichen aus Eingangspuffer lesen
    charcount++;
  }
  return atof(str); // String in Integer-Rückgabewert wandeln
}


void input_NN (void)
{
  Serial.println();
  Serial.println();
  Serial.print("Geben Sie > LearningRate < (standard = 0.3)ein: ");
  LearningRate = intInput();
  Serial.println(LearningRate, 5);


  Serial.print("Geben Sie > Momentum < (standard = 0.9)ein: ");
  Momentum =  intInput();
  Serial.println(Momentum, 5);


  Serial.print("Geben Sie > InitialWeightMax < (standard = 0.5)ein: ");
  InitialWeightMax =  intInput();
  Serial.println(InitialWeightMax, 5);


  Serial.print("Geben Sie > Success < (standard = 0.0004)ein: ");
  Success =  intInput();
  Serial.println(Success, 5);
/*
  Serial.print("Geben Sie > InputNodes < (standard = 2)ein: ");
  InputNodes = intInput();
  Serial.println(InputNodes);


  Serial.print("Geben Sie > HiddenNodes < (standard = 2)ein: ");
  HiddenNodes = intInput();
  Serial.println(HiddenNodes);


  Serial.print("Geben Sie > OutputNodes < (standard = 2)ein: ");
  OutputNodes = intInput();
  Serial.println(OutputNodes);


  Serial.print("Geben Sie > PatternCount < (standard = 4)ein: ");
  PatternCount = intInput();
  Serial.println(PatternCount);
*/  
/*
  Serial.print("Das Ergebnis Wert1 * Wert2 ist = ");
  long wert3 = (long)wert1 * wert2;
  Serial.println(wert3);
  */
  Serial.println();
}




void calculation()
{
  /******************************************************************
    Initialize HiddenWeights and ChangeHiddenWeights
  ******************************************************************/




  for ( i = 0 ; i < HiddenNodes ; i++ )
  {
    for ( j = 0 ; j <= InputNodes ; j++ )




    {
      ChangeHiddenWeights[j][i] = 0.0 ;
      Rando = float(random(100)) / 100;
      HiddenWeights[j][i] = 2.0 * ( Rando - 0.5 ) * InitialWeightMax ;
    }
  }
  /******************************************************************
    Initialize OutputWeights and ChangeOutputWeights
  ******************************************************************/




  for ( i = 0 ; i < OutputNodes ; i ++ )
  {
    for ( j = 0 ; j <= HiddenNodes ; j++ )
    {
      ChangeOutputWeights[j][i] = 0.0 ;
      Rando = float(random(100)) / 100;
      OutputWeights[j][i] = 2.0 * ( Rando - 0.5 ) * InitialWeightMax ;
    }
  }
  Serial.println("Initial/Untrained Outputs: ");
  toTerminal();
  /******************************************************************
    Begin training
  ******************************************************************/




  for ( TrainingCycle = 1 ; TrainingCycle < 2147483647 ; TrainingCycle++)
  {
    yield();




    /******************************************************************
      Randomize order of training patterns
    ******************************************************************/




    for ( p = 0 ; p < PatternCount ; p++)
    {
      q = random(PatternCount);
      r = RandomizedIndex[p] ;
      RandomizedIndex[p] = RandomizedIndex[q] ;
      RandomizedIndex[q] = r ;
    }
    Error = 0.0 ;
    /******************************************************************
      Cycle through each training pattern in the randomized order
    ******************************************************************/
    for ( q = 0 ; q < PatternCount ; q++ )
    {
      p = RandomizedIndex[q];




      /******************************************************************
        Compute hidden layer activations
      ******************************************************************/




      for ( i = 0 ; i < HiddenNodes ; i++ )
      {
        Accum = HiddenWeights[InputNodes][i] ;
        for ( j = 0 ; j < InputNodes ; j++ )
        {
          Accum += Input[p][j] * HiddenWeights[j][i] ;
        }
        Hidden[i] = 1.0 / (1.0 + exp(-Accum)) ;
      }




      /******************************************************************
        Compute output layer activations and calculate errors
      ******************************************************************/




      for ( i = 0 ; i < OutputNodes ; i++ )
      {
        Accum = OutputWeights[HiddenNodes][i] ;
        for ( j = 0 ; j < HiddenNodes ; j++ )
        {
          Accum += Hidden[j] * OutputWeights[j][i] ;
        }
        Output[i] = 1.0 / (1.0 + exp(-Accum)) ;
        OutputDelta[i] = (Target[p][i] - Output[i]) * Output[i] * (1.0 - Output[i]) ;
        Error += 0.5 * (Target[p][i] - Output[i]) * (Target[p][i] - Output[i]) ;
      }




      /******************************************************************
        Backpropagate errors to hidden layer
      ******************************************************************/




      for ( i = 0 ; i < HiddenNodes ; i++ )
      {
        Accum = 0.0 ;
        for ( j = 0 ; j < OutputNodes ; j++ ) {
          Accum += OutputWeights[i][j] * OutputDelta[j] ;
        }
        HiddenDelta[i] = Accum * Hidden[i] * (1.0 - Hidden[i]) ;
      }








      /******************************************************************
        Update Inner-->Hidden Weights
      ******************************************************************/








      for ( i = 0 ; i < HiddenNodes ; i++ )
      {
        ChangeHiddenWeights[InputNodes][i] = LearningRate * HiddenDelta[i] + Momentum * ChangeHiddenWeights[InputNodes][i] ;
        HiddenWeights[InputNodes][i] += ChangeHiddenWeights[InputNodes][i] ;
        for ( j = 0 ; j < InputNodes ; j++ )
        {
          ChangeHiddenWeights[j][i] = LearningRate * Input[p][j] * HiddenDelta[i] + Momentum * ChangeHiddenWeights[j][i];
          HiddenWeights[j][i] += ChangeHiddenWeights[j][i] ;
        }
      }




      /******************************************************************
        Update Hidden-->Output Weights
      ******************************************************************/




      for ( i = 0 ; i < OutputNodes ; i ++ )
      {
        ChangeOutputWeights[HiddenNodes][i] = LearningRate * OutputDelta[i] + Momentum * ChangeOutputWeights[HiddenNodes][i] ;
        OutputWeights[HiddenNodes][i] += ChangeOutputWeights[HiddenNodes][i] ;
        for ( j = 0 ; j < HiddenNodes ; j++ )
        {
          ChangeOutputWeights[j][i] = LearningRate * Hidden[j] * OutputDelta[i] + Momentum * ChangeOutputWeights[j][i] ;
          OutputWeights[j][i] += ChangeOutputWeights[j][i] ;
        }
      }
    }




    /******************************************************************
      Every 1000 cycles send data to terminal for display
    ******************************************************************/
    ReportEvery1000 = ReportEvery1000 - 1;
    if (ReportEvery1000 == 0)
    {
      Serial.println();
      Serial.println();
      Serial.print ("TrainingCycle: ");
      Serial.print (TrainingCycle);
      Serial.print ("  Error = ");
      Serial.println (Error, 5);




      toTerminal();




      if (TrainingCycle == 1)
      {
        ReportEvery1000 = 999;
      }
      else
      {
        ReportEvery1000 = 1000;
      }
    }








    /******************************************************************
      If error rate is less than pre-determined threshold then end
    ******************************************************************/




    if ( Error < Success ) break ;
  }
  Serial.println ();
  Serial.println();
  Serial.print ("TrainingCycle: ");
  Serial.print (TrainingCycle);
  Serial.print ("  Error = ");
  Serial.println (Error, 5);




  toTerminal();




  Serial.println ();
  Serial.println ();
  Serial.println ("Training Set Solved! ");
  Serial.println ("--------");
  Serial.println ();
  Serial.println ();
  ReportEvery1000 = 1;


}




void toTerminal()
{




  for ( p = 0 ; p < PatternCount ; p++ )
  {
    Serial.println();
    Serial.print ("  Training Pattern: ");
    Serial.println (p);
    Serial.print ("  Input ");
    for ( i = 0 ; i < InputNodes ; i++ )
    {
      Serial.print (Input[p][i], DEC);
      Serial.print (" ");
    }
    Serial.print ("  Target ");
    for ( i = 0 ; i < OutputNodes ; i++ )
    {
      Serial.print (Target[p][i], DEC);
      Serial.print (" ");
    }
    /******************************************************************
      Compute hidden layer activations
    ******************************************************************/




    for ( i = 0 ; i < HiddenNodes ; i++ )
    {
      Accum = HiddenWeights[InputNodes][i] ;
      for ( j = 0 ; j < InputNodes ; j++ )
      {
        Accum += Input[p][j] * HiddenWeights[j][i] ;
      }
      Hidden[i] = 1.0 / (1.0 + exp(-Accum)) ;
    }




    /******************************************************************
      Compute output layer activations and calculate errors
    ******************************************************************/




    for ( i = 0 ; i < OutputNodes ; i++ )
    {
      Accum = OutputWeights[HiddenNodes][i] ;
      for ( j = 0 ; j < HiddenNodes ; j++ )
      {
        Accum += Hidden[j] * OutputWeights[j][i] ;
      }
      Output[i] = 1.0 / (1.0 + exp(-Accum)) ;
    }
    Serial.print ("  Output ");
    for ( i = 0 ; i < OutputNodes ; i++ )
    {
      Serial.print (Output[i], 5);
      Serial.print (" ");
    }
  }








}

MfG