Diplomarbeit Der Vergleich von plastischen Synapsen gegenüber ...

Diplomarbeit
Dietmar Jung
Der Vergleich von plastischen Synapsen
gegenüber Synapsen mit konstantem Gewicht
in spikenden neuronalen Netzen
TU Berlin, Institut für Mikroelektronik
Betreuer: Dipl. -Ing. Nasser Mehrtash
Prof. Dr.-Ing. Heinrich Klar

1. Einleitung................................................................................................................ 3
2. Das biologische Neuron.......................................................................................... 6
2.1 Der Aufbau eines Neurons ..................................................................................................6
2.2 Das Ruhepotential ...............................................................................................................8
2.3 Das Aktionspotential ...........................................................................................................8
2.4 Die Fortpflanzung des Nervensignals entlang des Axons ...................................................9
2.5 Die Myelinhülle.................................................................................................................10
2.6 Die Impulsverarbeitung .....................................................................................................11
3. Pulscodierte Neuronale Netze............................................................................... 12
3.1 Das Marburger Neuronen Modell......................................................................................12
3.2 Das Feedingpotential.........................................................................................................13
3.3 Das Linkingpotential .........................................................................................................13
3.4 Das Membranpotential und der Schwellwert ....................................................................14
3.5 Die Fähigkeiten des Marburgersystems ............................................................................14
4. Synapsenplastizität ............................................................................................... 15
4.1 Modellierung der Synapsenplastizität ...............................................................................15
4.2 Depression oder Facility-Verhalten ...................................................................................16
4.3 Die Testumgebung.............................................................................................................18
5. Anwenderhandbuch .............................................................................................. 19
5.1 Programmstart ...................................................................................................................19
5.2 Menüeintrag Datei.............................................................................................................19
5.3 Menü Netz .........................................................................................................................20
5.3.1 Populationsanzahl...............................................................................................20
5.3.2 Neuronparameter ................................................................................................20
5.3.3 Dendritparameter ................................................................................................20
5.3.4 Netz erstellen ......................................................................................................22
5.3.4.1 Netztopologie......................................................................................................22
5.3.5 Start.....................................................................................................................24
5.4 Menü Option......................................................................................................................24
5.4.1 Hebb....................................................................................................................24
5.4.2 Neuronenkontrolle ..............................................................................................24
5.4.3 Inhibitionsverstärkung ........................................................................................25
5.4.4 Globale Inhibition...............................................................................................25
5.4.5 Neuron wählen....................................................................................................25
5.4.6 Potential darstellen..............................................................................................25
5.4.7 Population wählen ..............................................................................................25
5.4.8 Netzausgabe sichern ...........................................................................................26
5.4.9 Einzelschrittsimulation .......................................................................................26
5.5 Menü Bildfolge..................................................................................................................26
5.5.1 Bildfolge ein / aus...............................................................................................26
5.5.2 Bildwahl..............................................................................................................26
5.6 Menü Darstellung ..............................................................................................................26
5.6.1 Zeit......................................................................................................................27
5.6.2 PSP......................................................................................................................27
5.6.3 Bildgröße ............................................................................................................27
5.6.4 Reiz - Skalierung ................................................................................................27
5.7 Menü Debug ......................................................................................................................27
5.7.1 Schreibe Vorwärtsverbindungen .........................................................................27
5.7.2 Schreibe Rückwärtsverbindungen ......................................................................27
5.7.3 Schreibe Neuronenkontrolle ...............................................................................27
5.7.4 stat. Neuron-Daten..............................................................................................27
5.7.5 Speicherbelegung................................................................................................28
SpinnSoftSim 1

6. Programmierhandbuch.......................................................................................... 29
6.1 Die Programmiersprache C++...........................................................................................29
6.2 Die STL-Bibliothek...........................................................................................................29
6.3 Die graphische Benutzeroberfläche - Qt............................................................................30
6.4 Qt-Architect.......................................................................................................................30
6.5 Makefile - und Arbeitsumgebungs- Erstellung..................................................................31
6.6 Benötigte Bibliotheken zur Laufzeit .................................................................................31
6.7 Die Programmstruktur.......................................................................................................31
6.8 Definition der Vorwärtsverbindungen ...............................................................................32
6.9 Definition der Rückwärtsverbindungen.............................................................................32
6.10 Beschreibung der einzelnen Klassen .................................................................................34
6.10.1 check...................................................................................................................34
6.10.2 conback...............................................................................................................35
6.10.3 confront...............................................................................................................36
6.10.4 confrontit.............................................................................................................36
6.10.5 dendrite ...............................................................................................................36
6.10.6 dlgctrlchoosepop................................................................................................37
6.10.7 dlgctrldend ..........................................................................................................37
6.10.8 dlgctrldyneu ........................................................................................................37
6.10.9 dlgctrlhebb ..........................................................................................................37
6.10.10 dlgctrlneuron.......................................................................................................38
6.10.11 dlgctrlpop............................................................................................................38
6.10.12 dlgctrlsstep..........................................................................................................38
6.10.13 drawfield .............................................................................................................38
6.10.14 globalinhib ..........................................................................................................39
6.10.15 MainWin .............................................................................................................39
6.10.16 markram..............................................................................................................39
6.10.17 markramdata .......................................................................................................40
6.10.18 net .......................................................................................................................41
6.10.19 neurodisp.............................................................................................................42
6.10.20 neuron .................................................................................................................43
6.10.21 piccourse.............................................................................................................43
6.10.22 picture .................................................................................................................43
6.10.23 population ...........................................................................................................44
6.10.24 spinnsoftsim........................................................................................................45
6.10.25 spinncheck ..........................................................................................................45
7. Auswertung........................................................................................................... 46
8. Zusammenfassung ................................................................................................ 48
9. Anhang verwendete Literatur ............................................................................... 50
SpinnSoftSim 2

1. EINLEITUNG
An der Entwicklung künstlicher Neuronaler Netze sind verschiedenste Arbeitsgruppen
beteiligt, welche man in zwei Bereiche aufteilen kann. Zum einen erfolgt die Entwicklung
durch Ingenieure und Informatiker, deren Ziel eine Leistungssteigerung der
Computer durch Annäherung an das biologische Vorbild ist. Diese ist gerade im Bereich
der Mustererkennung, einer Sparte der Bildbearbeitung, gewünscht. Die andere Gruppe
besteht aus Neurobiologen, Psychologen und Medizinern, die unter Verwendung einer
Simulation die Vorgänge im Nervensystem besser verstehen können.
Informationstechnische Ansätze dienen zur Bewältigung bestimmter Klassen von
Aufgaben und folgen nicht immer dem biologischen Vorbild, Lernfähigkeit und Qualität
der Wiedererkennung sind hier von Interesse. Ihre Aufgaben sind im Bereich der
Mustererkennung, Szenensegmentierung, Erkennung von transformierten oder unvollständigen
Mustern, Änderungen im Bild durch Bewegung und Überlappung von Objekten
zu finden. Die im Gebiet der Mathematik beschäftigten Wissenschaftler erforschen
Neuronale Netzwerke, um Aussagen über deren Stabilität und Lernfähigkeit zu finden.
Der Bereich der Elektrotechnik stellt spezialisierte Hardware zur Verfügung, mit deren
Verwendung eine schnellere Simulation gegenüber reinen Software-Simulationen erfolgen
kann. Bei Neurobiologen steht die Ähnlichkeit des Modells zum biologischen
Vorbild im Vordergrund. Hier werden Modelle erstellt, deren Simulation beim Verständnis
von noch ungeklärten Eigenschaften des Gehirns helfen sollen. Psychologen
sind an der Simulation von Wechselwirkungen einzelner Bereiche des Gehirns interessiert.
Die Arbeitsweise eines Neuron läßt sich wie folgt beschreiben. Es empfängt die Informationen
von den Synapsen der vorgeschalteten Neuronen. Die Synapsen schütten
ihre Neurotransmitter aus, und die Neurotransmitter setzen sich auf die Rezeptormoleküle
des Dendriten. Es öffnen sich die Kanäle in der Membran des Dendriten und es
kommt zu einem Ionenstrom. Das postsynaptische Potential des Dendriten ist von der
Ionenkonzentration abhängig. Alle eingehenden Reize, der mit ihm verbundenen Synapsen
werden von dem Dendriten addiert. Ein Neuron besitzt mehrere Dendriten (Dendritbaum),
die alle in der Soma, dem Zellkörper, zusammenlaufen. Das Ausgangssignal
wird über den Axonhügel an die Synapsen und die nachfolgenden Neuronen weitergeleitet.
"Neuronale Netzwerke" bestehen aus gleichartigen, miteinander verknüpften Einheiten,
deren Zusammenwirken Eigenschaften wie Fehlertoleranz und Lernfähigkeit
entstehen lassen. Die Vervielfältigung eines Neurons erlaubt in den meisten Fällen eine
Parallelisierung des Programmablaufs, welche hier nicht zum Tragen kommt. Parallele
Programmabläufe stellen besondere Ansprüche an die Programmierung, denn bei der
Kommunikation der Prozesse darf es nicht zu Verklemmungen kommen. Vergleicht
man die Geschwindigkeit des menschlichen Gehirns mit der Geschwindigkeit eines modernen
Rechners, so sollte der Computer dem menschlichen Gehirn überlegen sein,
denn die Schaltzeiten eines Transistors (< 10 -9 s) ist um ein vielfaches geringer, als die
der Schaltzeit einer Nervenzelle (ca. 10 -3 s). Ein Computer benötigt ca. 10 9 Transistoren
um 128 MByte an Informationen zu speichern, diese Zahl ist nicht mehr weit entfernt
von 10 11 , der Anzahl der geschätzten Neuronen im Gehirn. Im Gehirn ist eine große Anzahl
von Neuronen gleichzeitig aktiv, während in einem klassischen Computer nur der
Prozessor permanent aktiv ist. Die Anzahl der Instruktionen pro Sekunde, die Maschinenbefehle
oder die Anzahl der Schaltvorgänge der Transistoren ist nur bedingt vergleichbar
mit den Leistungen des Gehirns. Allerdings ist zu erkennen, daß eine große
SpinnSoftSim 3

Parallelität der Elemente für eine hohe Gesamtleistung des informationsverarbeitenden
Systems steht.
Als Beispiel für die Notwendigkeit der Parallelverarbeitung gilt die 100-Schritt-Regel.
Ein Mensch kann das Bild eines ihm bekannten Gegenstandes in 0,1 s erkennen. Da
ein Neuron eine Schaltzeit von 1 ms besitzt, entspricht dies einer Zahl von 100 Schaltzeiten
eines Transistors. Wenn diese Zahl auf einen Computer übertragen wird, hat dieser
gerade angefangen die Aufgabe zu bearbeiten. Dieses Beispiel besagt nichts über die
Menge der an der Erkennung beteiligten Neuronen [1].
Die ersten Neuronen-Modelle verwendeten binäre Ausgangsgrößen und analoge
Eingangsgrößen und wurden bereits 1943 von McCulloch und Pitts vorgestellt. Mit diesen
Netzwerken konnte man bereits beliebige logische Funktionen berechnen. Die Modelle
wurden durch analoge Ausgangsfunktionen erweitert, womit Feuerraten des
Neurons dargestellt werden konnten. Die Information des Neurons wird mit der Frequenz
übertragen, mit der das Neuron feuert. Unter Berücksichtigung der Geschwindigkeit
mit der die Informationsverarbeitung im Gehirn stattfindet, wurde experimentell
bestätigt, daß nicht die Frequenz eines Neurons die Information übermittelt, sondern die
Zeitpunkte des Auftretens der Spikes die Informationen darstellen. Das Potential innerhalb
des Neurons setzt sich also aus der Menge aller eingegangenen Spikes in Abhängigkeit
der Zeitpunkte ihres Auftretens zusammen [3]. Die Simulation von
biologienahen Neuronalen Netzen ist sehr rechenintensiv. Bisher realisierte Neurocomputer
sind für diese Anwendungen kaum zu verwenden, weil sie die Dynamik des Neuronenmodells
nicht repräsentieren, ihre Programmierung zu aufwendig, oder ihr Preis
zu hoch ist und damit der Grad ihrer Verbreitung sinkt. Um diese Lücke zu schließen
wird am Institut für Mikroelektronik an der TU Berlin ein Prozessor entwickelt, der die
Plastizität der Synapsen berücksichtigt. Der SPINN- (Synapsen-Plastisch Spikende
Neuronale Netze) Prozessor soll später auf einer eigenen Steckkarte in einem Standard-
PC die Simulation beschleunigen. Über eine entsprechende Software kann dann die
Konfiguration der Simulationsumgebung erfolgen. Mehrere Gruppen von Neuronen,
sogenannte Populationen, können auf diesem Board verwaltet werden. Bei Bedarf, können
mehrere Steckkarten in einen PC eingebaut werden. Diese Boards können dann miteinander
kommunizieren und man erhält einen weiteren Geschwindigkeitsvorteil.
Viele Forschungsgruppen arbeiten mit Puls gekoppelten Neuronalen Netzwerken,
ohne dabei die Synapsenplastizität zu berücksichtigen. Hier wird mit einer großen Anzahl
von Neuronen gearbeitet und diese Netze finden bereits Verwendung bei der Auswertung
von Bildern in der Brustkrebserkennung, Blutzellenerkennung und bei der
Flugzeugerkennung für Raketensteuerungen. Andere Gruppen arbeiten mit wenigen
Neuronen, die dagegen plastische Synapsen verwenden. Diese Arbeitsgruppen analysieren
das Synapsenverhalten, aber Erfahrungen mit Neuronalen Netzen mit einer großen
Anzahl von Neuronen, liegen diesen Forschungsgruppen nicht vor [5].
Um erste Eindrücke über das Verhalten von einem Neuron mit plastischen Synapsen
zu gewinnen wurde diese Anwendung erstellt. Der Einsatz von Softwareapplikationen
kann beim Design spezieller Hardware helfen, denn ein entworfenes Konzept läßt sich
in Software schneller umsetzen und leichter korrigieren, da die Auswirkungen der Änderungen
sofort sichtbar sind. Am Ende der Entwicklung hält man eine spezialisierte
Hardware in den Händen, von der man unter anderem nicht weiß, welcher Wertebereich
für Parameter reserviert werden soll. Durch diese Softwareapplikationen kann unter
Umständen Speicherplatz gespart werden, ferner kann der Chip kleiner werden und benötigt
nicht soviel Leistung. Diese Arbeit soll einen Einblick in das Verhalten von Neu-
SpinnSoftSim 4

onen mit plastischen Synapsen geben gegenüber Neuronalen Netzwerken mit
konstanten Gewichten. Es werden die Ansätze des SPINN-Konzeptes berücksichtigt,
wobei keine Software-Version des SPINN-Systems erstellt wird. Das Programm kann
leicht durch weitere Module für andere Synapsen- oder Neuronenmodelle angepaßt
werden. Die Zahl der verwendeten Neuronen richtet sich nach der Vorlage des Eingangsreizes,
einem Bild mit 256 Graustufen. Als Hintergrund wird Weiß verwendet.
Bildpixel mit der Farbe weiß, die keinen Reiz liefern, werden nicht bearbeitet. Die Anzahl
der zu bearbeitenden Neuronen wird verringert und die Simulationszeiten werden
verkürzt.
Als Neuronen-Modell wird das Modell aus Marburg von Eckhorn verwendet. Der
Hauptreiz wird von Synapsen auf dem Feedingdendriten erfaßt. Das Neuronenmodell
gestattet die Berücksichtigung der unterstützenden Wirkung von feuernden Nachbarneuronen,
womit die für die Segmentierung notwendige Synchronität erreicht werden
kann. Dieser Einfluß wirkt sich auf das Potential des Linkingdendriten aus, so daß auf
ihm eingehende Spikes die Erhöhung des Membranpotential nur unterstützen können,
indem das Potential das Neurons angehoben wird. Sind die Impulse auf dem Linkingdendriten
die einzigen Eingangssignale, dann können sie das Neuron nicht zum Feuern
bringen. Gewisse Ereignisse wirken hemmend auf das Neuron, deshalb gibt es einen inhibitorisch
wirkenden Dendriten, dessen Potential negativ auf das Membranpotential
wirkt.
Zur Darstellung der Synapsenplastizität wird das Synapsenmodell von Tsodyks und
Markram verwendet. Das Synapsenmodell berücksichtigt die Zeitpunkte der vorangegangenen
Eingangsimpulse, dadurch kann die Regeneration der Transmitterstoffe in der
Synapse, sowie die Wirkungsdauer der Neurotransmitter nach ihrer Ausschüttung berücksichtigt
werden.
Zuerst wird eine Vorstellung des biologischen Vorbildes, eines Neurons, gegeben,
an den sich dann eine detaillierte Beschreibung des verwendeten Modells anschließt.
Für die Arbeit mit dem Programm erhält der Anwender eine ausführliche Anleitung.
Nachdem eine Einführung in die Arbeitsweise des Programms erfolgte, werden die erzielten
Ergebnisse dargestellt. Für spätere Erweiterungen erfolgt eine Vorstellung der
einzelnen Softwaremodule.
SpinnSoftSim 5

2. DAS BIOLOGISCHE NEURON
Dieses Kapitel soll einen Einblick in die Arbeitsweise biologischer Neuronen vermitteln,
damit die Funktionsweise der modellierten künstlichen Neuronen besser verstanden
wird. Der Komplexitätsgrad des Gehirn liegt weit über dem anderer Organe und
wird mit der Verschaltungsvielfalt der einzelnen Nervenzellen begründet. Das Gehirn
hat einen Anteil von 2% des gesamten Körpergewichts, aber es benötigt etwa ein Fünftel
des aufgenommenen Sauerstoffes, welcher durch das dichte Adernetz im Gehirn
fließt. Kein Neuron ist weiter als 50 mvon der nächsten Ader entfernt. Ohne die Sauerstoffzufuhr
reagiert das Gehirn nach 10 s mit Bewußtlosigkeit und nach 10 min treten
bereits irreparable Schäden auf.
2.1 DER AUFBAU EINES NEURONS
Neuronen unterscheiden sich gegenüber anderen Zellformen durch die Eigenschaft
Ausläufer zu bilden, an deren Enden Verdickungen (Synapsen) sitzen. Mit diesen Synapsen
ist das Neuron in der Lage mit anderen Nerven oder Muskelzellen in Kontakt zu
treten. Neuronen haben die Fähigkeit verloren, sich durch Zellteilung zu vermehren. Ein
Neuron wird umhüllt von mechanisch stabilisierenden Gliazellen, welche auch den
Stoffwechsel des Neurons beeinflussen [7]. Sie bilden eine Grenze zwischen dem Blutsystem
und dem Gehirn. Die Neuronen werden in drei Kategorien unterteilt (Bild 1) [1].
1. Unipolare Zellen
Diese Zellen besitzen neben einem Zellkörper, auch Soma genannt und einem Zellkern
(Nucleus) nur eine Nervenfaser (Axon) als Fortsatz.
2. Bipolare Zellen
Sie besitzen gegenüber den unipolaren Zellen zusätzliche einen Dendriten zur Reizaufnahme.
3. Multipolare Zellen treten nur bei Wirbeltieren auf. Sie besizten nicht nur einen, sondern
eine Vielzahl von Dendriten.
Eine Ausnahme bildet die Purkinje-Zelle. Ihr Aufbau entspricht dem multipolarer
Zellen, aber sie besitzt weit mehr (ca. 150.000) Synapsen. Purkinje-Zellen besitzen ein
großes nachbarschaftliches Einzugsgebiet.
Bild 1. die verschiedene Arten der Nervenzellen
SpinnSoftSim 6

Ein Neuron besteht im wesentlichen aus drei Komponenten: Dendriten, einem Zellkörper
und den Synapsen. Der Zellkörper beinhaltet Organellen und Mitochondrien zur
Energieversorgung der Zelle. Der Golgi-Apparat produziert die Transmitterstoffe der
Synapsen, die bei einer Reizübertragung ausgeschüttet werden (Bild 2).
Bild 2. Aufbau einer Nervenzelle
Die Aufnahme der Eingangssignale erfolgt über die Dendriten, welche dünne
röhrenförmige, häufig stark verästelte Fortsätze der Zelle darstellen. Die Informationsweiterleitung
erfolgt über das Axon. Die Länge eines Axon kann zwischen einigen Millimetern
und einem Meter variieren. Seine Verästelung beginnt erst im Zielgebiet. An
den Enden dieser Verästelungen sitzen die Synapsen. Ein menschliches Neuron besitzt
zwischen 1000 und 10.000 Synapsen und empfängt Informationen von 2000 bis 10.000
vorgeschalteter Neuronen.
An den Enden der Nervenfasern sitzen die Endköpfchen, die Synapsen. Diese enthalten
kleine Bläschen, die den Transmitterstoff umschließen. Wenn ein Nervenimpuls
die Synapse erreicht, verschmelzen die Bläschen (Vesikel) mit der Synapsenwand, dadurch
kommt es zu einer Ausschüttung der Neurotransmitter innerhalb des synaptischen
Spaltes (Bild 3). Spezielle Rezeptoren auf dem Dendriten des nachfolgenden Neurons
binden die freigesetzten Transmitterstoffe, wodurch die Rezeptoren ihre Struktur ändern.
Die Strukturänderung läßt Ionen in den Dendriten des nachfolgenden Neurons eindringen,
und es stellt sich eine Potentialänderung ein. Die Aktionspotentiale unterliegen
dem Alles-oder-Nichts-Gesetz, entweder tritt ein Signal auf oder nicht. Dagegen sind
die Amplituden der synaptischen Potentiale variabel und liegen im Bereich zwischen
1mV und 20 mV [8]. Eine Synapse verfügt meist nur über einen dominaten Transmitterstoff.
Man unterscheidet zwei Arten der Wirkung bei der Reizübertragung: Es gibt
die erregende (exzitatorische) Wirkung von Neurotransmittern auf das Membranpotential
des nachfolgenden Neurons und die hemmende (inhibitorische) Wirkung. Die Wir-
SpinnSoftSim 7

Bild 3. Ausschüttung der Neurotransmitter
kung einer Transmittersubstanz kann in einer Nervenzelle fördernd (bahnend) und in
einer anderen Nervenzelle hemmend wirken, obwohl in einem Bereich immer die gleiche
Wirkungsweise beobachtet wurde. Unterschiedliche Rezeptormoleküle auf der
postsynaptischen Membran können diese Eigenschaft erklären.
2.2 DAS RUHEPOTENTIAL
Das Nervensignal ist ein elektrisches Signal, das durch die Bewegung von Ionen
durch Kanäle in der Membran hervorgerufen wird. Die Zellmembran ist nicht für alle
Ionen gleichermaßen durchlässig, sonst würde sich auf beiden Seiten ein Gleichgewicht
der Ionenkonzentrationen einstellen. Man kann ein Ruhepotential von ca. -70 mV messen.
Die Membran ist für K + -Ionen stärker durchlässig als für Na + -Ionen, für CL - -Ionen
dagegen fast gar nicht durchlässig. Für die verschiedenen Ionenarten liegen damit auch
unterschiedliche Konzentrationen vor. Durch aktiven Transport wird laufend Na + aus
der Zelle und K + in die Zelle befördert. Proteine dienen als Energieträger für die Pumpe
(Bild 4). Die Energieträger sind notwendig, weil sich die Wassermoleküle, durch ihre
Bild 4. Schema der postsynaptischen Membran eines Dendriten
Dipolstruktur elektrostatisch um die Ionen sammeln (Bild 5). Erst nach der Trennung
des Ions von seinen an ihm haftenden Wassermolkülen kann es die Zellmembran durchdringen
[9].
2.3 DAS AKTIONSPOTENTIAL
Empfängt das Neuron von seinen vorgeschalteten Neuronen Reize auf den Dendriten
kommt es zu einem Anstieg des Membranpotentials. Wenn ein kleiner Reiz das
Membranpotential nur gering ändert, dann klingt die Potentialerhöhung schnell wieder
ab. Kommt es zu einer starken Reizung des Neurons, ändert sich auch sein Membranpotential
entsprechend. Die Aufhebung der Ionentrennung, die Depolarisation, bewirkt
SpinnSoftSim 8

Bild 5. Dehydration von Ionen aus [9]
eine Aussendung eines Nervenimpuls. Wenn der Reiz das Schwellenpotential erreicht,
werden Na + -Kanäle aktiviert, damit steigt die Na + -Leitfähigkeit. Es kommt zu einem
Zusammenbruch des Membranpotentials und es erreicht Werte um 30 mV. Während die
Na + -Leitfähigkeit schnell wieder abklingt, steigt die Konzentration der K + -Ionen nur
langsam an. Dies ist notwendig damit sich das Ruhepotential wieder einstellt. Das Neuron
kann innerhalb der nächsten ca. 2 ms, auch nach wiederholter Reizung nicht erneut
einen Impuls senden, es befindet sich in der absoluten Refraktärzeit. Die sich anschließende
Phase bis der Schwellwert wieder seinen Ausgangswert einnimmt, wird als relative
Refraktärzeit bezeichnet. Innerhalb der relativen Refraktärzeit kann das Neuron
erneut einen Impuls aussenden, wenn das Membranpotential wieder den Schwellwert
überschreitet. Kommt es zu einem erneuten Empfang eines Nervenimpulses, können die
Synapsen nicht die gleiche Änderung am Membranpotential des nachfolgenden Neurons
bewirken, denn in den Synapsen haben sich die Transmitterstoffe noch nicht regeneriert.
Die Änderungen des Membranpotentials fallen entsprechend geringer aus.[10]
2.4 DIE FORTPFLANZUNG DES NERVENSIGNALS ENTLANG DES AXONS
Das ankommende Nervensignal bringt ein elektrisches Feld mit sich, dieses Feld
öffnet die Natriumkanäle. Durch die offenen Kanäle strömen Natriumionen in das Innere
der Zelle. Es können nicht alle Ionen passieren, dies ist abhängig von der notwendigen
Dehydrationsenergie, die Kanäle arbeiten selektiv. Das abklingende
Membranpotential führt zur Öffnung weiterer Na + -Kanäle, deshalb fließt kurzfristig ein
hoher Strom von Natriumionen in die Zelle, bis das Membranpotential einen Wert von
+30 mV erreicht. Werden die Kaliumkanäle geöffnet, strömen die Kaliumionen aus der
Zelle heraus und das Ruhepotential stellt sich wieder ein.
Entscheidend ist die Selektivität mit der die Kanäle arbeiten, damit nicht jedes Element
hindurchströmt. Die Steuerbarkeit der Kanäle ist ebenfalls ein entscheidendes Kriterium
für die Funktionsweise des Neurons, denn die Kanäle sind entweder geöffnet
SpinnSoftSim 9

oder geschlossen. Sie besitzen keine Zustände dazwischen, damit ist die Menge der einströmenden
Kalziumionen abhängig von der Anzahl der geöffneten Kanäle und nicht
von einer variablen Durchlässigkeit.
Es gibt chemisch und spannungsgesteuerte Kanäle. Chemisch gesteuerte Kanäle
werden durch Neurotransmitter gesteuert, diese heften sich an die Rezeptoren auf der
Dendritemembran, damit kommt es zu einer Strukturänderung des Rezeptors und der
zugehörige Kanal wird geöffnet. Chemisch gesteuerte Kanäle findet man in der postsynaptischen
Membran. Spannungsgesteuerte Kanäle sind für die Leitung des Nervenimpulses
im Axon verantwortlich.
2.5 DIE MYELINHÜLLE
Die Myelinhülle wird aus den Gliazellen gebildet und hat einen positiven Einfluß
auf die Leitung des elektrischen Impulses innerhalb des Axons. Die Gliazellen versorgen
das Neuron nicht mit Nährstoffen sondern geben dem Neuron auch Halt. Durch seine
elektrisch isolierende Eigenschaft spart das Neuron Energie bei der
Impulsweiterleitung ein. Die Gliazellen bedecken das Neuron nicht vollständig, sondern
entlang des Axons wird die Myelinhülle durch Raveniersche Schnürringe unterbrochen.
In den Schnürringen findet ein Natriumionenaustausch statt. Dadurch bildet
sich ein elektrisches Feld. Bei nicht myelisierten Axonen entstehen kleine Stromschleifen,
da die Isolierung fehlt und der Reiz durch die Ionenpumpen und spannungsgesteuerte
Kanäle weitergeleitet werden muß. Bei myelisierten Axonen entstehen große
Stromschleifen, durch die isolierende Wirkung der Gliazellen, denn der Stromkreis
kann erst am nächsten Schnürring geschlossen werden. Auf diese Weise, muß von der
Zelle keine Energie für die Weiterleitung des Impulses aufgebracht werden und das Aktionspotential
springt von einem Schnürring zum nächsten. Die Weiterleitung des Signals
auf dem Axon erfolgt sehr viel schneller und energiesparender als bei Zellen ohne
Myelinhülle, die nur bei Wirbeltieren zu finden ist (Bild 6).
Bild 6. Wirkungsweise der Myelinhülle
SpinnSoftSim 10

2.6 DIE IMPULSVERARBEITUNG
Der Einfluß einer Potentialänderung durch die Transmitterstoffe ist in der postsynaptischen
Membran, dem Dendriten räumlich begrenzt, d.h der Transmitterstoff hat nur
geringen Einfluß auf das Nervensignal des Axon. Nur der Einfluß vieler Synapsen kann
eine hinreichend große Spannung aufbauen, damit eine Depolarisation stattfinden kann.
Die Wirkung mehrerer Synapsen wird als räumliche Summation der Wirkungsweise der
Transmitterstoffe bezeichnet. Aber auch mehrmalige Ausschüttung einer Synapse bewirkt
eine Anhäufung von Transmitterstoffen und öffnet weitere Kanäle, die eine Änderung
des Membranpotentials bewirken. Hier wird von einer zeitlichen Summation
gesprochen. Beide Vorgänge kann man an Nervenzellen beobachten und sie bewirken
ein schwankendes Depolarisationsniveau. Für die Verarbeitung der Impulse werden die
Zeitpunkte der ihres Auftretens betrachtet, denn diese bewirken eine sofortige Änderung
des Membranpotentials im Neuron durch die Übertragung der Neurotransmitter.
Gerade im visuellen Bereich des Gehirns werden die Impulse von mehreren Schichten
verarbeitet. Ihre Antwortszeit erlaubt keine Kodierung der Information durch Feuerraten
[3]. Die Antwortzeit des Systems ist zu kurz, gegenüber einer Impulsverarbeitung,
bei der die Feuerraten zur Informationskodierung verwendet werden. Bei Untersuchungen
von Neuronen im sensorischen Bereich, z. B. bei der Erfassung eines Druckes auf
der Haut, ist eine Informationsübertragung durch die Verwendung von Feuerraten zu erkennen.
Das Ausgangssignal des Neurons ist hier in der Frequenz seiner Impulse codiert.
SpinnSoftSim 11

3. PULSCODIERTE NEURONALE NETZE
Durch die Verwendung von pulscodierten Neuronalen Netzen erwartet man eine
Verringerung der Netzaktivität durch selten auftretende Impulse zwischen den Neuronen.
Diesen Vorteil erkauft man sich durch ein komplexes Neuronenmodell. Gegenüber
herkömmlichen Neuronalen Netzwerken wird bei der Erstellung von biologienahen
Neuronalen Netzen auf folgende Punkte geachtet:
• pulskodierte Darstellung der Ein- und Ausgangssignale des Neurons;
• ein Puls ist relativ kurz und tritt selten auf;
• innerhalb des Neurons werden die einzelnen internen Zustände gespeichert, aus den
internen Zuständen wird das Membranpotential gebildet;
• eine Ausgangsfunktion bestimmt in Abhängigkeit des Membranpotential und des
Schwellwertes ob das Neuron einen Impuls aussendet.
Bei Untersuchungen an Gehirnen von Katzen und Affen wurde festgestellt, daß ein
visueller Reiz bereits viele Neuronen in verschiedenen Bereichen des Gehirns aktiviert.
Die Neuronen in den ersten Ebenen der Bildverarbeitung im Gehirn müssen mit den Bereichen
des Gehirns kommunizieren, die für die Objekterkennung bzw. -trennung von
Objekten vom Hintergrund zuständig sind. Die Abhängigkeit der Aktivität der verschiedenen
Bereiche wurde als grundlegendes Merkmal der Bildbearbeitung im Gehirn angenommen.
Die Arbeitsgruppe von Prof. Reinhard Eckhorn an der Philipps Universität
in Marburg, hat durch Experimente den Nachweis für diese Annahme erbracht[6]. Die
Experimente zeigten ebenfalls, daß die abhängige Aktivität einzelner Bereiche die
grundlegende Eigenschaft ist, Bildmerkmale zu erkennen. Die Aktivität der zusammengehörenden
Bereiche eines Bildmerkmals wurde durch gleichzeitiges Feuern dieser
Neuronen dargestellt. Neuronen, die an der Bearbeitung oder Erkennung eines Objektes
beteiligt sind, feuern synchron. Die Synchronität wurde in Neuronalen Netzen als
grundlegender Mechanismus, zur Texterkennung, Bildsegmentierung oder Mustererkennung
verwendet. Aus diesen Erkenntnissen wurde ein neues Modell zur Beschreibung
der neuronalen Aktivität entworfen.
3.1 DAS MARBURGER NEURONEN MODELL
Das Marburger Modell bildet ein sehr biologienahes Neuronales Netzwerk. Es verwendet
Neuronen mit mehreren Dendriten, wobei die Dendriten unterschiedliche Aufgaben
haben. Die Synapsen werden hier zum Dendriten gehörend angesehen und stellen
nicht, wie bei einem biologischen Neuron, das Ende des Axons dar. Ein Reiz des vorhergehenden
Neurons wird durch einen Faktor in eine Potentialänderung innerhalb des
Dendriten umgewandelt. Diese Potentialänderung klingt mit der Zeit unter Verwendung
eines verlustbehafteten Integrators ab. Der Hauptreiz wird auf dem Feedingdendriten
empfangen. Der Einfluß des dort entstehenden Potentials kann durch das Potential des
Linkingdendriten verstärkt werden, aber ein ausschließlicher Reiz auf dem Linkingdendriten
kann das Neuron nicht zum Feuern bewegen. Das Potential des Feedingdendriten
wird mit eins und dem Potential des Linkingdendriten multipliziert. Der Einfluß weiterer
Dendriten kann anschließend additiv erfaßt werden. Negativ wirkende Impulse, die
hemmend auf das Membranpotential Einfluß nehmen, werden auf dem inhibitorisch
wirkenden Dendriten zusammengefaßt. Die Summe aller Dendritpotentiale bildet das
Membranpotential. Ein Vergleich des Schwellwertes mit dem Membranpotential bringt
die Entscheidung ob das Neuron feuert oder nicht. Das Membranpotential übersteigt
SpinnSoftSim 12

den Schwellwert und das Neuron sendet einen Impuls an die nachfolgenden Neuronen
aus. Der ausgelöste Impuls bewirkt ein emporschnellen des Schwellwertes, der exponentiell
mit der relativen Refraktärzeit abklingt (Bild 7).
Bild 7. Modell eines Neurons nach dem Marburger Modell
3.2 DAS FEEDINGPOTENTIAL
Das Potential des Feedingdendriten wird bestimmt durch den Einfluß der Synapsen
die an der Erfassung des Eingangsreizes beteiligt sind. Dieser Zusammenhang läßt sich
wie folgt mathematisch beschreiben:
Das Ausgangssignal des vorhergehenden Neurons y wird mit dem Gewichtsfaktor
w multipliziert, das Abklingverhalten wird mit dem verlustbehafteten Integrator beschrieben.
Für die erste Lage des Neuronalen Netzwerkes gibt es einen weiteren Teil der
die Aufnahme des Eingangsreizes beschreibt. Der Eingangsreiz x wird mit dem Gewicht
u multipliziert, auch hier wird das Abklingen des Eingangsreizes berücksichtigt.
3.3 DAS LINKINGPOTENTIAL
Ft () Σw ( ⋅ y)
IV F τ F ⋅ ( , , t)
Σ( u ⋅ x)
IV F τ F =
+ ⋅ ( , , t)
Das Potential des Linkingdendriten hat nur eine unterstützende Wirkung auf das
Membranpotential. Das Potential setzt sich aus dem postsynaptischen Einfluß der aufgeschalteten
Synapsen zusammen, deren Zugehörigkeit von Neuronen aus der unmittelbaren
Nachbarschaft oder anderen Populationen kommen kann. Das Potential läßt sich
wie folgt berechnen:
L Σ[ w⋅y] IV L τ L =
⋅ ( , , t)
Der Ausgang des vorgeschalteten Neurons y wird mit dem Gewicht w multipliziert,
I stellt die Impulsantwort des verlustbehafteten Integrators dar und beschreibt das Abklingen
des postsynaptischen Potentials.
SpinnSoftSim 13

3.4 DAS MEMBRANPOTENTIAL UND DER SCHWELLWERT
Das Membranpotential beschreibt die Summe der Dendritenpotentiale, wobei das
Potential der Feedingdendriten mit eins und dem Potential der Linkingdendriten multipliziert
wird, anschließend wird das Potential weiterer positiv wirkender Dendriten, sowie
hemmend wirkender, inhibitorischer Dendriten, berücksichtigt.
MP = F()1 t ( + L() t ) + ΣD– ΣI
Der Schwellwert des Neurons wird mit dem Ausgangswert des Neurons multipliziert
addiert wird der Schwellwert des Neurons aus der letzten Zeitscheibe, wobei der
zweite Term mit der Zeitkonstanten der relativen Refraktärzeit abklingt.
Θ( n ⋅ Δt)
V Θ – Δt
yn ( ⋅ Δt)
Θ( ( n – 1)
⋅ Δt)
τ Θ
=
⋅ +
exp⎛--------
⎞
⎝ ⎠
Ist der Schwellwert kleiner als das Membranpotential sendet das Neuron einen Impuls
an die nachfolgenden Neuronen aus.
3.5 DIE FÄHIGKEITEN DES MARBURGERSYSTEMS
Die Forschungsgruppe in Marburg konnte mit diesem Neuronenmodell synchron
feuernde Gruppen von Neuronen darstellen, die jeweils einem Objekt im Eingangsreiz
zugeordnet werden konnten. Die Eigenschaft zur Bildsegmentierung ist von der Feuerrate
und der Pulsphase abhängig, beide Werte können mit der Abklingkonstanten des
Schwellwertes variiert werden. Das verwendete Netzwerk ist in der Lage Objekte zu
identifizieren und Muster zu erkennen unter Verwendung synchron feuernder Neuronengruppen
und der Berücksichtigung des Zustandes der Nachbarneuronen durch Linkingverbindungen.
Andere Forschungsgruppen[5,11] erweiterten das Modell um einen
Kopplungsfaktor und konnten im Bild enthaltene Störungen beseitigen.
SpinnSoftSim 14

4. SYNAPSENPLASTIZITÄT
Bisher erstellte Neuronale Netzwerke ließen den Ansatz der Synapsenplastizität unberücksichtigt.
Als Synapsenplastizität wurde die Anpassung des Wichtungsfaktors an
gewisse Bildklassen bezeichnet, allerdings ist hier die Berücksichtigung der Mengen
ausgeschütteter Neurotransmitter und ihre Regenerationsfähigkeit gemeint. Die Änderung
der Menge der Neurotransmitter und die Frequenzabhängigkeit der Signalübertragung
wurden lange Zeit nicht berücksichtigt, obwohl die Existenz dieses Mechanismus
gut an der kalifornischen Meeresschnecke zu erkennen ist. Die Meeresschnecke verfügt
über einen Kiemenreflex, die Alphysia zieht ihre Kiemen in eine Mantelhöhle zurück,
wenn ein Lufthauch auf die Atemröhre trifft[1,12]. Nach mehreren Reizungen tritt der
Reflex nicht mehr auf. Die Schnecke hat sich an die Reizung gewöhnt, nach einiger Zeit
kann der Reflex dennoch wieder beobachtet werden, aber erst nach einem Tag hat der
Reflex wieder seine volle Stärke erreicht. Die Abnahme des Reizes läßt sich mit der
Verschmelzung der Bläschen (Vesikel), die Träger der Neurotransmitter, an der Synapsenwand
erklären. Bei der Verschmelzung der Vesikel mit der Synapsenwand werden
die Neurotransmitter ausgeschüttet, aber die Regenerierung der Transmitter erfolgt zu
langsam, daher nimmt die Stärke des Reflexes ab.
Bild 8. Aufbau einer Synapse
4.1 MODELLIERUNG DER SYNAPSENPLASTIZITÄT
Markram und Tsodyks haben ein Modell erstellt was die zeitlich variierenden Transmitterstoffmengen
und die Frequenzabhängigkeit berücksichtigt[12]. Die Grundmenge
der Neurotransmitter wird mit A bezeichnet. Die bei einer Impulszugübertragung ausgeschüttete
Menge an Transmitterstoffen wird durch die Variable u dargestellt und bei
jedem weiteren auftretenden Impuls neu berechnet. U 0 , als Transmitterstoffmenge des
ersten Impulses, wird als Verhältniszahl ohne Einheit angegeben. Aus Versuchen mit
dem spannungs- bzw. stromgesteuerten Kanal ergibt sich eine Änderung in der Ionen-
SpinnSoftSim 15

leitfähigkeit, die Rückschlüsse auf die synaptische Effektivität u zulassen. Die nach der
Ausschüttung in der Synapse verbleibenden synaptischen Vesikel erhalten den Kennbuchstaben
R. Diese Menge muß nach weiteren Impulsen neu berechnet werden und R
wird ebenfalls als einheitenlose Verhältniszahl dargestellt. Für den ersten Impuls gilt R 1
=1-U.DieZeitkonstanten mit der sich die synaptischen Bläschen regenerieren wird
mit τ rec bezeichnet. Die Konstante τ rec kann direkt aus dem Experiment bestimmt werden.
Das Zeitintervall, in dem die Wirkung der ausgeschütteten Neurotransmitter andauert,
wird mit τ fac angegeben. Die biophysische Wirkung der Potentialanhebung wird
den Calciumionen zugeschrieben. Der komplexe Vorgang unterliegt mehreren Zeitkonstanten,
von denen τ fac den Mittelwert darstellt.
Für den ersten eintreffenden Impuls gilt:
R1 = 1 – U0 Für alle weiteren eintreffenden Impulse lassen sich u und R wie folgt berechnen:
– Δt
Rn + 1 R ( 1– un+ 1)
⎛-------- ⎞ – Δt
= ⋅ ⋅ exp + 1 – exp⎛--------
⎞
⎝τ⎠ ⎝
rec
τ ⎠
rec
un + 1
u ⎛ – Δt
n ----------- ⎞ – Δt
= ⋅ exp + U⋅⎛1– un⋅exp⎛-----------
⎞⎞
⎝τ⎠ ⎝ ⎝
facil
τ ⎠⎠
facil
Für das postsynaptische Potential gilt dann:
PSPn = A⋅Rn⋅ un Wenn der Reiz der Synapse einer konstanten Frequenz r entspricht kann der zugehörige
Grenzwert für u und R wie folgt bestimmt werden [12]:
Rst() r
ust() r
– 1
1 – exp⎛--------------
⎞
⎝r⋅τ⎠ rec
= -----------------------------------------------------------------------
– 1
1– ( 1 – ust() r ) ⋅ exp⎛--------------
⎞
⎝r⋅τ⎠ rec
U
=
-----------------------------------------------------------------
– 1
1 – ( 1 – U)
⋅ exp⎛------------------
⎞
⎝r⋅τ⎠ facil
4.2 DEPRESSION ODER FACILITY-VERHALTEN
In Abhängigkeit der dynamischen Botenstoffmenge und der beiden Zeitkonstanten,
können beiden Verhaltensweisen ohne weitere Parameter dargestellt werden. Das Facilityverhalten
wird wie folgt beschrieben:
Die ausgeschüttete Menge an Neurotransmittern wirkt auf das postsynaptische Verhalten
des nachgeschalteten Neurons fördernd. Beim ersten Impuls wird eine geringe Menge
an Transmitterstoffen ausgeschüttet, U 0 hat einen sehr kleinen Wert (ca. 0.02 bis
0.08). Die nachfolgenden Werte für u steigen an, wenn der Eingangsreiz mit einer Frequenz
kleiner als die Grenzfrequenz der Synapse auftritt, sonst würde die Synapse sich
in den Sättigungsbereich bewegen und das Verhalten der Synapse wechselt vom Facilityverhalten
zum Depressionsverhalten. Beim Facilityverhalten ist die Regenerationskonstante
τ rec (ca. 60 ms - 800 ms) kleiner als die Facilitykonstante τ fac (ca. 1 s - 4 s).
SpinnSoftSim 16

Die Menge der Neurotransmitter regeneriert sich schnell im Synapsenköpfchen, während
die Wirkungsdauer der ausgeschüttetenden Neurotransmitter relativ lang ist.
Das Depressionverhalten besitzt einen Wert für U 0 zwischen 0,4 und 0,8. Die erste
Ausschüttung der Transmitterstoffe ist größer gegenüber der beim Facility-Verhalten.
Weitere Impulse lassen die Menge der ausgeschütteten Neurotransmitter wieder abklingen,
denn die Zeitkonstante τ rec (ca. 60 ms - 800 ms) für die Regenerierung der Neurotransmitter
ist größer als die Zeitkonstante τ fac (ca. 2 ms - 3 ms) für die Wirkungsdauer.
Bild 9. Synapse mit Facilityverhalten
Bild 9 soll als Beispiel für eine Synapse mit Facilityverhalten dienen. Bei etwa 50
ms tritt der erste presynaptische Impuls auf. Die Reizung ist stark genug, damit das Neuron
feuert. Bei weiteren eintreffenden Impulsen, kommt es zu weiteren Ausschüttungen
an Neurotransmittern, es ist zu beachten das die Ausschüttungsmenge zunimmt, es
kommt zu einem Anstieg des postsynaptischen Potentials. Ein Wechsel zum Depressionverhalten
ist bei diesem Beispiel nicht zu sehen.
Bild 10. Synapse mit Depressionverhalten
Die Menge der ausgeschütteten Neurotransmitter steigt bei jedem Impuls, Ausnahmen
sind bei Zeitpunkten t=200 ms und t=240 ms zu sehen. An diesen Stellen ist die
zeitliche Differenz zwischen den eingehenden Impulsen kleiner als die Abklingkonstante
des Synapsenpotentials und es kommt zu einer sprunghaften Abnahme des Synapsenpotentials.
Hier verläßt das Modell seinen Gültigkeitsbereich. Die Abklingkonstante ist
gegenüber den anderen Zeitkonstanten zu groß, denn eine sprunghafte Abnahme des
postsynaptischen Potentials, ist nicht plausibel. Das zeigt die Schwierigkeiten bei der
Parameterwahl.
SpinnSoftSim 17

4.3 DIE TESTUMGEBUNG
Das Programm SPINNSoftSim verwendet einen konstanten Eingangsreiz. Zur Darstellung
des Einflusses einer Impulsfolge auf eine Synapse wurde eine Testumgebung
erstellt, in der Impulsfolgen generiert werden können. Die Erstellung der Impulsfolge
sollte die Poissonverteilung der einzelnen Impulse berücksichtigen. Die Poissonverteilung
dient als Ersatz für die Binominalverteilung, weil für große Zahlen die Berechnung
recht unbequem ist.
Die Binominalverteilung betrachtet ein Experiment mit zwei Ereignissen A und A ~ .
Wenn das Experiment n-mal wiederholt wird, wird nach dem k-maligen Auftreten des
Ergebnisses von A gefragt. Der Vergleich zu einem Impulszug ergibt sich wie folgt, die
Anzahl der Zeitschritte stimmt mit der Anzahl der Wiederholungen überein. Die beiden
sich gegenseitig ausschließenden Ereignisse sind ein Impuls oder kein Impuls. In "Numerical
Recipes in C" [17] kann man für die Berechnung einer poissonverteilten Impulsfolge
einen Algorithmus finden. Für die Erstellung einer Impulsfolge werden zwei
Parameter benötigt ein Startwert für den verwendeten Zufallsgenerator und der Mittelwert
der Verteilung. Nach Gabbiani ist der Mittelwert der Verteilung das Produkt aus
der Intervalllänge und der gewünschten Frequenz der Impulse [18].
Für diese Impulsfolge wird dann das postsynaptische Potential der Synapse bestimmt
und graphisch ausgegeben. Damit die Funktionsweise des gesamten Neuronenmodells
kontrolliert werden kann, wurde das Programm um einen weiteren Impulszug
erweitert. Dieser Impulszug dient als Eingangssignal einer weiteren Synapse. Die Summation
der einzelnen Synapsenpotentiale konnte damit getestet werden und nach leichter
Modifikation wurden zwei Dendriten mit je einer Synapse implementiert, für die
Summation der Dendritenpotentiale. Die Synapsenpotentiale werden in den Farben der
zugehörigen Impulszüge rot und blau gekennzeichnet. Um zwischen Facility- und Depressionverhalten
wechseln zu können, sind die Synapsenparameter frei wählbar. Zur
Kontrolle der Schwellwertfunktion und der Generierung des Neuronausgangs sind diese
Kurvenzüge ebenfalls darzustellen. Der Schwellwert wird Cyan und das Membranpotential
in Magenta dargestellt. Das Dendritepotential hat die Farbe Grün. Oberhalb der
Potentialverläufe werden wiederum Impuls dargestellt, wenn das Membranpotential
den Schwellwert übersteigt und das Neuron feuert.
SpinnSoftSim 18

5. ANWENDERHANDBUCH
Mit diesem Programm kann der Anwender erste Erfahrungen mit dem Umgang von
"Synapsen plastisch spikende Neuronale Netze" (SPINN) sammeln. Dieses Programm
versucht eine Lücke zu schließen, denn es existieren noch keine Anwendungen die
Synapsenplastizität in Neuronalen Netzwerken berücksichtigen, zur Zeit gibt es nur Anwendungen
für herkömmliche Neuronale Netze.
5.1 PROGRAMMSTART
Das Programm startet mit der folgenden Bildschirmmaske. Es werden im oberen
Bereich drei Bilder dargestellt. Links erscheint der Eingangsreiz der auf das Netzwerk
wirken soll. Als Eingangsreiz können Bilder beliebiger Größe, mit 256 Graustufen verwendet
werden. In der Mitte wird die Aktivität einer ausgewählten Population dargestellt,
wenn mehrere Populationen verwendet werden. Am rechten Rand ist die Aktivität
der letzten Population, die Netzantwort plaziert. Bei Verwendung von einer einzigen
Population wird im mittleren und rechten Fenster dasselbe Bild dargestellt.(Bild 11)
Bild 11. Programmstart
5.2 MENÜEINTRAG DATEI
Im Menü "Datei" kann sowohl der Eingangsreiz geladen, als auch der Potentialverlauf
des zu beobachtenden Neurons gesichert werden. Wenn der Potentialverlauf gesichert
werden soll, öffnet sich ein weiteres Untermenü mit den unterstützten
Bildformaten, von denen eins ausgewählt werden kann. Zum Sichern des Bildes auf
dem Datenträger wird nach der Eingabe des Dateinamen die Datei an der ausgewählten
Position abgelegt. Desweiteren befindet sich hier der Menüpunkt "Beenden" mit dem
das Programm verlassen werden kann.
SpinnSoftSim 19

5.3 MENÜ NETZ
Alle Parameter zur Beschreibung des Neuronalen Netzwerkes sind im Menüeintrag
"Netz" zusammengefaßt. Es werden zum Einen die neuronalen Parameter erfaßt, als
auch die Parameter zur Beschreibung der Topologie. Zu den Topologieparametern gehört
unter anderem die Ausdehnung des Nachbarschaftsbereiches, als auch die Form des
Nachbarschaftsbereiches. Verschiedene Formen des Nachbarschaftsbereiches werden
später implementiert.
5.3.1 Populationsanzahl
Der oberste Eintrag dieses Menüs öffnet ein Dialogfenster zur Eingabe der Populationsanzahl.
Sie bestimmt die Anzahl der Ebenen aus denen das Netzwerk bestehen soll.
Alle Populationen besitzen die selbe Größe, diese entspricht den Abmessungen des geladenen
Bildes, das als Eingangsreiz verwendet wird.
5.3.2 Neuronparameter
Als Modell zur Beschreibung der Vorgänge innerhalb des Neurons wird das Marburger
Modell verwendet [6]. Das Modell wurde um den Kopplungsfaktor β erweitert,
wie er bei Kinser[5] zu finden ist. Der Kopplungsfaktor bietet eine weitere Möglichkeit,
den Einfluß der unterstützenden Wirkung des Potentials des Linkingdendriten zu variieren.
Das Marburger Modell bildet zuerst die Summe der postsynaptischen Potentiale
der Synapsen auf den Feedingdendriten bzw. Linkingdenriten. Das Potential auf dem
Linkingdendriten kann sich nur unterstützend auf das Membranpotential des Neurons
auswirken. Deshalb wird das Potential des Feedingdendriten mit der Summe aus 1 und
dem Potential des Linkingdendriten multipliziert bevor das Potential weiterer Dendriten
hinzuaddiert wird. Hemmend wirkende Einflüße werden von inhibitorischen Dendriten
erfaßt, ihr Dendritepotential wird subtrahiert vom Membranpotential. Für die Beschreibung
des Neurons werden in dieser Maske nur die Anzahl der gewünschten Dendriten
erfaßt, die Zuweisung der Funktion jedes Dendriten erfolgt in der Eingabemaske für die
Dendritparameter. Damit das Neuron einen Impuls aussendet, muß das Membranpotential
den Schwellwert übersteigen. Der Schwellwert setzt sich aus dem statischen und
dem dynamischen Anteil zusammen. Der statische Schwellwert liegt vor, wenn das
Neuron noch nicht oder lange Zeit nicht gefeuert hat. Der dynamische Anteil wird addiert,
wenn das Neuron gefeuert hat. Nach dem ein Impuls ausgesendet worden ist, kann
das Neuron eine gewisse Zeitspanne keinen weiteren Impuls senden. Diese Zeitspanne
wird absolute Refraktärzeit bezeichnet. Die relative Refraktärzeit ist ein Maß mit dem
der Schwellwert abklingt (Bild 12).
5.3.3 Dendritparameter
Die Dendritparameter setzen sich aus dem Dendrittypen bzw. seinem Namen und
den Parametern der auf ihm sitzenden Synapsen zusammen. Als Dendrittyp wurden
Feeding, Linking, inhibitorisch wirkende Dendriten und weitere positiv wirkende Dendriten
definiert. Das Synapsenmodell verwendet die Erkenntnisse von Markram und
Tsodyks [Mark98]. Innerhalb der Synapse existiert die gesamte Menge A des Transmitterstoffes,
aber bei der Reizübertragung wird nicht die gesamte Menge ausgeschüttet,
sondern nur der dynamische Anteil U 0 . Er wird in Prozent von A angegeben. Nach einer
Ausschüttung erfolgt die Regeneration der Neurotransmitter innerhalb der Synapse. Die
Regenerationsgeschwindigkeit wird durch die Zeitkonstante τ rec beschrieben. Die in der
SpinnSoftSim 20

Bild 12. Dialog der Neuronparameter
Synapse verbleibende Menge an Neurotransmittern wird durch den Parameter R n beschrieben.
Die zur Ausschüttung gekommende Menge an Neurotransmittern wird wieder
abgebaut. Die Zeitkonstante τ fac beschreibt die Wirkungsdauer der
Transmitterstoffmenge u n am Dendriten des nachfolgenden Neurons. Als letzter Parameter
bleibt die Abklingkonstante τ leaky des postsynaptischen Potentials zu nennen. Das
postsynaptische Potential wird durch die Ausschüttung der in den Synapsen befindlichen
Neurotransmitter, im nachfolgenden Dendriten der Synapse erzeugt. Eine Änderung
der Synapsenparameter kann durch "Hebb’sches Lernen" erfolgen. Der Parameter,
auf dem die Änderung erfolgen soll, kann aus dem gegebenen Rollmenü ausgewählt
werden. Innerhalb der Grenzen Hebb max und Hebb min kann die ausgewählte Variable
durch "Lernen nach Hebb" angepaßt werden. Die Angabe erfolgt in Prozent des Wertes
der ausgewählten Variablen. Für die Reizerfassung gibt es eine Einschränkung. Der
Grauwert des Bildpixels bewirkt eine Änderung der Neurotransmittermenge U 0 , wenn
das "Hebb’sche Lernen" ebenfalls auf U 0 wirkt, wird das Membranpotential von zwei
Grössen geändert, eine Kontrolle des Potentialverlauf wird dadurch erschwert. Die Impulse
werden auf einem Dendriten von seinen Synapsen empfangen, die Menge der
Synapsen auf diesem Dendriten ist von dem gewählten Nachbarschaftsbereich abhängig.
Wenn die Population ihr Ausgangssignal als Rückkopplung an sich selbst sendet,
wird das Signal des Neurons von seinen Nachbarneuronen empfangen, es findet aber
keine direkte Rückkopplung zu dem aktuellen Neuron statt, deswegen kann die Anzahl
der Synapsen, mittels des Check-Feldes um Eins verringert werden. Ist die nachfolgende
Population eine andere, so ist dieses Feld nicht zu betätigen. Die Entfernung zwischen
den Neuronen wird wie folgt berücksichtigt, es wird bei der Erstellung der
Verbindungslisten für jede Synapse ein Wichtungsfaktor bestimmt. Der Einfluß benachbarter
Neuronen soll mit steigendem Abstand geringer werden. Dieser Verlauf entspricht
der Gaußverteilung, diese benötigt einen Parameter für den Abstand der
Wendepunkte. Der Verstärkungsfaktor wurde hinzugefügt, um einen weiteren Freiheitsgrad
zu erlangen. Unter Verwendung der Schaltfläche "UpDate" wird mit den eingegebenen
Parametern die Gaußverteilung dargestellt und der Einfluß entfernt
liegender Neuronen ist sofort erkennbar (Bild 13).
SpinnSoftSim 21

Bild 13. Dialog der Dendriteparameter
5.3.4 Netz erstellen
Das Bild des gewünschten Eingangsreizes bestimmt die Größe des Neuronalen
Netzwerkes. Nach dem alle Parameter bestimmt wurden, sind die Verbindungslisten für
Vorwärts- und Rückwärtsverbindungen zu erstellen. Unter Verwendung der Verbindungslisten
wird ermittelt, welche Neuronen als Nachfolger geschaltet sind, damit wird
ein auftretender Impuls des gerade behandelten Neurons weitergeleitet werden. Für die
Anpassung der Parameter durch Hebbsches Lernen ist es notwendig einen Zugriff auf
die Feuerzeiten des vorhergehenden Neurons zu haben, dies geschieht mittels der Liste
der Rückwärtsverbindungen.
5.3.4.1 Netztopologie
Der Einsatz von Neuronalen Netzen in der Bildbearbeitung, bringt immer eine große
Anzahl von Neuronen mit sich. Ein Bild von 32 x 32 Pixel, benötigt 1024 Neuronen für
eine Schicht, wenn jedes Element des Bildes von einem eigenen Neuron aufgenommen
werden soll. Die große Anzahl von Neuronen macht es dem Anwender daher unmöglich
die Verbindungen selbst zu erstellen. Deshalb werden für Verbindungen innerhalb der
eigenen Population folgende Verbindungsstrukturen erstellt (Bild 14). Alle Neuronen
im Nachbarschaftsbereich besitzen zwei Verbindungen zum aktuell bearbeiteten Neuron.
Die Impulse der Neuronen im Nachbarschaftsbereich gelangen zum einen auf den
Linkingdendriten, damit eine Synchronisation zwischen den feuernden Neuronen stattfinden
kann, um den Potentialanstieg zu hemmen, werden die Impulse ebenfalls von einem
inhibitorisch wirkenden Dendriten aufgenommen. Für die Signalaufnahme von
anderen Populationen wurden weitere Dendriten eingefügt, dadurch stehen für diese
Verbindungen auch eigene Parameter zur Verfügung. Die Impulse einer vorhergehenden
Population werden von der nachfolgenden über den Dendriten mit dem Namen
"F_Population" aufgenommen. Eine Rückkopplung erfolgt durch Senden der Impulse
SpinnSoftSim 22

Bild 14. Verbindungen innerhalb der Population
auf die vorhergehende Population, in dem die vorhergehende Population einen weiteren
inhibitorischen Dendriten, "I_Population", besitzt (Bild 15).Die Namen sind mit dem-
Programm fest verbunden.
Bild 15. Verbindungen zu anderen Populationen
SpinnSoftSim 23

5.3.5 Start
Die Simulation des Netzwerkes wird für den ausgewählten Zeitbereich gestartet. Es
erscheint ein Fenster mit einem Füllbalken und der Schaltfläche "Abbruch", damit die
Simulation abgebrochen werden kann. Wird dagegen eine Einzelschrittsimulation
durchgeführt, erscheint ein Dialog mit der Frage, ob die nächste Zeitscheibe simuliert
werden, oder ob die Simulation abgebrochen werden soll. Nach dem ersten Lauf der Simulation
kann der Anwender die Parameter ändern. Damit nicht unnötige Wartezeiten
aufkommen, werden bei Anwahl dieses Menüpunktes alle vorgenommenen Änderungen
im Parametersatz an die Neuronen und Synapsen des Netzwerkes weitergeleitet.
Änderungen der Dendriten-, der Synapsenanzahl, bei einer Änderung des Nachbarschaftsbereichs
oder sogar eine Änderung der Populationsanzahl machen eine erneute
Erstellung der Verbindungslisten des Neuronalen Netzwerkes notwendig.
5.4 MENÜ OPTION
5.4.1 Hebb
Es erscheint ein Dialogfenster in dem der Zeitbereich eingetragen wird, wo
"Hebb’sches Lernen" die maximale Änderung der dynamischen Transmitterstoffmenge
aufweist (Bild 16). Die Eingabe der oberen und unteren Grenze der Neurotransmitter er-
Bild 16. Wirkungszeit für "Hebb’sches Lernen"
folgt in der Maske der Dendritparameter. Nach Hebb wird eine Verbindung verstärkt,
wenn die Differenz zwischen der aktuellen Zeit und dem Zeitpunkt des Eintreffens des
Eingangsimpuls der Synapse innerhalb der definierten Wirkungszeit nach Hebb liegt.
5.4.2 Neuronenkontrolle
Das Programm verwaltet eine Liste der Neuronen, bei denen eine Synapsenaktivität
aufgetreten ist. Wenn der dynamische Schwellwert des Neurons schneller abklingt als
das Membranpotential, wird das Neuron erneut feuern, ohne daß eine Synapse erneut
aktiviert wurde. Um diese Situation zu berücksichtigen, kann eine Anzahl von Zeitscheiben
angegeben werden, in der eine Überwachung der Neuronen erfolgt, die bereits
einmal gefeuert haben.
SpinnSoftSim 24

5.4.3 Inhibitionsverstärkung
Zur Dämpfung der allgemeinen Neuronenaktivität innerhalb einer Population kann
eine allgemeine Anpassung des statischen Anteils des Schwellwertes erfolgen. Die
Dämpfung ergibt sich aus dem Verhältnis der Anzahl von aktiven Neuronen zu der Gesamtanzahl
der Neuronen der Population. Dieser Wert kann mittels des Verstärkungsfaktors
angepaßt werden. Für die globale Inhibition gibt es in der Biologie mehrere
Ansätze, zum einen gibt es Pyramidalneuronen, die auf eine Vielzahl der ihr nachgeschalteten
Neuronen hemmend wirken, aber auch jedes einzelne Neuron besitzt einen
Mechnismus, der es vor einem zu starkem Potentialanstieg schützt.
5.4.4 Globale Inhibition
Die Aktivierung und Deaktivierung der populationsweiten Dämpfung erfolgt durch
diesen Menüpunkt. Bei eingeschalteter globalen Inhibition, wird dies mit einem Punkt
vor dem Menüeintrag dargestellt.
5.4.5 Neuron wählen
Für die Darstellung der Potentialverläufe eines ausgewählten Neurons, wird dieser
Dialog verwendet. Mittels der drei Drehfelder kann die Population, die x- und y- Koordinate
des Neurons ausgewählt werden. Mit diesen Parametern ist die Position des
Neurons im Netz bestimmt.
5.4.6 Potential darstellen
Damit der Potentialverlauf des ausgewählten Neurons auch dargestellt wird ist dieser
Menüpunkt zu aktivieren. Eine erneute Auswahl deaktiviert die Darstellung des Potentialverlaufs.
Die farbliche Kennzeichnung der Dendritpotentiale erfolgt in der
TABELLE 1. Farbliche Kennzeichnung der Potentialverläufe
Farbe Potentialverlauf
magenta 1. Dendrite F_Reiz
rot 2. Dendrite Linking-Dendrit
blau 3. Dendrite inhibitorischer Dendrit
dunkelrot 4. Dendrite F_Population
dunkelblau 5. Dendrite I_Population
cyan Membranpotential des Neurons
grün Schwellwert des Neurons
Reihenfolge der Definition der Dendriten und ist nicht den Dendritnamen zugeordnet.
Die Potentialverläufe der weiteren Feeding- und inhibitorischen Dendriten werden nur
bei der Verwendung mehrerer Populationen dargestellt. Die Potentiale der inhibitorisch
wirkenden Dendriten werden als Betrag dargestellt, damit eine bessere Nutzung der Zeichenfläche
gegeben ist. Durch die Kopplung des Linkingdendriten an den Faktor β wird
bei der Potentialdarstellung ebenfalls der Faktor β berücksichtigt.
5.4.7 Population wählen
Die Aktivität einer ausgewählten Population kann im mittleren Fenster dargestellt
werden. Das Drehfeld gestattet die Auswahl der Population mittels des Drehfeldes.
SpinnSoftSim 25

5.4.8 Netzausgabe sichern
Die Antwort des Neuronalen Netzes kann für jede Zeitscheibe in einer Datei gespeichert
werden. Der eingegebene Dateiname wird durch die Nummer der Zeitscheibe erweitert.
5.4.9 Einzelschrittsimulation
Die Simulation kann entweder kontinuierlich erfolgen, oder in einzelnen Schritten.
Während der kontinuierlichen Simulation wird ein Dialog mit einem Füllbalken und einer
Schaltfläche zum Beenden der Simulation dargestellt. Wird dagegen eine Einzelschrittsimulation
gewünscht, wird am Ende jeder Zeitscheibe ein Dialog mit zwei
Schaltflächen dargestellt. Eine zur Berechnung der nächsten Zeitscheibe und eine zur
Beendigung der Simulation.
5.5 MENÜ BILDFOLGE
Der Reiz des Netzwerkes besteht während des gesamten Simulationszeitraums, damit
ein Eindruck vermittelt werden kann wie sich das Neuronale Netz bei einer Reizänderung
verhält wurden die beiden folgenden Programmoptionen erstellt. Es besteht die
Möglichkeit in ausgewählten Zeitscheiben ein neues Bild zu laden. Voraussetzung für
die Abarbeitung von Bildfolgen ist, daß die Bilder alle das gleiche Format besitzen. Bei
größeren Bildern würden einige Regionen nicht von Netzwerk erfaßt werden. Bevor
die Bildauswahl erfolgen kann, ist die Bildfolgenbearbeitung einzuschalten, damit das
Drehfeld im Auswahldialog initialisiert wird.
5.5.1 Bildfolge ein / aus
Mit diesem Menüpunkt kann die Abarbeitung verschiedener Eingangsreize eingeschaltet
werden. Das erste Bild der Bildfolge ist nicht vorher zu laden, denn die Erstellung
der Verbindungslisten und des Netzwerkes erfolgt nach dem das erste Bild geladen
wurde. Die weiteren Bilder werden dann zu den ausgesuchten Zeitscheiben geladen.
5.5.2 Bildwahl
Das Dialogfenster besteht aus einem Drehfeld, mit dem die gewünschte Zeitscheibe
ausgewählt werde kann, in der das Bild geladen werden soll. Mit Betätigung der
Schaltfläche "Auswahl" erscheint ein weiteres Dialogfenster. Dieser Dialog erlaubt die
Auswahl des gewünschten Bildes. Wurde ein Bild ausgewählt, wird der Eintrag in dem
Listfeld dargestellt, wenn kein Bild ausgewählt wurde wird der Dialog für die Dateiauswahl
geschlossen. Ein Eintrag in dem Listfeld kann entfernt werden, wenn er mit
der Maus ausgewählt wurde und anschließend die Schaltfläche "Löschen" betätigt
wird.
5.6 MENÜ DARSTELLUNG
Für die einzelnen Fenster ist eine Anpassung an den erwarteten Wertebereich möglich,
damit die Ausgaben "formatfüllend" dargestellt werden.
SpinnSoftSim 26

5.6.1 Zeit
Dieser Programmpunkt erlaubt eine Änderung der Simulationszeit und der Schrittweite,
mit der die Simulation durchgeführt werden soll. Diese Angaben beeinflussen die
Achsenskalierung des Histogramms und auch der Potentialdarstellung.
5.6.2 PSP
Für die Darstellung der Potentialverläufe erfolgt eine Anpassung des Wertebereiches
der y-Achse und die Angabe der Schrittweite für die Beschriftung.
5.6.3 Bildgröße
Die Größe der Ausgabefläche des Fenster für die Potentialdarstellung eines ausgewählten
Neurons kann hier in Pixel angegeben werden.
5.6.4 Reiz - Skalierung
Bei Verwendung von kleineren Bildern für den Eingangsreiz kann mittels dieser
Funktion eine Skalierung erfolgen. Das Bild wird dann in entsprechender Größe dargestellt
und die Größe der Darstellung wird an die anderen Bilder angepaßt.
5.7 MENÜ DEBUG
Zur Kontrolle der implementierten Algorithmen stehen unter diesem Menüpunkt
folgende Optionen zur Verfügung:
5.7.1 Schreibe Vorwärtsverbindungen
Dieser Menüpunkt erstellt eine Textdatei der erstellten Vorwärtsverbindungen in
dem für jedes Neuron die Liste der nachfolgenden Neuronen ausgegeben wird. Der Dateiname
kann mittels des verwendeten Dialoges frei gewählt werden.
5.7.2 Schreibe Rückwärtsverbindungen
Es wird eine Textdatei erstellt, deren Name frei wählbar ist. Für jede Synapse jedes
Neurons wird der Verweis auf das vorhergehende Neuron ausgegeben.
5.7.3 Schreibe Neuronenkontrolle
Mit dieser Programmoption, kann die Verweildauer eines Neurons in der Liste der aktiven
Neuronen überwacht werden, damit kann das Ausscheiden des Neurons aus dieser
Liste kontrolliert werden, wenn das Membranpotential beim Abklingen den Schwellwert
nicht noch einmal schneidet. Neuronen mit einem aktiven Eingangsreiz bleiben in
der Liste, weil diese in jeder Zeitscheibe feuern.
5.7.4 stat. Neuron-Daten
Die Dendrit- und Synpasenparameter werden nach einer Änderung, an die Elemente
des Neuronlane Netzes weitergeleitet, mit diesem Dialog kann die Verteilung überprüft
werden. Mit den drei Drehfeldern kann die gewünschte Population, sowie die x- und y-
Koordinate eines Neurons eingestellt werden. Anschließend werden in dem Listenfeld
SpinnSoftSim 27

auf der linken Seite die statischen Daten des Neurons dargestellt.
5.7.5 Speicherbelegung
Der Speicherbedarf einer Schicht des Neuronalen Netzwerkes wird bestimmt, wenn ein
Eingangsbild geladen wurde. Die Speicherung aller Synapsenparameter in jeder Synapse
ist nicht Resourcen schonend, wenn die Konventionen des SPINN-Konzeptes
berücksichtigt werden kann Reduzierung des Speicherbedarfs erreicht werden. Die
Impulse von einem Neuron und der zugehörigen Nachbarschaft werden alle von den
Synapsen eines Dendriten aufgenommen. Diese Synapsen besitzen bis auf den Wichtungsfaktor
zur Entfernungsdarstellung, alle die selben Parameter. Durch die reguläre
Struktur des neuronalen Netzwerkes werden diese Parameter einmal in jeder Population
hinterlegt. Mit den Parametern des Neuronenmodells wird ebenso verfahren. Für
ein neuronales Netz mit einer Ausdehnung von 64x64 mit drei Dendriten, wobei der
Feedingdendrit zur Reizaufnahem nur über eine Synapse verfügt und die beiden anderen
Dendriten jeweils acht Synapsen besitzen, hat jedes Neuron 17 Synapsen. Eine
Synapse belegt 52 Byte im Speicher, alle Synapsen eines Neuron 884 Byte. Alle drei
Dendriten eines Neurons haben einen Speicherbedarf von 24 Byte. Ein Neuron mit all
seinen Parametern hat einen Speicherbedarf von 36 Byte. Für die Datenstruktur der
Population werden 56 Byte im Speicher reserviert. Damit ergibt sich für ein Bild von
64 * 64 Bildpunkten ein Speicherbedarf von 4 MByte. Hinzu kommen noch die Listen
der Vorwärts- (64008 Einträge / ca. 1MByte) und Rückwärtsverbindungen (64008 Einträge
/ ca. 77kByte).
SpinnSoftSim 28

6. PROGRAMMIERHANDBUCH
6.1 DIE PROGRAMMIERSPRACHE C++
Als Programmiersprache wird C++ verwendet. C++ ist eine Erweiterung der populären
Programmiersprache C durch objektorientierte Eigenschaften, welche Programmiersprachen
eine Kopplung der Daten an die benötigten Funktionen gestatteten. Damit
können kleine überschaubare Programmeinheiten gebildet werden, deren Funktionsweise
leicht überprüft werden kann. Ein weiterer Vorteil objektorientierter Programmiersprachen
ist die Vererbung. Neu erstellte Klassen können auf Eigenschaften bereits
bestehender Klassen zurückgreifen, d.h. der Programmcode ist nicht mehrfach zu erfassen
außerdem wird bei der Programmerstellung Zeit gespart. Die Programmiersprache
C++ erzeugt einen sehr kompakten Programmcode des ausführbaren Programms, wie
man ihn von Compilern der Programmiersprache C kennt. Dies äußert sich positiv auf
die Ausführungsgeschwindigkeit des Programms. Bei anderen Programmiersprachenhingegen
wird jede Programmzeile erst zur Ausführungszeit (Interpreter) übersetzt oder
es wird ein Zwischencode erzeugt. Bei der Programmiersprache Java, wird der Zwischencode
von einem Interpreter abgearbeitet, bei der Erstellung des Zwischencodes
werden schon viele Probleme z.B. bei der Typkonvertierung beachtet und bei Bedarf
durch Fehlermeldungen angezeigt. Die Free Software Foundation hat einen frei verfügbaren
C-Compiler erstellt, der für eine große Zahl von Betriebssysteme verfügbar ist.
Ziel der Free Software Foundation ist es, ein komplettes Unix zu erstellen. Das GNU
(GNU is not Unix)-Konzept der Free Software Foundation hat bereits eine Vielzahl von
Entwicklungswerkzeugen erstellt, auch Debugger mit denen sich Programmfehler aufspüren
lassen [13]. Die Verwendung dieser Entwicklungswerkzeuge ist relativ einfach.
Dagegen ist die Lokalisierung der verwendeten Bibliotheken im System für den Unix-
Neuling nicht immer problemlos.
6.2 DIE STL-BIBLIOTHEK
Für die Programmiersprache C++ wurde 1994 eine Klassen-Bibliothek von der ISO
(International Standards Organisation) verabschiedet, an deren Erstellung unter anderem
die Firmen Silicon Graphics und Hewlett Packard beteiligt waren. Diese Bibliothek
nutzt die Template-Eigenschaft von C++[14]. Templates kann man als Masken oder
Formulare beschreiben mit denen für selbst definierte Datentypen bereitgestellte Funktionen
verwendet werden können. Dieses Prinzip wird generische Programmierung genannt.
Aus dieser Standard Template Library (STL) wird die Verwaltung von
verketteten Listen verwendet, wodurch die Notwendigkeit einen eigenen Programmcode
für die Verkettung von Objekten zu erstellen entfällt. Die ST-Library stellt Eigenschaften
wie das Hinzufügen, Löschen und Ersetzen von Elementen, Einfügen von
anderen Listen, Aufteilen in verschiedene Listen und das Sortieren der Liste und andere
Eigenschaften zur Verfügung. Der Zugriff auf ein Listenelement erfolgt über sogenannte
Iteratoren. Diese Arbeiten wie Zeiger, mit der Operation ++ , erhält man einen Verweis
auf das nachfolgende Element in der Liste. Ein Vergleich der Iteratoren, ob ein
Iterator größer oder kleiner als ein anderer Iterator ist, ob zum Beispiel innerhalb einer
Liste der Iterator A vor dem Iterator B steht, ist erst möglich, wenn diese Eigenschaft
implementiert wird. Unter Verwendung der STL können ebenso vorhandene Algorithmen
zur Verwaltung von Stapelverarbeitenden-Strukturen oder Warteschlangen genutzt
werden. Aber es existieren auch Funktionen zum Suchen oder Zählen von Ausdrücken
innerhalb der Listen, Warteschlangen oder Stapelverarbeitenden Strukturen.
SpinnSoftSim 29

6.3 DIE GRAPHISCHE BENUTZEROBERFLÄCHE -QT
Als Schnittstelle zum Anwender bietet sich eine graphische Benutzeroberfläche an.
Auf dieser können alle Parameter geändert werden, ohne daß Konfigurationsdateien erstellt
oder geändert werden müssen oder das Programm neu übersetzt werden muß. Die
norwegische Firma Troll Tech hat die C++-Bibliothek Qt entwickelt und stellt diese zur
Verfügung, wenn das Programm anschließend mit seinem Quellcode veröffentlicht
wird und keine kommerziellen Absichten verfolgt werden. Die Bibliothek ist für viele
verschiedene Unix-Derivate verfügbar und kann ebenfalls unter Windows eingesetzt
werden. Damit kann ein einmal erstelltes Programm schnell auf ein anderes System
übertragen werden. Die Qt-Bibliothek stellt eine Vielzahl von graphischen Elementen
für den Dialog mit dem Anwender zur Verfügung und bietet mit ihren Beispielprogrammen
einen leichten Einstieg in die Programmierung[15].
Bei der Erstellung von Programmen die graphische Benutzeroberflächen verwenden,
kann nicht permanent die Mausposition überwacht werden und bei einer Betätigung
einer der Maustasten entsprechend reagiert werden. Diese Aufgabe übernimmt die
graphische Benutzeroberfläche und die Qt-Bibliothek. Wenn eine Schaltfläche, über
eine Maustastenbetätigung aktiviert wird, wird von dieser Schaltfläche ein Signal ausgesendet
(emittiert). Ein zugeordneter Briefkasten (Slot) empfängt das Signal und kann
entsprechend darauf reagieren. Es besteht die Möglichkeit, mit einem Signal mehrere
Empfänger zu erreichen. Unter Qt wurde der Befehle Emit hinzugefügt, damit ein Signal
emittiert werden kann. Mit den Befehlen connect und disconnect können die zugehörigen
Slots für den Empfang des Signals zugeordnet werden. Die Definition eines
Slots erfolgt innerhalb der Klassendefinition. Für diese Kommunikation der einzelnen
Objekte sind zusätzliche Klassen und Programmcodes notwendig, welche unter Verwendung
des Meta Object Compilers (MOC) erstellt werden können. Die Analyse eines
Projektes für die Abhängigkeit der einzelnen Dateien zueinander kann mittels des Programms
progen erfolgen. Unter Verwendung dieser Liste der Abhängigkeiten erstellt
das Programm tmake ein Makefile mit dem alle Programmkomponenten übersetzt werden
können, die Dateien zur Verarbeitung der Qt eigenen Signale werden ebenfalls erstellt.
Die beiden Programme progen und tmake können vom Web-Server der Firma
Troll Tech mit der Adresse www.troll.no bezogen werden und sind unter Linux lauffähig.
Eine Umgebungsvariable verweist auf die Zielumgebung. Damit kann das Makefile
für verschiedene Zielsysteme erstellt werden.
6.4 QT-ARCHITECT
Für die Erstellung der Dialogmasken wurde das Programm Qt-Architect verwendet.
Mit diesem Programm kann man unter Verwendung graphischer Bausteine die Dialoge
zusammen stellen und die Generierung des Programmcodes wird von Qt-Architect
übernommen. Das Programm wurde von Jeff Harris und Klaus Ebner (e-mail :
klaus@gaspode.ndh.com) erstellt und ist ebenfalls auf dem Web-Server der norwegischen
Firma Troll Tech zu finden. Es stellt den ersten verfügbaren Dialog-Editor für die
Qt-Bibliothek dar. Qt-Architect beinhaltet alle Steuerungselemente der Version 1.4.
Weitere Steuerelemente können eingebunden werden. Die Programmcodeerstellung
wurde von Klaus Ebener für die Solaris-Version des C++-Compilers angepaßt, da hier
einige Besonderheiten zu berücksichtigen waren. Das Programm ist unter Linux fehlerfrei
zu übersetzen und problemlos zu nutzen.
SpinnSoftSim 30

6.5 MAKEFILE - UND ARBEITSUMGEBUNGS- ERSTELLUNG
Für den g++-Compiler unter Solaris kann auf einem Linux-Rechner das Makefile
mit den folgenden Befehlszeile erstellt werden.
TMAKEPATH=/opt/tmake/lib/solaris-g++
progen -o projekt.pro
tmake projekt.pro -o Makefile
Im Makefile sind in der Zeile LIBS die Bibliotheken libqimgio, libjpeg, libpng und
libz hinzuzufügen, dies geschieht durch die Parameterfolge -lqimgio -ljpeg -lpng -lz, bei
Bedarf ist vorher aber in der selben Zeile noch der Pfad für die entsprechende Bibliothek
anzugeben. Mit der Option -L kann ein Pfad angegeben werden, in dessen Unterverzeichnis
sich dann die Bibliothek befindet.
Für erneute Übersetzung ist es vorteilhaft die Variablen QTINCLUDE und QTLIB
in der Arbeitsumgebung zu setzen. Dies kann an der selben Stelle erfolgen an der QT-
DIR definiert ist. QTDIR wird für das Übersetzen des Programms benötigt. Die Definition
ist abhängig von der verwendeten Shell und den Istallationsort der Qt-Bibliothek.
6.6 BENÖTIGTE BIBLIOTHEKEN ZUR LAUFZEIT
Die verwendeten Bibliotheken werden zur Programmausführung wieder benötigt,
weil sie dynamisch gelinkt werden. Die Bibliotheken werden bei der Übersetzung nicht
an das auszuführende Programm angefügt, sondern die Bibliotheken werden bei der
Ausführung des Programms ebenfalls in den Speicher geladen und die entsprechenden
Routinen stehen zur Verfügung. Die Variable LD_LIBRARY_PATH enthält die Pfade an
denen sich die entsprechenden Bibliotheken befinden.
6.7 DIE PROGRAMMSTRUKTUR
Das erstellte Programm läßt sich in drei Bereiche aufteilen. Den Bereich mit den
Anwenderdialogen zur Parametereingabe, den Bereich der Daten und Strukturen des
Neuronalen Netzwerkes und das Fenster zur Darstellung der Potentialverläufe für ein
ausgewähltes Neuron, sowie der Populationsaktivität und dem Histogramm (Bild 17).
Bild 17. Gliederung des Programms
SpinnSoftSim 31

Die Aufteilung erfolgte aus Gründen der Übersicht. Bei einfachen Dialogen, deren Daten
ohne weiteres innerhalb einer Maske dargestellt werden können, wurde auf die Einführung
einer steuernden Klasse verzichtet. Für Dialoge, die zur Eingabe von Daten aus
mehreren Populationen oder verschiedenen Dendriten entwickelt wurden, ist eine steuernde
Klasse geschaffen worden. Die übergeordnete Klasse wählt das entsprechende
Datenneuron oder den Dendriten aus und übernimmt die Aktualisierung der im Dialog
dargestellten Werte. Der Komfort, der dem Anwender geboten wird, daß alle Parameter
des Neuronen Modells zur Laufzeit geändert werden können bringt entsprechend viele
Dialogmasken mit sich. C++ unterscheidet bei den Variablen- und Klassennamen die
Groß- und Kleinschreibung, deswegen werden die Klassennamen, ihrer Definition entsprechend
geschrieben. Die Dialoge wurden mit dem Programm Qt-Architect erstellt
und der zugehörige Programmcode von Qt-Architect generiert, deshalb werden die erstellten
Klassen nicht beschrieben. Eine wichtige Bemerkung zu den von Qt-Architect
erstellten Dateien: in der Headerdatei der Data-Klasse wurde die Definition der Variablen
von protected auf public geändert, damit ein einfacher Zugriff auf die Dialogdaten
erfolgen kann. (Bild 18)
Die Daten und Strukturen des neuronalen Netzwerkes gliedern sich wie im Bild 19
dargestellt.
6.8 DEFINITION DER VORWÄRTSVERBINDUNGEN
Ein Neuron ist jeweils mit einer Synapse an seinen Nachfolger gekoppelt. Wenn das
aktuelle Neuron einen Impuls aussendet, erreicht der Impuls die nachfolgenden Neuronen
über eine jeweils andere Synapse. Die Verbindungen eines Neurons zu seinen nachfolgenden
Neuronen, wird über die Liste list_connect, in der Klasse neuron dargestellt.
Jedes Neuron hat damit seine eigene Nachfolgerliste. Diese Liste beinhaltet Iteratoren
der Liste list_confront (confront = conection front), welche in der Klasse net definiert
ist. In der Liste list_confront, die aus Elementen der Klasse confront besteht, wird ein
Iterator der Population des Zielneurons, ein Iterator auf das Zielneuron, ein Iterator
des Dendriten an dem die Synapse angeschlossen ist und ein Iterator auf die Synapse
der Impulsübertragung gespeichert. Damit ist eine Verbindung auf das nachfolgende
Neuron beschrieben und es kann eine Weiterleitung des Spikes erfolgen (Bild 20).
6.9 DEFINITION DER RÜCKWÄRTSVERBINDUNGEN
Jede Synapse ist mit nur einem Neuron verbunden, von dem es den Reiz empfangen
kann. Zur Bestimmung des vorgeschalteten Neurons ist ein Iterator auf dessen Population
und ein Iterator für die Position des Neurons innerhalb der Population notwendig.
Beide Informationen werden in der Liste der Rückwärtsverbindungen list_conback
(conback = connection backward) in der Klasse net gespeichert. Ein Iterator innerhalb
der jeweiligen Synapse speichert den Verweis des Eintrags in der Liste con_back in der
Variablen imp_base. Diese Verbindungen sind wichtig wenn eine Anpassung der Neurotransmitterstoffes
U 0 durch das „Lernen nach Hebb“ stattfinden soll (Bild 21).
SpinnSoftSim 32

Bild 18. Erstellte Dialogsteuerungen und verwendete Dialoge
SpinnSoftSim 33

Bild 19. Struktur der Klasse net
Bild 20. Defintion der Vorwärtsverbindungen
6.10 BESCHREIBUNG DER EINZELNEN KLASSEN
6.10.1 check
Die Eingaben werden als Zeichenfolge erfaßt und anschließend erst in eine Zahl umgewandelt.
Um Fehler bei der Umwandlung zu vermeiden, wird durch Verwendung der
Klasse QValidator eine Eingabekontrolle durchgeführt. Die Klasse check basiert auf der
Klasse QValidator aus der Qt-Bibliothek, verwendet aber reguläre Ausdrücke. Mit einem
regulären Ausdruck, kann eine Maske angegeben werden. Wenn die Eingabe des
Anwenders der Maske entspricht wird die Eingabe akzeptiert, andernfalls wird die Ein-
SpinnSoftSim 34

Bild 21. Definition der Rückwärtsverbindung
gabe zurückgewiesen. Durch die Verwendung der regulären Ausdrücke kommt es während
des Übersetzungsvorganges zu einer Warnung, denn die Parameter für die
Funktion Validate sind festgelegt und die Position der Eingabemarke ist bei der Verwendung
der regulären Ausdrücke nicht von Interesse.
6.10.2 conback
Jede Synapse kann nur den Reiz eines vorgeschalteten Neurons aufnehmen. Diese
Rückwärtsverbindungen sind notwendig, damit das Synapsenpotential durch
"Hebb’sches Lernen" angepaßt werden kann wenn das vorhergehende Neuron gefeuert
hat. Um ein Neuron mit seiner Position im Neuronalen Netzwerk beschreiben zu können
ist ein Zeiger auf die Population und ein weiterer Zeiger die Position innerhalb der Population
notwendig. Beide Informationen werden in der Klasse conback abgelegt.
Jede Synapse mit einem vorgeschaltetem Neuron besitzt einen Verweis auf einen
Eintrag in der Liste der Rückwärtsverbindungen. Die Synapse zur Erfassung des Eingangsreizes
hat kein Neuron als Vorgänger, und deshalb ist der Wert der Variablen
imp_base gleich null.
SpinnSoftSim 35

6.10.3 confront
Das Ausgangssignal eines feuernden Neurons kann an mehrere nachfolgende Neuronen
weitergereicht werden. Im Gegensatz zu seinem biologischem Vorbild werden
die Synapsen zum Dendriten des Zielneurons gehörend betrachtet. Damit die Synapsen
vollständig adressiert werden können, sind folgende Informationen notwendig die Population,
das Zielneuron, der Dendrit des Zielneurons an dem die Synapse angeschlossen
ist und ein Zeiger auf die Synapse an dem Dendriten. Diese Verbindungen werden
in der Liste list_confront abgelegt, die Liste ist in der Klasse net definiert. Ein Iterator
auf diese Liste stellt die Verbindung zu dem nachfolgendem Neuron her. Die Reihe der
nachfolgenden Neuronen wird durch eine Liste von Iteratoren auf Elemente der Liste
list_confront dargestellt.
6.10.4 confrontit
Eine Liste vom Typ confrontit, beschreibt die Zeiger auf die Einträge in der Liste
der Vorwärtsverbindungen, damit die zugehörigen Synapsen und die nachfolgenden
Neuronen über einen eventuell auftretenden Impuls benachrichtigt werden können. Diese
Liste wird in jedem Neuron abgelegt.
6.10.5 dendrite
Hier wird die Liste der Synapsen verwaltet, die zu dem Dendriten gehört. Der Dendritetyp
wird gleichzeitig auch als Name verwendet, damit eine bessere Unterscheidung
der Dendriten erfolgen kann. Die Aufteilung ist notwendig, um z.B. mehrere Feeding-
Dendriten unterscheiden zu können. Durch die Aufteilung der Synapsen auf mehrere
Dendriten können z.B. unterschiedliche Parameter für verschiedene Feeding-Verbindungen
innerhalb der eigenen Population gegenüber den Feeding-Verbindungen zu anderen
Populationen verwendet werden.
TABELLE 2. Variablen der Klasse dendrite
Klassenvariablen Erklärung
list list_markram Liste der Synapsen
list::iterator daten_it Iterator auf die Dendriteparameter
TABELLE 3. Funktionen der Klasse dendrite
Funktion Erläuterung
dendrite() Konstruktor der Klasse
dendrite(QString dendrite_typ) Konstruktor mit Angabe des Dendritetyps
getPSPges(float time) Berechnung des postsynaptischen Potentials
aller Synapsen
addSynapse(int anz) fügt anz Synapsen dem Dendriten hinzu
addSynapse(markram synapse) fügt dem Dendriten eine Synapse mit dem
angegebenen Parametern hinzu.
delSynapse(int location) Löschen der Synapse an der angegebenen
Position
expandParameter() der Parametersatz wird in alle Synapsen des
Dendriten kopiert
setDatenIt(parent) Iterator auf die Dendriteparameter setzen
SpinnSoftSim 36

Die Parameter einer Population werden in einem Eintrag in der Liste
list_datapopulation zusammengefaßt, die verschiedenen Parameter der Dendriten werden
in einer weiteren Liste list_synapsendaten abgelegt. Diese Liste ist in der Populationsdefinition
enthalten. Jeder Eintrag in der Liste list_synapsendaten entspricht einem
Dendriten mit dem auf ihm sitzenden Synapsen. Die Synapsen eines Dendriten besitzen
alle die gleichen Parameter, dadurch kann der Speicherbedarf enorm verringert werden.
6.10.6 dlgctrlchoosepop
Bevor der Dialog zur Auswahl der Population, deren Ausgabe im mittleren Fenster
dargestellt werden soll, gestartet werden kann, ist es notwendig, vorher den Zeiger auf
das Neuronale Netz zu übergeben. Über einen Zeiger auf die Klasse net erfolgt der Zugriff
auf die Populationsnummer. Die Auswahl kann erst nach der Erstellung des Neuronalen
Netzes erfolgen.
6.10.7 dlgctrldend
Die Daten für die Initialisierung des Netzwerkes sind in der Liste
list_datapopulation in der Klasse MainWin definiert. Damit ein Zugriff auf diese Daten
erfolgen kann, ist es notwendig mittels der Funktion setDataPointer einen Zeiger auf
das Hauptfenster zu übergeben. Von der Liste der Dendritedaten wird eine Kopie angelegt,
alle Eingaben werden auf der Kopie der Daten durchgeführt. Erst bei Betätigung
der Schaltfläche „OK“ werden die geänderten Daten zurückgeschrieben. Damit ist gewährleistet,
daß bei Betätigung der Schaltfläche „Abbruch“ die ursprünglichen Daten
nicht verloren gehen. Ein Neuron verfügt über mehrere Dendriten. Um nicht mehrere
Masken für Dendritparameter erstellen zu müssen, wurde das Drehfeld eingefügt, mit
dem der gewünschte Dendrit dargestellt und seine Parameter geändert werden können.
Die Funktion changevalue nimmt die Aktualisierung der Dialogfelder vor. Für die Verwaltung
der Parameter der verschiedenen Populationen gibt es ein weiteres Drehfeld,
dies ist an die Funktion updatepopulation gekoppelt. Bei einem Wechsel der Population
wird auf den ersten Dendriten gewechselt, damit die Iteratoren initialisiert werden und
kein fehlerhafter Zugriff auf den Speicher erfolgt. Mit den Schaltflächen „Laden“ bzw.
„Sichern“ werden die Funktionen loaddend() bzw. savedend() aufgerufen, zum Laden
bzw. Sichern der Dendriteparameter.
6.10.8 dlgctrldyneu
Drei Drehfelder dienen zur Auswahl des Neurons, dessen Potentialverlauf während
der Simulation dargestellt werden soll. Mit der Funktion setNetPointer wird zuerst ein
Zeiger auf die Klasse net übergeben, damit ein Zugriff auf die Variablen glasspopulation,
glass_x und glass_y erfolgen kann. Diese Variablen beschreiben die Position des
Neurons im Neuronalen Netz.
6.10.9 dlgctrlhebb
Mit diesem Dialog wird die Zeit bestimmt, zu der die maximale Änderung des ausgewählten
Parameters durch „Hebb’sches Lernen“ erfolgen soll. Mit der Funktion set-
DataPointer wird ein Zeiger auf die Klasse net übergeben, damit ein Zugriff auf die
Variable time_hebb erfolgen kann.
SpinnSoftSim 37

6.10.10 dlgctrlneuron
Dieser Dialog dient zur Eingabe der Neuronparameter, vor dem Start des Dialoges
ist mit der Funktion setDataPointer ein Zeiger auf die Daten der verschiedenen Populationen
zu übergeben. In einer Population besitzen alle Neuronen die gleiche Parameter,
deshalb wird für jede Population ein Element in der Liste list_datapopulation
abgelegt. Die Liste ist in der Klasse MainWin abgelegt. Von dieser Liste
list_datapopulation wird in der Funktion setDataPointer eine Kopie angelegt. In der
Kopie der Daten werden alle Änderungen vorgenommen und bei Betätigung der Schaltfläche
„OK“ werden die geänderten Parameter zurück geschrieben. Andernfalls werden
bei Betätigung der Schaltfläche „Abbruch“ alle Änderungen verworfen. Unter Verwendung
des Drehfeldes spinpop kann die Population ausgewählt werden, das Drehfeld ist
mittels einer connect-Anweisung mit dem Funktion updatepopulation verbunden. Bei
Betätigung der Drehfeldschaltflächen wird die Funktion updatepopulation ausgeführt
und der Iterator wird auf das entsprechende Listenelement gesetzt. Die Funktion updatepopulation
führt die Funktion dlgneuroupdate aus, damit die dargestellten Parameter
aktualisiert werden. Unter Verwendung der Schaltflächen „Laden“ bzw.
„Speichern“ werden die eingegebenen Neuronenparameter aus einer Datei geladen bzw.
gesichert. Die Schaltflächen „Laden“ bzw „Sichern“ sind mit den Funktionen loadneuron()
bzw saveneuron() verbunden.
6.10.11 dlgctrlpop
Die Populationsanzahl wird unter Verwendung dieses Dialoges erfaßt. Bevor der
Dialog gestartet werden kann, ist der Zeiger auf die Klasse net und auf das Hauptfenster,
der Klasse MainWin zu übergeben. Zum einen wird die Anzahl der Populationen in der
Klasse net hinterlegt. Dies geschieht in der Variablen maxpopulation. In der Klasse
MainWin wird die Liste list_datapopulation mit den Neuronendaten inder angegebenen
Länge angelegt.
6.10.12 dlgctrlsstep
Für die Simulation kann zwischen dem automatischen Ablauf und dem Ablauf in
einzelnen Schritten gewählt werden. Der Dialog dlgsstep erscheint am Ende einer Zeitscheibe
und der Anwender kann den nächsten Simulationsschritt starten oder die Simulation
abbrechen.
6.10.13 drawfield
Die Klasse drawfield wurde für die Darstellung der Potentialverlaufs eines ausgewählten
Neurons, zur Darstellung des Histogramms und zur Aussgabe der Gaussverteilung
geschaffen. Die Intervalle für die Achsenskalierungen für die Zeit und die
Potentialhöhe bzw. die Zeit und die Anzahl der ausgelösten Impulse, sowie die zugehörigen
Schrittweiten für die Achsenbeschriftungen erfolgen durch die Funktion setEnviroment
für die Darstellung des Potentials und setHistoEnviroment für die
Histogrammdarstellung. Die Funktion zeroline zeichnet das Koordinatensystem für die
Potentialdarstellung und histozeroline für die Darstellung des Histgramms.
SpinnSoftSim 38

6.10.14 globalinhib
Zur Dämpfung der Aktivität innerhalb jeder definierten Population, sind die Anzahl der
aktiven Neuronen jeder Zeitscheibe für jede Population getrennt zu betrachten. Aus
dem Verhältnis der Änderung der Anzahl der aktiven Neuronen von zwei aufeinander
folgenden Zeitscheiben wird dann die Änderung des statischen Schwellwertes
bestimmt. Die Liste ist in der Klasse net definiert und ihre Länge entspricht der Anzahl
der verwendeten Populationen.
6.10.15 MainWin
Die Klasse MainWin stellt das Hauptprogramm dar. Es erfolgt im Konstruktor der
Klasse die Initialisierung des gesamten Programms, die Zeiger auf das Fenster für den
Eingangsreiz, die Aktivität einer ausgewählten Population und das Fenster der Antwort
des Neuronalen Netzwerkes. Das Fenster zur Ausgabe wird des Histogramms wird
ebenfalls erzeugt. Das Fenster zur Ausgabe des Potentialverlaufs, eines ausgewählten-
Neurons wird erst vor dem Simulationslauf in der Funktion netstart definiert. Es erfolgt
die Definition des Menüsystems mit der Anbindung an die jeweiligen auszuführenden
Funktionen. Die Umschaltung zwischen der Einzelschrittsimulation und dem automatischen
Ablauf über alle Zeitscheiben wird durch die Funktion singlestep durchgeführt
und entsprechend durch einen Punkt vor dem Menüeintrag gekennzeichnet. Es wird in
der Variablen b_singlestep festgehalten, welche Einstellung vorgenommen wurde, in
der Funktion netstart wird dann die Einstellung berücksichtigt. Wenn der Anwender
eine Sicherung aller Ausgangsbilder wünscht, so erfolgt die Änderung des Menüeintrag
durch die Funktion saveoutputtoggle, hier wird die Variable b_saveoutput geändert.
Auch der Wert dieser Variablen wird später in der Funktion netstart ausgewertet. Die
Darstellung des Ausgabefensters für die Potentialdarstellung erfolgt durch die Auswertung
des Wertes der Variablen b_dynamic in der Funktion netstart. Der Wert von
b_dynamic kann durch die Funktion dynamictoggle beeinflußt werden. Die Funktion
dynamictoggle kann durch den Menüpunkt „Potential darstellen“ ausgeführt werden.
Nach dem Laden des Eingangsreizes durch die Funktion loadsource werden die beiden
anderen Ausgabefenster in der gleichen Größe angelegt. Nach der Eingabe aller Parameter
werden die gewählte Anzahl an Synapsen durch die Funktion expandSynapsen
angelegt, der Aufruf erfolgt durch die Funktion expand. Die Funktion expand erzeugt
für jede Population, die der Bildgröße angepaßte Anzahl an Neuronen und erstellt ebenfalls
die Verbindungslisten. Um spätere Parameteränderungen an die entsprechenden
Neuronen in allen Populationen weiterzureichen wird die Funktion expandParameter
verwendet. Die Funktion InitNeuroNet erstellt das erste Neuron-Modell, während NeuroNetInit
die Initialisierung der dynamischen Parameter durchführt. Die Funktion netstart
führt die Simulation durch.
6.10.16 markram
Das Synapsenmodell nach Tsodyks und Markram wird durch diese Klasse dargestellt.
TABELLE 4. Variablen der Klasse markram
Variablen Erläuterung
b_fire Signal ob die Synapse zum erstenmal gefeuert hat
f_time_fire Zeitscheibe in der die Synapse zuletzt gefeuert hat
SpinnSoftSim 39

TABELLE 4. Variablen der Klasse markram
Variablen Erläuterung
f_R Menge des Neurotransmitters der im Synapsenkopf verbleibt, nach dem
Eintreffen eines Impulses
f_u Menge des Neurotransmitters der ausgeschüttet wurde
f_PSP postsynaptisches Potential der Synapse
imp_base Zeiger auf den Eintrag in der Liste der Rückwärtsverbindungen auf das
vorhergehende Neuron
daten_it Iterator auf die Synapsendaten
TABELLE 5. Funktionen der Klasse markram
Funktion Erläuterung
gettimefire ermitteln des Zeitpunktes wann die synapse zuletzt gefeuert hat
getu ermitteln des aktuellen Wertes der dyn. Menge des Neurotransmitters
getR ermitteln des aktuellen Wertes der verbliebenen Menge des Neurotransmitters
getPSP ermitteln des momentanen Membranpotentials
hasfired true, wenn die Synapse einmal gefeuert hat
fire berechnet neue Werte für u und R und das aktuelle Membranpotential
6.10.17 markramdata
Mit dieser Klasse wird eine Liste innerhalb jeder Population erstellt, jeder Eintrag in
dieser Liste umfaßt die Parameter eines Dendriten. Durch die regulären Strukturen
besitzen alle Neuronen der Population die gleiche Anzahl an Dendriten mit den gleichen
Parametern, da die Dendriten immer die selbe Aufgabe erfüllen. Die verwendeten
Variablen sind Tabelle 6 zu entnehmen.
TABELLE 6. Variablen der Klasse markramdata
Variablen Erläuterung
f_A Gesamtmenge des Neurontransmitters in der Synapse
f_U_0_std Neurotransmittermenge bei der ersten Ausschüttung
f_tau_rec Regenerationszeit der Neurotransmitter innerhalb der Synapse
f_tau_facil Wirkungsdauer der Neurotransmitter auf den Dendriten
f_tau_leaky Abklingkonstante des postsynaptischen Potentials
i_hebbvar Kennzeichnung auf welchen Parameter "Lernen nach Hebb" durchgeführt
werden soll.
f_hebbmax obere Grenze in %, für die Anpassung durch Hebb
f_hebbmin untere Grenze in % für die Anpassung durch Hebb
neighb_x Nachbarschaftsradius in x-Richtung
neighb_y Nachbarchaftsradius in y-Richtung
gauss_v Verstärkungsfaktor der Gaussverteilung
gauss_sigma Wichtung der Entfernung zwischen Sender- und Empfängerneuron
dendrite_typ Name und Typ des Dendriten
SpinnSoftSim 40

TABELLE 7. Funktionen der Klasse markramdata
Funktion Erläuterung
getA Ermittlung der Neurotransmittermenge der Synapse
getU_0 Ermittlung der Neurotransmittermenge beim ersten Ausstoß
gettau_rec Ermittlung der Regenerationszeit
gettau_fac Ermittlung der Wirkungsdauer
gettau_leaky Ermittlung der Ablingzeit des postsynaptischen Potentials
setA Setzen der Neurotransmittermenge der Synapse
setU_0 Setzen der Neurotransmittermenge die beim ersten mal ausgeschüttet
werden soll.
setTau_rec Setzen der Regenarationszeit
setTau_fac Setzen der Wirkungsdauer der Neurotransmitter auf den Dendriten
setTau_leaky Setzen der Abklingkonstanten des postsynaptischen Potentials
setHebbMax obere Grenze für Hebbsches Lernen setzen; die Angabe erfolgt in %
setHebbMin untere Grenze für Hebbsches Lernen setzen; die Angabe erfolgt in %
getHebbMax Ermittlung der oberen Grenze für Hebbsches Lernen
getHebbMin Ermittlung der unteren Grenze für Hebbsches Lernen
setHebbVar Auswahl des Parameters auf den Hebbsches Lernen wirken soll
getHebbVar Abfrage des Parameters auf den Hebbsches Lernen wirkt
setGaussV Verstärkungsfaktor für die Gaußkurve setzen
getGaussV Verstärkungsfaktor für die Gauß-Verteilung ermitteln
setGaussSigma Wichtungsfaktor der Gaußveteilung setzen
get‘GaussSigma Wichtungsfaktor der Gaußverteilung ermitteln
setInputFlag Wird gesetzt, wenn der Eingangsreiz aufgenommen werden soll
get InputFlag Ermittelt ob der Eingangsreiz von dem dendriten aufgenommen wird.
setNeighbour X- und Y-Radius des Nachbarschaftsbereich können gesetzt werden
setNeighbourX Setzen des Nachbarschaftsradius in horizontaler Richtung
set NeighbourY Setzen der vertikalen Nachbarschaftsradius
getNeighbourX Ermittlung des horizontalen Nacbarschaftsradius
getNeighbourY Ermittlung des vertikalen Nachbarschaftsradius
setType Setzen des Dendritypen und -namen
getType Ermittlung des Dendrittypen und -namen
load Laden der Parameter aus einer Datei
save Schreiben der Parameter in eine Datei
6.10.18 net
Diese Klasse beinhaltet alle Daten des Neuronalen Netzwerkes, die Daten der Populationen,
Neuronen, Dendriten und Synapsen, sowie die Listen zur Beschreibung der
Vorwärts-(list_confront) bzw. Rückwärtsverbindungen (list_conback) und die Listen
über die zubehandelnden Neuronen (list_aktiv_neuron) und Synapsen
(list_aktiv_synapsen), deren Eingangssynapsen aktiv waren. Aus den Elementen der
aktiven Synapsen werden die zugehörigen, in der nächsten Zeitscheibe zu behandelnen
Neuronen gewonnen. Die Variablen glass_population, glass_x und glass_y werden zur
Positionsbeschreibung des zu beobachtenden Neurons im Netz benötigt, dessen Poten-
SpinnSoftSim 41

tialverlauf, auf Wunsch des Anwenders dargestellt werden kann. In Anlehnung an den
gläsernen Menschen wird hier das gläserne Neuron eingeführt. Die Nummer der ausgewählten
Population, deren Aktivität im mittleren Fenster dargestellt werden soll, ist in
der Variablen popoutnr gespeichert. Das Zeitintervall in dem „Lernen nach Hebb“ die
maximale Wirkung hat ist in der Variablen time_hebb hinterlegt. Die Funktion connect
erstellt die Verbindungslisten für Verbindungen innerhalb der eigenen Population wie
in der Tabelle 8 dargestellt wird. N stellt das aktuelle Neuron dar, F beschreibt eine Feeding-,
L eine Linking und I eine inhibitorische Verbindung zu den benachbarten Neuronen.
Bei Neuronen am Rande der Population ist auf eine Änderung des Bereiches zu
achten, damit keine Zugriffe auf nicht definierte Speicherbereiche erfolgen. Verbindungen
zu benachbarten Populationen werden durch die Funktion popconnect erstellt. Ein
Neuron in der Population n überträgt seinen Impuls auf die neun Neuronen in der Population
n+1, wobei der Impuls von den Synapsen auf den Feeding-Dendrit aufgenommen
wird, ebenfalls wird sein Impuls an die Population n-1 übertragen. Dort wird der Impuls
von den Synapsen auf dem inhibitorisch wirkenden Dendriten aufgenommen. Die Er-
stellung der Einträge in die Liste der Vorgänger erfolgt durch die Funktionen addCon-
Back bzw für die Liste der nachfolgenden Neuronen durch die Funktion addConFront.
In der Klasse MainWin wird in der Funktion netstart während der Simulation festgestellt,
ob ein Neuron feuert. Wenn ein Neuron feuert, werden die nachfolgenden Synapsen
aktualisiert, die Aufnahme der nachfolgenden Synapsen in die Liste
list_active_synapsen erfolgt durch die Funktion addNewActive.
6.10.19 neurodisp
TABELLE 8. Verbindungen zu der eignen Population
L I L I L I
L I N L I
L I L I L I
TABELLE 9. Verbindungen zu benachbarten Populationen
Population n-1 Population n Population n+1
I I I F F F
I I I N F F F
I I I F F F
Dies ist eine Klasse zur Ausgabe der Neuronenparameter, zur Überprüfung des Verbindungsalgorithmus
in der Klasse net. Die Variablen population_nr, x_nr und y_nr beschreiben
die Position des Neurons innerhalb des Neuronalen Netzes. Ihre Werte
entsprechen den Werten in den Drehfeldern. Wenn der Inhalt eines Drehfeldes geändert
wird, werden die Iteratoren neu positioniert und die Daten des ausgewählten Neurons
werden in die Listbox eingelesen.
SpinnSoftSim 42

6.10.20 neuron
Diese Klasse beschreibt das modifizierte Neuronen Modell von Eckhorn.
TABELLE 10. Variabeln der Klassen neuron
Variable Erläuterung
list_dendrite Liste der Dendriten
list_connect Liste der Iteratoren auf die Einträge der Liste der Vorwärtsverbindungen
pos_nr dient zur Kontrolle des Verbindungen und der Simulation
population_nr dient zur Kontrolle des Verbindungen und der Simulation
MP Membranpotential des Neurons
time_fire Zeitpunkt des zuletzt ausgelösten Impulses
y_out Ausgangsignal des Neurons
Die Berechnung des Ausgangssignals erfolgt durch die Funktion calc_y_out, hier
wird die Variable time_fire gesetzt. Dies ist notwendig für die anschließende Anpassung
des ausgewählten Parameters, durch Lernen nach Hebb, in der die Zeitpunkte des Feuerns
der Synapsen zu der Zeit des Feuerns des aktuellen Neurons betrachtet werden.
Dies bezeichnet man als "Lernen nach Hebb". Die Funktion calc_y_out bedient sich der
Funktionen calc_Theta zur Bestimmung des Schwellwertes und calc_MP zur Berechnung
des Membranpotentials..
TABELLE 11. Funktionen der Klasse Neuron
Funktion Erläuterung
calc_MP Berechnung des Membranpotentials
calc_Theta Berechnung des Schwellwertes
calc_y_out Vergleich des Membranpotentials mit dem Schwellwert, bei Bedarf
wird ein Ausgangsimpuls gesendet.
gettime_fire Ermittlung des Zeitpunktes an dem das Neuron zuletzt gefeuert hat.
setParent Iteratoruebergabe des Iterators der auf die Population des Neurons
zeigt
6.10.21 piccourse
Wenn ein veränderter Eingangsreiz gewünscht wird, ist die Bildfolgeverarbeitung einzuschalten.
In dieser Klasse werden die gewünschten Bildnamen mit den Zeitscheiben
hinterlegt in denen die Bilder geladen werden sollen. Die Liste der Daten wird in der
Klasse MainWin erstellt. Während der Simulation wird zu Beginn einer Zeitscheibe der
neue Reiz in Form des gewünschten Bildes geladen, anschließend erfolgt dann die
Wertübernahme durch die zuständigen Synapsen.
6.10.22 picture
Unter Verwendung dieser Klasse werden die Aktivitäten der letzten Population, sowie
der ausgewählten Population dargestellt. In den Variablen xscale und yscale wird
der Skalierungsfaktor zur Darstellung hinterlegt. Dies ist bei der Verwendung von kleinen
Bildern interessant, da diese vergrößert dargestellt werden können, denn bei ihnen
erfolgt eine zügige Erstellung der Verbindungslisten. Mit der Funktion setColor kann
SpinnSoftSim 43

die gewünschte Zeichenfarbe bestimmt werden. Das Feuern eines Neurons wird durch
Setzen eines Pixel an der korrespondierenden Stelle im Bild dargestellt. Unter Verwendung
der Funktion showImage wird das Bild in das Ausgabefenster kopiert.
6.10.23 population
Eine Population stellt eine Reihe von Neuronen dar, welche in der Liste list_neuron
hinterlegt werden. Mit der Funktion putNeuron wird ein vorgegebenes Datenneuron
entsprechend der resultierenden Anzahl aus xmax und ymax, in die Liste der Neuronen
kopiert. Die Grösse der Population kann mittels der Funktion setSize bestimmt werden.
TABELLE 12. Variablen der Klasse Population
Variable Erläuterung
list_neuron Neuronenliste
pos_nr Nummer der Population, zur Kontrolle der Algorithmen
neuron_init Flag, ob die Neuronen erzeugt worden sind
connect_init Flag, ob die Verbindngslisten estellt worden sind
list_synapsendaten Liste der Dendritparameter jeder Element der Liste entspricht einem
Dendriten
xmax Ausdehnung der Population in horizontaler Richtung
ymax Ausdehnung der Population in vertikaler Richtung
dendrite_max Anzahl der Dendriten eines Neurons dieser Population
stat_Theta_std statischer Schwellwert der Population, kann nicht durch die globale
Inhibition verändert werden.
stat_Theta statischer Schwellwert der Population für alle Neuronen
dyn_Theta dynamischer Anteil des Schwellwertes dieser Population
beta Kopplungsfaktor zwischen dem Feeding und dem Linkingdendriten
t_Ra Absolute Refraktärzeit der Neuronen
t_Rr relative Refraktärzeit der Neuronen
TABELLE 13. Funktionen der Klasse Population
Funktion Erläuterung
setSize Die Parameter x und y bestimmen die Grösse der Population
get XSize Ermittlung der horizontalen Ausdehnung der Population
getYSize Ermittlung der vertikalen Ausdehnung der Population
pos Ermittlung der Positionsnummer aus der X- und Y-Koordinate
des Neurons
delNeuronen Löscht die Liste der Neuronen
putNeuronen Erstellt die Liste der Neuronen gemäß der vorher gesetzten Populationsgröße
getDendriteCounter Ermittlung der Länge der Liste list_synapsendaten
setDendriteCounter Setzen der maximalen Dendritanzahl
setStatTheta Statischen Schwellwert setzen
getStatTheta Statischen Schwellwert ermitteln
setStatTheta_inhib setzen des statischen Schwellwertes,
geändert durch die globale Inhibition
SpinnSoftSim 44

TABELLE 13. Funktionen der Klasse Population
Funktion Erläuterung
getStatTheta_inhib Ermittlung des statischen Schwellwertes
der bereits durch globale Inhibition geändert wurde.
setDynTheta Setzen des dynamischen Schwellwertes
getDynTheta Dynamischen Schwellwert der Population ermitteln
setBeta Kopplungsfaktor der Population setzen
getBeta Koplungsfaktor zwischen Feeding u. Linking-Dendriten ermitteln
setT_Ra Setzten der absoluten Refraktärzeit
getT_Ra Abfrage der absoluten Refraktärzeit
setT_Rr relative Refraktärzeit der Population setzen
getT_Rr Ermittlung der relativen Refraktärzeit
6.10.24 spinnsoftsim
Diese Datei stellt das Hauptprogramm dar. Es wird nur das Hauptfenster definiert
und dargestellt, alle Funktionen gehen dann von der Klasse MainWin aus.
6.10.25 spinncheck
Diese Klasse wird zur Kontrolle der Eingabe bei Drehfeldern verwendet, denn der
Anwender hat nicht nur die Möglichkeit unter Verwendung der beiden Schaltflächen
die dargestellte Zahl zu ändern, sondern er kann auch über die Tastatur direkt einen
Wert eingeben. Um fehlerhafte Eingaben von Buchstaben und Sonderzeichen zu vermeiden,
wird ein regulärer Ausdruck verwendet, der nur ganze Zahlen als Eingabe
zuläßt.
SpinnSoftSim 45

7. AUSWERTUNG
Das vorliegende Programm sollte als Werkzeug zur Auswertung des Verhaltens der
plastisch feuernden Synapsen dienen. Auf Grund des großen Wertebereichs und der
großen Sensibilität der Parameter, ist kein Vergleich zwischen dem Einsatz von spikenden
plastischen Synapsen gegenüber herkömmlichen pulscodiert arbeiten Synapsen in
Neuronalen Netzwerken zu stande gekommen.
Für die Betrachtung der herkömmlichen pulscodierten Neuronalen Netzwerke ist
kein weiteres Programm zu erstellen. Für hinreichend kleine Zeitkonstanten für die Regenerierung
bzw. Wirkungsdauer der Neurotransmitter geht u n gegen U und R wird 1.
Damit ergibt sich für das postsynaptische Potential der Synapse folgende Beziehung:
PSP = A x U. Dieser Wert kann mit einem Gewichtsfaktor der herkömmlichen Neuronalen
Netze verglichen werden. Auch hier konnten die bereits entdeckten Phänomene
nicht nach vollzogen werden. Dies zeigt die Empfindlichkeit der Neuronalen Netze auf
ihre Parameter.
Auch der Versuch einen einfachen Lernalgorithmus zu implementieren zeigte keinen
Erfolg. Das "Lernen nach Hebb" vergleicht nur die Zeitpunkte der eingehenden Impulse
mit den Zeitpunkten an denen ein eigener Impuls ausgesendet wird. Findet dies in
einem vorgegebenen Intervall statt, wird die Transmitterstoffmenge entsprechend angepaßt.
Bei diesem Lernverfahren findet keine Rückkopplung statt. Es kann keine Aussage
getroffen werden, ob die Änderung eine Verbesserung der Verbindung bringt, da
kein Vergleich mit dem Eingangsreiz statt findet.
Die Möglichkeit mit mehreren Populationen, weitere Parameter zur Verfügung zu
haben um das Verhalten des Netzwerkes positiv zu beeinflussen, brachten leider auch
nicht den gewünschten Erfolg. In der zweiten Population wurden die erkannten Segmente
immer größer und weiteten sich bis an die Grenzen des Netzes aus.
Zur Dämpfung der Netzaktivität wurde die globale Inhibition eingefügt. Hier wird
bei einer Steigerung der Netzaktivität der Schwellwert aller Neuronen der zugehörigen
Population angehoben. Es sollte eine Reduzierung der Netzaktivität erreicht werden, damit
erkannte Segmente eines Bildes nicht wachsen. Hier konnten keine stabilen Parameter
gefunden werden und die Netzwerkaktivität ging nach kurzer Zeit gegen Null.
Die Eigenschaft des Neuronalen Netzes, ein Objekt zu erkennen ist vorhanden. Für
gefundene Parameter erfolgt eine getrennte Darstellung von dem Rand und der Fläche
des Objektes. Die Fläche wird einen Pixel kleiner dargestellt als das Objekt. Kinser beschreibt
ebenfalls diese Eigenschaft pulsgekoppelter Neuronaler Netzwerke in seinem
Buch [5]. Das Problem der Kantendetektion wir ebenfalls von David Horn und Irit Opher
dargestellt [16].
In ausgewählten Zeitscheiben erfolgt eine Umschaltung zwischen der Fläche, Kante
und Ecken dieser Vorgang erfolgt aber nicht stabil. Die dargestellten Kanten und Flächen
verlaufen mit der Zeit. Bei Betrachtung des Potentialverlaufs eines ausgewählten
Neurons, ist zu erkennen, daß das Potential des Linkingdendriten zu stark ansteigt und
den Wert des absoluten Schwellwertes übersteigt. Womit dann das Neuron seinen definierten
Wertebereich verläßt. Das Membranpotential eines Neurons ist immer kleiner
gleich dem aktuellen Schwellwert.
SpinnSoftSim 46

Bild 22. Bildfolge zur Kantenerkennung
SpinnSoftSim 47

8. ZUSAMMENFASSUNG
Das SPINNSoftSim-Programm wurde entwickelt, um eine Gegenüberstellung zwischen
herkömmlichen Neuronalen Netzen mit gewichteten Eingangswerten und Netzen
mit plastischen Synapsen zu erstellen. Zunächst wurde ein Synapsenmodell gebildet,
daß dem Tsodyks-Markram-Modell entspricht. Auf eine Speicherung der Zustandswerte
der aktuellen Zeitscheibe wurde verzichtet, denn es wird die Differenz zwischen dem
Zeitpunkt des letzten Eintreffens eines Impulses und der aktuellen Zeitscheibe bestimmt.
Das Abklingen erfolgt dann durch die Exponentialfunktion. Das Programm zur
Darstellung der Synapsenplastizität wurde erweitert um die Summation der Synapsenpotentiale
zur Berechnung des Dendritpotentials und die Bildung des Membranpotentials.
Als Neuronmodell wurde das Marburger Modells gewählt und es wurde um die
Eigenschaft der absoluten Refrakträrzeit erweitert, damit es seinem biologischem Vorbild
einen Schritt näher kommt. Die Implementierung der Synapsenplastizität brachte
keinen Unterschied zu den Erkenntnissen der Arbeitsgruppe aus Marburg. Der nächste
Schritt war die Vervielfältigung des Neurons und die Erstellung einer Verbindungsliste.
Mit den Erkenntnissen der Vorreiter aus Marburg war kein Fortschritt zu erzielen. Die
experimentell ermittelten Parameter aus Marburg brachten keine Ergebnisse. Die Kantendetektion
war die einzige nachvollziehbare Eigenschaft, die das erstellte Neuronale
Netzwerk offenbarte. Aber die Segmentierung von einzelnen Bildregionen hat das
Netzwerk nicht im gewünschten Maß hervorgebracht. Das Feuern einer Synapsengruppen
bleibt in einigen Zeitscheiben aus, aber eine Bildsegmentierung wie sie für pulscodierte
Neuronale Netze beschrieben wird, war nicht zu erkennen. Erst die Erkenntnisse
von Johnson, brachten den Ansatz einer Objektsegmentierung. Es findet immer noch
keine vollständige Segmentierung statt, aber die Teile der Bildelemente werden in der
Netzantwort zumindest wechselweise dargestellt.
Um Unzulänglichkeiten bei der Parameterwahl zu reduzieren wurde ein Algorithmus
für "Lernen nach Hebb" implementiert. Durch "Lernen nach Hebb" wird die dynamische
Transmitterstoffmenge erhöht, wenn innerhalb einer gesetzten Zeitspanne das
Neuron nach dem Eingang eines Reizes selbst einen Impuls aussendet, andernfalls wird
die Menge des Transmitterstoffes reduziert. Eine Verbesserung bei der Segmentierung
von Objekten im Bild oder bei der Kantenerkennung waren nicht zu erkennen. Für einen
hinreichend langen Simulationszeitraum war durch die Beobachtung von ausgewählten
Neuronen zu erkennen, daß das Membranpotential überaus stark ansteigt und den definierten
Bereich verläßt, das System wird instabil. Ein Nachteil ist, daß kein direkter
Vergleich mit dem Eingangsreiz vorgenommen wird
Um diesen Umstand des ständigen Potentialanstiegs zu berücksichtigen wurde eine
Funktion zu Bestimmung der globalen Inhibition implementiert. Diese Funktion erhöht
den statischen Schwellwert aller Neuronen innerhalb einer Population, wenn die Aktivität
innerhalb der Population ansteigt. Aber nach einigen Simmulationsschritten ging
die Aktivität gegen Null.
Unter Umständen stellt sich der Erfolg ein, wenn ein geeigneter Lernalgorithmus installiert
wird oder der Einfluß der Nachbarschaft weiter vergrößert wird und damit eine
geänderte Vebindungsstruktur zum Einsatz kommt.
Die Erstellung eines eigenen Programms zur Simulation eines Neuronalen Netzwerkes
mit plastischen Synapsen ist gerechtfertigt, da vorhandene Simulatoren entweder
die Synapsenplastizität nicht berücksichtigten oder ihre Programmierung zu komplex
ist. Als Vorteil dieses Programmes ist zu nennen, daß der Quellcode des Programms
SpinnSoftSim 48

vorliegt und den eigenen Anforderungen angepaßt werden kann, ohne weitere Arbeitsgruppen
um ihre Hilfe zu bemühen. Das SpinnSoftSim-Programm verwendet zur Darstellung
des Abklingverhaltens die Exponentialfunktion, während bei der Realisierung
des SPINN-Chips das Abklingen der Potentiale durch Geradenfunktionen angenähert
wird. Durch Änderung dieses Sachverhaltes in den entsprechenden Programmfunktionen
kann eine Annäherung an das SPINN-Konzept erfolgen und Abweichungen zum ursprünglichen
Modell können aufgezeigt werden. Der Ansatz der Synapsenplastizität ist
für die Verwendung in Neuronalen Netzen ein neues Gebiet, auf dem es, bis jetzt, kaum
vergleichbare Ergebnisse gibt, da die Parameterwahl stark von der gestellten Aufgabe
abhängig ist. Für Aufgaben aus dem Bereich der Bildbearbeitung wurde der Wertebereich
der biologischen Neuronen verlassen. Die Zeitkonstanten im Sekundenbereich
wurden durch Werte im Millisekundenbereich (ca. 10 ms bis 300 ms) ersetzt. Für diese
Werte wurde eine bessere Kantenerkennung erreicht.
Mit einem Verhaltenswechsel der Synapsen des Linkingdendriten vom Facilityzum
Depressionverhalten ergeben sich ähnliche Netzantworten. Es findet für die verschiedenen
Zeitscheiben ebenfalls ein Wechsel zwischen der Kante und der Fläche in
der Netzantwort statt. Auch die teilweise Segmentierung der Bildelemente ist in der
Netzantwort zu erkennen.
SpinnSoftSim 49

9. ANHANG VERWENDETE LITERATUR
TABELLE 14. Auflistung der verwendeten Literatur
1 Zell Andreas; Simulation neuronaler Netze;
Oldenburg Verlag ; ISBN 3-486-24350-0
2 Hagenbach Jochen
Entwicklung eines universellen dynamischen Neuronenmodells und Implementierung eines
Simulationsprogrammes für Vernetzungen dieses Modells
3 Natschläger Thomas;
Netzwerke von "spiking" Neuronen : Die dritte Generation von Modellen für Neuronale
Netzwerke
4 Mehrtash Nasser
Das SPINN-Konzept
5 Lindblad Thomas, Kinser Jason
Image Processing using Pulse- Coupled Neural Networks
6 Eckhorn Reinhard;
A Neural Network for scene segmentation by temporal coding
7 Wehner Rüdiger, Gehring Walter
Zoologie; Thieme Wissenschaft ISBN 3 13 367422 6
8 Czihak G, Langer H., Ziegler H.
Biologie ; ISBN 3-540-56003-3
9 Frings Stephan
Kernforschungszentrum Jülich
Biologische Informationsverarbeitung
www.kfa-juelich.de/ibi/ibi-1/ibihome.html
10 Mehrtash Nasser;
Entwicklung des nichtregulären Gewichte-Moduls für den Neurocomputer NESPINN
11 Ranganath, H.S.;
Iterative segmentation using pulse coupled neural networks
12 Markram Heny, Tsodyks Misha;
Potential for multiple mechanisms, phenomena and algorithms for dynamic plasticity
at single synapses
13 Loukides, Mike & Oram, Andy;
GNU Software; O’Reilly; ISBN 9 78390 673322
14 Breymann Ulrich;
Komponenten entwerfen mit der C++ STL; Addison Wesley ISBN 9 783827 314741
15 Dalheimer, Matthias Kalle;
Programming with Qt; O’Reilly; ISBN 9 781565 925885
16 Horn, David and Opher, Irit
Collective Excitation Phenomena and their Applications
17 Press, William
Numerical Recipes in C; Cambridge University Press
18 Gabbiani, Fabrizio
Signal Processing Techniques for Spike Train Analysis Using MatLab
http://klab.caltech.edu/~gabbiani/signproc.html
19 Johnson John,
Pulse-coupled neural nets: translation, rotation, scale, distortion, and
intensity signal invariance for images
SpinnSoftSim 50