lernfähiger Lininenfolger mit KI

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.

Code:

---

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

Code:

---

#include <math.h>

void setup()
{

}

void loop()
{

}

---

Gar nicht so schwer - schon fast fertig \\:D/


MfG
:Weihnacht

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

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

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.

Zitat:

---

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:

Code:

---

...
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);

...

}

---

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
:Weihnacht

Zitat:

---

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.

---

Das ist mir jetzt ein wenig zu "low level". Schau Dir doch erst mal ein paar Videos auf Youtube zum Aufbau neuronaler Netze an, damit Du mal ein wenig Grundverständnis für die Sache bekommst, sonst wird das hier wie das Lernen des 1x1.

Zitat:

---

Zitat von stochri

Schau Dir doch erst mal ein paar Videos auf Youtube zum Aufbau neuronaler Netze an, damit Du mal ein wenig Grundverständnis für die Sache bekommst, sonst wird das hier wie das Lernen des 1x1.

---

Ich habe mir schon einige Sachen angeschaut, dennoch muss doch ein Grundgerüst erarbeitet werden und damit einhergehend ein Verständnis, dem auch jeder hier folgen kann.

Zitat:

---

Zitat von stochri

Das ist mir jetzt ein wenig zu "low level".

---

Gut, dann passt das nicht in diesen Thread. Denn Du hast den ja erstellt.
Da von Deiner Seite aus nichts kam, hatte ich einfach mal angefangen.
Dann mach Du auf einem andern Level weiter. Wenn Du das nichts kannst, aber eine Lösung für Dich suchst, verstehe ich das auch. Mir geht es mehr um die Allegmeinheit, damit wir hier mehr Leute finden, die an einem solchen Thema teilnehmen können, aber dafür braucht es idealer Weise eine einheitliche Wissensbasis. Das ist nicht so schnell gemacht, das weiß ich.

Manf kann den bisherigen Verlauf löschen und Du kannst neu starten.



MfG
:Weihnacht

Zitat:

---

Manf kann den bisherigen Verlauf löschen und Du kannst neu starten.

---

Das ist mehr ein Kurs abstecken und gehört eher dazu, wenn es ganz neu sein soll dann ist auch ein neuer Thread möglich.
Aber ich lösche bei Bedarf auch selektiv.

Zitat:

---

Zitat von stochri

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

Code:

---

...
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... 8)

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.