-         
Seite 3 von 12 ErsteErste 12345 ... LetzteLetzte
Ergebnis 21 bis 30 von 112

Thema: GI = Guckis Intelligenz

  1. #21
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.841
    Anzeige

    Zitat Zitat von Rumgucker Beitrag anzeigen
    Ich bin zum Beispiel nicht der Meinung, dass die KNN-Freaks die Natur richtig herum abbilden.

    Mein Hirn ist nicht matrizengesteuert. Ich arbeite eher reizgesteuert. Wenn mein Augennerv feuert, dann weiß er, mit welchen Synapsen er verbunden ist. Genau so viele Messages müssen geschickt werden.

    Wenn man matrizenbezogen herangeht, dann muss eine Zellschicht alle einzelnen Neuronen der vorgeschalteten Schicht abfragen. Immer und immer wieder. Dem Mathematiker ist das Banane. Aber dem Informatiker geht dadurch zu viel Rechenkapazität nutzlos verloren.

    Das Wort "feuern" ist mir auch sehr wichtig. Im Hirn wird ja gar nicht mit float gerechnet. Eher mit ganz wenigen Bit. Angeregte Nerven feuern einfach häufiger. Wodurch man auch die Chronologie gleich am Wickel hat, denn sie sehe ich bei klassischen KNN irgendwie nicht richtig implementiert. Kann ein klassisches 3-Schichten-NN die Ablaufsteuerung einer Waschmaschine lernen? Ich hab da große Zweifel. Gestenerkennung ja. Waschmaschinensteuerung nein.
    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.
    Aber nur zu!
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  2. #22
    Erfahrener Benutzer Fleißiges Mitglied Avatar von Rumgucker
    Registriert seit
    07.11.2019
    Ort
    Hamburg
    Beiträge
    109
    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

  3. #23
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.841
    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!
    Geändert von HaWe (17.11.2019 um 15:55 Uhr)
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  4. #24
    Erfahrener Benutzer Fleißiges Mitglied Avatar von Rumgucker
    Registriert seit
    07.11.2019
    Ort
    Hamburg
    Beiträge
    109
    Hallo,

    so langsam wächst und gedeiht das System:

    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 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.
    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
    Miniaturansichten angehängter Grafiken Miniaturansichten angehängter Grafiken sec_link.jpg  
    Geändert von Rumgucker (15.11.2019 um 20:23 Uhr)

  5. #25
    Erfahrener Benutzer Fleißiges Mitglied Avatar von Rumgucker
    Registriert seit
    07.11.2019
    Ort
    Hamburg
    Beiträge
    109
    Hallo,

    es lebt...

    Klicke auf die Grafik für eine größere Ansicht

Name:	first_link.jpg
Hits:	5
Größe:	33,8 KB
ID:	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.

    Klicke auf die Grafik für eine größere Ansicht

Name:	sec_link.jpg
Hits:	6
Größe:	32,1 KB
ID:	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

    Klicke auf die Grafik für eine größere Ansicht

Name:	thrd_link.jpg
Hits:	2
Größe:	32,3 KB
ID:	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:

    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 */
    Wie gesagt: noch Kleinkram dran zu machen.

    Viele Grüße

    Wolfgang
    Geändert von Rumgucker (15.11.2019 um 22:29 Uhr)

  6. #26
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    12.06.2005
    Ort
    Südwestdeutschland
    Beiträge
    1.111
    Blog-Einträge
    3
    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:


    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
    Geändert von stochri (16.11.2019 um 09:37 Uhr) Grund: Video wird nicht angezeigt

  7. #27
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.841
    @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?
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  8. #28
    Erfahrener Benutzer Fleißiges Mitglied Avatar von Rumgucker
    Registriert seit
    07.11.2019
    Ort
    Hamburg
    Beiträge
    109
    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
    Geändert von Rumgucker (16.11.2019 um 10:08 Uhr)

  9. #29
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    09.10.2014
    Beiträge
    4.841
    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?
    ·±≠≡≈³αγελΔΣΩ∞ Schachroboter:www.youtube.com/watch?v=Cv-yzuebC7E Rasenmäher-Robot:www.youtube.com/watch?v=z7mqnaU_9A8

  10. #30
    Erfahrener Benutzer Fleißiges Mitglied Avatar von Rumgucker
    Registriert seit
    07.11.2019
    Ort
    Hamburg
    Beiträge
    109
    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
    Geändert von Rumgucker (16.11.2019 um 10:37 Uhr)

Seite 3 von 12 ErsteErste 12345 ... LetzteLetzte

Ähnliche Themen

  1. Nupic: Auf dem Weg zu maschineller Intelligenz
    Von Roboternetz-News im Forum Neuigkeiten / Technik-News / Nachrichten / Aktuelles
    Antworten: 0
    Letzter Beitrag: 05.06.2013, 09:50
  2. TV: Künstliche Intelligenz
    Von Günter49 im Forum Allgemeines zum Thema Roboter / Modellbau
    Antworten: 17
    Letzter Beitrag: 29.06.2009, 15:29
  3. Computersystem intelligenz
    Von runner02 im Forum PC-, Pocket PC, Tablet PC, Smartphone oder Notebook
    Antworten: 11
    Letzter Beitrag: 18.03.2009, 19:43
  4. Künstliche Intelligenz (KI)
    Von Devil im Forum Allgemeines zum Thema Roboter / Modellbau
    Antworten: 2
    Letzter Beitrag: 12.04.2005, 17:18
  5. Intelligenz in Werkzeugen
    Von Frank im Forum Neuigkeiten / Technik-News / Nachrichten / Aktuelles
    Antworten: 0
    Letzter Beitrag: 03.05.2004, 20:36

Stichworte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •