GI = Guckis Intelligenz

Wolfgang schrieb:

Zitat:

---

doch. Ich hab nur abweichende Begriffe und abweichende strukturelle Ansätze.

Meine Links haben das "Nutzen"-Feld. Das entspricht der Eingangsgewichtung der Perceptron-Matrizen.
Meine Zellen haben Summenspeicher (sie bestehen nur aus einem 7-Bit Summenspeicher und einem FIRE-REQ-Bit). Als Aktivierungsfunktion dient der FIRE_LIMIT-Schwellwert.

Ungewohnt ist, dass ich Eingang (Dendriten) und Neuron nicht mehr fest verbunden habe. Dadurch ist mein System nicht mehr an Schichten, sondern an Ereignisse gekoppelt. Und ich erspar mir Multiplikationen und addiere die Gewichtungen lediglich zum Summenspeicher hinzu.

Kein Hexenwerk. Nur eben gut angepasst an die kläglichen Möglichkeiten eines PICs.

....
ok. Also ein Perceptron-Abklatsch, ein "Perceptklatsch".

Mir fällt aber gerade ein, dass ich mich noch mit Negationen befassen muss. Das war mir für meinen Irrgarten nicht so wichtig. In so ner trostlosen Einöde sollte man negative Gedanken gleich im Ansatz verhindern.

---

Nix Abklatsch. Du bist ganz vorne dabei, du hast quasi die IAF-Pulsneuronen nachgebaut. Ich kann nicht glauben, dass Du in so kurzer Zeit so weite gekommen bist. Das ist der Hammer, ehrlich.

schick mal bitte einen frei lesbaren Link zu "IAF-Pulsneuronen"!
Ich sehe allerdings auch keine exakte Analogie zu einem Perzeptron-Netz (auch keinen "Abklatsch") - ich schrieb ja schon, dass ich es für irgendetwas anderes halte..

Hallo,

wow.. Ihr seid aber charmant. Das geht mir ja runter wie Öl. Dankeschön!

Ich hab aber keinen Hintergrund und keine Ahnung. Das sehe ich als Vorteil, weil ich dadurch frei denken kann.

--------

Die Uni Ulm macht viel mit FPAAs rum, das analoge Gegenstück zum digitalen FPGA. Eine Ansammlung von analogen Rechenelementen und eine programmierbare Schaltmatrix.

https://www.uni-ulm.de/in/mikro/fors...altungen/fpaa/

Genau wie ein FPGA hat das Ding leider auch nicht die dynamische Konnektivität, die man eigentlich bräuchte.

DER Analog-Guru Prof. Bernd Ulmann beobachtet das Gebiet analog + KI sehr genau.

Viele Grüße

Wolfgang

wie unterscheidet sich "analog" vom Rechnen mit Fließkommazahlen?


PS,
auch die DACs oder ADCs in FPAA rechnen ja wieder digitale Integer-Zahlen in analoge Spannungswerte (und umgekehrt) um, die man auch als floats repräsentiern kann.

Hallo Helmut,

natürlich gar nicht. "Analoges Rechnen" bedeutet ja erstmal nur, dass ein Analogon erschaffen wird. Statt eines OPV-Integrators kann das auch der Wasserstand einer Badewanne sein.

-------

Aber es gibt gewichtige Unterschiede. Analoge Schaltungen arbeiten bevorzugt zeitkontinuierlich. Eine analog errechnete PWM schlägt beispielsweise einfach alles. Theoretisch können ihre Flanken in Attosekunden aufgelöst sein. Im Gegenzug freut man sich bei analogen Verstärkern schon über unlineare Verzerrungen von unter 0,1%. Also 10 Bit Auflösung umgerechnet.

In der Digitaltechnik gehts komplett andersrum. Zeitdiskrete Schritte und irrwitzige Auflösungen.

Viele Grüße

Wolfgang

wozu brauche ich Attosekunden Auflösung in neuronalen Netzen?
Ich vermute: überhaupt nicht - wo ist also der Vorteil von analogen Rechnern vs. digitalen cpus z.B. auch + fpus (ESP32, SAMD51, ARM Cortex A57)?

PS,
64bit double hat 16 Stellen im Dezimalsystem - das sind auch schon 100 atto Genauigkeit!

Hallo Helmut,

ach komm. Erzähl mir nicht, dass die genannten Controller immer gleich zur Stelle sind, wenn ein Lichtblitz am Eingang vorbeihuscht. Oftmals tingeln die irgendwo im Subsystem herum und es kann schon mal ein paar Millisekunden dauern, bis sie sich den Port anschauen können.

Natürlich kann man auch dagegen gegenan programmieren. Mit Port-change-Interrupts und ähnlichen Dingen. Aber die Systemstabilität, Belastung und Testbarkeit wird durch sowas nicht besser. Ein vergessener Semaphor und die Bombe tickt.

Wie elegant ist im Vergleich dazu eine analoge Schaltung, die von morgens bis abends nichts anderes tut, als nur auf Lichtblitze zu lauern. Das macht sie völlig gleichzeitig zu allen anderen sonstigen analogen Schaltungen.

Diese Parallelität ist ein potentieller Vorteil. Wie eben beim FPAA-Chip.

Und nicht ganz unerheblich in den heutigen Zeiten ist die Energieeffizienz des System. Das analoge Gehirn versorgst Du mit ner verdreckten Solarzelle. Versuch das mal mit einer GPU.

Es gibt keien pauschale Antwort auf Deine Frage. Es ist einfach die Frage nach den gestellten Anforderungen. Analogtechnik kann vielfach effektiver, schneller und zielführender sein. Ein PID-Regler setz ich in 5 Minuten zusammen und hab ihn in 10 Minuten parametriert. Da hast Du kaum das Projektverzeichnis angelegt.

Viele Grüße

Wolfgang

da kommt es auf die Detektoren an: wenn es ein i2c-Detektor ist, dauert es zweifellos immer ein paar Millisekunden. SPI ist schon um den Faktor 100 schneller.
Wenn es aber z.B. um digitale GPIOs geht, dann lese ich die beim Raspi mit 10-100ns Genauigkeit/Schnelligkeit (wenn ich muss oder will), und wenn ich in Multithreading-Environments arbeite, dann locker in < 1 µs Auflösung, per pthread timeslice-Scheduler.

Wenn man es genau nimmt arbeitet jede Digitalschaltung analog, da sie aus Bauteilen besteht,deren Kennlinien analog sind.

Und wenn man es genau nimmt, arbeiten die Neuronen gemischt: Sowohl analog als auch digital. Das Zellpotential wird analog integriert, das Aktionspotential ( der Puls ) ist digital. Entweder das Neuron erzeugt einen Ausgangspuls oder keinen. In der Art und Weise hat sich hier an der Uni auch vor kurzem mal einer der Gastprofessoren geäußert.

Zitat:

---

DER Analog-Guru Prof. Bernd Ulmann beobachtet das Gebiet analog + KI sehr genau.

---

Er ist auf jeden Fall ein begeisteter Analogelektroniker:
https://www.youtube.com/watch?v=UnKCCpRFrrk

Man könnte einwenden, dass die große Zeit der Analogcomputer vorbei ist, aber wer weiß, vielleicht lassen sich einige der Prinzipien wieder verwenden.

Hallo,

nach der Verscheuchung erstaunlich vieler Bugs aus erstaunlich wenigen Programmzeilen hat sich mittlerweile auch meine Faszination über das Wachsen und Vergehen von "Links" etwas gelegt.

--------

Mit der nun von Helmut geforderten Dekodiererei steh ich allerdings noch auf Kriegsfuß. "Klatschi" optimiert die zeitliche Korrelation. Ein Dekoder optimiert Funktionen.

Klatschi reißt den Lenker nach links, wenn ihm etwas von rechts vors Auto läuft und fragt sich nicht erst stundenlang, ob das ne alte Oma, ein Auto oder ein Hund ist.

Helmuts Dekoder fährt erstmal drüber weg, setzt zurück und analysiert dann die Überreste des Opfers und entscheidet mit 89%-iger Sicherheit, dass das mal ne alte Oma gewesen sein könnte.

Vermutlich muss ich den Begriff "dekodieren" irgendwie anders verstehen. Bei mir gehts wohl eher um die zeitliche Staffelung als um die Anzahl und Kombination von statischen Eingängen. Ich kann mir zum Beispiel vorstellen, dass Klatschi das Start- und Stopbit in einem Datenstrom finden ("dekodieren") könnte.

Irgendwas beibringen muss ich dem System eigentlich nicht. Die Neuronen sollten sich vollautomatisch auf Pegelsprünge synchronisieren und Cluster bilden.

Ja... so muss ich - glaub ich - Helmuts Aufgabe an Klatschi anpassen. Klatschi ist was serielles, was chronologisches.

Helmut könnte jetzt fragen, woher ich denn wissen will, welcher (parallele) Ausgang welchem (seriellen) Datum zugeordnet ist. Das weiß ich schlichtweg nicht. Ich könnte also zur Zeit nicht mit Sicherheit sagen, ob Klatschi das Lenkrad wirklich nach links reißt. Vielleicht reißt er auch das Lenkrad nach rechts.

Die Bordelektronik eines Teslas sollte also zur Zeit noch nicht mit einem Klatschi-PIC ersetzt werden. Auch wenn der Kostenvorteil sehr verlockend erscheint.

-------

Ich bau den Generator für den Datenstrom kurzerhand mit ins Klatschi rein.

Mal gucken, was passiert.

Viele Grüße

Wolfgang

Ich fürchte, du hast weder meine Frage zu deinem Netz noch mein eigenes BP Netz verstanden, was es genau wie tut, daher deine aus meiner Sicht momentan etwas seltsamen Interpretationen. Mich interessiert:
a) jedes einzelne mögliche Inputmuster, und auf welches Outputmuster es per Training abgebildet werden soll (also was genau gelernt werden soll), und
b) ob nach dem Training diese Muster auch tatsächlich korrekt nachgebildet werden:

auf 00000 folgt Output...
auf 00001 folgt Output...
auf 00010 folgt Output...
auf 00011 folgt Output...
auf 00100 folgt Output...
usw.
Lässt du einzelne Reizmuster untrainiert, musst du sie später nachtrainieren können, falls darauf nicht die gewünschte Reaktion erfolgt.

Das heißt:
a) DU bist es, der dem Netz im Detail vorgeben muss, wie bestimmte Lernmuster aussehen müssen (Trainingssets: auf Inputmuster=Reiz abcde folgt Outputmuster=Reaktion yz)
und
b) JETZT kommen erst die Auswertungen ("Dekodierungen?") während der Laufzeit usw., wo du nach dem Lernen experimentelle definierte Reize setzt und dein Netz dahingehend kontrollierst, ob die Reaktion genau das ist, was vorher trainiert wurde.

Hat das ganze eine zeitliche Dimension, musst du sagen können:

wenn erst Reiz abcde angelegen hat und darauf Reiz ghijk folgt, dann passiert Reaktion ßv,
wenn erst Reiz abcde angelegen hat und darauf Reiz lmnop folgt, dann passiert Reaktion wx,
wenn erst Reiz abcde angelegen hat und darauf Reiz qrstu folgt, dann passiert Reaktion yz,

wenn erst Reiz bcdef angelegen hat und darauf Reiz ghijk folgt, dann passiert Reaktion ß'v',
wenn erst Reiz bcdef angelegen hat und darauf Reiz lmnop folgt, dann passiert Reaktion w'x',
wenn erst Reiz bcdef angelegen hat und darauf Reiz qrstu folgt, dann passiert Reaktion y'z',

Sobald du aber dein System irgendwie sich selber überlässt, macht es wie schon geschrieben "irgend etwas Nebulöses", was keinem gezielten Lernmuster zuzuordnen ist ("bei welchem definierten Reiz muss wann wie ausgewichen werden und wann nicht?") noch eine Kontrolle und/oder Korrektur von gelerntem Verhalten ermöglicht.
Dazu musst du als allererstes kodieren, wie die möglichen Outputs
00
01
10
11
auf Fahr-Aktionen kodiert werden (gerade.vor, gerade.zurück, vorw.links, vorw.rechts, eigentlich auch stopp und ggf. rückw.li und rückw.re, das wären aber 5-7 Zustände, für die du mindestens 3 Outputs benötigst).

Wenn dann z.B. auf Input-Muster
00110 die falsche Reaktion erfolgt, muss per neuem Training korrigiert werden können:
"Das war Quatsch, hier hätte nach rechts statt nach links ausgewichen werden müssen"
oder falsche Reaktion auf 01001: "Auch das war Quatsch, hier hätte gebremst werden müssen"
oder falsche Reaktion auf 10011 "Hier hilft kein Bremsen und kein Lenken sondern nur Rückwärtsfahren")

Hallo Helmut,

Klatschi arbeitet anders als das Dir Bekannte. Ich wollte lediglich erklären, wo und warum es Unterschiede in der Herangehensweise gibt. Ich hab kein Problem damit, wenn Dich mein Gerede nicht erreicht.

Aber ich hab ein Problem damit, wenn Du glaubst, dass ich schüchtern sei. Ich bin nicht schüchtern. Wenn ich was nicht versteh, frag ich stets nach. Ich kann mich nicht erinnern, dass ich bei Deinen Ausführungen schon jemals nachfragen musste. Du erklärst stets sehr gut und nachvollziehbar.

Also hab einfach Geduld. Ich arbeite an dem Dekoder-Problem.

---------------

Hallo Forum,

nach Beseitigung der Bugs bin ich mutig rangegangen und hab meinen ersten Dekodierungsversuch (drei Eingänge, drei Ausgänge) gemacht. Die parallelen Eingänge hab ich einfach per Software serialisiert.

Alles noch gänzlich ohne Training, weil ich erstmal die Selbstorganisation sehen wollte.

Der EEPROM-Inhalt nach dem Durchlauf:

Anhang 34482

Von jedem 16-Bit-Wort zählt immer nur das erste Byte. Drei Bytes geben einen "Link": Source-Zelle, Destination-Zelle und "Nutzen" (Gewichtungen). Ein Nutzen von 0x0A ist der Endanschlag.

Dann hab ich den EEPROM-Inhalt in einem Netz dargestellt:

Anhang 34483

Die Diodensymbole zeigen Zellen an. Die Anode ist der Eingang, die Katode der Ausgang. Die Verbindungen hab ich mit der Stärke beschriftet.

Erfreulich ist erstmal, dass die Software keinen Mist gebaut hat. Alle Verbindungen und Gewichtungen sind erklärlich. Und das in Millisekunden entstehende Netzwerk ist beeindruckend. Ich hab zwei Stunden gebraucht, um es zu analysieren. Ohne es allerdings wirklich zu verstehen. KNN ist schräger Stuff.

Wie erwartet, haben sich Cluster und sogar Rückkopplungen gebildet. Allerdings nicht vollständig ausgebildet. IN_0 ist umfangreich vernetzt. IN_1 schon deutlich weniger. Und IN_2 konnte gar nicht mehr verbunden werden. Mir fehlte es offensichtlich an Zellen und Links. Alle Links wurden verbraucht. Es konnten zwei Zellen überhaupt nicht angeschlossen werden.

Der PIC verfügt nur über 30 Zellen und 42 Links.

Das erinnert mich an ein Geschwür. Klatschi expandiert zu schnell. Zeitlich spätere Ereignisse (wie gesagt: ich musste Helmuts parallele Daten ja serialisieren) haben keine Chance.

Ich muss also das Wachstum bremsen. Erst wenn alle Inputs mit ungefähr gleich vielen Zellen versorgt sind, kann ich an Dekodierungen denken.

Viele Grüße

Wolfgang

ich verstehe es nicht: Was ist ein "Nutzen"? Wann tritt ein "Nutzen" auf? Woran wird ein "Nutzen" gemessen?

Und welche "parallele Daten" von mir (?) mussten "serialisert" werden? Worauf beziehst du dich und was meinst du damit?

Hallo Wolfgang,

Zitat:

---

Die Diodensymbole zeigen Zellen an. Die Anode ist der Eingang, die Katode der Ausgang. Die Verbindungen hab ich mit der Stärke beschriftet.

---

eine sehr beeindruckende Graphik. Hast Du sie automatisch aus den Gewichten erstellen lassen?
Was ich nicht verstehe, wie die Werte dort genau zu interpretieren sind.
Ich sehen z.B. oft den Wert 0A.

- - - Aktualisiert - - -

Ein Interpretationsversuch:
Anhang 34484

Hallo Helmut,

"Nutzen" = "Gewichtung". Hatte ich vielfach erklärt. Das mit der seriellen Arbeitsweise erklär ich nochmal in gebündelter Form, wenn ich die PDF erstelle. Im Moment ist es ja nicht so wichtig. Es ist beiden doch letztlich egal, wie Klatschi intern arbeitet. Wichtig ist das Ergebnis. Und das soll dekodieren können.

---------

Hallo stochri,

ich hab einfach LTSpice genommen und mir jedes Byte einzeln "händisch" aus dem Dump abgelesen und versucht, damit ein Netz zu zeichnen.

Mittlerweile bin ich aber schon deutlich schneller. Ich hab die Neigung zu Geschwüren durch zwei Maßnahmen gebremst. Ich duchsuche die Zellen jetzt vom Ausgang kommend. Dadurch können einzelne Eingänge das Netz nicht mehr so schnell mit Zellen vollwuchern. Und ich hab den Detektor zum Neuanlegen von Links etwas straffer gestellt.

Nun kommmt schon was raus (ohne jegliches Training), was an einen Dekoder erinnert (da fehlen noch ein paar Strippen, aber die sind alle unbedeutend:

Anhang 34485

Es hat sich also ganz ohne Training eine 1:1 Dekodierung ergeben. Das ist nun keine Spezialversion der 20 Zeilen. Das soll so bleiben. Er kann jetzt alten Omas ausweichen UND dekodieren. Zumindest stehen genug Zellen pro Pin zur Verfügung.

Das reicht mir erstmal für heute. Ich werde so langsam zum Klatschi-Versteher.

Ich muss mir nun eh Gedanken machen, wie ich das arme Ding für falsche Dekodierungen bestrafe und was dann genau mit dem Netzwerk geschehen soll.

Das kriegen wir auch noch hin.

Viele Grüße

Wolfgang

Zitat:

---

Wie gesagt: noch Kleinkram dran zu machen.

---

Ähäm, naja ... Ich hab's mal im Rahmen der Möglichkeiten für einen Arduino-Uno "Arduinofiziert".
Es lebt tatsächlich, aber im wesentlichen von den Softwarefehlern.

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
*/

// PIC C-Compiler compatibility

typedef int8_t uns8; // stdint compatibility
typedef bool  BOOL;
#define FALSE  false
#define TRUE  false

/*
  #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 ******
#define NUMBEROFNEURONS 30
uns8 zellen[NUMBEROFNEURONS];    // 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
#define MAX_LINKS 32

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
};

#define LINK_SRC 0
#define LINK_DST 1
#define LINK_USE 2
/*
uint8_t src;
uint8_t dst;
uint8_t use;
*/
// LINK-Zugriffe im PIC
// #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)
_link Simulated_EEPROM[NUMBEROFNEURONS];

uns8 LINK_RD(uns8 address, uns8 component)
{
  uns8 value = 0;
  if (component == LINK_SRC) value = Simulated_EEPROM[address].src;
  if (component == LINK_DST) value = Simulated_EEPROM[address].dst;
  if (component == LINK_USE) value = Simulated_EEPROM[address].use;
  return value;
}

void LINK_WR(uns8 address, uns8 component, uns8 value)
{

  if (address < NUMBEROFNEURONS)
  {
    if (component == LINK_SRC) Simulated_EEPROM[address].src = value;
    if (component == LINK_DST) Simulated_EEPROM[address].dst = value;
    if (component == LINK_USE) Simulated_EEPROM[address].use = value;
  } else
  {
    Serial.print("Error: link address out of range "); Serial.println(address);
    delay(100);
  }
}

static uns8 rand_link = 0;  // randomize link

/*
  void gpio_out(uint8_t pin)
  {

  }
*/

uint16_t FSR; //pointer auf zelle
uint16_t INDF; // ?


static void gi_denke(void)  // die genesis
{
  uns8 zell_ind = 0, link=0, freeLink=0, buf=0;
  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

    INDF &= ~(1 << FIRE_REQ);
    freeLink = NO_LINK; link = 0; hit = FALSE;
    do {      // alle links durchsuchen
      rand_link++;    // randomize link
      buf = LINK_RD(link, LINK_SRC); // linkbyte lesen
      if (buf == NO_LINK) freeLink = link; // leeren link merken
      else if (buf == zell_ind) { // link gefunden
        FSR = zellen + LINK_RD(link, LINK_DST); // pointer auf dst-zelle lesen
        //if ((++INDF == FIRE_LIMIT) && (!(INDF.FIRE_REQ))) { // will dst feuern?
        if ((++INDF == FIRE_LIMIT) && (!(INDF & (1 << FIRE_REQ)))) { // will dst feuern?
          //INDF.FIRE_REQ = TRUE; // feuer_req schon mal vormerken
          INDF |= (1 << FIRE_REQ);
          buf = LINK_RD(link, LINK_USE); // zwei zellen feuern synchron
          LINK_WR(link, LINK_USE, ++buf); // dadurch wird der link nuetzlicher
          hit = TRUE;  // zumindest ein nützlicher link
        }
      }
      //link += sizeof(struct _link);// nächsten link adressieren
      link++;// the link pointer is only an address
    } while (link < MAX_LINKS);
    //while (link < MAX_LINKS * sizeof(struct _link));

    /** wenn kein nützlicher link gefunden und platz ist: erzeuge neuen link **/
    if ((!hit) && (freeLink != NO_LINK)) {
      LINK_WR(freeLink, LINK_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(freeLink, LINK_DST, buf);
      LINK_WR(freeLink, LINK_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, LINK_SRC) != NO_LINK) { // gelöschte ignorieren
      if (steuer == DELETE) buf = 0;
      else {
        buf = LINK_RD(link, LINK_USE); // nuetzlichkeit lesen
        if (buf) LINK_WR(link, LINK_USE, --buf); // langsam verlernen
      }
      if (!buf) LINK_WR(link, LINK_SRC, NO_LINK); // link ganz löschen
    }
    //link += sizeof(struct _link); // nächster link
    link++;
  } while (link < MAX_LINKS);
  //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 showLinks(uint8_t adr)
{
  Serial.print(adr); Serial.print(" -");
  Serial.print(" src:"); Serial.print(Simulated_EEPROM[adr].src);
  Serial.print(" dst:"); Serial.print(Simulated_EEPROM[adr].dst);
  Serial.print(" use:"); Serial.print(Simulated_EEPROM[adr].use);
  Serial.println();
}

void showAll()
{
  Serial.println("list Neurons:");
  for (int n = 0; n < MAX_LINKS; n++)
  {
    showLinks(n);
  }
  Serial.println();
}

void setup()
{
  Serial.begin(115200);
  Serial.println("Gugi ;-)");
  delay(1000);
  gi_links(DELETE);  // alle links löschen
  gi_zellen(DELETE);    // zellerregungen löschen

}

uns8 loopCounter = 0;
//  FOREVER {
void loop()
{
  Serial.println("gi_denke");
  gi_denke();
  if (!++loopCounter) {
    Serial.println("gi_links");
    gi_links(REDUCE);  // links langsam verlernen
    Serial.println("gi_zellen");
    gi_zellen(SLEEP);  // schlafen
  }
  else if (!(loopCounter & 0x1F)) // alle 32 durchläufe
  {
    Serial.println("gi_zellen");
    gi_zellen(REDUCE);  // zellerregungen vermindern
    showAll();
    delay(1000);
  }
}

---

Hallo stochri,

ich wusste nicht, dass Du "arduinifizieren" wolltest. Die Freitags-Version war noch sehr krank. Hier die aktuelle Sonntags-Version:

Anhang 34486

----

Zu Deinen "Arduinifizierungen":

FALSE ist bei mir 0
TRUE ist bei mir 1

Der FSR, INDF-Mechanismus ist ein PIC-Feature und zentral. Ich denke an den Konstrukt:

static unsigned char* FSR;
#define INDF (*FSR)

Du solltest auch keinesfalls mit 16-Bit-Werten arbeiten. Dann scheitern Schleifen, Offsets und Bit-Dröseleien.

Ich rechne damit, dass die Anzahl meiner Links eh nicht reichen wird, um Dekoder zu errichten. Dann muss ich sowieso auf Tiny85 umsteigen. Dann gibts naturgemäß kein "Arduinifizierungs"-Problem mehr.

Ich hatte den PIC lediglich genommen, weil er mich gleich zum sparsamen Umgang mit allen Ressourcen anhalten sollte. Mal gucken, wie weit ich damit noch komme....

Ich wäre dafür, dass wir weiterhin gemütlich bleiben. In der Ruhe liegt die Kraft. Zum Nachbauen oder gar zum Konvertieren auf andere Plattformen ist es m.E. noch zu früh. Ich kümmere mich noch nicht um Versionenpflege und Administration und will das zur Zeit auch keinesfalls im Hinterkopf haben. Auch die Anzahl meiner "Links" und Zellen ist beschränkt... ;)

Viele Grüße

Wolfgang

Hallo Forum,

ich falle mal wieder in meine kleinen Schrittchen zurück.

Über den in der hochgeladenen Sonntags-Software enthaltenen "pattern"-Mechanismus hab ich die drei Sensor-Zellen mit vier Bitmustern geladen, die dann nacheinander im Netzwerk abgearbeitet wurden.

switch(zell_ind) {
case SENS_0: WR_FIRE_REQ(pattern == 1); break;
case SENS_1: WR_FIRE_REQ(pattern == 2); break;
case SENS_2: WR_FIRE_REQ(pattern == 3); break;

Es wird pro Netzwerkdurchlauf also immer ein Bit gesetzt. Oder auch keins.

000 - Ergebnis: alle Ausgänge low
100 - Ergebnis: OUT_0 high
010 - Ergebnis: OUT_1 high
001 - Ergebnis: OUT_2 high

Ohne weiteres Zutun kann Klatschi also drei serielle Bits auseinanderhalten und eindeutig dekodieren.

Ein "zeitloses" Perzeptron-Netz zur Mustererkennung hätte dagegen eher so geanwortet:

000 - Ergebnis: alle Ausgänge low
100 - Ergebnis: OUT_0 high (= ein Input-Bit ist gesetzt)
010 - Ergebnis: OUT_0 high (= ein Input-Bit ist gesetzt)
001 - Ergebnis: OUT_0 high (= ein Input-Bit ist gesetzt)

Ich muss also bei zukünftigen Diskussionen höllisch aufpassen, dass ich mir die Kernidee der 20 Zeilen bewahre und nicht verwässern lasse.

Wenn ein gestelltes Problem nicht auf Anhieb von Klatschi gelöst werden kann, dann muss das nicht unbedingt an Klatschi liegen. Es kann auch am Problem liegen. Da kann schon eine simple Übersetzung des Problems von "Perceptronisch" auf Klatschis Sprache helfen.

------------

Zur Zeit kann Klatschi ohne "Einlernen" zeitliche Ereignisse dekodieren. Nicht mehr und nicht weniger. Unter "zeitlichem Ereignis" verstehe ich das Setzen eines FIRE_REQ-Bits in einer Sensorzelle. Das kann durch eine high-low- oder durch eine low-high-Flanke des serialisierenden patterns entstehen.

Man muss sich jetzt fragen, ob damit die Aufgabe der "Dekodierung" schon hinreichend gelöst ist, denn ich sollte die 8 möglichen Muster von drei Eingangsbits damit vollständig in 8 eindeutige Ausgangssignale wandeln können (wenn ich genug Ausgänge hätte).

Für vier Eingangsmuster konnte ich das gestern Abend ja schon zeigen.

-------

Klatschi ist tatsächlich ein "wenig anders". Es muss anders gedacht werden. Für Klatschi besteht eine "Information" aus Ereignis und dem Zeitpunkt des Ereignisses. Ein klassisches Perzeptron kennt nur Ereignisse und es macht Mühe, ihm ein Zeitgefühl beizubringen.

Mein pattern-Generator "versteckt" sozusagen die Anweisung zur richtigen Dekodierung im Zeitpunkt der Information. Das ist das Geheimnis, warum Klatschi keinen besonderen Lehrer braucht. Der pattern-Generator IST der Lehrer.

Ich werde diese Klatschi-Informationseinheit zukünftig "Ereigniszeit" nennen.

Viele Grüße

Wolfgang

Zitat:

---

ich wusste nicht, dass Du "arduinifizieren" wolltest. Die Freitags-Version war noch sehr krank. Hier die aktuelle Sonntags-Version:

gi.txt

---

Das wollte ich eigentlich gar nicht unbedingt. Aber um deinen Code nachzuvollziehen schien es mir am besten, etwas lauffähiges auf dem Tisch zu haben.
Den Arduino-Uno habe ich gewählt, weil hier wahrscheinlich jeder einen zu Haus rumliegen hat und die niedrige Leistungsklasse ganz im Sinne deiner PIC-Wahl zur Demonstrationszwecken ist, sonst hätte ich einen ESP32 genommen.

Zitat:

---

Ich wäre dafür, dass wir weiterhin gemütlich bleiben. In der Ruhe liegt die Kraft. Zum Nachbauen oder gar zum Konvertieren auf andere Plattformen ist es m.E. noch zu früh. Ich kümmere mich noch nicht um Versionenpflege und Administration und will das zur Zeit auch keinesfalls im Hinterkopf haben. Auch die Anzahl meiner "Links" und Zellen ist beschränkt...

---

Es ging mir keineswegs darum vorzugreifen oder dir davon eilen zu wollen. Ich finde es nur schön, wenn ich etwas Lauffähiges auf dem Tisch liegen habe, das irgendwas tut. Das ist besser als abstrakter Code.

Moin stochri,

ich kann Dich verstehen. Mir würds genauso gehen. Dann nimm aber bitte die Sonntags-Version.

Und ich werde - wenn sich was erhebliches gändert hat - immer gleich die aktuelle Version hochladen.

Wir müssen einfach nur unsere Ereigniszeiten besser synchronisieren. Klatschi ist da vorbildhaft...

Viele Grüße

Wolfgang

Hallo Forum,

Klatschi entdeckt das Auftreten oder Fehlen von Ereignissen zu autonom gelernten Zeitpunkten. Es kann diese Zeitpunkte an langsame Änderungen anpassen. Das ist schon mal gut.

Ein brauchbarer Dekoder muss aber noch mehr können! Klatschi müsste von Natur aus auch kombinieren können (obwohl ich das noch nie beobachtet/nachvollzogen hab).

Zur Erlangung einer vorgegebenen Kombinationsfähigkeit muss es eine Steuerung geben, die mehrere Ereigniszeiten einspeist und den ersten aus deren Kombination resultierenden Feuerimpuls mit einem gewünschten Ausgang verbindet. Der Lernvorgang ist beendet, wenn alle gewünschten Ausgänge verlinkt wurden.

So sollte ich dann auch x-beliebige Dekodierungen hinbekommen können.

Das bau ich (ab) heute.

Viele Grüße

Wolfgang

Hallo,

Dekoder klappt bestens:

10 -> OUT_0
01 -> OUT_1
11 -> OUT_2

Mikrominimale Erweiterung an der Source. Neue Links werden im "learn"-Mode auf die gewünschte Ausgangszelle gelenkt:

Anhang 34487


Es werden nun genau vier Links angelegt und keinerlei Neuronen belegt. Links mit "FF" am Anfang sind noch leer:

Anhang 34489

Das sich ergebende Netzwerk ist anscheinend goldrichtig:

Anhang 34488

Der Nutzen aller Links ist noch "00", weil sie halt erst gelernt und noch nicht benutzt wurden.

So wurde das Programm aufgerufen:

Code:

---

  FOREVER {
    switch(loop) {
      case 0: pattern = 0x01; learn = AKT_0; break;
      case 1: pattern = 0x02; learn = AKT_1; break;
      case 2: pattern = 0x03; learn = AKT_2; break;
      default: FOREVER;
    }
    gi_lerne();
    loop++;
  }

---

Es wurde also für jedes pattern ein zuzuweisender Ausgangsport festgesetzt.

Damit sind also Dekoder mit logischen Verknüpfungen realisierbar.

Ich bin mir noch nicht sicher, ob out_2 wirklich bei "11" kommt oder schon bei einem der beiden Bits. Zu dem Test müsste ich in die RAM-Zellen gucken können, damit ich sehe, wann die feuern. Kann ich aber nicht.

Da muss ich mir noch was zum Test einfallen lassen. Da kann ich noch ne kleine Leiche im Logik-Keller haben.

Viele Grüße

Wolfgang

---------------

So würde ich ODER "einlernen" (schreckliches Wort):
pattern=0x10 learn=AKT_2
pattern=0x01 learn=AKT_2

und so UND:
pattern=0x11 learn=OUT_2

Ich bin mir aber noch nicht sicher, ob das Klatschi auch so siieht.

Moin Forum,

gestern wurde mir bewusst, dass ich mich mal genauer mit der Frage der "Link"-Neubildung befassen muss.

Wenn ich die Neubildung zu großzügig erlaube, wuchert das Netz. Ich kann zwischen Stagnation und Wucherung alles einstellen.

Wuchernde Netze sind unvorhersehbarer und erscheinen intelligenter. Sie scheitern aber schnell bei einfachsten Dekodern, weil ihnen vor lauter Wucherung die Links und Zellen ausgehen.

Wachstumsgebremste Netze sind ideal für Dekoder iund können sich auch an veränderliche Umwelten anpassen. Sie kommen aber keinesfalls in den Verdacht, intelligent zu sein.

------------

Ich halte es für sinnvoll, das Netz in mehreren Phasen wachsen zu lassen.

Zuerst mal müssen die Reflexe wachsen. Die kann man auch Dekoder nennen. "Etwas kommt von rechts - reiße das Lenrad nach links" wäre so ein Dekoder, bei dem ich auch vorgeben muss, was das System genau tun soll. Dazu reicht mein gestriger pattern/learn-Mechnismus vom Prinzip her erstmal aus. Bei diesem Vorgang stelle ich die Wucherneigung sehr gering ein, wodurch auch nur wenige Ressourcen an Links und Zellen verbraucht werden.

Danach könnte ein weiterer Durchlauf stattfinden, in dem ich die Wucher-Bremsen lockere. In den höheren Schichten wird dann abstrahiert und findet Intelligenz statt.

**************

Weiterhin muss ich mich mit dem Nützlichkeits-Mechanismus befassen. Meine gestrige Software konnte leider nicht "undieren", weil ich die Nützlichkeit ("Gewichtung") eines Links stets nur erhöht hatte, wenn erer folgreich war.

Es dauerte nicht lange, bis es nicht mehr zweier Links bedurfte, um eine Zelle zum Feuern zu bewegen (= UND-Funktion) sondern ein einziger der beiden Links ausreichte (= ODER). Der Dekoder mutierte also vom erwünschten UND zum unerwünschten ODER.

Das sind also die beiden momentanen Baustellen. Schichtenweise Wachstumsstrategie und liebevollere Ausgestaltung der Lernregel.

Viele Grüße

Wolfgang

Ich habe gerade mal kurz den Code überflogen.
Vielleicht könntest Du oben ein

typedef uns8 int8_t;

einbauen, dann könnte man alle Typdefinitionen im Code "stdint.h" kompatibel machen, damit sie später auch ohne Mühen auf den Attiny portierbar sind.
Ich habe mir schon überlegt, das Programm einfach mit GCC auf dem PC laufen zu lassen, dann wäre das Debugging auch viel einfacher. Hast Du Linux?

Hallo stochri,

warum bauen wir nicht einfach einen Kompatibilitätsheader? Den klinken wir ein oder lassen ihn weg.

Da kommt der typedef rein. Diese FSR/INDF-Geschichte. Und was sonst noch nötig ist. Und all die Header, die der Arduino braucht. Das ist doch ne 5-Minuten-Sache.

-------

Ich könnte auch gleich mit Atmel programmieren. Und natürlich auch unter Linux. Aber das bringt für mich alles Ablenkungen. Da werde ich dann langsamer, weil ich dann mit Tools kämpfen muss, die ich nur äußerst selten verwende. Linux zum Beispiel zuletzt 2007. Ich weiß nicht mal, ob meine Installation noch anständig hochläuft.

Im Moment weiß ich ja auch ganz genau, wo ich Mist gebaut hab. Die Vergabe neuer "Links" ist unklar. Zur Zeit brauch ich dafür noch nicht mal ein Windows oder nen Compiler oder einen PIC. Wichtiger ist ein Block auf dem Nachttisch und öfter mal ein paar Minuten Ruhe im Büro.

Die Menschheit kam zigtausend Jahre ohne die GI-KNN aus. Sie wird es auch noch ein paar weitere Tage überstehen. Da bin ich absolut zuversichtlich... ;)

Viele Grüße

Wolfgang

Neue Entwicklungstools kosten immer Zeit. Aber manchmal kann sich der Aufwand lohnen und ein Mikrocontroller ist keine gute Debugging-Plattform für Algorithmen.

Ich hab's jetzt mal mit Eclipse-CDT probiert, damit kann man gut durchs Programm steppen.

Mein ( Dein )Programm wirft allerdings folgends aus:
Gucki running
error, no pattern

Code:

---

#define RUNNING_ON_PC

#define NUMBEROFNEURONS 30

//********************** RUNNIN ON PC ***********************************
#ifdef RUNNING_ON_PC
#include <iostream>
#include <stdint.h>
using namespace std;

#define FOREVER while(1)
typedef uint8_t uns8; // stdint.h compatibility
typedef bool  BOOL;
#define FALSE  0
#define TRUE  1

// funktioniert nicht
static unsigned char* FSR;
#define INDF (*FSR)

#define LINK_SRC 0
#define LINK_DST 1
#define LINK_USE 2

/*
#define src 0
#define dst 1
#define use 2
*/
#endif
//************************** RUNNING ON PIC ***************************************

#ifdef PIC
#include "allpic.h"
#pragma config = 0b000110000100    // hex-datei: fuses des 12F629

#pragma cdata[0x2100] =            \
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0xFF                // eeprom initialisierung

#define EE_ROM                // eeprom nutzen
#include "pic_mem.h"

#include "timeloop.h"

// 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)
#endif


#define OUT_0        0        // GPIO
#define OUT_1        1        //
#define OUT_2        2        //
#define IN_2        3        //
#define IN_1        4        //
#define IN_0        5        //

//** alle sensoren, aktoren, triebe und neuronen nach abstraktion gestaffelt ******
uns8 zellen[30];            // zellen im RAM anlegen

#define FIRE_LIMIT    10        // fire_limit

#define RD_SUM        (INDF & 0x3F)    // ZELL-Zugriffe
#define WR_SUM(s)    {INDF &= ~0x3F; INDF |= (s);}

#ifdef RUNNING_ON_PIC
#define RD_FIRE_REQ    (INDF.7)
#define WR_FIRE_REQ(b)    {INDF.7 = (b);}
#endif

#ifdef RUNNING_ON_PC
#define RD_FIRE_REQ    !!(INDF>>7)
#define WR_FIRE_REQ(b)    {INDF&=~0x80;INDF|=b;} //{INDF.7 = (b);}
#endif

#define SENS_0        0              // sensoren
#define SENS_1        1
#define SENS_2        2
#define AKT_0        3              // spezialzellen definieren
#define AKT_1        4
#define AKT_2        5
#define TIMER        6        // Timer-Zelle
#define HUNGER        7        // Hunger-Zelle
#define FIRST_NEURON    8        // Beginn des Hirns

//******* 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
};

//********************** RUNNIN ON PC ***********************************
#ifdef RUNNING_ON_PC

_link Simulated_EEPROM[NUMBEROFNEURONS];

uns8 LINK_RD(uns8 address, uns8 component)
{
  uns8 value = 0;
  if (component == LINK_SRC) value = Simulated_EEPROM[address].src;
  if (component == LINK_DST) value = Simulated_EEPROM[address].dst;
  if (component == LINK_USE) value = Simulated_EEPROM[address].use;
  return value;
}

void LINK_WR(uns8 address, uns8 component, uns8 value)
{

  if (address < NUMBEROFNEURONS)
  {
    if (component == LINK_SRC) Simulated_EEPROM[address].src = value;
    if (component == LINK_DST) Simulated_EEPROM[address].dst = value;
    if (component == LINK_USE) Simulated_EEPROM[address].use = value;
  } else
  {
      cout << "Error: link address out of range " + address << endl;
//    Serial.print("Error: link address out of range "); Serial.println(address);
//    delay(100);
  }
}

#endif

static uns8 rand_link;            // randomize link

static uns8 pattern;
static uns8 learn;

static void gi_lerne(void)        // die genesis
{
  uns8 zell_ind = 0, link, free, buf;
  BOOL hit;
  do {                    // suche feuernde zellen
    FSR = &zellen[zell_ind];        // pointer auf zelle
    /**** sensoren, aktoren und triebe sind besondere zellen *****/
/*
    switch(zell_ind) {
      case SENS_0: WR_FIRE_REQ(pattern.0); break;
      case SENS_1: WR_FIRE_REQ(pattern.1); break;
      case SENS_2: WR_FIRE_REQ(FALSE); break;
      case AKT_0:  GPIO.OUT_0 = RD_FIRE_REQ; continue;
      case AKT_1:  GPIO.OUT_1 = RD_FIRE_REQ; continue;
      case AKT_2:  GPIO.OUT_2 = RD_FIRE_REQ; continue;
      default: break;
    }
*/

    /***** diese zeilen sind der kern des systems *****************/
    if(!RD_FIRE_REQ) continue;        // zelle möchte nicht feuern
    WR_FIRE_REQ(FALSE);            // zell-feuerwunsch wird nun erfüllt
    free = NO_LINK; link = 0; hit = FALSE;    // verfolge die links
    do {                // alle links durchsuchen
      buf = LINK_RD(link,LINK_SRC);        // linkbyte lesen
      if(buf == NO_LINK) free = link;    // leeren link merken
      else if(buf == zell_ind) {    // einen link gefunden
    uns8 hbuf = LINK_RD(link,LINK_USE);    // nuetzlichkeit lesen
    if(hbuf) hit = TRUE;        // nutzlink gefunden
    if(++hbuf > FIRE_LIMIT) hbuf = FIRE_LIMIT;// limitieren
    FSR = zellen + LINK_RD(link,LINK_DST);// pointer auf dst-zelle
    buf = RD_SUM + hbuf;        // zellsumme berechnen
    if(buf > FIRE_LIMIT) buf = FIRE_LIMIT;    // limitieren
    WR_SUM(buf);            // zellsumme speichern
    if((buf == FIRE_LIMIT)&&(!RD_FIRE_REQ)) {// will dst feuern?
      WR_FIRE_REQ(TRUE);        // FIRE_REQ vormerken
      LINK_WR(link,LINK_USE,hbuf);    // nuetzlichkeit inkrementieren
    }
      }
      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,LINK_SRC,zell_ind);    // link neu erzeugen
      if(learn) buf = learn;        // gewollte verlinkung
      else {                // zufällige verlinkung
    if(++rand_link >= sizeof(zellen)) rand_link = FIRST_NEURON;
    buf = rand_link;
    if((buf == zell_ind)&&(++buf >= sizeof(zellen))) buf = FIRST_NEURON;
      }
      LINK_WR(free,LINK_DST,buf);
      LINK_WR(free,LINK_USE,0);        // ob der link nützlich wird, weiß keiner
    }
  } while(++zell_ind < sizeof(zellen));    // nächste zelle
}

static void gi_verlerne(void)        // links überarbeiten
{
  uns8 link = 0, buf;
  do {                    // alle links durchsuchen
    if(LINK_RD(link,LINK_SRC) != NO_LINK) {    // leere links skippen
      buf = LINK_RD(link,LINK_USE);        // nuetzlichkeit lesen
      if(buf) LINK_WR(link,LINK_USE,--buf);    // langsam verlernen
      if(!buf) LINK_WR(link,LINK_SRC,NO_LINK);// link ganz löschen
    }
    link += sizeof(struct _link);    // nächster link
  } while(link < MAX_LINKS * sizeof(struct _link));
}

#define DELETE        0
#define REDUCE        1
#define SLEEP        2

static void gi_zellen(uns8 steuer)    // zell-erregungen überarbeiten
{                    // DELETE, REDUCE oder SLEEP
  uns8 zell_ind = 0;
  do {                    // suche zellen
    FSR = zellen + zell_ind;
    if(steuer == DELETE) INDF = 0;    // flags und summe auf einen schlag
    else if(steuer == REDUCE) {if(RD_SUM) WR_SUM(RD_SUM - 1);}
    else if(RD_SUM > FIRE_LIMIT) WR_SUM(FIRE_LIMIT);
  } while(++zell_ind < sizeof(zellen));    // nächste zelle
}

#define NUMBER_OF_SIMULATION_STEPS 100

int main()
{
    cout << "Gucki running" << endl;

#ifdef PIC
  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);
  TRISIO = _BV(IN_0) | _BV(IN_1) | _BV(IN_2);    // eingänge

  RP0 = 0;                // normale register und ram
  CMCON = 0x07;                // komparator aus
  timeloop_init();            // timer initialisieren
#endif

  rand_link = FIRST_NEURON;
  gi_zellen(DELETE);            // zellerregungen löschen

  uns8 loop = 0;

  int steps=0;
  for(steps=0;steps<NUMBER_OF_SIMULATION_STEPS;steps++)
  {
    switch(loop)
    {
      case 0: pattern = 0x01; learn = AKT_0; break;
      case 1: pattern = 0x02; learn = AKT_1; break;
      case 2: pattern = 0x03; learn = AKT_2; break;
      default:
      {
          cout << "error, no pattern" << endl;
      }//FOREVER;
    }
    gi_lerne();
    loop++;

#ifdef WEG
    gi_verlerne();            // links langsam verlernen

    if(!++loop) {
      gi_verlerne();            // links langsam verlernen
      gi_zellen(SLEEP);            // schlafen
    }
    else if(!(loop & 0x1F))        // alle 32 durchläufe
      gi_zellen(REDUCE);        // zellerregungen vermindern
#endif
  }

  cout << steps + " simulations steps done" << endl;
  cout << " Gucki stopped" << endl;
    //return 0;
}


/* ENDE */

---

Hallo stochri,

die Meldung "error no pattern" verstehe ich nicht. "pattern" ist deklariert und wird benutzt.

Ah ne... Du scheinst die Switcherei gleich am Anfang von gi-lerne() ausgeklammert zu haben. Die ist aber unverzichtbar.


Viele Grüße

Wolfgang

Hallo Forum,

es sperrt sich in mir alles, die momentane Anpassung des GI-Systems an die Mustererkennung weiterzugehen. Es führt m.E. zur Verblödung des Systems.

Diese für Dekoder scheinbar so ungünstige Mutation nützlicher Zellverschaltungen vom UND zum ODER ist nicht ganz unnatürlich. Dem pawlowschen Hund reicht irgendwann zum Speichelfluss Glocke ODER Futter.

Mustererkennung kann man zwar mit einfach strukturierten KNN betreiben. Aber das ist m.E. nicht natürlich. In der Natur ist Mustererekennung ein hochkomplexer Vorgang. Viele Lebewesen beschränken sich darauf, alles für fressbar zu halten, was sie nicht (oder nicht mehr) zur Fortpflanzung gebrauchen können.

Nein! Ich hab den Pfad der Tugend verlassen. Helmuts: "bau nen Dekoder um zu beweisen, dass GI funktioniert" ist ein Paradoxon. Man müsste sogar andersrum formulieren: "wer einen Dekoder erschaffen hat, muss beweisen, ob sein KNN überhaupt noch was anderes kann".

Wenn ich neue Wege finden will, muss ich mir zukünftig fest die Ohren zuhalten und komplett alles ignorieren, was mir erzählt wird. Sonst fahr ich das Projekt gegen die Wand des Altbekannten.

Trotzdem war dieser Ausflug in die Dekoderei hochinteressant. So versteh ich immer besser, wo die KI zur Zeit steht.



Viele Grüße

Wolfgang

Tja, jetzt tut es das:

Code:

---

Gucki running
Number of Neurons: 30
Number of Links: 42
press return

Simulation step number 0
show state of the links:
0 - src:255 dst:0 use:0
1 - src:255 dst:0 use:0
2 - src:255 dst:0 use:0
3 - src:255 dst:0 use:0
4 - src:255 dst:0 use:0
5 - src:255 dst:0 use:0
6 - src:255 dst:0 use:0
7 - src:255 dst:0 use:0
8 - src:255 dst:0 use:0
9 - src:255 dst:0 use:0
10 - src:255 dst:0 use:0
11 - src:255 dst:0 use:0
12 - src:255 dst:0 use:0
13 - src:255 dst:0 use:0
14 - src:255 dst:0 use:0
15 - src:255 dst:0 use:0
16 - src:255 dst:0 use:0
17 - src:255 dst:0 use:0
18 - src:255 dst:0 use:0
19 - src:255 dst:0 use:0
20 - src:255 dst:0 use:0
21 - src:255 dst:0 use:0
22 - src:255 dst:0 use:0
23 - src:255 dst:0 use:0
24 - src:255 dst:0 use:0
25 - src:255 dst:0 use:0
26 - src:255 dst:0 use:0
27 - src:255 dst:0 use:0
28 - src:255 dst:0 use:0
29 - src:255 dst:0 use:0
30 - src:255 dst:0 use:0
31 - src:255 dst:0 use:0
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:1 dst:3 use:0
36 - src:255 dst:0 use:0
37 - src:255 dst:0 use:0
38 - src:255 dst:0 use:0
39 - src:255 dst:0 use:0
40 - src:255 dst:0 use:0
41 - src:255 dst:0 use:0
show Neurons
0 - val:0, fire:0
1 - val:0, fire:0
2 - val:0, fire:0
3 - val:0, fire:0
4 - val:0, fire:0
5 - val:0, fire:0
6 - val:0, fire:0
7 - val:0, fire:0
8 - val:0, fire:0
9 - val:0, fire:0
10 - val:0, fire:0
11 - val:0, fire:0
12 - val:0, fire:0
13 - val:0, fire:0
14 - val:0, fire:0
15 - val:0, fire:0
16 - val:0, fire:0
17 - val:0, fire:0
18 - val:0, fire:0
19 - val:0, fire:0
20 - val:0, fire:0
21 - val:0, fire:0
22 - val:0, fire:0
23 - val:0, fire:0
24 - val:0, fire:0
25 - val:0, fire:0
26 - val:0, fire:0
27 - val:0, fire:0
28 - val:0, fire:0
29 - val:0, fire:0

Simulation step number 1
show state of the links:
0 - src:255 dst:0 use:0
1 - src:255 dst:0 use:0
2 - src:255 dst:0 use:0
3 - src:255 dst:0 use:0
4 - src:255 dst:0 use:0
5 - src:255 dst:0 use:0
6 - src:255 dst:0 use:0
7 - src:255 dst:0 use:0
8 - src:255 dst:0 use:0
9 - src:255 dst:0 use:0
10 - src:255 dst:0 use:0
11 - src:255 dst:0 use:0
12 - src:255 dst:0 use:0
13 - src:255 dst:0 use:0
14 - src:255 dst:0 use:0
15 - src:255 dst:0 use:0
16 - src:255 dst:0 use:0
17 - src:255 dst:0 use:0
18 - src:255 dst:0 use:0
19 - src:255 dst:0 use:0
20 - src:255 dst:0 use:0
21 - src:255 dst:0 use:0
22 - src:255 dst:0 use:0
23 - src:255 dst:0 use:0
24 - src:255 dst:0 use:0
25 - src:255 dst:0 use:0
26 - src:255 dst:0 use:0
27 - src:255 dst:0 use:0
28 - src:255 dst:0 use:0
29 - src:255 dst:0 use:0
30 - src:255 dst:0 use:0
31 - src:255 dst:0 use:0
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:2 dst:4 use:0
36 - src:255 dst:0 use:0
37 - src:255 dst:0 use:0
38 - src:255 dst:0 use:0
39 - src:255 dst:0 use:0
40 - src:255 dst:0 use:0
41 - src:255 dst:0 use:0
show Neurons
0 - val:0, fire:0
1 - val:0, fire:0
2 - val:0, fire:0
3 - val:0, fire:0
4 - val:0, fire:0
5 - val:0, fire:0
6 - val:0, fire:0
7 - val:0, fire:0
8 - val:0, fire:0
9 - val:0, fire:0
10 - val:0, fire:0
11 - val:0, fire:0
12 - val:0, fire:0
13 - val:0, fire:0
14 - val:0, fire:0
15 - val:0, fire:0
16 - val:0, fire:0
17 - val:0, fire:0
18 - val:0, fire:0
19 - val:0, fire:0
20 - val:0, fire:0
21 - val:0, fire:0
22 - val:0, fire:0
23 - val:0, fire:0
24 - val:0, fire:0
25 - val:0, fire:0
26 - val:0, fire:0
27 - val:0, fire:0
28 - val:0, fire:0
29 - val:0, fire:0

Simulation step number 2
show state of the links:
0 - src:255 dst:0 use:0
1 - src:255 dst:0 use:0
2 - src:255 dst:0 use:0
3 - src:255 dst:0 use:0
4 - src:255 dst:0 use:0
5 - src:255 dst:0 use:0
6 - src:255 dst:0 use:0
7 - src:255 dst:0 use:0
8 - src:255 dst:0 use:0
9 - src:255 dst:0 use:0
10 - src:255 dst:0 use:0
11 - src:255 dst:0 use:0
12 - src:255 dst:0 use:0
13 - src:255 dst:0 use:0
14 - src:255 dst:0 use:0
15 - src:255 dst:0 use:0
16 - src:255 dst:0 use:0
17 - src:255 dst:0 use:0
18 - src:255 dst:0 use:0
19 - src:255 dst:0 use:0
20 - src:255 dst:0 use:0
21 - src:255 dst:0 use:0
22 - src:255 dst:0 use:0
23 - src:255 dst:0 use:0
24 - src:255 dst:0 use:0
25 - src:255 dst:0 use:0
26 - src:255 dst:0 use:0
27 - src:255 dst:0 use:0
28 - src:255 dst:0 use:0
29 - src:255 dst:0 use:0
30 - src:255 dst:0 use:0
31 - src:255 dst:0 use:0
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:3 dst:5 use:0
36 - src:255 dst:0 use:0
37 - src:255 dst:0 use:0
38 - src:255 dst:0 use:0
39 - src:255 dst:0 use:0
40 - src:255 dst:0 use:0
41 - src:255 dst:0 use:0
show Neurons
0 - val:0, fire:0
1 - val:0, fire:0
2 - val:0, fire:0
3 - val:0, fire:0
4 - val:0, fire:0
5 - val:0, fire:0
6 - val:0, fire:0
7 - val:0, fire:0
8 - val:0, fire:0
9 - val:0, fire:0
10 - val:0, fire:0
11 - val:0, fire:0
12 - val:0, fire:0
13 - val:0, fire:0
14 - val:0, fire:0
15 - val:0, fire:0
16 - val:0, fire:0
17 - val:0, fire:0
18 - val:0, fire:0
19 - val:0, fire:0
20 - val:0, fire:0
21 - val:0, fire:0
22 - val:0, fire:0
23 - val:0, fire:0
24 - val:0, fire:0
25 - val:0, fire:0
26 - val:0, fire:0
27 - val:0, fire:0
28 - val:0, fire:0
29 - val:0, fire:0

error, no pattern
Simulation step number 3
show state of the links:
0 - src:255 dst:0 use:0
1 - src:255 dst:0 use:0
2 - src:255 dst:0 use:0
3 - src:255 dst:0 use:0
4 - src:255 dst:0 use:0
5 - src:255 dst:0 use:0
6 - src:255 dst:0 use:0
7 - src:255 dst:0 use:0
8 - src:255 dst:0 use:0
9 - src:255 dst:0 use:0
10 - src:255 dst:0 use:0
11 - src:255 dst:0 use:0
12 - src:255 dst:0 use:0
13 - src:255 dst:0 use:0
14 - src:255 dst:0 use:0
15 - src:255 dst:0 use:0
16 - src:255 dst:0 use:0
17 - src:255 dst:0 use:0
18 - src:255 dst:0 use:0
19 - src:255 dst:0 use:0
20 - src:255 dst:0 use:0
21 - src:255 dst:0 use:0
22 - src:255 dst:0 use:0
23 - src:255 dst:0 use:0
24 - src:255 dst:0 use:0
25 - src:255 dst:0 use:0
26 - src:255 dst:0 use:0
27 - src:255 dst:0 use:0
28 - src:255 dst:0 use:0
29 - src:255 dst:0 use:0
30 - src:255 dst:0 use:0
31 - src:255 dst:0 use:0
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:3 dst:5 use:0
36 - src:255 dst:0 use:0
37 - src:255 dst:0 use:0
38 - src:255 dst:0 use:0
39 - src:255 dst:0 use:0
40 - src:255 dst:0 use:0
41 - src:255 dst:0 use:0
show Neurons
0 - val:0, fire:0
1 - val:0, fire:0
2 - val:0, fire:0
3 - val:0, fire:0
4 - val:0, fire:0
5 - val:0, fire:0
6 - val:0, fire:0
7 - val:0, fire:0
8 - val:0, fire:0
9 - val:0, fire:0
10 - val:0, fire:0
11 - val:0, fire:0
12 - val:0, fire:0
13 - val:0, fire:0
14 - val:0, fire:0
15 - val:0, fire:0
16 - val:0, fire:0
17 - val:0, fire:0
18 - val:0, fire:0
19 - val:0, fire:0
20 - val:0, fire:0
21 - val:0, fire:0
22 - val:0, fire:0
23 - val:0, fire:0
24 - val:0, fire:0
25 - val:0, fire:0
26 - val:0, fire:0
27 - val:0, fire:0
28 - val:0, fire:0
29 - val:0, fire:0

error, no pattern
Simulation step number 4
show state of the links:
0 - src:255 dst:0 use:0
1 - src:255 dst:0 use:0
2 - src:255 dst:0 use:0
3 - src:255 dst:0 use:0
4 - src:255 dst:0 use:0
5 - src:255 dst:0 use:0
6 - src:255 dst:0 use:0
7 - src:255 dst:0 use:0
8 - src:255 dst:0 use:0
9 - src:255 dst:0 use:0
10 - src:255 dst:0 use:0
11 - src:255 dst:0 use:0
12 - src:255 dst:0 use:0
13 - src:255 dst:0 use:0
14 - src:255 dst:0 use:0
15 - src:255 dst:0 use:0
16 - src:255 dst:0 use:0
17 - src:255 dst:0 use:0
18 - src:255 dst:0 use:0
19 - src:255 dst:0 use:0
20 - src:255 dst:0 use:0
21 - src:255 dst:0 use:0
22 - src:255 dst:0 use:0
23 - src:255 dst:0 use:0
24 - src:255 dst:0 use:0
25 - src:255 dst:0 use:0
26 - src:255 dst:0 use:0
27 - src:255 dst:0 use:0
28 - src:255 dst:0 use:0
29 - src:255 dst:0 use:0
30 - src:255 dst:0 use:0
31 - src:255 dst:0 use:0
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:3 dst:5 use:0
36 - src:255 dst:0 use:0
37 - src:255 dst:0 use:0
38 - src:255 dst:0 use:0
39 - src:255 dst:0 use:0
40 - src:255 dst:0 use:0
41 - src:255 dst:0 use:0
show Neurons
0 - val:0, fire:0
1 - val:0, fire:0
2 - val:0, fire:0
3 - val:0, fire:0
4 - val:0, fire:0
5 - val:0, fire:0
6 - val:0, fire:0
7 - val:0, fire:0
8 - val:0, fire:0
9 - val:0, fire:0
10 - val:0, fire:0
11 - val:0, fire:0
12 - val:0, fire:0
13 - val:0, fire:0
14 - val:0, fire:0
15 - val:0, fire:0
16 - val:0, fire:0
17 - val:0, fire:0
18 - val:0, fire:0
19 - val:0, fire:0
20 - val:0, fire:0
21 - val:0, fire:0
22 - val:0, fire:0
23 - val:0, fire:0
24 - val:0, fire:0
25 - val:0, fire:0
26 - val:0, fire:0
27 - val:0, fire:0
28 - val:0, fire:0
29 - val:0, fire:0

error, no pattern
Simulation step number 5
show state of the links:
0 - src:255 dst:0 use:0
1 - src:255 dst:0 use:0
2 - src:255 dst:0 use:0
3 - src:255 dst:0 use:0
4 - src:255 dst:0 use:0
5 - src:255 dst:0 use:0
6 - src:255 dst:0 use:0
7 - src:255 dst:0 use:0
8 - src:255 dst:0 use:0
9 - src:255 dst:0 use:0
10 - src:255 dst:0 use:0
11 - src:255 dst:0 use:0
12 - src:255 dst:0 use:0
13 - src:255 dst:0 use:0
14 - src:255 dst:0 use:0
15 - src:255 dst:0 use:0
16 - src:255 dst:0 use:0
17 - src:255 dst:0 use:0
18 - src:255 dst:0 use:0
19 - src:255 dst:0 use:0
20 - src:255 dst:0 use:0
21 - src:255 dst:0 use:0
22 - src:255 dst:0 use:0
23 - src:255 dst:0 use:0
24 - src:255 dst:0 use:0
25 - src:255 dst:0 use:0
26 - src:255 dst:0 use:0
27 - src:255 dst:0 use:0
28 - src:255 dst:0 use:0
29 - src:255 dst:0 use:0
30 - src:255 dst:0 use:0
31 - src:255 dst:0 use:0
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:3 dst:5 use:0
36 - src:255 dst:0 use:0
37 - src:255 dst:0 use:0
38 - src:255 dst:0 use:0
39 - src:255 dst:0 use:0
40 - src:255 dst:0 use:0
41 - src:255 dst:0 use:0
show Neurons
0 - val:0, fire:0
1 - val:0, fire:0
2 - val:0, fire:0
3 - val:0, fire:0
4 - val:0, fire:0
5 - val:0, fire:0
6 - val:0, fire:0
7 - val:0, fire:0
8 - val:0, fire:0
9 - val:0, fire:0
10 - val:0, fire:0
11 - val:0, fire:0
12 - val:0, fire:0
13 - val:0, fire:0
14 - val:0, fire:0
15 - val:0, fire:0
16 - val:0, fire:0
17 - val:0, fire:0
18 - val:0, fire:0
19 - val:0, fire:0
20 - val:0, fire:0
21 - val:0, fire:0
22 - val:0, fire:0
23 - val:0, fire:0
24 - val:0, fire:0
25 - val:0, fire:0
26 - val:0, fire:0
27 - val:0, fire:0
28 - val:0, fire:0
29 - val:0, fire:0

error, no pattern
Simulation step number 6
show state of the links:
0 - src:255 dst:0 use:0
1 - src:255 dst:0 use:0
2 - src:255 dst:0 use:0
3 - src:255 dst:0 use:0
4 - src:255 dst:0 use:0
5 - src:255 dst:0 use:0
6 - src:255 dst:0 use:0
7 - src:255 dst:0 use:0
8 - src:255 dst:0 use:0
9 - src:255 dst:0 use:0
10 - src:255 dst:0 use:0
11 - src:255 dst:0 use:0
12 - src:255 dst:0 use:0
13 - src:255 dst:0 use:0
14 - src:255 dst:0 use:0
15 - src:255 dst:0 use:0
16 - src:255 dst:0 use:0
17 - src:255 dst:0 use:0
18 - src:255 dst:0 use:0
19 - src:255 dst:0 use:0
20 - src:255 dst:0 use:0
21 - src:255 dst:0 use:0
22 - src:255 dst:0 use:0
23 - src:255 dst:0 use:0
24 - src:255 dst:0 use:0
25 - src:255 dst:0 use:0
26 - src:255 dst:0 use:0
27 - src:255 dst:0 use:0
28 - src:255 dst:0 use:0
29 - src:255 dst:0 use:0
30 - src:255 dst:0 use:0
31 - src:255 dst:0 use:0
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:3 dst:5 use:0
36 - src:255 dst:0 use:0
37 - src:255 dst:0 use:0
38 - src:255 dst:0 use:0
39 - src:255 dst:0 use:0
40 - src:255 dst:0 use:0
41 - src:255 dst:0 use:0
show Neurons
0 - val:0, fire:0
1 - val:0, fire:0
2 - val:0, fire:0
3 - val:0, fire:0
4 - val:0, fire:0
5 - val:0, fire:0
6 - val:0, fire:0
7 - val:0, fire:0
8 - val:0, fire:0
9 - val:0, fire:0
10 - val:0, fire:0
11 - val:0, fire:0
12 - val:0, fire:0
13 - val:0, fire:0
14 - val:0, fire:0
15 - val:0, fire:0
16 - val:0, fire:0
17 - val:0, fire:0
18 - val:0, fire:0
19 - val:0, fire:0
20 - val:0, fire:0
21 - val:0, fire:0
22 - val:0, fire:0
23 - val:0, fire:0
24 - val:0, fire:0
25 - val:0, fire:0
26 - val:0, fire:0
27 - val:0, fire:0
28 - val:0, fire:0
29 - val:0, fire:0

error, no pattern
Simulation step number 7
show state of the links:
0 - src:255 dst:0 use:0
1 - src:255 dst:0 use:0
2 - src:255 dst:0 use:0
3 - src:255 dst:0 use:0
4 - src:255 dst:0 use:0
5 - src:255 dst:0 use:0
6 - src:255 dst:0 use:0
7 - src:255 dst:0 use:0
8 - src:255 dst:0 use:0
9 - src:255 dst:0 use:0
10 - src:255 dst:0 use:0
11 - src:255 dst:0 use:0
12 - src:255 dst:0 use:0
13 - src:255 dst:0 use:0
14 - src:255 dst:0 use:0
15 - src:255 dst:0 use:0
16 - src:255 dst:0 use:0
17 - src:255 dst:0 use:0
18 - src:255 dst:0 use:0
19 - src:255 dst:0 use:0
20 - src:255 dst:0 use:0
21 - src:255 dst:0 use:0
22 - src:255 dst:0 use:0
23 - src:255 dst:0 use:0
24 - src:255 dst:0 use:0
25 - src:255 dst:0 use:0
26 - src:255 dst:0 use:0
27 - src:255 dst:0 use:0
28 - src:255 dst:0 use:0
29 - src:255 dst:0 use:0
30 - src:255 dst:0 use:0
31 - src:255 dst:0 use:0
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:3 dst:5 use:0
36 - src:255 dst:0 use:0
37 - src:255 dst:0 use:0
38 - src:255 dst:0 use:0
39 - src:255 dst:0 use:0
40 - src:255 dst:0 use:0
41 - src:255 dst:0 use:0
show Neurons
0 - val:0, fire:0
1 - val:0, fire:0
2 - val:0, fire:0
3 - val:0, fire:0
4 - val:0, fire:0
5 - val:0, fire:0
6 - val:0, fire:0
7 - val:0, fire:0
8 - val:0, fire:0
9 - val:0, fire:0
10 - val:0, fire:0
11 - val:0, fire:0
12 - val:0, fire:0
13 - val:0, fire:0
14 - val:0, fire:0
15 - val:0, fire:0
16 - val:0, fire:0
17 - val:0, fire:0
18 - val:0, fire:0
19 - val:0, fire:0
20 - val:0, fire:0
21 - val:0, fire:0
22 - val:0, fire:0
23 - val:0, fire:0
24 - val:0, fire:0
25 - val:0, fire:0
26 - val:0, fire:0
27 - val:0, fire:0
28 - val:0, fire:0
29 - val:0, fire:0

error, no pattern
Simulation step number 8
show state of the links:
0 - src:255 dst:0 use:0
1 - src:255 dst:0 use:0
2 - src:255 dst:0 use:0
3 - src:255 dst:0 use:0
4 - src:255 dst:0 use:0
5 - src:255 dst:0 use:0
6 - src:255 dst:0 use:0
7 - src:255 dst:0 use:0
8 - src:255 dst:0 use:0
9 - src:255 dst:0 use:0
10 - src:255 dst:0 use:0
11 - src:255 dst:0 use:0
12 - src:255 dst:0 use:0
13 - src:255 dst:0 use:0
14 - src:255 dst:0 use:0
15 - src:255 dst:0 use:0
16 - src:255 dst:0 use:0
17 - src:255 dst:0 use:0
18 - src:255 dst:0 use:0
19 - src:255 dst:0 use:0
20 - src:255 dst:0 use:0
21 - src:255 dst:0 use:0
22 - src:255 dst:0 use:0
23 - src:255 dst:0 use:0
24 - src:255 dst:0 use:0
25 - src:255 dst:0 use:0
26 - src:255 dst:0 use:0
27 - src:255 dst:0 use:0
28 - src:255 dst:0 use:0
29 - src:255 dst:0 use:0
30 - src:255 dst:0 use:0
31 - src:255 dst:0 use:0
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:3 dst:5 use:0
36 - src:255 dst:0 use:0
37 - src:255 dst:0 use:0
38 - src:255 dst:0 use:0
39 - src:255 dst:0 use:0
40 - src:255 dst:0 use:0
41 - src:255 dst:0 use:0
show Neurons
0 - val:0, fire:0
1 - val:0, fire:0
2 - val:0, fire:0
3 - val:0, fire:0
4 - val:0, fire:0
5 - val:0, fire:0
6 - val:0, fire:0
7 - val:0, fire:0
8 - val:0, fire:0
9 - val:0, fire:0
10 - val:0, fire:0
11 - val:0, fire:0
12 - val:0, fire:0
13 - val:0, fire:0
14 - val:0, fire:0
15 - val:0, fire:0
16 - val:0, fire:0
17 - val:0, fire:0
18 - val:0, fire:0
19 - val:0, fire:0
20 - val:0, fire:0
21 - val:0, fire:0
22 - val:0, fire:0
23 - val:0, fire:0
24 - val:0, fire:0
25 - val:0, fire:0
26 - val:0, fire:0
27 - val:0, fire:0
28 - val:0, fire:0
29 - val:0, fire:0

error, no pattern
Simulation step number 9
show state of the links:
0 - src:255 dst:0 use:0
1 - src:255 dst:0 use:0
2 - src:255 dst:0 use:0
3 - src:255 dst:0 use:0
4 - src:255 dst:0 use:0
5 - src:255 dst:0 use:0
6 - src:255 dst:0 use:0
7 - src:255 dst:0 use:0
8 - src:255 dst:0 use:0
9 - src:255 dst:0 use:0
10 - src:255 dst:0 use:0
11 - src:255 dst:0 use:0
12 - src:255 dst:0 use:0
13 - src:255 dst:0 use:0
14 - src:255 dst:0 use:0
15 - src:255 dst:0 use:0
16 - src:255 dst:0 use:0
17 - src:255 dst:0 use:0
18 - src:255 dst:0 use:0
19 - src:255 dst:0 use:0
20 - src:255 dst:0 use:0
21 - src:255 dst:0 use:0
22 - src:255 dst:0 use:0
23 - src:255 dst:0 use:0
24 - src:255 dst:0 use:0
25 - src:255 dst:0 use:0
26 - src:255 dst:0 use:0
27 - src:255 dst:0 use:0
28 - src:255 dst:0 use:0
29 - src:255 dst:0 use:0
30 - src:255 dst:0 use:0
31 - src:255 dst:0 use:0
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:3 dst:5 use:0
36 - src:255 dst:0 use:0
37 - src:255 dst:0 use:0
38 - src:255 dst:0 use:0
39 - src:255 dst:0 use:0
40 - src:255 dst:0 use:0
41 - src:255 dst:0 use:0
show Neurons
0 - val:0, fire:0
1 - val:0, fire:0
2 - val:0, fire:0
3 - val:0, fire:0
4 - val:0, fire:0
5 - val:0, fire:0
6 - val:0, fire:0
7 - val:0, fire:0
8 - val:0, fire:0
9 - val:0, fire:0
10 - val:0, fire:0
11 - val:0, fire:0
12 - val:0, fire:0
13 - val:0, fire:0
14 - val:0, fire:0
15 - val:0, fire:0
16 - val:0, fire:0
17 - val:0, fire:0
18 - val:0, fire:0
19 - val:0, fire:0
20 - val:0, fire:0
21 - val:0, fire:0
22 - val:0, fire:0
23 - val:0, fire:0
24 - val:0, fire:0
25 - val:0, fire:0
26 - val:0, fire:0
27 - val:0, fire:0
28 - val:0, fire:0
29 - val:0, fire:0


simulations steps done: 10
 Gucki stopped

---

Code:

---

#define RUNNING_ON_PC

#define NUMBEROFNEURONS 30

//********************** RUNNING ON PC ***********************************
#ifdef RUNNING_ON_PC
#include <iostream>
#include <stdint.h>
#include <stdio.h>
using namespace std;

#define FOREVER while(1)
typedef uint8_t uns8; // stdint.h compatibility
typedef bool  BOOL;
#define FALSE  0
#define TRUE  1

// funktioniert nicht
static unsigned char* FSR;
#define INDF (*FSR)

#define LINK_SRC 0
#define LINK_DST 1
#define LINK_USE 2

#endif
//************************** RUNNING ON PIC ***************************************

#ifdef RUNNING_ON_PIC
#include "allpic.h"
#pragma config = 0b000110000100    // hex-datei: fuses des 12F629

#pragma cdata[0x2100] =            \
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,0xFF,0,0,\
  0xFF,0xFF                // eeprom initialisierung

#define EE_ROM                // eeprom nutzen
#include "pic_mem.h"

#include "timeloop.h"

// 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)
#endif


#define OUT_0        0        // GPIO
#define OUT_1        1        //
#define OUT_2        2        //
#define IN_2        3        //
#define IN_1        4        //
#define IN_0        5        //

//** alle sensoren, aktoren, triebe und neuronen nach abstraktion gestaffelt ******
uns8 zellen[NUMBEROFNEURONS];            // zellen im RAM anlegen

// cells are bit coded
// b7        b6 b5 b4 b3 b2 b1 b0
// FIRE_REQ  ( cell potential  )

#define FIRE_LIMIT    10        // fire_limit

#define RD_SUM        (INDF & 0x3F)    // ZELL-Zugriffe
#define WR_SUM(s)    {INDF &= ~0x3F; INDF |= (s);}

#ifdef RUNNING_ON_PIC
#define RD_FIRE_REQ    (INDF.7)
#define WR_FIRE_REQ(b)    {INDF.7 = (b);}
#endif

#ifdef RUNNING_ON_PC
#define RD_FIRE_REQ    !!(INDF&0x80)
#define WR_FIRE_REQ(b)    {INDF&=~0x80;INDF|=b<<7;} //{INDF.7 = (b);}
#endif

#define SENS_0        0              // sensoren
#define SENS_1        1
#define SENS_2        2
#define AKT_0        3              // spezialzellen definieren
#define AKT_1        4
#define AKT_2        5
#define TIMER        6        // Timer-Zelle
#define HUNGER        7        // Hunger-Zelle
#define FIRST_NEURON    8        // Beginn des Hirns

//******* 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
};

//********************** RUNNIN ON PC ***********************************
#ifdef RUNNING_ON_PC

_link Simulated_EEPROM[NUMBEROFNEURONS];

void initEEPROM()
{
    for(int n=0;n<MAX_LINKS    ;n++)
    {
        int address=n;

        Simulated_EEPROM[address].src=0xFF;
        Simulated_EEPROM[address].dst=0;
        Simulated_EEPROM[address].use=0;
    }
}

uns8 LINK_RD(uns8 address, uns8 component)
{
  uns8 value = 0;
  if (component == LINK_SRC) value = Simulated_EEPROM[address].src;
  if (component == LINK_DST) value = Simulated_EEPROM[address].dst;
  if (component == LINK_USE) value = Simulated_EEPROM[address].use;
  return value;
}

void LINK_WR(uns8 address, uns8 component, uns8 value)
{

  if (address < NUMBEROFNEURONS)
  {
    if (component == LINK_SRC) Simulated_EEPROM[address].src = value;
    if (component == LINK_DST) Simulated_EEPROM[address].dst = value;
    if (component == LINK_USE) Simulated_EEPROM[address].use = value;
  } else
  {
      printf("Error: link address out of range, address:%d\n ",address);
  }
}

void showAktor(int aktorId,bool bit)
{
    /*
    printf("%d:",aktorId);
    if(bit) printf("ON ");
    else printf("OFF ");
    */
}

void showLinks(uint8_t adr)
{
    int src=Simulated_EEPROM[adr].src;
    int dst=Simulated_EEPROM[adr].dst;
    int use=Simulated_EEPROM[adr].use;
    printf("%d - src:%d dst:%d use:%d\n",adr,src,dst,use);
}

void showNeurons()
{
    for(int n=0;n<NUMBEROFNEURONS;n++)
    {
        int neuronNumber=n;
        int potential=zellen[n]&0x3F;
        int fireRequest=(zellen[n]&0x80)>>7;
        printf("%d - val:%d, fire:%d\n",neuronNumber,potential,fireRequest);
    }
}

void showAll()
{
  puts("show state of the links:");
  for (uint16_t n = 0; n < MAX_LINKS; n++)
  {
    showLinks(n);
  }
  puts("show Neurons");
  showNeurons();
  puts("");
}
#endif

static uns8 rand_link;            // randomize link

static uns8 pattern;
static uns8 learn;

static void gi_lerne(void)        // die genesis
{
  uns8 zell_ind = sizeof(zellen), link, free, buf;
  BOOL hit;
  do {                    // suche feuernde zellen
    //FSR = &zellen[zell_ind];        // pointer auf zelle
    //FSR = zellen + zell_ind;
    FSR = zellen + --zell_ind;        // pointer auf zelle
    /**** sensoren, aktoren und triebe sind besondere zellen *****/
#ifdef RUNNING_ON_PIC
    switch(zell_ind) {
      case SENS_0: WR_FIRE_REQ(pattern.0); break;
      case SENS_1: WR_FIRE_REQ(pattern.1); break;
      case SENS_2: WR_FIRE_REQ(FALSE); break;
      case AKT_0:  GPIO.OUT_0 = RD_FIRE_REQ; continue;
      case AKT_1:  GPIO.OUT_1 = RD_FIRE_REQ; continue;
      case AKT_2:  GPIO.OUT_2 = RD_FIRE_REQ; continue;
      default: break;
    }
#endif

#ifdef RUNNING_ON_PC
    switch(zell_ind) {
      case SENS_0: WR_FIRE_REQ(pattern&1); break;
      case SENS_1: WR_FIRE_REQ((pattern>>1)&1); break;
      case SENS_2: WR_FIRE_REQ(FALSE); break;
      case AKT_0:  showAktor(0,RD_FIRE_REQ); continue;
      case AKT_1:  showAktor(1,RD_FIRE_REQ); continue;
      case AKT_2:  showAktor(2,RD_FIRE_REQ); continue;
      default: break;
    }
#endif

    /***** diese zeilen sind der kern des systems *****************/
    if(!RD_FIRE_REQ) continue;        // zelle möchte nicht feuern
    WR_FIRE_REQ(FALSE);            // zell-feuerwunsch wird nun erfüllt
    free = NO_LINK; link = 0; hit = FALSE;    // verfolge die links
    do {                // alle links durchsuchen
      buf = LINK_RD(link,LINK_SRC);        // linkbyte lesen
      if(buf == NO_LINK) free = link;    // leeren link merken
      else if(buf == zell_ind) {    // einen link gefunden
    uns8 hbuf = LINK_RD(link,LINK_USE);    // nuetzlichkeit lesen
    if(hbuf) hit = TRUE;        // nutzlink gefunden
    if(++hbuf > FIRE_LIMIT) hbuf = FIRE_LIMIT;// limitieren
    FSR = zellen + LINK_RD(link,LINK_DST);// pointer auf dst-zelle
    buf = RD_SUM + hbuf;        // zellsumme berechnen
    if(buf > FIRE_LIMIT) buf = FIRE_LIMIT;    // limitieren
    WR_SUM(buf);            // zellsumme speichern
    if((buf == FIRE_LIMIT)&&(!RD_FIRE_REQ)) {// will dst feuern?
      WR_FIRE_REQ(TRUE);        // FIRE_REQ vormerken
      LINK_WR(link,LINK_USE,hbuf);    // nuetzlichkeit inkrementieren
    }
      }
      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,LINK_SRC,zell_ind);    // link neu erzeugen
      if(learn) buf = learn;        // gewollte verlinkung
      else {                // zufällige verlinkung
    if(++rand_link >= sizeof(zellen)) rand_link = FIRST_NEURON;
    buf = rand_link;
    if((buf == zell_ind)&&(++buf >= sizeof(zellen))) buf = FIRST_NEURON;
      }
      LINK_WR(free,LINK_DST,buf);
      LINK_WR(free,LINK_USE,0);        // ob der link nützlich wird, weiß keiner
    }
  } while(++zell_ind < sizeof(zellen));    // nächste zelle
}

static void gi_verlerne(void)        // links überarbeiten
{
  uns8 link = 0, buf;
  do {                    // alle links durchsuchen
    if(LINK_RD(link,LINK_SRC) != NO_LINK) {    // leere links skippen
      buf = LINK_RD(link,LINK_USE);        // nuetzlichkeit lesen
      if(buf) LINK_WR(link,LINK_USE,--buf);    // langsam verlernen
      if(!buf) LINK_WR(link,LINK_SRC,NO_LINK);// link ganz löschen
    }
    link += sizeof(struct _link);    // nächster link
  } while(link < MAX_LINKS * sizeof(struct _link));
}

#define DELETE        0
#define REDUCE        1
#define SLEEP        2

static void gi_zellen(uns8 steuer)    // zell-erregungen überarbeiten
{                    // DELETE, REDUCE oder SLEEP
  uns8 zell_ind = sizeof(zellen);
  do {                    // suche zellen
    FSR = zellen + --zell_ind;
    if(steuer == DELETE) INDF = 0;    // flags und summe auf einen schlag
    else if(steuer == REDUCE) {if(RD_SUM) WR_SUM(RD_SUM - 1);}
    else if(RD_SUM > FIRE_LIMIT) WR_SUM(FIRE_LIMIT);
  } while(zell_ind);            // nächste zelle
}

#define NUMBER_OF_SIMULATION_STEPS 10

int main()
{
#ifdef RUNNING_ON_PC
    printf("Gucki running\n" );
    initEEPROM();
    printf("Number of Neurons: %d\n",NUMBEROFNEURONS);
    printf("Number of Links: %d\n",(int)MAX_LINKS);
    puts("press return");
    getchar();
#endif

#ifdef RUNNING_ON_PIC
  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);
  TRISIO = _BV(IN_0) | _BV(IN_1) | _BV(IN_2);    // eingänge

  RP0 = 0;                // normale register und ram
  CMCON = 0x07;                // komparator aus
  timeloop_init();            // timer initialisieren
#endif

  rand_link = FIRST_NEURON;
  gi_zellen(DELETE);            // zellerregungen löschen

  uns8 loop = 0;

  int steps=0;
  for(steps=0;steps<NUMBER_OF_SIMULATION_STEPS;steps++)
  {
    switch(loop)
    {
      case 0: pattern = 0x01; learn = AKT_0; break;
      case 1: pattern = 0x02; learn = AKT_1; break;
      case 2: pattern = 0x03; learn = AKT_2; break;
      default:
      {
        #ifdef RUNNING_ON_PC
          printf("error, no pattern\n");
              #endif

      }//FOREVER;
    }
    gi_lerne();
#ifdef RUNNING_ON_PC
    printf("Simulation step number %d\n",steps);
    showAll();
#endif
    loop++;

#ifdef WEG
    gi_verlerne();            // links langsam verlernen

    if(!++loop) {
      gi_verlerne();            // links langsam verlernen
      gi_zellen(SLEEP);            // schlafen
    }
    else if(!(loop & 0x1F))        // alle 32 durchläufe
      gi_zellen(REDUCE);        // zellerregungen vermindern
#endif
  }
#ifdef RUNNING_ON_PC
  printf("\nsimulations steps done: %d\n",steps);
  printf(" Gucki stopped\n");
#endif

    //return 0;
}


/* ENDE */

---

Wenn Du Linux hast, kannst Du die Datein mit

gcc Gucki.cpp

und dann laufen lassen.

Ansonsten gäbe es noch die Möglichkeit, Cygwin auf Windows zu installieren, da ist der GCC auch drinn.

- - - Aktualisiert - - -

So richtig ist mir nicht klar, was die Variable "pattern" genau macht. Kannst Du was dazu sagen?

Zitat:

---

Helmuts: "bau nen Dekoder um zu beweisen, dass GI funktioniert" ist ein Paradoxon.

---

ich habe nie gesagt, du sollest einen Dekoder bauen - das war deine eigene Idee, weil du ja gar nicht wusstest oder zeigen konntest, was dein GI intern überhaupt macht
MIR war das völlig egal - wichtig waren nur inputs und zugehörige Outputs.

Stattdessen solltest du nur zeigen, dass dein GI überhaupt in der Lage ist, simpelste logische Verknüpfungen darzustellen und zu lernen, welche als Basis der Booleschen Aussagenlogik (Boolesche Algebra) auch gleichzeitig Basis jedes logischen Verhaltens ist und aller wenn-dann-Beziehungen: nämlich UND, ODER und NICHT.
Dabei werden ganz einfach Input-Muster auf Outputs abgebildet, die für die jew. Verknüpfung entsprechend zu lernen wären ("Lern-Pattern") .

Ein intelligentes System muss einfach gezielt mindestens lernen können, dass bei 2 unabhängigen Eingängen
a) ein Ausgang nur true ist, wenn beide zugeordnete Eingänge gleichzeitig true sind (UND)
b) ein Ausgang nur true ist, wenn mindestens einer der beiden zugeordneten Eingänge true ist (ODER)
c) ein Ausgang nur true ist, wenn der zugeordnete Eingang false ist - und umgekehrt (NICHT).
(Dabei war jetzt noch nicht einmal die XOR Verkrnüpfung dabei.)

Und das muss selbstverständlich auch tatsächlich experimentell nachweisbar sein: das ist kein Paradox, sondern zwingende Vorraussetzung.
Sonst lernt das System nicht reproduzierbar Gezieltes und Nachprüfbares, sondern macht nur irgendetwas unachvollziehbar Nebulöses.

Hallo Wolfgang,

im Moment verstehe ich Dein Netz so, dass die Links die Verbindungen zwischen Neuronen sind. Da es nur 42 gibt, müssen wahrscheinlich schwächere Links von Neuronen abgezogen werden, falls ein anderes stärkere Links hat.
Den Parameter "USE" würde man in klassischen KNN meiner Meinung nach als "Gewichtsfaktoren" (überlicherweise als "weight") abgekürzt, bezeichnen.
Im Programm waren noch Fehler, die ich erst mal oben im Code korrigiert habe.

Was mich wundert, ist dass sich nur die Werte 32-35 in der Simulation ändern:
32 - src:157 dst:32 use:96
33 - src:0 dst:0 use:0
34 - src:0 dst:0 use:8
35 - src:1 dst:3 use:0

Der Wert 157 für den Link 32 kann wahrscheinlich auch nicht stimmen ( es geht ja nur bis 41 ).

Moin stochri,

richtig. Links verbinden Neuronen. Schwächere Links können verkümmern mit der Prozedur "gi_verlerne()", die aber bei Dir noch nicht genutzt wurde. Use ist Gewichtung. Den "157"-Fehler kenn ich nicht.

--------------

Moin Helmut

Zitat:

---

Stattdessen solltest du nur zeigen, dass dein GI überhaupt in der Lage ist, simpelste logische Verknüpfungen darzustellen und zu lernen, welche als Basis der Booleschen Aussagenlogik (Boolesche Algebra) auch gleichzeitig Basis jedes logischen Verhaltens ist und aller wenn-dann-Beziehungen: nämlich UND, ODER und NICHT.
Dabei werden ganz einfach Input-Muster auf Outputs abgebildet, die für die jew. Verknüpfung entsprechend zu lernen wären ("Lern-Pattern") .

---

Das nenne ich "Dekoder bauen". Logische Verknüfungen haben m.E. in der Form der boolschen Algebra im GI-System nichts zu suchen.

Dekodierung bzw. Mustererkennung gehört nicht auf die erste(n) Zellschichten einer KNN, sondern ist eine sehr hohe Abstrahierung.

----

Zellen kennen kein NOT, XOR und noch nicht mal ein stabiles AND. Sehr wohl aber ein OR. Und noch ein paar andere Funktionen, die es nun wiederrum in der boolschen Algebra nicht gibt.

Über solche fundamentalen Dinge würde ich mich mit Euch viel lieber unterhalten.

Aber Helmut kommt aus seiner engen Mustererkennung nicht raus und stochri hat komische Fehler mit GI-Derivaten auf anderen Plattformen.

Beides bringt mich zur Zeit nicht voran. Ich zieh mich mal ein paar Tage aus dem Forum zurück, bis ich liefern kann.

Viele Grüße

Wolfgang

Zitat:

---

Aber Helmut kommt aus seiner engen Mustererkennung nicht raus und stochri hat komische Fehler mit GI-Derivaten auf anderen Plattformen.

---

Deshalb wäre es ja gut, wenn wir eine gemeinsam funktionierende Softwarebasis haben. Denn ich bin vorwiegend mit Fehlersuche statt mit dem eigentlichen Problem beschäftigt, was mich auch daran hindert, weiterführende Gedanken zum Thema zu äußern. Ich sehe einige Dinge bei deinem Verfahren, die man verbessern könnte. Dazu will ich mich aber erst äußern, wenn der Algortihmus auch so läuft wie mit deinem PIC.
Normalerweise entwickle ich meine Algortihmen selbst, auch weil es mühselig ist, sich in anderer Leute Gedanken einzuarbeiten. Ich habe es mal angefangen, Dein Programm zu portieren, weil es vielversprechende Ansätze hat. Wenn es mich aber zu viel Zeit kostet, den Grundalgorithmus ans Laufen zu bekommen, dann lasse ich es bleiben.

Zitat:

---

Zellen kennen kein NOT, XOR und noch nicht mal ein stabiles AND. Sehr wohl aber ein OR. Und noch ein paar andere Funktionen, die es nun wiederrum in der boolschen Algebra nicht gibt.

---

selbstverständlich kennen Zellen UND, ODER und NICHT:
Es gibt hemmende und aktivierende Neurotransmitter in Synapsen für hemmende Zwischenneuronen oder Reflexbögen und aktivierende Zwischenneuronen oder Reflexbögen, sodass das Aktivierungspotential von Zellen bereits angehoben sein kann für eingehende Signale (ODER) oder abgesenkt, damit es erst bei mehreren ± gleichzeitigen Signalen zur Aktivierung kommt (UND) oder eine Aktivierung ein hemmendes Zwischenneuron trifft (NICHT): genau so lässt es sich aussagenlogisch strukturieren!
a XOR b
ist wiederum nichts anderes als
(a UND ^b) ODER ( ^a UND b)
Deine Unkenntnis physiologischer Vorgänge und aussagenlogischer Prinzipien ist wirklich erschreckend.
Gerade die Erkenntnis über diese Zusammenhänge hat ja gerade die Konstruktion von Perzeptronen angestoßen (Eingänge, Eingangsgewichte, Eingangssummation, Schwellenwert, Aktivierungsfunktion), auch wenn es sicherlich auch anders geht (McCulloch-Pitts-Neuronen oder analog oder wie auch immer).

Auch für andere lösbare Probleme wie in der Analysis oder der Algebra ist es hilfreich, wenn man die Grundrechenarten und die Mengenlehre beherrscht (eine Boolesche Algebra mit UND und ODER bildet ebenso einen mathematischen Ring wie die Ganzen Zahlen mit + und *, beides ist elementare, universelle Mathematik, an der weder unbelebte Materie (wie Computer) noch lebende Zellen (wie in Gehirnen) vorbei kommen!), und gleiches gilt für die Grundlagen der Anatomie und der Physiologie, wenn man sich über natürliche neuronale Strukturen äußert.

PS, bin gerade erst ganz zufällig auf diesen Link gestoßen:
https://towardsdatascience.com/mccul...l-5fdf65ac5dd1

Hallo,

dieser entschleunigende Rückzug ins stille Kämmerlein war bisher für mich sehr wohltuend. Ich wollte mal ein kurzes Lebenszeichen senden.

-----------

Muss ich jetzt verstehen, warum Helmut mir "erschreckende Unkenntnis" vorwirft? Oder darf ich das einfach wegignorieren?

Dass sich bei Perzeptrons das AND zu einem OR verwachsen kann, hatte ich völlig richtig erkannt.

Weiterhin kennt die Natur auch kein NOT. Sie kennt sehr wohl aber ein Wegfall eines Teils einer AND-Verbindung.

Wenn wir die Mauer zum ersten Mal sehen, werden wir nicht feststellen: "Da liegt aber keine tote Katze auf der Mauer". Eine Negation ohne Kontext ist uns fremd. Wer NOT-Funktionen in Perzeptrons einbaut, hat den Schuss nicht gehört.

Sehr wohl fällt uns aber ein Stuhl auf, auf dem seit ein paar Minuten keine schlafende Katze mehr liegt. Wir haben also gelernt "Stuhl AND schlafende Katze" und wir triggern auf "Stuhl AND not(Katze)".

"Kann Dein Dekoder OR, AND und NOT?" ist also im Ansatz Humbug. Zumindest beim GI-System ist AND ein Spezialfall von ODER und NOT ist ein Spezialfall von AND. Das hat mit Zufälligkeiten usw. nichts zu tun. Es geht schlichtweg darum, eine "natürliche" Logik zu entwickeln. Die boolsche Algebra ist nicht natürlich. Die kommt in mein GI-System nicht rein.

Ich will mir diese Gedanken machen dürfen!

---------

@stochri:

Zitat:

---

Denn ich bin vorwiegend mit Fehlersuche statt mit dem eigentlichen Problem beschäftigt.

---

Ich hab hier stets nur Software hochgeladen, die das jeweils in den Beiträgen und Dumps beschriebene auf einem PIC12F629 tut. Also exakt das fehlerfrei tut, was ich beschrieben hatte.

Ich hatte Dich weder gebeten noch sollte es nötig sein, irgendwelche Fehler zu beseitigen, wenn man die jeweiligen Beispiele exakt so laufen lässt, wie ich sie hochgeladen hatte.

Weiterhin hatte ich mehrfach geschrieben, dass ich zwar Verständnis für Neugierde hab, aber eben auch keinerlei Versionspflege betreibe. Wenn Du also einen Fehler in einer zwei Tagen alten Software findest, dann schenk ich ihn Dir. Ich kann ihn nicht mal mehr nachvollziehen, weil ich mittlerweile die Software weiterentwickelt hab. Und ich will ihn auch nicht nachvollziehen, weil mich zur Zeit nur meine Plattform interessiert.

----------

Ich hab den Fehler gemacht, dass ich meine bisherige 2,5-wöchige Einarbeitung ("Registriert seit 07.11.2019") in das GI-Thema hier im Forum dokumentiert hab.

Anyway....

Ich entwickele trotzdem in aller Seelenruhe in genau meinem Tempo weiter und schreib die nächsten Tage die PDF zusammen. Sobald ich die fertig hab, stell ich die hier als ersten Milestone rein.


Viele Grüße

Wolfgang

ok, ich sehe schon: es ist schwer, ein Glas zu füllen, das bereits voll ist...
Es soll ja auch immer noch Leute geben, die die Quadratur des Kreises beweisen wollen (obwohl es mathematisch definitiv bewiesen ist, dass es nicht geht) oder die ein Perpetuum mobile zum Patent anmelden wollen (obwohl es durch den Energieerhaltunssatz bewiesen ist, dass es nicht geht) ;)
Aber es st ja nicht verboten, dazuzulernen - vlt wird dir ja noch irgendwann klar, was Boolesche Aussagenlogik ist und warum sie gültig ist, und zwar im gesamten Universum, genau wie auch das Kleine Einmaleins 8)

Aber mach mal... ;)

Hallo,

wer hat jetzt Recht und wer bekommt seine Ruhe? Hier mal eine andere Meinung zu dem Thema.

Das "GI"-System ist ein weiterer Versuch von hunderten oder tausenden, ein Neuronales Netzwerk zu erstellen.
Ich sehe den Fehler, das ein Neuronales Netz mit Intelligenz gleichgesetzt wird.
Das beides hat aber wenig miteinander zu tun. Dagegen sollte auf die Verarbeitung von Daten gesetzt werden,
weil es das ist, was Intelligenz am Ende ausmacht. Nicht nur die Menge der Daten, die gespeichert und zur Verarbeitung zur Verfügung steht,
sondern vor allem die Art und Weise der Verarbeitung. Das Reduzieren auf das Wesentliche, um Verarbeitung auf jede erdenkliche Art und Weise
zu ermöglichen. Ganz wichtig für Intelligenz ist zudem Abstraktion. Das ist eins der wichtigsten Prinzipien überhaupt. Deshalb erstaunt es auch nicht,
dass man dies in künstlich neuronalen Netzen wiederfindet, die ja versuchen, das menschliche Gehirn nachzubilden.
Künstlich neuronale Netze sind sehr alt und werden dauernd weiterentwickelt. Sie können vor allem eines, Muster erkennen. Das geschieht durch
tausend- oder millionenfaches Training. Das, was ein KNN in einem solchen Fall kann bzw. tut, könnte auch auf andere Weise programtechnisch entwickelt
werden.


Jetzt zu versuchen, aus ein paar künstlich nachgebauten Neuronen eine Intelligenz zu entwickeln, wird nicht funktionieren. Ansatzweise kann
aber mit so ein paar künstlichen Neuronen intelligente Verarbeitung "versucht" oder demonstriert werden, ohne aber Anspruch auf eine Intelligenz
zu erheben, die zu "Überwältigendem" fähig ist. Wahrscheinlich hält es der Definition von Intelligenz im menschlichen Maßstab auch nicht stand.


Es gibt Forschung in die Richtung der exakten Nachbildung menschlicher Neuronen und was damit zu tun hat, auf künstlicher Basis. Was durchaus extrem
sinnvoll ist. Denn dadurch kann es eines Tages möglich werden, dass man Menschen mit Verlust an Gehirnmasse (z.B. Schlaganfälle und Unfälle) durch
ein Implantat helfen kann. Es wäre denkbar, z.B. nach einem Schlaganfall, das im Gehirn entstandene Loch mit einem Implantat zu ersetzen, das
von wenigen Quadratmillimeter bis Quadratzentimeter groß sein kann. Die abgestorbene Gehirnmasse wird abgebaut und das hinterbliebene Loch schließt sich.
Da das Gehirn in der Lage ist, sich umzuorganisieren und gerade in der ersten Zeit, nach aufgetretenen Defekten, schnell neue Verbindungen zwischen
den Zellen herzustellen (ähnlich, wie bei einem Kleinstkind), könnte ein künstlicher Speicher, der so funktioniert, wie menschliche Gehirnmasse,
von dem Organ "Gehirn" assimiliert werden. Es ist aber völlig unklar, wie sich das Gehirn umorganisieren wird und wie ein künstlich eingebrachtes Netz
überhaupt genutzt würde oder ob das alles nicht doch noch viel komplizierter ist, als man sich das heute vorstellen kann. Die Forschung geht schon länger
auch in diese Richtung, Neuronen künstlich nachzubauen, die in der Funktion exakt der dem organischen Vorbild entsprechen, inkl. Signale und deren Stärken.


Die CPU als solches besitzt bereits Strukturen zur Verarbeitung und Milliarden Transistoren, die vernetzt sind. Alle Grundmechanismen, auf denen komplexe
Intelligenz basiert, sind bereits in einer heutigen CPU vorhanden. Neuronale Netze können direkt auf Siliziumscheiben nachgebaut werden, ohne, dass eine
CPU im Hintergrund für die Verarbeitung sorgt, was nebenbei auch sehr energieaufwendig ist.


Wenn man davon absieht, dass die Neuronen Mustererkennung lernen sollen oder meinetwegen auch die XOR-Wahrheitstabelle: was sollen sie denn dann lernen?
Auf ein bestimmtes Eingangsmuster eine bestimmte Reaktion zeigen oder eine unbestimmte/nicht vorhersehbare Reaktion zeigen? Irgendwie muss es schon
eine "Grundfunktion" geben, damit zielgerichtetes Lernen möglich ist und nicht nur Chaos. Und das bieten die KNNs, mit denen Mustererkennung möglich ist.
Jedes Lebewesen funktioniert so, dass es auf seine Umwelt reagiert, also lernt, wie es mit den Umweltreizen umgeht. Deshalb entwickelt sich das
Projekt "GI" zu einem KNN, wie auch immer das versucht wird. Deshalb überschneiden sich hier auch die Meinungen, über das, was notwendig und sinnvoll ist.
Natürlich ist es bildlich schön gesprochen, dass "GI" auf "Futter" reagieren soll und also ein "Bein" krumm macht. Das ist aber auch nur eine andere Art und Weise,
zu sagen, dass am Eingang eines KNN eine "1" statt einer "0" vorliegt und der Ausgang an Bit#X dann auch aus der "0" eine "1" machen soll.


Gruß

Rumgucker:

Zitat:

---

Muss ich jetzt verstehen, warum Helmut mir "erschreckende Unkenntnis" vorwirft? Oder darf ich das einfach wegignorieren?

---

Der Link von Helmut ist ziemlich gut, aber Du darfst es trotzdem wegignorieren. Die zu starke Fokusierung auf die Mathematik und das sogenannte "XOR"-Problem war nämlich die Ursache, dass die KI-Forschung für rund 20 Jahre in den sogenannten "KI-Winter"

https://de.wikipedia.org/wiki/KI-Winter

geschickt wurde, weil die Forschungsmittel massiv gekürzt wurden. Der KI-Winter wurde durch die Erfindung des Back-Propagation-Algorithmus beendet

Zitat:

---

Ich hab hier stets nur Software hochgeladen, die das jeweils in den Beiträgen und Dumps beschriebene auf einem PIC12F629 tut. Also exakt das fehlerfrei tut, was ich beschrieben hatte.

---

Es geht mir nicht um die Kritik an Deiner Software, die Wahrscheinlichkeit ist nicht ganz klein, dass die Fehler in meiner Implementierung liegen.
Damit ich mit Dir kommunizieren kann, brauche ich aber eine funktionierende Version. Meiner Meinung nach kostet die Kommunikation mit anderen immer Zeit, aber bringt einem oft auch weiter.

Das Forum ist genau dazu geeignet, Sachen zu diskutieren die dem einzelnen mehr oder weniger klar sind, und gemeinsam Lösungen zu finden, oder auch nur einen nächsten Schritt in Richtung einer Klärung.
Dabei diskutieren oft auch Teilnehmer, die es unterschiedlich gut verstehen, sich an einer solchen Diskussiuon zu beteiligen.
Als Maßstab hierfür kann immer wieder dienen, zwischen der Beurteilung von Argumenten und der Beurteilung von Personen zu trennen. Damit kommt man erst einmal schon recht weit.
Das ist eigentlich gut verständlich, kann aber doch aktuell immer wieder eine Hilfe sein.