lernfähiger Lininenfolger mit KI

[Moppi]

Vielleicht kennt Ihr ja auch ein paar Projekte, die das schon umsetzen.

Direkt ein Linienfolger nicht. Aber an einem ähnlichen Projekt arbeite ich gerade. Dazu habe ich mir zuerst angesehen, wie ein einfacher Linienfolger funktioniert. Das geht nach dem Schema, in Fahrtrichtung: wenn der rechte Sensor über die schwarze Linie gerät, dann lenke nach rechts, wenn der linke Sensor über die schwarze Linie gerät, dann lenke nach links. Die schwarze Linie befindet sich zwischen den Sensoren. Das Trainieren eines KNN sollte daher nicht so kompliziert sein. Im Grunde sollte ein Perceptron-Modell mit 2 Eingabe und 2 Ausgabeneuronen für's Erste genügen.


MfG

[Moppi]

Ein Link zu einer deutschen Seite, wo Grundsätzliches zu Neuronalen Netzen erklärt wird. Unten auf der Seite, unter Trackbacks & Pingbacks, sind noch weitere Links, hinter denen sich weitere Erklärseiten verbergen.
Da gibt es eine schöne Übersicht, über Arten neuronaler Netze.

Auch schon mehrmals erwähnt, glaub ich: http://neuronalesnetz.de


MfG

[Moppi]

MXT hatte, in einem andern Thread, schon einen guten Link auf diese Seite: http://robotics.hobbizine.com/arduinoann.html
Nachdem ich das mehrfach angeschaut und nichts verstanden habe, hat mein biologisches Netz aber langsam gelernt, dass das nicht soo schwer ist. Zumal auf der Seite jeder einzelne Schritt gut erklärt ist. Allerdings lernt das Netz nur. Jetzt weiß ich nicht, wie man das einfach nutzt, wenn es trainiert ist.

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

Macht man das einfach mit diesem Programmteil? - Aus Unwissenheit würde ich vermuten: ja

Dann kann aus den einzelnen Fragmenten (des kompletten Codes), die alle erklärt sind, ein eigenes KNN aufgebaut werden. Man kann auch mit einem Eingabe-, einem Ausgabeneuron und einem Neuron für die Zwischenschicht starten. Dann evaluieren, wie das funktioniert und ob es funktioniert, um den Durchblick zu bekommen. Klar ist mir außerdem nicht, wieviele Neuronen für eine Zwischenschicht benötigt werden. Wovon hängt das ab? Kann man die Anzahl, je nach Anwendungsfall, frei wählen?

Vielleicht bauen wir ein Grundgerüst auf, das jeder nachvollziehen und verstehen kann. Ich würde das mit dem PAP dann schon machen, wenn das sonst keiner tun will, nur muss ich nat. dafür selber den Programmcode erst einmal verinnerlicht haben, der dann auch funktionieren sollte. Deshalb: Schritt um Schritt aufbauen.

Man kann ja so anfangen, wenn man sich hier auf Arduino-Code einigt:

#include <math.h>

void setup()
{

}

void loop()
{

}

Gar nicht so schwer - schon fast fertig


MfG

[HaWe]

Faustregel
InputLayer = Anzahl der Inputs
HiddenLayer = etwa wie Inputlayer oder auch etwas größer
OutputLayer = Anzahl der Outputs

[Moppi]

Warum nimmt man für die versteckte Schicht mehr Neuronen?

[HaWe]

hängt vom Lernziel und Zweck ab, man kann auch einen Wert zwischen In- und Outputzahl nehmen, muss man ausprobieren - daher: "Faustregel".
Je kleiner das HiddenLayer, desto weniger Input-Informationen werden logischerweise an die Outputs weitergereicht, und je größer, desto differenzierter können diese moduliert werden.

[stochri]

Gar nicht so schwer - schon fast fertig

Ein guter Anfang. Man muss konkret werden, sonst nützt alles nichts.
Man kann das System am Anfang auch ohne lernen ganz einfach aufbauen:

...
boolean SensorLinks;
boolean SensorRechts;

boolean MotorLinks;
boolean MotorRechts;

int w[4];

.... 
void loop()
{

MotorLinks=w[0]*SensorLinks+w[1]*SensorRechts;
MotorRechts=v[2]*SensoLinks+w[3]*SensorRechts;

stepMotorLinks(MotorLinks);
stepMotorRechts(MotorRechts);

...

}

[Moppi]

Ich würde zunächst auf eine konkrete Problemlösung verzichten. Und erst einmal mit den grundsätzlichen Dingen und Fragen zum neuronalen Netz anfangen.


1. Netzstruktur


Hier würde ich mich jetzt auf das Beispiel beziehen, daher wäre das ein was für ein Netz? Feed Forward mit Backpropagation, wenn ich richtig gelesen habe.
Dafür wir mindestens benötigt: ein Eingangsneuron, ein verstecktes Neuron (zwischen Ein- und Ausgang) und ein Ausgangsneuron.
Wenn ich das richtig sehe, ist jedes Eingangsneuron mit jedem versteckten Neuron verbunden (ich brauche einen Speicherplatz für das Gewicht jeder dieser Verbindungen)
und jedes versteckte Neuron ist mit jedem Ausgangsneuron verbunden (auch hier wieder Speicherplatz für das Gewicht jeder dieser Verbindungen).




Für die Gewichtsberechnung wird wohl der Datentyp "float" benötigt, für Datenmengen werden Arrays benötigt:


//Gewicht für Verbindungen Eingangsneuron, mit jedem versteckten Neuron
float IH_Weights[InputNeurons][HiddenNeurons];


//Gewicht für Verbindungen jedes versteckte Neuron, mit jedem Ausgangsneuron
float HO_Weights[HiddenNeurons][OutputNeurons];






Wenn ich mir das jetzt im Vergleich zur Beispielseite ansschaue, ist dort nur die Rede von HiddenWeights und OutputWeights.


Die Frage, wie bezeichne ich die Gewichte zwischen den Input Nodes und den Hidden Nodes - als InputWeights oder als HiddenWeights? - war für mich noch nicht ganz so spontan zu beantworten.
Deshalb habe ich die mal IH_Weights und HO_Weights genannt.
Man will ja auch nicht immer langwierig den Sachverhalt in jeder Variablen beschreiben, was zu Vereinfachungen führt, die für Außenstehende aber missverständlich sein können.
Deswegen lasse ich das jetzt erst mal so stehen.







MfG

[HaWe]

Ein guter Anfang. Man muss konkret werden, sonst nützt alles nichts.
Man kann das System am Anfang auch ohne lernen ganz einfach aufbauen:

...
boolean SensorLinks;
boolean SensorRechts;

boolean MotorLinks;
boolean MotorRechts;

int w[4];

.... 
void loop()
{

MotorLinks=w[0]*SensorLinks+w[1]*SensorRechts;
MotorRechts=v[2]*SensoLinks+w[3]*SensorRechts;

stepMotorLinks(MotorLinks);
stepMotorRechts(MotorRechts);

...

}

das hat aber weder etwas mit einem Perzeptron noch mit einem Netz noch mit lernfähig zu tun...
und wie das (mindestens) designed werden müste, habe ich ja bereits oben skizziert...

Außerdem halte ich nach wie vor einen Linienfolger nicht für NN-Anfänger-geeignet, hier braucht man schon das Grundwissen und das Verständnis über einfache Netze, wie das in Mxts Link.

[inka]

ich trau mich mal aus der deckung:


was wir haben:
-ein paar leute, die sich auskennen
- ein paar mehr leute, die nicht so viel wissen, die aber interesse haben (kann man irgendwo sehen, wie viele z.b. dieses thema aboniert haben? Manf?)
- kaum jemmand wird einen "12F629" in der schublade haben, von der beschaltung und dem handling mal ganz zu schweigen, aber einen arduino? Hat wohl fast jeder. Manch einer sogar einen ESP32...

was wir nicht haben:
- lust auf rechthaberei oder streit

mein vorschlag wäre, dass sich einer, der sich auskennt, gedanken darüber macht, wie man zum KI und NN einen arduino nutzen könnte und schön step by step das ganze aufbaut. Von der beschaltung, bis hin zu basis der software, vielleicht mal einiges anhand von beispielen erklärt. Hinweise auf weblinks sind zwar manchmal hilfreich, hier wären sie nicht so gut passend ...
Dieser KI-tutorial sollte weder in Rumgucker's flapsiger noch mit (manchmal) HaWe's herablassender art erfolgen, da geht doch sicher noch was anders. Auch ein ganz neuer thread könnte es werden...

Nun, wer machts?