GI = Guckis Intelligenz

[Rumgucker]

Hallo,

es lebt...



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.



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



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:

#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