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.
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
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:
Code:// 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;
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/perce...m-d5db0deab975
Bild hier
Bild hier
Bild hier
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.
Lesezeichen