GI = Guckis Intelligenz

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