lernfähiger Lininenfolger mit KI

[inka]

Du bist jetzt jedenfalls erst mal auf meiner ignore-Liste.

aus eigener erfahrung - das funktioniert nicht. Man möchte dann doch wissen was der andere "idiot" geschrieben hat

noch einmal vielleicht andersherum zu meinen "bedürfnissen" was KI bzw. NN betrifft. Ich will keinen code schreiben bzw. entwickeln. Ich möchte am anfang an einem - für mich schon recht komplexen - beispiel wie dem hier z.b.

/******************************************************************
   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
 ******************************************************************/

const int PatternCount = 10;
const int InputNodes = 7;
const int HiddenNodes = 8;
const int OutputNodes = 4;
const float LearningRate = 0.3;
const float Momentum = 0.9;
const float InitialWeightMax = 0.5;
const float Success = 0.0004;

const byte Input[PatternCount][InputNodes] =
{
  { 1, 1, 1, 1, 1, 1, 0 },  // 0
  { 0, 1, 1, 0, 0, 0, 0 },  // 1
  { 1, 1, 0, 1, 1, 0, 1 },  // 2
  { 1, 1, 1, 1, 0, 0, 1 },  // 3
  { 0, 1, 1, 0, 0, 1, 1 },  // 4
  { 1, 0, 1, 1, 0, 1, 1 },  // 5
  { 0, 0, 1, 1, 1, 1, 1 },  // 6
  { 1, 1, 1, 0, 0, 0, 0 },  // 7
  { 1, 1, 1, 1, 1, 1, 1 },  // 8
  { 1, 1, 1, 0, 0, 1, 1 }   // 9
};

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

/******************************************************************
   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 ()
{


  /******************************************************************
    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++)
  {

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


}

unter "anleitung" in den einstellungen etwas verändern und lernen wie ich diese verändern muss um ein bestimmtes ergebnis zu erreichen. Und vielleicht noch der hinweis, in welchem codeteil das passiert, wäre aber schon unter nice to have zu sehen...
Das würde mir zunächst einmal völlig reichen. Dazu muss ich keine 10 jahre lang (bewundernswert) die theorie studieren. Ich glaube nicht, dass Du - HaWe das kannst und willst - nichts für ungut...

@Moppi:

ein vorschlag. Ich habe vor jahren den versuch gestartet mit meinem enkel zusammen (der wohnt ca. 600km weit weg) einen roboter zu bauen. Dazu habe ich ca. ein dutzend video-tutorials aufgenommen, wie das hier z.b. Natürlich geht es da nicht um KI oder NN, sondern um simple mechanik. Könntest Du Dir vorstellen Deine versuche in der richtung KI in einem video, also anders als schriftlich zu erklären? Man könnte auch den serialmonitor und die IDE aufnehmen und erklären was bei welcher änderung des codes passiert...
Auch wenn mein (technisches) englisch - allerdings hauptsächlich mechanik betreffend - nicht schlecht ist, der vorteil wäre, dass das video in deutsch wäre

[Moppi]

unter "anleitung" in den einstellungen etwas verändern und lernen wie ich diese verändern muss um ein bestimmtes ergebnis zu erreichen. Und vielleicht noch der hinweis, in welchem codeteil das passiert, wäre aber schon unter nice to have zu sehen...
Das würde mir zunächst einmal völlig reichen.

So hatte das mal angefangen, irgendwo, aber es gab keine Antworten, in der Form, dass das mal wirklich zusammenhängend erklärt worden wäre.
In dem Thema, dass ich mal erstellt habe, habe ich schon, auf den von Dir angeführten Code, Bezug genommen. Dort kannst Du sehen, wie weit ich damit vorangeschritten bin. Dort habe ich auch selbst etwas zu den ursprünglichen Fragestellungen geschrieben.

Ich bin nun gezwungen worden, mich selbst mit dem Thema eingehend auseinanderzusetzen. Dabei sind mir viele Beispielerklärseiten über den Weg gelaufen. Um es kurz zu machen: so schwer ist es nicht. Und es ist besser, wenn man es in einer gewissen Tiefe verstanden hat. Man muss ja nicht die mathematisch abgeleiteten Formeln beherrschen und verstehen. Oftmals steht Anfangs schlicht eine Beobachtung und eine einfache Problembeschreibung. Siehe Herr Hebb. Mit Mathematik kann man diese Vorgänge dann beschreiben. Man kann aber auch anders ran gehen. Der Rumgucker hat das so gemacht. Und er war ja nicht auf einem schlechten Weg! Er war ja mit seinem Netz schon in der Weiterentwicklung. Als er ein zusätzliches Neuron eingeführt hat, um das XOR-Problem zu lösen. Die Art und Weise, die er dabei hatte... ist eine andere Frage... das war schon sehr herausfordernd und hat sicher nicht zuletzt deshalb bestimmte Reaktionen in der Diskussion hervorgebracht.

Der Code oben, Inka, ist auch noch nicht der Weisheit letzter Schluss. Da gibt es noch einige Sachen mehr dazu. Z.B. verschiedene Aktivierungsfunktionen und deren Auswirkungen auf das gesamte Netz. Dann kommt man zu Netzen mit mehr Schichten, als nur drei. Dann gibt es verschiedene Lernregeln/Lernmethoden, von denen jede ihre Vor und Nachteile hat, Backpropagation aber eine sehr verbreitete Methode ist.

Ich schreibe das nicht, weil ich es mal wieder "besser weiß", sondern einfach mal in die Richtung arbeiten möchte, dass man Einblick in das Thema bekommt.




MfG


- - - Aktualisiert - - -

Bezüglich des Codes habe ich schon damit begonnen, den auseinander zu nehmen und mir zu den einzelnen Vorgängen Fakten im Netz zu suchen, um daraus eine im Detail nachvollziehbare Beschreibung in Deutsch zu erstellen. Das habe ich gemacht, weil ich mich gerade selber in das Thema einarbeite. Erfahrungsgemäß ist dies der beste Zeitpunkt, so eine Beschreibung zu erstellen, weil dann am Umfassendsten auf die Fragen der Themenneulinge eingegangen wird. Aber ich bin noch nicht fertig, und - vielleicht auch verständlich - gerade etwas demotiviert, dass dann hier so öffentlich zur Verfügung zu stellen. Schauen wir mal. Vielleicht ergeben sich hier im Forum auch noch andere Möglichkeiten.

[Holomino]

Was ist denn eigentlich das Ziel der Sache?
Ein Linienfolger, der Kurven (einem Kreis) folgen kann?
Ein Linienfolger, der Ecken (einem Rechteck) folgen kann?
Ein Linienfolger, der Beides kann, aber zweifellos aufgrund der physikalischen Trägheit und dem Unvermögen, Ecken rechtzeitig zu sehen, nur langsam fährt?
Oder ein Linienfolger, der den Parcours erlernt, sich die Ecken merkt und rechtzeitig bremst, ansonsten aber auf Geraden und sanften Kurven Gummi gibt?

[Moppi]

Es ging wohl darum, anhand dieses Beispiels eines Linienfolgers (sicher auf einfachste Art und Weise umgesetzt), eine Beispielsteuerung durch ein KNN zu realisieren, sicher nicht zuletzt, um überhaupt erst einmal Verständnis für die Materie zu bekommen. Nur hier war dann die Grundlagenerarbeitung nicht gewünscht (das scheint bekannt zu sein), sondern einfach ein KNN vorzustellen, dass die Forderung erfüllen könnte, aber eben möglichst einfach (nach Möglichkeit einfachste Netzstuktur des KNN, auf das Nötigste reduziert - was das genau heißt, war glaub ich noch nicht so ganz klar).


MfG

[Holomino]

Hmm,
mit dem typischen Aufbau mit einer Reihe von Farb- oder Reflexlichtschranken an der Front ließe sich zusammen mit der Bewegung des Gefährts ja vielleicht ein grobes 2-D-Bild zusammenbasteln, über das sich mit einem NN zumindest die Klassifizierung "Gerade/Kurve/Ecke/Verzweigung" aufbauen ließe. Das wäre dann so etwas wie eine abgewandelte Handschrifterkennung.
Motorregelung oder Entscheidung, wohin man abzweigt, kann man ja auch außerhalb des NN programmieren.

[Moppi]

Im Grunde ist die Idee nicht schlecht. Aber ich glaube weit von einfach(st) entfernt. Mal sehen, vielleicht ist was Brauchbares hinzubekommen. Die Sensoren für einen Linienfolger habe ich schon. Dann probiere ich das mal mit herkömmlicher Programmierung. Das wird wohl funktionieren und dann mal sehen, ob derselbe Code als KNN-Geschichte funktioniert.
Bloß das so, wie es in dem Video zu sehen ist, hinzubekommen, wird vermutlich schwieriger. Das Teil trifft auf ein Hindernis und sucht sich scheinbar einen anderen Weg. Aber ich finde, das ist schon auf jeden Fall für ein Forum interessant, als Gemeinschaftsprojekt. Es wird nicht viel Hardware dafür benötigt. Interessant ist dabei, zunächst zu wissen, wie man sich die "Intelligenz" vorstellt. Vor allem wie, zumindest nach außen sichtbar, das Lernen stattfinden soll.


Das mit

dem typischen Aufbau mit einer Reihe von Farb- oder Reflexlichtschranken an der Front

kann ich mir noch nicht vorstellen. Aber wie wäre es mit 4x oder 5x BH1750? Zumindest haben die gewisse Lichtempfindlichkeit. Aber die Auflösung wäre so schlecht, dass damit womöglich kaum verwertbare Daten zusammen kommen.


MfG

[inka]

Im Grunde ist die Idee nicht schlecht. Aber ich glaube weit von einfach(st) entfernt. Mal sehen, vielleicht ist was Brauchbares hinzubekommen. Die Sensoren für einen Linienfolger habe ich schon. Dann probiere ich das mal mit herkömmlicher Programmierung. Das wird wohl funktionieren und dann mal sehen, ob derselbe Code als KNN-Geschichte funktioniert.

es ist ja nicht nur das mit dem "linienfolgen". Das allein geht vermutlich sogar mit einer standard-programmierung besser (weil schneller?) Auch hindernisse, lichtquellen, IR-baken und was weiss ich noch könnten da einfliessen...

Bloß das so, wie es in dem Video zu sehen ist, hinzubekommen, wird vermutlich schwieriger. Das Teil trifft auf ein Hindernis und sucht sich scheinbar einen anderen Weg. Aber ich finde, das ist schon auf jeden Fall für ein Forum interessant, als Gemeinschaftsprojekt. Es wird nicht viel Hardware dafür benötigt. Interessant ist dabei, zunächst zu wissen, wie man sich die "Intelligenz" vorstellt. Vor allem wie, zumindest nach außen sichtbar, das Lernen stattfinden soll.

welches video?

mit dem typischen Aufbau mit einer Reihe von Farb- oder Reflexlichtschranken an der Front ließe sich zusammen mit der Bewegung des Gefährts ja vielleicht ein grobes 2-D-Bild zusammenbasteln, über das sich mit einem NN zumindest die Klassifizierung "Gerade/Kurve/Ecke/Verzweigung" aufbauen ließe. Das wäre dann so etwas wie eine abgewandelte Handschrifterkennung.

Das mit kann ich mir noch nicht vorstellen. Aber wie wäre es mit 4x oder 5x BH1750? Zumindest haben die gewisse Lichtempfindlichkeit. Aber die Auflösung wäre so schlecht, dass damit womöglich kaum verwertbare Daten zusammen kommen.

Ich habe schon auch diese Sensoren ( https://www.ebay.de/i/352895817780?c...BoCPK8QAvD_BwE ) verwendet, die helligkeitsunterschiede waren gut zu verwenden...

[Moppi]

welches video?

Musst Du den Thread von Anfang an lesen!


Übrigens, Dein eBay-Link funkt. nicht.

es ist ja nicht nur das mit dem "linienfolgen". Das allein geht vermutlich sogar mit einer standard-programmierung besser (weil schneller?)

Es geht doch darum, klein anzufangen. Und so ein Verständnis zu entwickeln.
Wir wollen doch nicht mit der Mondlandung anfangen, sondern erst mit dem Bau einer Rakete.


MfG

[inka]

ach, dumeinst das mit dem nibo-bee? Ich dachte da wäre noch was anderes....

https://www.youtube.com/watch?v=D0R-...qRWq0w&index=2

habe noch einmal mein ebaylink getestet, bei mir geht er - hier noch einmal...

[Moppi]

Also lange Rede kurzer Sinn: bei dem eBay-Link bekomme ich Schriftgröße 86 mit dem Hinweis Daten speichern zu wollen und zwei Buttons.
Da die Schrift so riesig ist, kann ich nichts anderes sehen.

Ja, das mit dem Nibo-dings ... Haste gesehen?

MfG