Neuronale Netze Editor und SImulator

[Friggle]

Im Download Bereich liegt seit heute eine neue Version von MemBrain, die ein erweitertes Neuronen- und Linkmodell unterstützt. Die Links haben jetzt auch funktionale Längen, man kann sehen, wie Aktivitätsmuster zwischen den Neuronen hin- und herflitzen und das ganze kann nun wesentlich mehr zeitabhängig gestaltet werden.

Also wer Lust hat: Einfach ausprobieren.

Grüße,
Friggle

[Freiheitspirat]

Hey Friggle, super interessant !
Ich würde das Programm gerne mal für ein paar Aufgaben auf meinem Roboter nutzen, aber da brauche ich dringend ein Interface von den IO-Neuronen zu meinen Hardwaretreibern.
Braucht gar nicht so aufwendig sein, nur z.B. irgendwie defininieren welche Message bei einem Outputneuron "gefeuert" wird, bzw. wie ein Event ein Input-Neuron setzt...

[Friggle]

Ja, das mit der Anbindung an die "echte Welt" steht jetzt so langsam als nächstes an. Muss allerdings wie immer schauen, wann ich Zeit dazu finde...
Eigentlich schwebt mir dazu ein universelles Treiberkonzept vor, das ist im Moment allerdings noch alles andere als ausgegoren, da muss ich erst noch ein bißchen über der Softwarearchitektur grübeln...

Hast Du schon eine bestimmte Vorstellung davon, welche Aufgaben ein NN in Deinem Roboter übernehmen könnte? Denkst Du an ein "Hybrid"-Konzept aus NN und klassischer KI oder an ein vollständig NN gesteuertes Vehikel?

Grüße,
Friggle

[Freiheitspirat]

Mehr an ein Hybrid-Konzept.
Ich habe ein paar kleine Treiber gebaut, die einzelne "intelligente" Aufgaben haben.
Bsp.: ein Ultraschall-Entfernungs-Modul; Liefert in einem Output-Register permanent die aktuelle Entfernung, hat ein Input-Register für einen Schwellenwert und feuert "automatisch" eine Message bei Schwellenwertunterschreitung.
Wenn jetzt so ein "Event" auftaucht, soll das NN diese Situation "verarbeiten", also z.B. mit Entfernungen anderer Entfernungs-Module abgleichen und daraus Richtung bestimmen.
Später dann vieleicht Abgleich mit einem Umgebungskartenmodul (XY-Array) für die Objekterkennung...
Ein Beispiel für eine Ausgabe könnte einfach eine Message an einen Motortreiber sein: "Output-Neuron Linksdrehung" sendet einfach einen vordefinierten Message-String an einen entsrechenden Port, hinter dem ein Modul die Anweisung in die Steuerung der Schrittmotoren umwandelt.

Letztlich brauch man pro Schnittstellenneuron neben dem eigentlichen Wert, eine Datenaustauschart, einen Empfänger (Port) und ein "freidefinierbares" Messageprotokoll.

Also z.B.
Art = "TCP"
Port = 4711
Message = "Befehlzumlinksdrehen"

Wenn Art = "TCP"
ConnectWinsock(Port)
Send Message
...

[Friggle]

Hallo Freiheitspirat,

ja, ich denke auch die Anbindung über einen Socket wäre die zunächst wichtigste, dann könnte man auch problemlos über WLAN auf andere Rechner zugreifen (z.B. Laptop auf dem Roboter, gesteuert über PC sonst wo) etc.
Muss mich allerdings erst noch in die Socket-Programmierung einarbeiten, MSDN bietet hier zwar einiges an Doku über die konkrete Verwendung der entsprechenden MFC-Klassen, aber es fehlt mir so ein bisschen an Netzwerk-Hintergrundwissen. Hast Du vielleicht einen guten Link oder Büchertipp hierzu?

Finde natürlich auch selber was, nur mit guten Tipps ist es immer deutlich effizienter...

Grüße,
Friggle

[Freiheitspirat]

Fürs rein Technische vieleicht erstmal so was:
http://download.pearsoned.de/leseeck...data/kap20.htm
Oder ist das zu Oberflächlich ?

Wenn es an ein irgend geartetes Protokoll geht, sollten wir dazu hier nochmals ein paar Ideen austauschen...

[Friggle]

Ist gar nicht so übel für einen Einstieg, jedenfalls wenn man bzgl. Netzwerktechnologie so unbeleckt ist, wie ich. Das Wesentliche ist drin und ich denke auch genug, um für meine Anwendung weiterzudenken, vielen Dank auch, Freiheitspirat!

Bzgl. eines App. Layer Protokolls muss ich sowieso noch ein bißchen grübeln... Neben der Anbindung von Sensorik und Motorik sollte es auf jeden Fall auch erlauben, mehrere Instanzen von MemBrain zu größeren Netzen auf verschiedenen Rechnern verteilt zusammenzulinken. Somit sollte es wohl wirklich möglich sein, für jedes I/O Neuron einen eigenen Port festzulegen. Auf der anderen Seite möchte ich auch die Möglichkeit bieten, mehrere I/Os über den selben Port laufen zu lassen, wenn sie sowieso an den selben Addressaten gehen (oder von diesem kommen), da dies bestimmt wesentlich performanter ist.
Auch die Frage bzgl. Server oder Client läßt sich wohl nicht so auf die Schnelle und einheitlich klären, das sollte man vielleicht sogar für Gruppen von Neuronen unterschiedlich festlegen können, inkl. Servernamen im Falle eines Clients natürlich.
Hinzu kommt, dass ich den Benutzern von MemBrain möglichst viel Freiheit beim Gestalten des Protokolls geben möchte, vielleicht sogar die Möglichkeit, für verschiedene I/O Neuronen unterschiedliche Protokolle zu definieren, da sie vielleicht mit verschiedenen Anwendungen kommunizieren müssen.

Werde mir wohl erst einmal alle Anforderungen an ein Protokoll- und ein Verbindungsmanagement aufschreiben müssen, damit das von vorn herein ein sauberes Konzept ergibt.

Auf jeden Fall möchte ich das Protokoll schlank halten bzw. zumindest ermöglichen, auch ein schlankes zu definieren, wenn man das möchte. Deshalb muß es die Möglichkeit bieten, Floating Point Zahlen und Neuron-IDs effizient zu übertragen. Damit sollte es nicht auf Text-Repräsentation beschränkt sein, sondern auch binär arbeiten. Außerdem sollte man kompakte Start/Stop Sequenzen definieren können, nach denen sich sicher synchronisieren lässt (z.B. DLE/STX, DLE ETX mit DLE Verdopplung o.ä.). Auch eine Fixed-Point Formatierung sollte man in Betracht ziehen, schließlich braucht man keinen riesigen Wertebereich...
Vielleicht möchte man in manchen Fällen sogar nur binär ("= feuern") übertragen, was man mit noch weniger Daten übertragen könnte.

Ich freue mich jedenfalls weiterhin über jeden Input, schließlich will ich so viele unterschiedlich Anforderungen wie möglich unter einen Hut bringen, damit das Programm auch in der Praxis einsetzbar wird!

Grüße,
Friggle

[Freiheitspirat]

Hier noch ein paar Ideen:

- Mehrere Instanzen von MemBrain sowohl auf einem Rechner, als auch auf mehreren Rechnern verteilt.

- Relationale Verknüpfungen der Instanzen bzw. der entsprechenden Steuerprogramme

- Dynamische DLL - Schnittstelle
- Output-Schnittstelle zum Starten eine .EXE mit Parametern

Betr.:Client / Server
Bei Zentralistischen Systemen werden die Verbindungen von einem Server auf mehrere Clients organisiert.
So z.B. auch bei ssmirs von Johannes/mindrobots wo alle Module sich als Clients an ein "Obermodul" anmelden und dieses die einzelnen Messages deligiert.
Ich würde mehr ein relationales System bevorzugen, bei dem eine freie Wahl zwischen Client/Server-Status gewählt werden kann.
Bevorzugt sollte dabei ein Modul, welches Output-Informationen liefert als Server angesehen werden und eines, welches Input-Information benötigt, als Client - Information ist eine Holschuld !

Protokolle:
Das einfachste Protokoll ist sicherlich ein "Beep" / "feuern"
Dann ein Übermitteln von Einzelwerten (in welcher Darstellung auch immer)
Dann die Übermittlung einer Kombination aus Konstanten/Text und Werten
Dann die zusätzliche Integration von Steuerbefehlen (z.B.:Start/Stop)
Bis hin zu einem Schichtenmodell (siehe z.B.: ISO/OSI)

[Friggle]

Also soviel ist mir schon klar: Was ich auf keinen Fall will, ist irgend eine Art "Zentralserver" o.ä. Alle Teilnehmer müssen gleichberechtigt sein, völlig egal, wo Sie laufen und wie Sie konfiguriert sind. Möglichst sollten sie auch gar nichts voneinander wissen, ein völlig verteiltes System von gleichberechtigten Makro-Einheiten, egal ob es sich um MemBrain Instanzen, I/O Treiber oder sonstwas handelt.
Das ist mir auch aus Gründen der Fehlertoleranz des Gesamtsystems sehr wichtig. Wenn irgendwelche Teilnehmer nicht erreichbar sind, oder permanent Übertragungsfehler haben, so sollte das die anderen nicht stören.

Ich gehe mit Dir D'Accord, daß zumindest bzgl. der Verbindungsanfrage die Inputs die Clients und die Outputs Server sind. Wahrscheinlich ist es ausreichend, einen Listening-Server für alle Outputs eines Netzes zu haben, d.h. einen Server Port (und ggf. eine IP-Adresse im Falle mehrerer Netzwerkkarten) für jede MemBrain Instanz, soweit ich das bis jetzt überblicke.
Ob die Clients die Output-Daten des Servers dann zyklisch abfragen müssen, oder automatisch permanent gesendet bekommen, weiß ich noch nicht. Abfragen hat natürlich den Vorteil, dass man einen Client nicht mit Daten zuballert, die er u.U. so schnell gar nicht verarbeiten kann...

Bei den Input Neuronen müsste ich dann wohl soweit gehen, dass man für jedes die IP-Adresse und den Port angeben kann auf die es verbinden soll sowie natürlich eine ID oder einen Namen des Output Neurons von dem es input erhalten soll. Am besten sollte ein input Neuron sich sogar mit mehreren Servern und/oder Neuronen verbinden können, im lokalen NN kann es schließlich auch Signale von vielen anderen Neuronen erhalten.
MemBrain (und jeder andere Teilnehmer) muss dann eben so schlau sein und erkennen, welche Inputs auf den selben Server gehen und die Datenübertragung für diese über einen einzigen Socket abwickeln (aus Performanzgründen), das sollte ja aber kein größeres Problem sein.

Ich denke, es wäre für's erste doch eine Option, das Protokoll festzuschreiben. Erweiterungen über zwischengeschaltete Konverter sind dann schließlich immer noch möglich.

Was möchtest Du mit einer DLL Schnittstelle erreichen? Möchtest Du DLLs für unterschiedliche Protokolle einbinden oder woran hast Du dabei gedacht? Auch die .Exe Start-Option habe ich noch nicht ganz begriffen. Meinst Du das Starten einer Exe durch ein Output-Neuron getriggert? Wäre natürlich auch eine Idee, die relativ "kostengünstig" zu implementieren ist.

Brainstorming:


Wenn ich mit mehreren Internet-Explorer-Instanzen gleichzeitig surfe, dann gehen alle Anfragen von mir und meinen Browser-Fenstern über den selben Port ab (80 oder 8080), gerichtet an den Standard-Port des Dienstes, den ich von dem Server erwarte (80 oder 8080), und dann mit dem Hinweis, auf welchem Port meine jeweilige IE-Instanz die Antwort vom Server erwartet (irgendein Port jenseits der 4000-Grenze). So müsste MemBrain mit mehreren Instanzen doch auch agieren.

Eigentlich wäre doch zu überlegen,ob die Netzwerkwege sich nicht irgendwie als Links in MemBrain verstehen lassen. Sozusagen mit variabler Länge (je nach momentaner Internet-Geschwindigkeit). Uuhh, dann stellt sich die Frage, wie man ein Netz, das sich auf diverse PCs verteilt, die zwar übers Netz verbunden sind, trainiert.

Ich würde es mal so formulieren: Andauerndes Abfragen der Clients im Netz führt dazu, daß jeder Client dauernd in der Gegend rumschreit, ob einer im Netz ihm was gesagt hat. Clients müssen schnell genug sein, die Infos, die sie bekommen, entgegenzunehmen (Vielleicht könnte man ja doch was drehen an der Priorität von MemBrain, damit auch stärkerer Netzwerkverkehr noch durchkommt). Wenn die Clients ein Datenpäckchen bekommen und zu beschäftigt sind, dann geht es besser
verloren, find ich.

Ein (MemBrain-)Netz über ein (TCP-)Netzwerk zu verteilen, stößt meiner Ansicht nach an schon fast philosophische Grenzen. Wie will man das bei unbekannten Laufzeiten zwischen den Teilnetzen je trainieren? Interessant auf jeden Fall...

Die Werte der IO-Neuronen übers Netz zu senden/empfangen ist in dieser Hinsicht wohl machbarer. Die Frage ist doch, wer deutet die Werte? Der Sender oder der Empfänger?
MemBrain kann doch nur die Output-Daten senden, die Output-Neuronen liefern, nämlich ihren Namen und ihren Zustand. Andere Daten sind nicht vorhanden.
Die Deutung, daß z.B. Start "1" bedeutet und Stop "0", kann man dem
Client oder jedenfalls der Gegenstelle überlassen.

Andererseits könnte man es auch so angehen, daß es bei MemBrain eine
Programmerweiterung gibt (Jippieh), bei der ich explizit definieren kann,
(Alarmanlage-Beispiel) wenn das Output-Neuron den Wert 1 erreicht, dann starte diese .exe oder .bat Datei oder schicke den Befehl "Einbruch_Vollzogen" an die IP-Adresse und diesen Port (mit dem und jenem Protokoll, die wissen dann schon, was mit anzufangen).
Genauso könnte es bei Input-Neuronen laufen, aber wahrscheinlich viel komplizierter.
Da könnte man ja rumspinnen mit Bildimporten, die man in Echtzeit auf ein Netz loslässt, Pixel für Neuron, um Signale einer Kamera auszuwerten, lauschen auf dem MemBrain-Port auf eingehende neue Werte für die und die Neuronen u.s.w.