da bst du wschl nicht so ganz auf dem Stand der Nerven- und Hirnforschung, und auch nicht so ganz auf dem Stand der KI-Forschung. :DZitat:
Zitat von Rumgucker
Aber nur zu!
Druckbare Version
da bst du wschl nicht so ganz auf dem Stand der Nerven- und Hirnforschung, und auch nicht so ganz auf dem Stand der KI-Forschung. :DZitat:
Zitat von Rumgucker
Aber nur zu!
Hallo HaWe,
ich ahne, was Dir wohl eher auf der Zunge lag.....
Jedes dahergelaufene Greenhorn, das die KI nicht mal ansatzweise überblickt, versucht aus Unwissen heraus, das Rad neu zu erfinden. Aber schon nach kurzer Zeit verschwinden sie wieder reihenweise in der Versenkung des Nicht-Verstehens und des Nicht-Könnens. Bzw. benutzen dann doch die fertigen Tools - ohne sie jedoch wirklich zu begreifen. Derartige Typen würden mich an Deiner Stelle genauso nerven.
Anfänglich sieht das alles nach dem gleichen Grünzeug aus und raschelt auf gleiche Weise im Wind. Aber erst nach der Ernte trennt man Spreu von Weizen. Und erst dann stellt sich raus, ob ich Spreu oder Weizen bin.
Deswegen lass mich mal noch etwas reifen, bevor wir die Ernte prüfen können.
Viele Grüße
Wolfgang
da hast du meine Zielrichtung falsch verstanden:
Deine obigen Aussagen über Nerven, Augen, Gehirn, ihren Aufbau, ihre Funktionen und Funktionsprinzipien sind einfach (lange) nicht auf dem heutigen Stand, und gleiches gilt für die grundsätzliche Lernfähigkeit von KNN. Die Vorraussetzungen (Bedingungen), auf Grund derer du bestimmte Schlüsse ziehst, stimmen also einfach nicht.
Dennoch schließt das nicht aus, dass du trotz falscher Vorraussetzungen auch funktionierende Programme schreiben kannst: Sie funktionieren dann aber nicht WEGEN, sondern TROTZ einer falschen Wissensbasis.
Aber ich schrieb ja: Nur zu! Schreib deine Programme, und wenn du dann etwas entwickelt hast, was wirklich funktioniert, dann zeige es uns!
Das von mir aber schon erwähnte Q-Learning ist ebenfalls lauffähig auf sehr anspruchslosen Prozessoren, und es würde mich überhaupt nicht überraschen, wenn dann das von dir "from the scratch" entwickelte Programm genau solchen Q-learning-Algorithmen entspricht - es wäre ein um so größerer Erfolg für dich, wenn du das selber entwickelt hast ohne abzuschreiben.
Also, nochmal:
Nur zu!
Hallo,
so langsam wächst und gedeiht das System:
Der 12F629 hat 1 kWorte Flash, wovon ich zur Zeit 13% benutze. Bis aufs "Verlernen", "Reflexe" und "Schlafen" (= Zellen-Erregungen wieder normalisieren) ist alles schon programmiert.Zitat:
CC5X Version 3.5, Copyright (c) B Knudsen Data, Norway 1992-2014
--> FREE edition, 8-16 bit int, 24 bit float, 32k code, reduced optim.
Warning : Main file extension should be '.c'
gi.cp:
Chip = 12F629
RAM: 00h : -------- -------- -------- --------
RAM: 20h : =====7.. ........ ........ ........
RAM: 40h : ....**** ******** ******** ********
RAM usage: 36 bytes (5 local), 28 bytes free
Optimizing - removed 1 instructions (-0 %)
File 'gi.pic'
File 'gi.lst'
File 'gi.hex'
Total of 135 code words (13 %)
Der PIC hat 64 Byte RAM, von denen ich 36 nutze. Damit verwalte ich 30 Neuronen ("Zellen"). Die 128 Byte des EEPROMs werden für Dendriten benutzt, die ich "Links" nenne.
Die Anzahl der Zellen wird vorgegeben. Die Links organisieren sich vollständig alleine. Sie bilden Korrelations-Cluster. Man kann beim GI-System auch nicht von Zell-"Schichten", starren Matrizen oder Deep Learning sprechen. Jede Zelle kann potentiell mit jeder Zelle verlinkt sein. Links können verstärkt werden. Das entspricht der klassischen Gewichtung oder auch vollständig verkümmern. Propagation ist in alle Richtungen möglich. Das System kann sich selbst organisieren, optimieren und anpassen, muss also nicht einem Training unterzogen werden. Kann aber.
Enthalten ist auch schon das "Gehirnknistern" (Stochastik), "Hunger", vier Sensoren und zwei Aktoren.
Neu ist auch die Art des Feuerns. Bei mir wird gefeuert, wenn Deltas auftreten. Dadurch und durch die dynamische Anzahl von Links hab ich auch bei starken System-Erregungen nur eine relativ geringe Anzahl von Operationen abzuleisten.
Das flutscht schon alles ganz gut. Morgen mach ich das Gegenstück dazu: den Umwelt-PIC.
Es wird, es wird.... ich tippe auf ersten laufenden Prototypen am WE.
Viele Grüße
Wolfgang
Hallo,
es lebt...
Anhang 34478
Zu sehen sind EEPROM-Bytes, die die 3-Byte-"Links" (Dentriten) beinhalten. Die führenden Nullen sind der Galep-Anzeige geschuldet. Und die letzten beiden Bytes werden wegen der 3-Byte-boundaries nicht verwendet.
Spannend ist, dass sich ein Dendrit gebildet hat, der die Sinneszelle "x00" mit einem Neuron "x0D" verbunden hat und noch "00" Nutzen brachte. Dass der Dendrit sich am Ende des Speichers gebildet hat, hat den Grund, dass der PIC das ganze EEPROM komplett durchsucht hatte und keinen mit der Sinneszelle verbundenen Dendriten finden konnte.
Nach einem Durchlauf hab ich das System angehalten, damit ich das EEPROM analysieren kann. Die Zellen kann man nicht sehen, weil die im RAM versteckt sind.
Aber mir zeigen die drei Byte an, dass alles komplett erfolgreich durchgelaufen ist. Jetzt nehm ich alle Bremsen raus und lass das System sich komplett vernetzen.
Ich rechne mit Sekundenbruchteilen.
Viele Grüße
Wolfgang
----------------------------------
Tatsache: 256-mal alles komplett durchgerechnet. Gesamtlaufzeit dafür vilelleicht 1/4 Sekunde.
Anhang 34479
Nun ist die Sinneszelle 0x00 (nur die war aktiv) mit acht Links an andere Zellen x19, x11 x09 x07 x17 x0F x15 x0D angeschlossen. Alle Verbindungen konnten ihre Nützlichkeit noch nicht beweisen, weil es nur einen einzigen Lichtblitz gab.
Sobald weitere Lichtblitze erscheinen, werden die zur Zeit noch verkümmerten Links wachsen. Es können sich auch gänzlich neue Links anlegen. Das Dingens sollte sich selbst belohnen können und deep-learning machen. Schon deshalb, weil die Zellen nicht in festen Schichten, sondern sich in dynamischen Clustern organisieren.
Das alles ohne jegliche Matrizen oder Multiplikationen.
Die Weichware sieht auch schon richtig hübsch aus. Zwar spezieller PIC-C-Slang. Aber kurz und knackig. Mit Debug-Code beleg ich zur Zeit 29% des 1 k Flashs.
So richtig große Dinge hab ich wohl nicht vergessen. Da kommt fast nichts mehr dazu. Sensor- und Aktoren-Treiber sind auch schon drin. Es fehlt nur noch die Logik der beiden Zellen für "Hunger" und "Gehirnknistern". Aber das ist beides trivial.
GI-Sourcenvorstellung am WE könnte was werden.
Viele Grüße
Wolfgang
- - - Aktualisiert - - -
Jepp,
Motoren laufen. Sieht schrecklich intelligent aus. Ein zuckeln und ruckeln. Er hat ja noch kein Feedback. Die Umwelt erscheint ihm völlig statisch. Singularität.
Aber das System hat sich in Clustern organisiert. Der Nutzen in den Links läuft hoch (ich hab nen Endanschlag vergessen). Außerdem wird er noch nicht verrechnet, nur geschriebnen. Zellen feuren synchron
Anhang 34480
Ein Beispiel: die beiden Motorzellen heißen x1C und x1D.
x1D hat sich zweimal direkt mit dem einzigen aktiven Sensor verkoppelt. Offensichtlich war die Motor-Zelle gerade nicht feuerbereit, als der Sensor wieder einen Lichtblitz erzeugte. Welcher der beiden Links sich schließlich durchsetzen kann, ist noch nicht klar.
x1C hatte am Anfang auch geruckelt. Wurde dann aber immer schwächer und seine Dendriten verkümmerten. Zur Zeit ist er taub. Mit nur einer Sinneszelle wird sich daran auch erst dann was ändern können, wenn die Stochastik hilt (Gehirnknistern) oder wenn x1D nicht alle Ereignisse vom Sensor mitbekommt.
Die restlichen Zellen haben sich untereinander vernetzt. Worüber die wohl nachdenken? Vielleicht weden sich die die nächste Zeit mit dem tauben Motor verkoppeln?
Es hat was. Streckenweise läuft es mir etwas kalt den Rücken runter. Ich könnte ein Programm gebrauchen, was mir in einem grafischen 3D-Netz die Zellen als Kugeln und die Links als Verbindungen darstellt. Feuerbereite Kugeln müssten größer sein. Und nützliche Links dicker sein.
Da das ganze aber atmet (lebt) und schon in den nächsten Millisekunden ganz neue Verbindungen schlagen kann, müsste man sowas eigentlich kontinierlich darstellen.
Ich glaub, ich hab was ganz Spannendes erdacht. Die Interpretation ist so komplex, dass man geneigt ist, dem Ding zuzutrauen, dass es schon eine Lösung finden wird. Früher oder später. Aber in jedem Fall in wenigen Millisekunden.
Soll ich die Source mal zeigen. Noch ohne Abfabgen des Nutzen-Überlaufs und ohne Logik für Hunger und Knistern.
Ich machs mal einfach:
Wie gesagt: noch Kleinkram dran zu machen.Code:#include "allpic.h"
#pragma config = 0b000110000100 // hex-datei: fuses des 12F629
#define EE_ROM // eeprom nutzen
#include "pic_mem.h"
#include "timeloop.h" // timer-routinen
#define IN_0 0 // GPIO-Eingänge
#define IN_1 1 //
#define IN_2 2 //
#define IN_3 3 //
#define OUT_0 4 // GPIO-Ausgänge
#define OUT_1 5 //
//** alle sensoren, aktoren, triebe und neuronen nach abstraktion gestaffelt ******
uns8 zellen[30]; // zellen im RAM anlegen
#define FIRE_REQ 7 // fire_req bit in der zelle
#define FIRE_LIMIT 10 // fire_limit
#define SENS_0 0 // spezialzellen definieren
#define SENS_1 1 // sensoren
#define SENS_2 2
#define SENS_3 3
#define TIMER 4 // Timer-Zelle
#define HUNGER 5 // Hunger-Zelle
#define FIRST_NEURON 6 // davor nur read-only-zellen
#define AKT_0 (sizeof(zellen) - 2)
#define AKT_1 (sizeof(zellen) - 1)
//******* verbunden werden zellen mit vielen links (dendriten) *********
#define NO_LINK -1
#define MAX_LINKS (128 / sizeof(struct _link))// viele links im EEPROM
struct _link { // struktur eines EEPROM-links
uns8 src; // leerer link: src_zelle == NO_LINK
uns8 dst; // verbindet source- mit dest-zelle
uns8 use; // nützlichkeit dieses links
};
// LINK-Zugriffe
#define LINK_RD(a,m) ee_read((a) + offsetof(struct _link,m))
#define LINK_WR(a,m,v) ee_write((a) + offsetof(struct _link,m),v)
static uns8 rand_link; // randomize link
static void gi_denke(void) // die genesis
{
uns8 zell_ind = 0, link, free, buf;
BOOL hit;
do { // suche feuernde zellen
rand_link++; // randomize link
FSR = zellen + zell_ind; // pointer auf zelle
/**** sensoren, aktoren und triebe sind besondere zellen *****/
if(zell_ind <= SENS_3) { // sensoren abfragen
buf = _BV(zell_ind); // bit-maske entwickeln
if(GPIO & buf) { if(!(INDF.0)) INDF = FIRE_LIMIT + _BV(FIRE_REQ);}
else INDF.0 = 0 // FIRE_REQ bearbeiten
} // nun die aktoren
else if(zell_ind == AKT_0) GPIO.OUT_0 = INDF.FIRE_REQ;
else if(zell_ind == AKT_1) GPIO.OUT_1 = INDF.FIRE_REQ;
if(INDF.FIRE_REQ == FALSE) continue;// zelle möchte nicht feuern
/***** wenn zelle feuern will, verfolge die links *************/
INDF.FIRE_REQ = FALSE; // zelle möchte feuern
free = NO_LINK; link = 0; hit = FALSE;
do { // alle links durchsuchen
rand_link++; // randomize link
buf = LINK_RD(link,src); // linkbyte lesen
if(buf == NO_LINK) free = link;// leeren link merken
else if(buf == zell_ind) {// link gefunden
FSR = zellen + LINK_RD(link,dst);// pointer auf dst-zelle lesen
if((++INDF == FIRE_LIMIT)&&(!(INDF.FIRE_REQ))) {// will dst feuern?
INDF.FIRE_REQ = TRUE; // feuer_req schon mal vormerken
buf = LINK_RD(link,use);// zwei zellen feuern synchron
LINK_WR(link,use,++buf);// dadurch wird der link nuetzlicher
hit = TRUE; // zumindest ein nützlicher link
}
}
link += sizeof(struct _link);// nächsten link adressieren
} while(link < MAX_LINKS * sizeof(struct _link));
/** wenn kein nützlicher link gefunden und platz ist: erzeuge neuen link **/
if((!hit)&&(free != NO_LINK)) {
LINK_WR(free,src,zell_ind);// link neu erzeugen
buf = rand_link % sizeof(zellen); // randomize verlinken, aber eingrenzen
if(buf < FIRST_NEURON) buf += FIRST_NEURON; // keine read-only-zellen
if(buf == zell_ind) buf++; // zellen nicht direkt rückkoppeln
LINK_WR(free,dst,buf);
LINK_WR(free,use,0); // ob der link nützlich wird, weiß keiner
}
} while(++zell_ind < sizeof(zellen)); // nächste zelle
}
#define DELETE 0
#define REDUCE 1
#define SLEEP 2
static void gi_links(uns8 steuer) // links abschwächen
{
uns8 link = 0, buf;
do { // alle links durchsuchen
if(LINK_RD(link,src) != NO_LINK) { // gelöschte ignorieren
if(steuer == DELETE) buf = 0;
else {
buf = LINK_RD(link,use); // nuetzlichkeit lesen
if(buf) LINK_WR(link,use,--buf);// langsam verlernen
}
if(!buf) LINK_WR(link,src,NO_LINK);// link ganz löschen
}
link += sizeof(struct _link); // nächster link
} while(link < MAX_LINKS * sizeof(struct _link));
if(steuer == DELETE) rand_link = 0;
}
static void gi_zellen(uns8 steuer)// zell-erregungen abschwächen
{
uns8 zell_ind = 0;
do { // suche zellen
FSR = zellen + zell_ind; // zellerregung lesen
if(steuer == DELETE) INDF = 0;
if(INDF) INDF--;
if((steuer == SLEEP)&&(INDF > FIRE_LIMIT)) INDF = FIRE_LIMIT - 1;
} while(++zell_ind < sizeof(zellen));// nächste zelle
}
void main(void)
{
RP0 = 1; // erstmal alle Spezialregister...
#asm
DW /*CALL*/ 0x2000 + /*ADRESSE*/ 0x03FF // oscal abholen
#endasm
OSCCAL = W; // und Oszillatorkalibrierung speichern
OPTION = 0; // global weak-pullup ein (je 20kOhm)
WPU = _BV(IN_0) | _BV(IN_1) | _BV(IN_2) /*| _BV(IN_3)*/;
TRISIO = _BV(IN_0) | _BV(IN_1) | _BV(IN_2) | _BV(IN_3);// eingänge
RP0 = 0; // normale register und ram
CMCON = 0x07; // komparator aus
timeloop_init(); // timer initialisieren
gi_links(DELETE); // alle links löschen
gi_zellen(DELETE); // zellerregungen löschen
uns8 loop = 0;
FOREVER {
gi_denke();
if(!++loop) {
gi_links(REDUCE); // links langsam verlernen
gi_zellen(SLEEP); // schlafen
}
else if(!(loop & 0x1F)) // alle 32 durchläufe
gi_zellen(REDUCE); // zellerregungen vermindern
}
}
/* ENDE */
Viele Grüße
Wolfgang
Herzlichen Glückwunsch zu deinen Fortschritten. Es wäre schön, wenn Du irgendwann eine gaphische Darstellung machst, bei dem man den Systemaufbau auf einen Blick erkennen kann.
Die kleinen Roboter machen sehr schnell den Eindruck, dass sie "belebt" sind.
Vielleicht braucht dein Roboter ja auch einen Partnerroboter, damit er sich nicht zu einsam fühlt.
Vor etwa 10 Jahren hatte ich hier im Forum mal einiges mit den Asuros gemacht.
Hier zeigt sich schön, wie sie in Wechselwirkung treten:
https://www.youtube.com/watch?v=oscbdxMhX_4
Komisch: Das eingebetete Video wird nur bei mir im Editor Fenster angezeigt.
Ich hänge es mal noch in Rohform an:
https://www.youtube.com/watch?v=oscbdxMhX_4
@Rumgucker:
worin besteht jetzt die Intelligenz oder Lernfähigkeit?
Welche Reiz-Reaktionsmuster kann es lernen, sich merken oder neu/umlernen,
wer oder was trainiert es zu den gewünschten Lernzielen,
und wie erkennt es, dass es sein/e Lernziel/e erreicht hat?
Und nochmals zum Aufbau deines Netzes:
wieviele Eingänge / welche möglichen Eingangszustände hat das Netz,
und wieviele Ausgänge / welche möglichen Ausgangszustände hat das Netz?
Hallo stochri,
danke! Da waren noch ein paar kleine Bugs drin bzgl. der Nutzenverarbeitung. Ohne die wirds lustig. Weiterhin wird nur ein Photosensor konstant beleuchtet. Zuerst versucht er im Zickzack zu fahren. Und dann schließlich arbeiten beide Motoren konstant geradeaus.
Würde ich als Mensch auch nicht anders machen. Zuerst mal durch eigene Bewegung versuchen, der statischen Lampe auszuweichen. Und dann beruhigt sein und mit Vollgas auf das offensichtlich entfernte Objekt zufahren.
Es gruselt einen, wie intelligent ein paar wenige Byte erscheinen können. Hätte ich nie gedacht. Aber schon nach wenigen Durchläufen ist eine Analyse des Denk-Systems praktisch nicht mehr möglich. Man bewundert nur noch das Verhalten. Das Hirn gaukelt einem vor, dass da was Vernunftbegabtes umherirrt. Verblüffender Effekt.
------------
Hallo Helmut,
im Prinzip funktioniert auch mein Netz wie Perceptrons mit Matritzen. Meine Dendritengewichtung versteckt sich im Wort "Nutzen" eines "Links". "Links" wachsen, wenn sie zwei Zellen (das können Sinneszellen, Neuronen, Aktuatoren oder Hunger und Knistern sein) verbinden, die synchron feuern.
Jede Zelle sucht sich also über die Links "Freunde", die ähnlich wie sie selbst ticken. Es kann kreuz und quer durchs ganze Nervensystem verlinkt werden. Es gibt keine Schichten mehr. Dabei bilden sich zwangsweise Cluster aus. In diesen Clustern versteckt sich das Lernen.
Lernen kann das System ohne Training, Agenten etc. einfach dadurch, dass die Zellen Freunde suchen. Die Umwelt wird in diesen Optimierungsvorgang mit eingeschlossen. Es werden sich also die derart verlinkten Cluster bevorzugt ausbilden, die zu einem Erfolg führen. Also die Clustersysteme, die besonders effektiv und schnell eine Situation verarbeiten können.
Wenn zwei kompetitive Links an einem Zelleingang hängen, so wird der verkümmern, der asynchron zum Zellenfeuern arbeitet und der erstarken, der mit der Zelle synchron ist. Das System optimiert den zeitlichen Durchsatz.
Zur Zeit hab ich
4 binäre Eingäne (spezialisierte Sinneszellen z.B. für Fototransistoren etc.)
2 interne Statuszellen (Hunger und Gehirnknistern - immer noch nicht programmiert aber schon enthalten)
2 binäre Ausgänge für zwei Motoren (feedbackfähig, also normale Neuronen)
22 Neuronen
Die Anzahl aller Zellen beträgt also 30 und diese können mit bis zu 42 Links verbunden werden. Es sollten deutlich mehr Links als Zellen zur Verfügung stehen.
Ich mach heute noch ein Update der 20 Kernzeilen. Der ganze Rest befasst sich mit Speicherverwaltung. Aber die ganze "GI" steckt in 20 'C'-Zeilen. Daran werde ich den Kern haarklein erklären.
Viele Grüße
Wolfgang
der interne Aufbau ist zur Charakterisierung der Zustände gar nicht so wichtig, wichtig sind zunächst nur inputs und outputs.
Da du 4 inputs hast, sind 16 Eingangszustände möglich,
und da du 2 outputs hast, sind 4 Ausgangszustände möglich.
Damit muss das Netz in der Lage sein, beliebige Zustände zu lernen, z.B. (mindestens)
für alle (paarweisen) Eingänge a, b ∈ {In1...In4}: output[n]= a ODER b ( für alle n ∈ {1,2} )
für alle (paarweisen) Eingänge a, b ∈ {In1...In4}: output[n]= a UND b ( für alle n ∈ {1,2} )
für alle (einzelnen) Eingänge c ∈ {In1...In4}: output[n]= (NICHT c) ( für alle n ∈ {1,2} )
Wie erreichst du, dass das Netz diese Basiszustände wahlweise gezielt lernen kann?
Und wie erkennt es, dass es sein/e Lernziel/e erreicht hat?
Hallo Helmut,
der Lernerfolg einer Mustererkennung oder eines Dekoders ist ein anderer als der Lernerfolg eines autonomen Roboters. Mein System freut sich, wenn es genug Futter findet.
Die Frage muss also lauten: "wie weiß Dein System, ob es genug Futter gefunden hat?"
Dieser Hunger-Mechanismus ist schon vorbereitet. Es gibt eine Hunger-Zelle (0x05). Die noch zu programmierende Logik wird dem GI-System damit ab und an mal "Hunger" signalisieren.
Dann kurvt es rum. Dabei erfährt es eine Bestrafung zum Beispiel dadurch, dass sich die Umwelt nicht mehr bewegt. Dann hat es sich festgefahren. Und muss andere Wege finden und diese Wege optimieren.
Und irgendwann gibt es eine besondere Lampenkombination an seinen Eingängen (meinetwegen alle vier Eingänge auf high), die dazu führen, dass der Hunger verschwindet.
Mir fehlt immer noch der Umwelt-Chip, also das Gegenstück zur GI. Damit fang ich erst an, wenn ich keine gröberen Fehler im GI-System mehr erkennen kann.
Dann kommt auch die Hunger-Geschichte mit dazu.
Viele Grüße
Wolfgang
---------------
Nachtrag. ein anderer "Umwelt"-Chip könnte die GI alllerdings dazu bringen, dass er auch als Dekoder funktioniert. Jedesmal, wenn er die richtige Ausgangskombination als Funktion der Eingänge "würfelt", wird die GI belohnt und die "Links" manifestieren sich.
Das funktioniert an sich wie bei Dir. Nur Du machst alles mit der gleichen Software: lehren und lernen. Und ich verwende einen Lehrer (= "Umweltchip"), den man nach Benutzung einfach abkoppeln kann. Das spart knappen Flash-Speicher im Schüler.
Viele Grüße
Wolfgang