Archiv verlassen und diese Seite im Standarddesign anzeigen : einfaches neuronales Netz, inkl. deep learning
Guten Morgen,
ich habe ein Video gesehen, wo schon sehr gut erklärt ist, wie ein neuronales Netz zur Bilderkennung funktioniert.
Jetzt würde ich mir wünschen, dass es jemand ganz genau erklärt, der die Essenz wirklich verstanden hat und das praktisch, auch an einem Programmbeispiel, mit meinetwegen nur 4 Neuronen in der ersten Schicht, Stück für Stück erklärt. Anhand eines Beispiels die programmtechnischen Zusammenhänge und Aufbau praktisch erläutert. Das Beispiel sollte funktionstüchtig sein.
Dann würde ich mir wünschen, dass dieses kleine, funktionierende, neuronale Netz um Deep Learning erweitert wird. So, dass man die Wirkungsweise - auch im Quellcode, am besten nachvollziehbar tatsächlich für Arduino bzw. nodeMCU (wegen des größeren Speichers und der höheren Taktgeschwindigkeit) - bis auf den letzten C-Befehl nachvollziehen kann.
MfG
ich habe es vor vielen Jahren schon einmal programmiert, sowohl mit NXC für Lego Mindstorms als auch mit Arduino - aber das zu erklären, würde den Rahmen des Forums sprengen. Hier ist mein erster Ansatz (später dann im Aufbau deutlich verändert): http://www.robotc.net/forums/viewtopic.php?f=15&t=557 (Feed Forward funktionierte, bei Backpropagation war noch ein Bug drin).
Suche mal nach Perzeptron, das ist die einfachste Struktur, die man dann zu einschichtigen (Feed Forward Netzen), 2-schichtigen (Backpropagation-Netzen), 2-schichtigen mit Rückkopplung (Jordan-/ Elman-Netz mit Backpropagation) und vielschichtigen (Deep learning) kombinieren kann.
https://www.statworx.com/de/blog/das-rosenblatt-perzeptron-die-fruehen-anfaenge-des-deep-learnings/
Ich weiß, dass das Thema insgesamt sehr komplex ist. Links dazu gibt es im Netz haufenweise. Und es gibt genau so haufenweise unsachliche und nicht zielführende Kommentare.
Aber ich dachte an Grundlagen, die man praktisch verdeutlicht. Das sollte das Forum nicht sprengen. Wenn man anscheinend in ein paar Minuten Youtube-Video erklären kann (oder die taugen einfach nichts) sollte es so schwer nicht sein, das in einem Forum wie diesem ganz genau Schritt für Schritt praktisch umzusetzen. Gerne und lieber wäre eigentlich sogar Pseudocode, weil am einfachsten für jeden zu verstehen, egal von welcher Programmiersprache er kommt. Ich habe z.B. ein Buch gefunden, dass das können soll, hat aber auch keine 1000 Seiten. Leider nimmt man dort wieder Python. Deshalb wünsche ich mir, dass das in diesem Forum mal aufgedröselt wird. Am besten wärs, nicht nur Pseudocode zu haben, sondern auch PAPs dazu.
MfG
besser erklären als hier könnte ich es auch nicht:
https://www.statworx.com/de/blog/das-rosenblatt-perzeptron-die-fruehen-anfaenge-des-deep-learnings/
https://de.wikipedia.org/wiki/Perzeptron
im ersten Link oben von mir http://www.robotc.net/forums/viewtopic.php?f=15&t=557 findest du ja C-ähnlichen Code für kleine einschichtige Netze.
Im Anhang ist ein Backpropagation Netz für Arduino Due:
Hier gibt es ein kleines neuronales Netz auf einem Arduino Uno
http://robotics.hobbizine.com/arduinoann.html
Wie man schön sieht, reduziert sich das größtenteils auf mathematische Operationen, insbesondere Matrizenmultiplikationen. Eigentlich gibt es bei NN nur die Ebene der Mathematik und die der Infrastruktur, um die Mathematik möglichst effizient abzuarbeiten.
ich habe hier noch mal ein neueres Beispiel für ein einfaches Feed-Forward Netz bei mir gefunden, in C-ähnlich (NXC):
Ich kehre mal wieder vom HTML-KeyPad (https://www.roboternetz.de/community/threads/74178-html-Code-f%C3%BCr-virtuelles-website-Button-Pad) zurück zum diesem Thread hier.
Hier die Überleitung dazu:
..... wende ich mich dem Thema Arduino zu und beschäftige mich etwas damit. Einen guten Link dazu gab es ja. Mal schauen, wie weit man damit kommt. Leider gibts hier offenbar keinen, der in der Lage wäre, das Thema Neuronales Netz für Bastler verständlich darzustellen und Projekte, angefangen vom Arduino UNO, über schnellere nodeMCUs mit mehr Speicherplatz und schließlich darüber hinaus verständlich darzustellen und zu beschreiben. Wenn man im Laufe der Entwicklung ableitet, dass man noch schnellere und noch mehr Speicherplatz und noch andere Technik (wie Multitasking) benötigt, ist das durchaus sinvoll und hat seine Berechtigung und macht dann auch Sinn.
Falls es jemand verpasst hat, nochmal hier lesen (https://www.roboternetz.de/community/threads/74167-einfaches-neuronales-Netz-inkl-deep-learning?p=655844&viewfull=1#post655844), was MXT schrieb.
MfG
- - - Aktualisiert - - -
Ich hatte mir das gestern angeschaut. Wenn es funktioniert, ist es ein guter Anfang, denke ich. Muss ausprobiert werden, dafür gibt es einen UNO in der Schublade.
ja, ich habe den Code gecheckt (nicht getestet), es ist sicher ein guter Anfang, und weil alle Inputs und alle Ziel-Net-Outputs hard-coded sind, kann es auch ohne User-Interface auskommen.
Um mein Anliegen noch mal zu erläutern:
Ich vertrete die Theorie, dass nur der, der neuronale Netze in der Grundfunktion verstanden hat und eigenständig aufbauen kann,
in der Lage ist abzuschätzen, was ganz genau damit möglich und was nicht machbar ist oder, wozu es überflüssig ist.
Und wenn bestimmte Probleme anstehen, ob man die besser mit einem neuronalen Netz löst und wenn, dann wie genau und in
welchem Umfang.
MfG
Um mein Anliegen noch mal zu erläutern:
Ich vertrete die Theorie, dass nur der, der neuronale Netze in der Grundfunktion verstanden hat und eigenständig aufbauen kann,
in der Lage ist abzuschätzen, was ganz genau damit möglich und was nicht machbar ist oder, wozu es überflüssig ist.
Und wenn bestimmte Probleme anstehen, ob man die besser mit einem neuronalen Netz löst und wenn, dann wie genau und in
welchem Umfang.
MfG
ja, stimme zu, nur kann der "normale" Arduino viele Netztopologien gar nicht aufbauen, u.a. wegen mangelndem RAM - aber als Einstieg in jedem Falle richtig.
Genau zu solchen Dingen sollten wir uns hier hinarbeiten.
MfG
ja, einen Einstieg über Mxt's Link mit Input/Output-Hardcoding hast du ja, und wenn man jetzt weiter machen will, um auch neue Muster während der Laufzeit zu trainieren, braucht man ein User-Interface mit vielen Switches und ein Dashboard.
Das kleine Beispiel zeigt aus meiner Sicht sehr schön, was einen bei neuronalen Netzwerken an Berechnungen erwartet.
Ich habe etwas den Eindruck, Moppi erwartet bei komplexeren NN irgendwelche komplexeren C Konstrukte in der Programmierung. Das ist aber so nicht der Fall, der komplexere Code ist nur die größere erforderliche Infrastruktur für die Berechnung der größeren neuronalen Netze. Im Grunde bleibt es auch bei komplexeren NN nur bei for-Schleifen, Arrays und den Grundrechenarten. Sonst gibt es da auf der Ebene der "einzelnen C Zeile" nicht wirklich was interessantes zu sehen.
Es gibt einen festen Zusammenhang zwischen diesen Netzwerkstrukturen und dem mathematischen Gebiet der linearen Algebra. Ein Tensor, bekannt aus den Namen von NN Software wie TensorFlow oder TensorRT, ist dort die Veralgemeinerung von Skalaren, Vektoren, Matrizen usw.
D.h. bei einem komplexeren NN habe ich noch mehr Vektoren, Matrizen usw. zu verrechnen. Sonst ändert sich da nix. Ob ich das Rechnen nur mit einem Prozessor, mit vielen oder mit Bleistift und Papier mache, ist dem NN völlig egal.
NN werden heute gerne mit Grafikkarten Hardware berechnet, weil man da heute tausende (aber relativ doofe) Kerne in einem Chip hat. Da kann man die Zillionen Multiplikationen und Additionen halt schön schnell durchschieben. Auch Googles spezielle KI Prozessoren enthalten im wesentlichen nur viele Kerne, die nichts anderes als 256x256 Matrizen verarbeiten können.
völlig richtig, ich habe mein Netz deshalb ja auch 100% skalierbar aufgebaut, mit beliebig vielen Inputs, Outputs und Neuron-Layer-Größen - die Rechnerei bleibt bei einem 3-Neuronen-Netz oder bei einem 50-Neuronen-Netz absolut dieselbe:
// neural net size
#define NMAXIN 108 // max number of inputs (sensors)
#define NMAXHID 20 // max number hidden layer neurons
#define NMAXOUT 20 // max number output layer neurons
#define NMAXPAT 70 // <<< max number of traineable patterns;
//-------------------------------------------------------------------------------------
// neural net: neurons and patterns
float WeightLIn[NMAXIN+1][NMAXHID+1];
float WeightLOut[NMAXHID+1][NMAXOUT+1];
float Input[NMAXPAT+1][NMAXIN+1];
float Target[NMAXPAT+1][NMAXOUT+1];
float Output[NMAXPAT+1][NMAXOUT+1];
//float Contxt[NMAXOUT+1]; // Jordan-net: neuron-number == output-number
float currIn[NMAXIN+1], // currently polled inputs
inbuf[NMAXIN+1]; // intermediate stored inputs for editing
float currOut[NMAXOUT+1], // currently computed net outputs
outbuf[NMAXOUT+1]; // intermediate stored outputs
int16_t NumInput = NMAXIN, NumHidden = NMAXHID, NumOutput = NMAXOUT;
Ich habe etwas den Eindruck, Moppi erwartet bei komplexeren NN irgendwelche komplexeren C Konstrukte in der Programmierung.
Kann man so nicht sagen. Ich weiß noch nicht, was da kommt. Nur Theorie genügt mir nicht. Was sich später ergibt, wird sich zeigen. Sicher werden aber weitere Codeschnipsel hinzukommen, wenn man zu komplizierteren Techniken übergeht. Hier erwarte ich schon, dass es da noch Unterschiede gibt. Mich interessieren auch nicht die C-Konstrukte, sondern die Funktion. Deshalb habe ich an Pseudocode appelliert und an PAPs.
MfG
Perzeptron-Learning und Backpropagation sind reine mathematische Matrizen-Operationen, die sich mathematisch (Formeln) und algorithmisch (Programmcode) darstellen lassen.
Was passiert: Neurons sind Strukturen mit inneren Variablen, die beim Training schrittweise (Schleifen) so verstellt werden, bis für jeden Input der gewünschte Output "passt" (Approximierung), d.h. der Fehler (float) unter einem frei gewählten Grenzwert liegt.
Für ein Verständnis habe ich mir damals KI-Bücher gekauft, wo beides schrittweise erklärt wird; in Web-Tutorials ist das sehr komprimiert, dennoch hier noch ein Link:
https://towardsdatascience.com/perceptron-learning-algorithm-d5db0deab975
https://miro.medium.com/max/870/1*Fyapb-JRFJ-VtnLYLLXCwg.png
https://miro.medium.com/max/910/1*C5LeL8JDfoGbkUg0cu1M-w.png
https://miro.medium.com/max/516/1*PbJBdf-WxR0Dd0xHvEoh4A.png
Google: Perzeptron-Learning
Hier mal grob der Workflow für DeepLearning mit (32 Bit) Arduino als Ziel:
Entwicklung und Training des DNN auf dem PC (ersatzweise Raspi)
https://www.tensorflow.org/
Dann Portierung auf TensorFlow Lite und das Ergebnis auf den Arduino bringen
https://www.tensorflow.org/lite/
https://www.tensorflow.org/lite/microcontrollers
(Arduino_TensorFlowLite ist als -> Alpha ! <- Version über den Arduino Bibiliotheksmanager installierbar.)
Keine eigene Erfahrung damit, vielleicht mal, wenn ich viel Zeit habe.
Aber z.B. bei Adafruit gibt es Spracherkennung auf deren M4 Boards, die so gemacht wurde.
@Mxt: das ist aber sääähr schwäääre Kost für Anfänger!
Ist ja nicht für den Anfänger, sondern für den noch zu findenden, der das freiwillig für den Anfänger in der Arduino IDE nachbaut ...
Jenseits der einfachen Beispiele sind NN heute nun mal bei fertigen Tools, diversen verbreiteten Dateiformaten usw. angekommen. Wenn man das alles ablehnt, wird es schwierig da über die einfachen Beispiele hinaus zu kommen.
ich habe jetzt versucht, Mxt's verlinktes NN auf dem esp8266 zum Laufen zu kriegen, aber die Routinen führen dazu, dass der esp dauernd rebootet (wschl wegen watchdog timeout) - fast wie ich es befürchtet habe.
Nach ein paar delay(1) zwischendrin rebootet er nicht mehr, aber es dauert nun sehr lange - mal gucken.....
http://robotics.hobbizine.com/arduinoann.html
// A Neural Network for Arduino
// http://robotics.hobbizine.com/arduinoann.html
// 2-layer Backpropagation net
// modified by HaWe
// version 0.0.2
#include <math.h>
#define REPORT_N 100
/************************************************** ****************
* 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.00040;
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 ReportEvery_n;
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(115200);
delay(1000);
randomSeed(analogRead(3));
ReportEvery_n = 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 ;
delay(1);
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++ ) {
delay(1);
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
************************************************** ****************/
ReportEvery_n = ReportEvery_n - 1;
if (ReportEvery_n == 0)
{
Serial.println();
Serial.println();
Serial.print ("TrainingCycle: ");
Serial.print (TrainingCycle);
Serial.print (" Error = ");
Serial.println (Error, 5);
toTerminal();
if (TrainingCycle==1)
{
ReportEvery_n = REPORT_N-1;
}
else
{
ReportEvery_n = REPORT_N;
}
}
/************************************************** ****************
* 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 ();
ReportEvery_n = 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 (" ");
}
}
}
- - - Aktualisiert - - -
Update:
konnte inzwischen ein paar delays wieder rausnehmen, klappt immer noch und ist wieder ein bisschen schneller.
- - - Aktualisiert - - -
jawohl, er hat das Training geschafft:
TrainingCycle: 5375 Error = 0.00040
Training Pattern: 0
Input 1 1 1 1 1 1 0 Target 0 0 0 0 Output 0.00775 0.00009 0.00431 0.00639
Training Pattern: 1
Input 0 1 1 0 0 0 0 Target 0 0 0 1 Output 0.00092 0.00465 0.00439 0.99653
Training Pattern: 2
Input 1 1 0 1 1 0 1 Target 0 0 1 0 Output 0.00244 0.00013 0.99975 0.00190
Training Pattern: 3
Input 1 1 1 1 0 0 1 Target 0 0 1 1 Output 0.00038 0.00698 0.99533 0.99567
Training Pattern: 4
Input 0 1 1 0 0 1 1 Target 0 1 0 0 Output 0.00609 0.99732 0.00555 0.00466
Training Pattern: 5
Input 1 0 1 1 0 1 1 Target 0 1 0 1 Output 0.00173 0.99669 0.00484 0.99655
Training Pattern: 6
Input 0 0 1 1 1 1 1 Target 0 1 1 0 Output 0.00034 0.99465 0.99296 0.00011
Training Pattern: 7
Input 1 1 1 0 0 0 0 Target 0 1 1 1 Output 0.00005 0.99232 0.99417 1.00000
Training Pattern: 8
Input 1 1 1 1 1 1 1 Target 1 0 0 0 Output 0.99110 0.00002 0.00254 0.00019
Training Pattern: 9
Input 1 1 1 0 0 1 1 Target 1 0 0 1 Output 0.99327 0.00678 0.00002 0.99424
Training Set Solved!
--------
Ich habe das auch versucht, bei mir hat es funktioniert - Originalcode, ohne delay oder was anderes.
nin, er rebootet definitiv und startet dann neu:
TrainingCycle: 100 Error = 0.04521
Training Pattern: 0
Input 1 1 1 1 1 1 0 Target 0 0 0 0 Output 0.06243 0.02479 0.05091 0.05631
Training Pattern: 1
Input 0 1 1 0 0 0 0 Target 0 0 0 1 Output 0.00231 0.06811 0.04512 0.94515
Training Pattern: 2
Input 1 1 0 1 1 0 1 Target 0 0 1 0 Output 0.04356 0.00191 0.98995 0.03381
Training Pattern: 3
Input 1 1 1 1 0 0 1 Target 0 0 1 1 Output 0.02843 0.06270 0.97317 0.97425
Training Pattern: 4
Input 0 1 1 0 0 1 1 Target 0 1 0 0 Output 0.05156 0.93669 0.03940 0.05695
Training Pattern: 5
Input 1 0 1 1 0 1 1 Target 0 1 0 1 Output 0.04218 0.96939 0.06712 0.98471
Training Pattern: 6
Input 0 0 1 1 1 1 1 Target 0 1 1 0 Output 0.00227 0.96866 0.92983 0.00949
Training Pattern: 7
Input 1 1 1 0 0 0 0 Target 0 1 1 1 Output 0.00317 0.92403 0.93362 0.99969
Training Pattern: 8
Input 1 1 1 1 1 1 1 Target 1 0 0 0 Output 0.91035 0.00619 0.03578 0.01782
Training Pattern: 9
Input 1 1 1 0 0 1 1 Target 1 0 0 1 Output 0.94078 0.07733 0.00163 0.93763
Soft WDT reset
>>>stack>>>
ctx: cont
sp: 3ffffd30 end: 3fffffc0 offset: 01b0
3ffffee0: dc000000 3fba4933 35793c76 be0a39ef
3ffffef0: 9c5d2286 3f4dd77a 00000000 40201d95
3fffff00: 3ffe861d 3ffe861d 3ffee70c bff06660
3fffff10: 20000000 3ffee70c 00000006 4020baa3
3fffff20: 3ffee6c8 0000000c 3ffee70c 40201324
3fffff30: 3ffee5b4 3ffee514 0000001c 40be7a11
3fffff40: 00000007 3ffee700 3ffee734 40201dc0
3fffff50: 40100f78 002f51d8 3ffee6d4 3ffee734
3fffff60: 3ffee714 3ffee70c 00000006 402015e7
3fffff70: 0000000c 3ffee5a4 3ffe8688 4018fb97
3fffff80: 3a262eb6 00000070 b886e74e 3ffe866c
3fffff90: feefeffe 00000000 3ffee760 3ffee790
3fffffa0: 3fffdad0 00000000 3ffee760 40202634
3fffffb0: feefeffe feefeffe 3ffe8504 4010049d
<<<stack<<<
ets Jan 8 2013,rst cause:2, boot mode:(3,6)
load 0x4010f000, len 1384, room 16
tail 8
chksum 0x2d
csum 0x2d
v8b899c12
~ld
Initial/Untrained Outputs:
Training Pattern: 0
Input 1 1 1 1 1 1 0 Target 0 0 0 0 Output 0.46877 0.38939 0.51073 0.54921
Training Pattern: 1
Input 0 1 1 0 0 0 0 Target 0 0 0 1 Output 0.47558 0.37645 0.46304 0.58882
Training Pattern: 2
Input 1 1 0 1 1 0 1 Target 0 0 1 0 Output 0.44487 0.38804 0.51166 0.58088
Training Pattern: 3
Input 1 1 1 1 0 0 1 Target 0 0 1 1 Output 0.46660 0.38491 0.47829 0.58919
Training Pattern: 4
Input 0 1 1 0 0 1 1 Target 0 1 0 0 Output 0.45748 0.37212 0.46751 0.59319
Training Pattern: 5
Input 1 0 1 1 0 1 1 Target 0 1 0 1 Output 0.49832 0.37738 0.48112 0.56172
Training Pattern: 6
Input 0 0 1 1 1 1 1 Target 0 1 1 0 Output 0.50337 0.38582 0.49144 0.56569
Training Pattern: 7
Input 1 1 1 0 0 0 0 Target 0 1 1 1 Output 0.46656 0.37699 0.46670 0.57934
Training Pattern: 8
Input 1 1 1 1 1 1 1 Target 1 0 0 0 Output 0.45989 0.38881 0.50251 0.56673
Training Pattern: 9
Input 1 1 1 0 0 1 1 Target 1 0 0 1 Output 0.44974 0.37243 0.47104 0.58365
TrainingCycle: 1 Error = 5.35015
Tatsache! Ist mir gar nicht aufgefallen, musste ich erst mal suchen gehen.
MfG
wenn du es jetzt laufen lässt (s.o., // version 0.0.2), wird der Zwischenstand alle 100 Iterationen angezeigt, da kann man den Lern-Fortschritt besser verfolgen.
Hallo!
Ich möchte nochmal dran erinnern, was hier im Forum, für die breite Masse der User, fehlt.
Es kommen zwar, nun verstreut über verschiedene Threads, immer wieder Beispiele zu neuronalen Netzen,
davon gibt es auch sicher noch ganz viele, aber es ändert an der Problematik nichts. Deshalb nochmal zur
Erinnerung:
dass es jemand ganz genau erklärt, der die Essenz wirklich verstanden hat und das praktisch, auch an einem Programmbeispiel, mit meinetwegen nur 4 Neuronen in der ersten Schicht, Stück für Stück erklärt. Anhand eines Beispiels die programmtechnischen Zusammenhänge und Aufbau praktisch erläutert. Das Beispiel sollte funktionstüchtig sein.
Mal ein Wunschzettel, welche Themen behandelt werden sollten:
1. Was sind Neuronen in einem NN?
2. Wie bilde ich ein Neuron im Programm (Arduino-C-Code) ab/nach?
3. Wie funktioniert die Gewichtung in einem NN, wie bilde ich dies im Programmcode ab/nach?
4. Wie "lernt" das Netz, wie bilde ich dies im Programmcode ab/nach?
5. Wie entsteht aus einem Eingangsmuster eine Zuordnung am Ausgang?
6. Wie speichere ich Gewichtungen aus dem Netz und lade sie wieder dort hinein, um das Netz verschiedene Aufgaben erledigen zu lassen?
7. Wie weiß ein Netz, wann es alles fertig ist mit Lernen und wann es das gelernte anwenden kann, also wie schalte ich ein Netz um, von Lernen auf Anwenden und wie sieht dies im Programmcode ganz genau aus, wie wird es realisiert?
Sicherlich fehlt hier noch mehr, was wichtig zu wissen ist. Diese Wunschliste darf gerne ergänzt werden!
Ansonsten: reichlich Links auf Bücher und Abhandlungen findet man zur Genüge bei den einschlägigen Suchmaschinen.
Ich denke, das muss nicht alles zusammengesucht und hier in die Threads kopiert werden. Viele Beispiele davon sind
nicht vollständig oder behandeln nur ganz bestimmte Aspekte eines neuronalen Netzes.
Freundliche Grüße
Moppi
Mal ein Wunschzettel, welche Themen behandelt werden sollten:
1. Was sind Neuronen in einem NN?
2. Wie bilde ich ein Neuron im Programm (Arduino-C-Code) ab/nach?
3. Wie funktioniert die Gewichtung in einem NN, wie bilde ich dies im Programmcode ab/nach?
4. Wie "lernt" das Netz, wie bilde ich dies im Programmcode ab/nach?
5. Wie entsteht aus einem Eingangsmuster eine Zuordnung am Ausgang?
6. Wie speichere ich Gewichtungen aus dem Netz und lade sie wieder dort hinein, um das Netz verschiedene Aufgaben erledigen zu lassen?
7. Wie weiß ein Netz, wann es alles fertig ist mit Lernen und wann es das gelernte anwenden kann, also wie schalte ich ein Netz um, von Lernen auf Anwenden und wie sieht dies im Programmcode ganz genau aus, wie wird es realisiert?
Sicherlich fehlt hier noch mehr, was wichtig zu wissen ist. Diese Wunschliste darf gerne ergänzt werden!
ich bin nach wie vor der Meinung, dass damit das Forum hier samt möglicher Autoren überfordert ist. Man müsste wegen Copyrights selber neue Bilder malen und eigene mathematische Formeln per LaTeX einfügen, allein dieser Aufwand ist gewaltig und hier gar nicht zu schaffen - noch nicht mal verlinkte .png Bilder können hier eingefügt werden, und der Speicher für eigene geuploadede Bilder ist hier auch noch massiv begrenzt!!
Dazu gibt es aber ganze Bücher, die sich Schritt für Schritt damit beschäftigen.
Ich habe z.B.:
Uwe Lümmel, Jürgen Cleve: Lehr- und Übungsbuch Künstliche Intelligenz
Burkhard Lenze: Einführung in die Mathematik neuronaler Netze
Klaus Rädle: Neuronale Netze
Ich hatte allerdings oben schon einige Kurz-Tutorials verlinkt - besser als die es machen, könnte ich es auch nicht.
Suche z.B. in Wikipedia und per Google nach "Künstliches Neuron"
https://de.wikipedia.org/wiki/K%C3%BCnstliches_Neuron
mit schönen Bildern wie
https://de.wikipedia.org/wiki/K%C3%BCnstliches_Neuron#/media/Datei:ArtificialNeuronModel_deutsch.png https://de.wikipedia.org/wiki/K%C3%BCnstliches_Neuron#/media/Datei:ArtificialNeuronModel_deutsch.png,
Perzeptron,
Hebbsche Lernregel,
Perzeptron-Learning,
einschichtige Netze,
Feed-Forward-Netze,
mehrschichtoge Netze und dann auch nach
Backpropagation.
- - - Aktualisiert - - -
PS,
aber lies dir doch mal das hier sorgfältig durch https://de.wikipedia.org/wiki/K%C3%BCnstliches_Neuron ,
und wenn du dazu spezielle Verständnisfragen hast, dann frag einfach!
Wie benötigen dieses Forum nicht, um Wissen zu Themen zu finden, auch in russischer Sprache oder in polnisch findet man interessante Ausführungen, wenngleich das meiste vermutlich in englisch verfasst wird.
Ich bin der Meinung, es sollte hier darum gehen, gemeinsam Lösungen zu erarbeiten, gemeinsam an Themen zu arbeiten. Irgendwie sollten doch die vielen kleinen Projekte zu Robotern, Steuerung usw., der einzelnen User, hier im "Roboternetz" unter ein Dach gebracht werden. Mit eine gemeinsamen Wissensbasis kann man sich doch besser verständigen; wenn diese auch noch in der Gemeinschaft gewachsen ist, um so besser. Nicht zuletzt deswegen ist ja sicher auch der RN-Standard für Schaltungen entstanden.
Es ist doch einen Versuch wert, für "Roboternetz" eine Entwicklung anzustoßen, die zukunftsorientiert ist, mit Themen, für die man sich gerne in diesem Forum austauschen mag.
MfG
Moppi
Wie benötigen dieses Forum nicht, um Wissen zu Themen zu finden, auch in russischer Sprache oder in polnisch findet man interessante Ausführungen, wenngleich das meiste vermutlich in englisch verfasst wird.
Ich bin der Meinung, es sollte hier darum gehen, gemeinsam Lösungen zu erarbeiten, gemeinsam an Themen zu arbeiten. Irgendwie sollten doch die vielen kleinen Projekte zu Robotern, Steuerung usw., der einzelnen User, hier im "Roboternetz" unter ein Dach gebracht werden. Mit eine gemeinsamen Wissensbasis kann man sich doch besser verständigen; wenn diese auch noch in der Gemeinschaft gewachsen ist, um so besser. Nicht zuletzt deswegen ist ja sicher auch der RN-Standard für Schaltungen entstanden.
Es ist doch einen Versuch wert, für "Roboternetz" eine Entwicklung anzustoßen, die zukunftsorientiert ist, mit Themen, für die man sich gerne in diesem Forum austauschen mag.
MfG
Moppi
das ist aber jetzt eine ganz andere Fragestellung als
Mal ein Wunschzettel, welche Themen behandelt werden sollten:
1. Was sind Neuronen in einem NN?
2. Wie bilde ich ein Neuron im Programm (Arduino-C-Code) ab/nach?
3. Wie funktioniert die Gewichtung in einem NN, wie bilde ich dies im Programmcode ab/nach?
4. Wie "lernt" das Netz, wie bilde ich dies im Programmcode ab/nach?
5. Wie entsteht aus einem Eingangsmuster eine Zuordnung am Ausgang?
6. Wie speichere ich Gewichtungen aus dem Netz und lade sie wieder dort hinein, um das Netz verschiedene Aufgaben erledigen zu lassen?
7. Wie weiß ein Netz, wann es alles fertig ist mit Lernen und wann es das gelernte anwenden kann, also wie schalte ich ein Netz um, von Lernen auf Anwenden und wie sieht dies im Programmcode ganz genau aus, wie wird es realisiert?
Zunächst braucht man für Projekte u.a. dieses gewisse Grundwissen.
dann frag einfach
Habe ich im Grunde ja gemacht, jetzt noch mal genauer in diesem Beitrag: https://www.roboternetz.de/community/threads/74167-einfaches-neuronales-Netz-inkl-deep-learning?p=656114&viewfull=1#post656114
Aber da haben wir dann solche Antwort darauf:
ich bin nach wie vor der Meinung, dass damit das Forum hier samt möglicher Autoren überfordert ist.
Warum?
Warum soll man überfordert sein?
Man kann ein Thema#1 aufmachen und fängt mit dem ersten Schritt an, etwas zu erklären. Dann lass doch das bei dem Beitrag, damit reichlich Kommentare angehängt werden können.
Für den nächsten Beitrag zu dem Thema NN, der dann auf dem Ersten aufbaut, mach ein neues Thema#2 auf, wo der nächste Schritt erklärt wird.
Usw.
Also nur so als Beispiel, das kann man vielleicht aber auch anders machen. Aber es sollte schon irgendwie eine Struktur haben. Querverweise zwischen den Themen kann man ja per Links einbauen.
MfG
welche gezielte Frage hast du gestellt?
wie ein Neuron aufgebaut ist und wie es funktioniert, das steht doch alles da, ausführlich erklärt: https://de.wikipedia.org/wiki/K%C3%BCnstliches_Neuron
was genau hast du daran nicht verstanden?
Zunächst braucht man für Projekte u.a. dieses gewisse Grundwissen.
Richtig erkannt!
Darum geht es.
MfG
also nochmal:
welche gezielte Frage hast du gestellt?
wie ein Neuron aufgebaut ist und wie es funktioniert, das steht doch alles da, ausführlich erklärt: https://de.wikipedia.org/wiki/K%C3%BCnstliches_Neuron
was genau hast du daran nicht verstanden?
also nochmal:
welche gezielte Frage hast du gestellt?
wie ein Neuron aufgebaut ist und wie es funktioniert, das steht doch alles da, ausführlich erklärt: https://de.wikipedia.org/wiki/K%C3%BCnstliches_Neuron
was genau hast du daran nicht verstanden?
Chapeau, gut offtopic geführt!
Holomino
07.11.2019, 13:39
Zunächst braucht man für Projekte u.a. dieses gewisse Grundwissen.
Vielleicht braucht man zuerst einmal ein interessantes, für viele nachvollziehbares Projekt? Z.B. das selbständige Lernen/Optimieren der Regelkonstanten eines PID-Reglers im Antrieb mit Bezug auf Versorgungsspannung und Zuladung fände ich schon interessant.
Z.B. das selbständige Lernen/Optimieren der Regelkonstanten eines PID-Reglers im Antrieb mit Bezug auf Versorgungsspannung und Zuladung fände ich schon interessant.
das fände ich z.B. schon unglaublich weit fortgeschritten als Projekt - ich selber wüsste noch gar ncht, wie ich genau daran herangehen müsste.
Zeichenerkennung auf einer Punktmatrix ist da 1000mal einfacher!
- - - Aktualisiert - - -
Chapeau, gut offtopic geführt!
es waren doch deine eigenen Fragen! :p
1. Was sind Neuronen in einem NN?
2. Wie bilde ich ein Neuron im Programm (Arduino-C-Code) ab/nach?
3. Wie funktioniert die Gewichtung in einem NN, wie bilde ich dies im Programmcode ab/nach?
4. Wie "lernt" das Netz, wie bilde ich dies im Programmcode ab/nach?
5. Wie entsteht aus einem Eingangsmuster eine Zuordnung am Ausgang?
6. Wie speichere ich Gewichtungen aus dem Netz und lade sie wieder dort hinein, um das Netz verschiedene Aufgaben erledigen zu lassen?
7. Wie weiß ein Netz, wann es alles fertig ist mit Lernen und wann es das gelernte anwenden kann, also wie schalte ich ein Netz um, von Lernen auf Anwenden und wie sieht dies im Programmcode ganz genau aus, wie wird es realisiert?
1.-3. und eigentlich sogar 1.-5. steht im Wikipedia Artikel
Holomino
07.11.2019, 13:59
Man muss ja nicht die ganze Regelung mit KI machen, sondern einfach nur die Konstanten generieren.
Eingangsgrößen könnten z.B. Betriebsspannung und Zuladung sein. Ausgangsgrößen sind die Regelkonstanten. Bewertungskriterien sind Zeit bis zum Ziel und Anzahl der Überschwinger.
Wenn ich das alles richtig verstehe, sollte sich ein einfaches Fahrgestell mit Motoren und Inkrementalgebern doch so mit der Zeit selbst optimieren.
Arduino-Code übersetzt nur die Formeln in Arduino-Bezeichner, also für
S = i=0i=100Σxi als
S=0;
for (i=0; i<=100; i++) {S+=x[i]}
(hier sieht man auch, dass man hier im Forum gar keine vernünftigen Formeln reinschreiben kann, was aber unbedingt nötig wäre für ein Tutorial. Dazu bräuchte man LaTeX.)
- - - Aktualisiert - - -
Man muss ja nicht die ganze Regelung mit KI machen, sondern einfach nur die Konstanten generieren.
Eingangsgrößen könnten z.B. Betriebsspannung und Zuladung sein. Ausgangsgrößen sind die Regelkonstanten. Bewertungskriterien sind Zeit bis zum Ziel und Anzahl der Überschwinger.
Wenn ich das alles richtig verstehe, sollte sich ein einfaches Fahrgestell mit Motoren und Inkrementalgebern doch so mit der Zeit selbst optimieren.
Die Menge an Inputs sind viel größer als du wschl denkst, denn du kannst ja nur Zahlen als bit-Inputs eingeben.
Wenn du einen Incrementalgeber verfolgen willst, brauchst du auch die vorherige Position oder Geschwindigkeit.
wenn du also 4 16-Bit-Zahlen als Inputs eingeben willst, brauchst du alleine schon 64 Inputs.
Und wenn du eine 16-bit Encoder-Zielposition eingeben willst, brauchst du ebenfalls 16 In-oder Outputs. Hinzu kommen die Zahlen für Ki, Kp und Kd, das sind float-Zahlen, die ebenfalls als Int mindestens mit je 16bit dargestellt werden müssen, also nochmal 48 Inputs und sicher auch Outputs, denn als Outputs müssen sie ja korrigiert werden - ggf geht das auch über ein rückgekoppeltes 4-Schicht-Netz (Elman oder Jordan) oder eine "self-organizing map" - die SOMs sind aber um etliches schwerer auf Arduinos zu verwirklichen als Backpropagation Netze.
Verwende doch mal mein Backpropagation Netz als Basis und versuche es so abzuwandeln, dass es PID-Werte lernt und optimiert!
Insgesamt sicher nicht trivial!
- - - Aktualisiert - - -
Auch lernt ein Backpropagation Net keine Optimierung, sondern lernt nur präsentierte Inputs den gewünschten Ziel-Outputs zuzuordnen,
und es wird anschließend neu präsentierte Input-Muster dann entweder bisher gelernten Outputs zuordnen oder aber auch neue, eigene Outputs generieren, die sinnvoll, aber auch völlig sinnlos sein können,
also z.B
gelernt (als bit-Inputs):
1 -> 1
0 -> 1
3 -> 1
4 -> 1
8 -> 1
11 -> 2
10 -> 2
12 -> 2
15 -> 2
17 -> 2
20 -> 3
21 -> 3
22 -> 3
25 -> 3
27 -> 3
und wenn man nun präsentiert: 13 (nicht trainiert)
dann wird vlt als Ergebnis kommen: 2
und als Input: 24 (nicht trainiert)
dann möglicherweise als Output 3
es könnte aber durchaus auch 1 oder 0 als Ergebnis herauskommen.
Weicht das Ergebnis zu stark vom erwarteten Ergebnis ab, muss man es zusätzlich nachtrainieren.
Bei der Objekt-Erkennung auf Fotos oder in Videos wird man dem Netz beim Training z.B. 10000000 Fotos zu je mindestens 1000x1000 16-Graustufen Pixeln (16.000.000 Inputs) mit Fahrrädern, PKWs, LKWs, Menschen, Straßenschildern und Ampeln präsentieren und als Output, ob und wieviele Fahrräder (erste 7bits) , PKWs (zweite 7bits), LKWs (dritte 7bits), Menschen (vierte 7bits) oder Straßenschilder (fünfte 7bits) drauf waren und wo (Bildkoordinaten).
Dann präsentiert man ein Bild mit einem Zug, einer Auto-Schlange und ein paar Motorrädern und einer Schranke, und dann kann man sich überraschen lassen, was es per pixelweiser Bild-Analyse erkennt.
https://raw.githubusercontent.com/EdjeElectronics/TensorFlow-Object-Detection-on-the-Raspberry-Pi/master/doc/Picamera_livingroom.png
https://s3-us-west-2.amazonaws.com/static.pyimagesearch.com/opencv-yolo/yolo_car_chase_01_output.gif
PS,
Man kann solche BP-Netze u.U. auch zur Optimierung von Prozessen verwenden, dazu sind aber noch etliche weitere Prozeduren oder Schritte nötig - möglicherweise wären aber speziell dafür SOMs oder auch Q-Learning Netze besser geeignet.
Man muss ja nicht die ganze Regelung mit KI machen, sondern einfach nur die Konstanten generieren.
Eingangsgrößen könnten z.B. Betriebsspannung und Zuladung sein. Ausgangsgrößen sind die Regelkonstanten. Bewertungskriterien sind Zeit bis zum Ziel und Anzahl der Überschwinger.
Wenn ich das alles richtig verstehe, sollte sich ein einfaches Fahrgestell mit Motoren und Inkrementalgebern doch so mit der Zeit selbst optimieren.
Ich denke, dass ist schon etwas kompliziert.
Deshalb habe ich gefragt, ob das jemand auseinander nehmen kann und so ein Netz von der Pike auf erklären und aufbauen kann.
Dann kann jeder sehen, welches Potential drin steckt und wie wir das verbessern können. Oder ob das schon sehr aufwendig ist, so etwas damit anzustellen, wie Holomino als Beispiel gegeben hat.
Nach der ganzen Leserei darüber glaube ich schon, eine ungefähre Vorstellung zu haben, wie es funktioniert und wo die Grenzen sind oder wo es kompliziert wird.
Würde mir aber noch nicht selber zutrauen, so ein einfaches Netz neu aufzubauen, bis es irgendwann so umfangreich ist, dass man damit Probleme lösen kann, wie wir sie für einfachere Roboter bräuchten (s. Holomino).
MfG
Rumgucker
08.11.2019, 18:22
Hallo Moppi, HaWe, Mxt und Holomino,
ich danke Euch für diesen interessanten Thread und hoffe, dass "Thread erledigt" nicht heißt, dass mein später Beitrag hier unerwünscht ist.
Ich stelle mir eine nur mir bekannte geheime und dunkle "Umwelt" vor.
Sie besteht aus einem Schachbrett mit 8 mal 8 Feldern, von denen viele mit Mauern besetzt sind. Ein vollständig blinder Roboter soll durch diese ihm unbekannte Umwelt hüpfen und den Ausgang finden.
Der Roboter kann ausgehend von seiner Position in alle acht Richtungen springen. Wenn der arme Kerl gegen eine Mauer hüpft, wird er bestraft und zurück auf die Startposition gestellt. Die Anzahl der Strafen wird gezählt.
Als "normales" Programm wäre das ein 50-Zeiler inkl. Deklarationen und man findet findet mit weniger als 64 Strafen nicht nur irgendeinen, sondern sogar den optimalen Weg, wenn es denn überhaupt einen Weg gibt.
Ich spekuliere, dass KNN dem weit unterlegen sind.
Man wird viele ähnlich einfache (aber sinnvolle) Anwendungen finden, in denen KI eher hinderlich erscheint. Sinnvoller scheint der Einsatz erst zu werden, wenn die Aufgaben komplexer werden. Sprach- und Bildererkennung. Aber damit geht automatisch die von Moppi geforderte anschauliche Einfachheit verloren.
Bei großen Projekten treten auch strukturelle Probleme in den Vordergrund. Die mangelnde Parallelität und die fehlende dynamische Vernetzung unserer Computer. Beide strukturellen Mängel können nur mit der brutalen Rechnergeschwindigkeit von GPUs halbwegs ausgebügelt werden.
---------------
Mich persönlich würden winzige lernende und sich vernetzende KNN sehr interessieren. Aber dann mit einem matrixarmen Ansatz, der besser an die Gegebenheiten unserer kleinen Controller angepasst ist.
Und ich glaube auch, dass hier im Forum genug Expertise vorhanden ist, um auf neue Ansätze zu kommen.
Viele Grüße
Wolfgang
Ich habe den auf "erledigt" gesetzt, weil ich der Meinung war, dass zu einem bestimmten Zeitpunkt ausreichend geklärt war, worum es bei meinem Anliegen geht.
Das darf deswegen ruhig weiter diskutiert werden, wenn noch jemand was dazu zu sagen hat.
MfG
Hallo Moppi, HaWe, Mxt und Holomino,
ich danke Euch für diesen interessanten Thread und hoffe, dass "Thread erledigt" nicht heißt, dass mein später Beitrag hier unerwünscht ist.
Ich stelle mir eine nur mir bekannte geheime und dunkle "Umwelt" vor.
Sie besteht aus einem Schachbrett mit 8 mal 8 Feldern, von denen viele mit Mauern besetzt sind. Ein vollständig blinder Roboter soll durch diese ihm unbekannte Umwelt hüpfen und den Ausgang finden.
Der Roboter kann ausgehend von seiner Position in alle acht Richtungen springen. Wenn der arme Kerl gegen eine Mauer hüpft, wird er bestraft und zurück auf die Startposition gestellt. Die Anzahl der Strafen wird gezählt.
Als "normales" Programm wäre das ein 50-Zeiler inkl. Deklarationen und man findet findet mit weniger als 64 Strafen nicht nur irgendeinen, sondern sogar den optimalen Weg, wenn es denn überhaupt einen Weg gibt.
Ich spekuliere, dass KNN dem weit unterlegen sind.
Man wird viele ähnlich einfache (aber sinnvolle) Anwendungen finden, in denen KI eher hinderlich erscheint. Sinnvoller scheint der Einsatz erst zu werden, wenn die Aufgaben komplexer werden. Sprach- und Bildererkennung. Aber damit geht automatisch die von Moppi geforderte anschauliche Einfachheit verloren.
Bei großen Projekten treten auch strukturelle Probleme in den Vordergrund. Die mangelnde Parallelität und die fehlende dynamische Vernetzung unserer Computer. Beide strukturellen Mängel können nur mit der brutalen Rechnergeschwindigkeit von GPUs halbwegs ausgebügelt werden.
---------------
Mich persönlich würden winzige lernende und sich vernetzende KNN sehr interessieren. Aber dann mit einem matrixarmen Ansatz, der besser an die Gegebenheiten unserer kleinen Controller angepasst ist.
Und ich glaube auch, dass hier im Forum genug Expertise vorhanden ist, um auf neue Ansätze zu kommen.
Viele Grüße
Wolfgang
NNs sind nur dann festem prozeduralem Code überlegen, wenn sie auf komplexe und auch auf unscharfe Bedingungen sinnvolle Reaktionen bringen müssen.
Um verschieden große Autos, Fussgänger und Fahrräder an beliebigen Stellen und aus verschiedenen Perspektiven in Bildern zu identifizieren
- oder auch Gesichter in verschiedenen Größen und aus verschiedenen Perspektiven mit unterschiedlichem Gesichtsausdruck als Personen zu identifizieren und zu erkennen, wirst du um NNs nicht herumkommen.
Gleiches gilt für Buchstaben- und Ziffernerkennung (Texterkennung) bei verschieden großer Schrift mit verschiedenen Font-Typen, die auch an verschiedenen Stellen und auch geneigt und verdreht gegen die Matrix-Waagerechte/Senkrechte in einem großen Pixel-Feld erscheinen (TFT-Pixelmatrix, Kamera-CCD-Sensor).
Es gibt aber für verschiedene Anwendungszwecke viele verschiedene NN-Topologien und - Funktionalitäten, sowohl assistiert trainiert als auch selbst-trainierend, und nicht jedes Netz ist für alle Zwecke geeignet.
Ein EINFACHES Netz (Topic-Titel) wird jedoch KEINE sinnvollen Anwendungsgebiete in der Robotik haben, sondern nur sehr komplizierte, große und komplexe NNs:
Zum Verständnis der einfachsten Neuron-Funktionen sind große und komplexe aber absolut ungeeignet.
Ein schon etwas größeres NN mit verwendbarer Funktionalität habe ich ja hier entworfen:
https://www.roboternetz.de/community/threads/74190-Neuronales-Netz-Backpropagation-Netz-f%C3%BCr-Arduino-ESP
doch es gerät bereits extremst an die Grenzen der Leistungsfähigkeit (RAM, Speed) von Arduino-MCUs.
PS,
Einen ganz entscheidenden Aspekt von NNs habe ich aber noch gar nicht erwähnt, obwohl er eigentlich aber auch offensichtlich ist:
Ist eine NN-Struktur per Programm erstellt (gewisse Anzahl von verschieden großen, miteinander verknüpften Neuron-Layern samt Sensor-Eingängen und Output-Devices), dann kann es zur Laufzeit (!) auf verschiedenste Lerninhalte trainiert werden, es kann alte Muster durch neues "Wissen" überschreiben und auch ganz neue Wissensinhalte dazulernen.
Und das nicht nur für eine Spezielle Kategorie wie z.B. Schrifterkennung, sondern man kann das bisherige Wissen abspeichern, alles löschen, und nun mit dem selben Netz z.B. Gesichter- oder Sprach-Erkennung trainieren.
Oder auch "4 Gewinnt" oder evt sogar "Go" spielen.
Dann wieder alles abspeichern, und wieder ein anderes Wissens-Set laden, neu erstellen oder weiter trainieren.
Rumgucker
09.11.2019, 09:49
Danke Euch. Spannende Materie.
Nach einigen Irrwegen komme ich hier her zurück. :)
Ich will versuchen, das Ursprungsthema dieses Threads zu lösen. Weil wir kommen, egal, worum es bei KI hier geht, immer wieder auf dasselbe zurück. In jedem neuen Thema immer wieder dieselben Fragen und Lösungswünsche.
Deshalb suche ich jetzt ein paar Sachen zusammen und versuche eine Art Zwischenstand darzustellen:
Das war mein Wunschzettel, hinzu packe ich Sachen, die ich gefunden habe und von denen ich denke, dass sie zum jeweiligen Thema passen und markiere mal, wie weit ich gekommen bin:
1. Was sind Neuronen in einem NN?
https://www.roboternetz.de/community/threads/74362-Kommunikation-der-Zellen
2. Wie bilde ich ein Neuron im Programm (Arduino-C-Code) ab/nach?
Die Funktion mittels Funktionen in der Programmiersprache (hier bin ich schon weit gekommen), die berechneten Gewichte, die auch aus dem Lernen resultieren, in Arrays.
3. Wie funktioniert die Gewichtung in einem NN, wie bilde ich dies im Programmcode ab/nach?
Etwas umfangreiches Thema und komplizierter, aber nicht unmöglich, es allgemeinverständlich darzustellen. Dafür gibt es mehrere Funktionen, die auch in C abgebildet werden können.
Das ist für mich erst einmal erledigt.
4. Wie "lernt" das Netz, wie bilde ich dies im Programmcode ab/nach?
Indem ein Fehlerwert (positiv oder negativ) aus dem Signal der Ausgangsneuronen berechnet wird und dieser den Gewichten der Neuronenverbindungen hinzugefügt wird.
Dafür wird ein Vergleichsmuster benötigt. Für versteckte Neuronenschichten (zwischen Ein- und Ausgangsneuronen) gibt es ein ähnliches Verfahren, aber keinen direkten Vergleichswert.
Wie wird es nachgebildet: hat sich so weit aufgeklärt.
Allerdings lässt mich die Dokumentation, bezüglich des Programmcodes (MXTs verlinkte Seite), mit Details gerade etwas im Stich. Gwisse Teile im Quelltext, die aber auch äußerst wichtig sind, sind nicht genau erklärt. Hier muss ich den Programmcode nachempfinden und aufbauen, um die einzelnen Schritte und Zusammenhänge besser zu verstehen.
5. Wie entsteht aus einem Eingangsmuster eine Zuordnung am Ausgang?
Durch die Prozesse innerhalb der Neuronen, deren Verbindungen untereinander (die üblicher Weise immer von einem Neuron zu allen anderen Neuronen, in der nächsten Schicht, existieren) und deren Gewicht. Durch Wiederholung im Lernprozess entsteht im gesamten Netz langsam eine Gewichtsverteilung, die das Eingangsmuster auf das Ausgangsmuster abzubilden vermag.
6. Wie speichere ich Gewichte aus dem Netz und lade sie wieder dort hinein, um das Netz verschiedene Aufgaben erledigen zu lassen?
Die Gewichte befinden sich in Arrays und können dort nicht nur berechnet werden, sondern auch geladen, gelöscht und daraus gespeichert. Es muss das gesamte Array gespeichert werden.
7. Wie weiß ein Netz, wann es alles fertig ist mit Lernen und wann es das Gelernte anwenden kann, also wie schalte ich ein Netz um, von Lernen auf Anwenden und wie sieht dies im Programmcode ganz genau aus, wie wird es realisiert?
In der einfachen Variante hat das Netz kein Wissen darüber, wie es von Lernen auf Ausgabe umschalten sollte. Ein eigenständiges Verhalten eines neuronales Netzes ist so erst mal gar nicht gegeben. Im Grunde werden in einer Schleife, bis das gewünschte Ergebnis erreicht ist, Werte aus Arrays immer wieder berechnet. Die Berechnungen bauen auf Werten, aus den vorhergehenden Berechnungen, auf. Das neuronale Netz als solches tut gar nichts. Wann gelernt wird oder nicht, entscheidet einzig der Entwickler der Software, in einem Programmablauf.
Ich glaube, Erklärungen kann man kaum genug haben. Deshalb hier nochmal ein Link (deutschprachig): http://www.informatik.uni-ulm.de/ni/Lehre/SS04/ProsemSC/ausarbeitungen/Ruland.pdf
MfG
:Weihnacht
Powered by vBulletin® Version 4.2.5 Copyright ©2024 Adduco Digital e.K. und vBulletin Solutions, Inc. Alle Rechte vorbehalten.