Inleiding

Niemand kan met droge ogen beweren dat knopen in connectionistische netwerken in het werking lijken op neuronen. Hoe meer bekend wordt over neuronen, hoe ingewikkelder ze lijken en hoe duidelijker het wordt dat ze niet functioneren als eenvoudige optellers en doorgevers van inputs. Knopen hoeven ook niet te lijken op biologische neuronen. Nog afgezien van dat het niet de ambitie van elke connectionist is om het brein te simuleren, is realisme op het niveau van de neuron misschien niet nodig om realisme op het niveau van het hersendeel te bereiken. Er zijn ook kosten verbonden aan het simuleren van realistische neuronen. Het kost zoveel rekenwerk om neuronen realistisch te modelleren dat het vaak onmogelijk is grote netwerken te bouwen. Bovendien wordt het simuleren met zulke neuronen al snel zo ingewikkeld dat resultaten nauwelijks meer te interpreteren zijn. Als modelleerder heb je hier een trade-off: hoe meer detail in het neuron hoe realistischer een simulatie kan worden. Hoe minder detail, hoe makkelijker het is om grote netwerken te bouwen en hoe uitgebreider je simulatie kan zijn.

Toch wordt steeds vaker getracht om netwerkknopen zo veel mogelijk te laten lijken op neuronen. Dat heeft veel te maken met de explosie van de neurowetenschappen: de laatste decennia is er zoveel nieuwe kennis beschikbaar geworden over het brein, van het biochemische niveau tot aan het niveau van de twee hemisferen, dat het niet meer onrealistisch is om bijvoorbeeld een model voor de hippocampus te ontwerpen. Onder de noemer ‘computationele neurowetenschap’ bloeit een heel veld op waarin breindelen gesimuleerd worden met behulp van neurale netten, of de interactie tussen twee hersengebieden.

Soms zijn deze modellen klassieke netwerken met klassieke eenheden, en is enkel in de structuur van het netwerk informatie over breinanatomie verwerkt. Vaak echter wordt ook getracht te werken met zo realistisch mogelijke ‘neuronen’. In de model-neuronen worden expliciet membraanpotentialen, ionenstromen, ‘spike’-eigenschappen en de werking van verschillende neurotransmitters gesimuleerd op een realistische tijdsschaal van milliseconden. Meestal wordt het gedrag van zulke model-neuronen bepaald door een ingewikkeld stelsel van differentiaalvergelijkingen.

Een voorbeeld van zo’n model-neuron is de MacGregor-eenheid . Oorspronkelijk bedoeld voor het begijpen van electrofysiologische data (opnames van membraanpotentialen van individuele neuronen), wordt dit model nu regelmatig gebruikt voor connectionistische simulaties. In een bijgeleverde tekst (appendix 1) wordt de werking van de neuron uit de doeken gedaan. MacGregor-neuronen zijn overigens nog relatief eenvoudig vergeleken met meer recente modellen .

Het MacGregorparadigma

-Open Nutshell, en open een "MacGregor"-workspace.

-Klik op Insert Layer om een layer aan te maken. Klik de laag aan, klik op de rechtermuisknop om het menu zichtbaar te maken, ga naar "Layer" en klik op ‘parameters’. Klik het vinkje bij "Is kWTA" (laatste parameter) weg. Of knopen vuren wordt nu niet meer bepaald door een k Winner Take All-mechanisme, maar door of de activatie van de knoop over een threshold komt.

-Kijk naar de andere parameters. Als je op het vraagtekentje klikt rechtsboven het parameterwindow verandert je cursor in een vraagteken. Klik je nu op variabelenaam dan krijg je een regeltje uitleg te zien over de parameter. Een aantal parameters hebben te maken met tijd: met bijvoorbeeld de snelheid waarmee kalium ‘wegsijpelt’ uit de neuron. Er is er ook eentje die bepaalt of de laag inhiberend (vinkje) dan wel exciterend (geen vinkje) is, d.w.z. of alle knopen in de laag inhiberende connecties leggen of exciterende.

-Klik op een knoop, en kijk naar de parameters. ‘Act’ is het membraanpotentiaal, ‘Potas’ (van Postassium) de kaliumconcentratie. Fire is een binaire variabele: vinkje betekent dat de knoop in de huidige iteratie vuurt. ‘Clamped’ and ‘deactivated’ hebben hun gebruikelijke betekenissen.

5.1 Kennismaken met MacGregor

Vorm een eenvoudig netwerk: twee lagen van 1 bij 1 knoop, en een verbinding van laag 1 naar laag 2. Klik bij elke laag het vinkje bij "Is kWTA" (laatste parameter) weg, zodat vuren door de ‘threshold’ bepaald wordt (anders worden steeds de ‘k’ knopen met de meeste activatie actief).

a) Kijk wat er gebeurt als je de activatie of de kalium-concentratie verandert. Verander in de knoop van layer 1 de activatie van 0 naar 4. Verander in de knoop van layer 2 de kaliumconcentratie van 0 naar 18. Run een aantal iteraties zonder leren (klik hiervoor op de knop voor de functie ‘Cycle’). Beschrijf wat er met beide knopen gebeurt voor een aantal iteraties (oftewel, check de parameters).

b) Bekijk in Appendix 1 de formule voor de activatie, formule 1, uit Murre & Raffone (in prep.). Dit is een zogenaamde differentiaalvergelijking. Zo’n vergelijking geeft de verandering van een bepaalde variabele (dU/dt) als functie van o.a. de huidige waarde van de variabele (U). De U uit de eerste vergelijking is het membraanpotentiaal, de variabele die bepaalt of de neuron gaat vuren. G^k, uit de tweede vergelijking, is de kaliumconcentratie. Nadat een neuron heeft gevuurd stroomt kalium de cel binnen, wat het moeilijker maakt nog eens te vuren. Dit veroorzaakt de relatieve refractaire periode na het vuren.

Om differentiaalvergelijkingen te kunnen gebruiken voor een simulator moet je ze integreren (tegengestelde van differentiëren). Je kunt hun gedrag echter ruw benaderen door ze als discrete stappen te zien. Je neemt dan de waarden van U en andere variabelen (bijv. G^k) om hun verandering uit te rekenen (bijv. DU), telt die op of trekt die af van de uitgangswaarden om de waarden in de volgende tijdsstap te berekenen. Vervolgens bereken je weer de verandering in die volgende tijdsstap, etc.

Neem als uitgangswaarden voor een pyramidale neuron op t=0: U = 2 (of U=-45 als je de millivoltagewaarden wilt gebruiken), en G^k = 0. In elke tijdsstap komt er excitatie (G^ex) bij de neuron aan ter grootte van 0.25. De neuron vuurt op tijdsstip 0 (ga dit na). Bereken de waarden voor U, G^k en S voor 10 tijdsstappen. Reken steeds eerst G^k door, gebruik die waarde om de verandering in U te berekenen, en dan de nieuwe U om te kijken of de neuron vuurt. Rond af op 1 of 2 decimalen.

Zet de waarden in een Excel-sheet (met U, G^k en S in drie rijen, en elke tijdsstap in een nieuwe kolom). Maak er een grafiek van (selecteer alle cellen met data en druk op "Chart Wizard"-knop, een knop met iets dat op een staafdiagram lijkt. Mocht het misgaan, excel-help vertelt uitgebreider hoe het moet). Lijkt het gedrag van je pyramidaalneuron op dat van de neuronen in vraag a?

c) De Hebb regel stelt dat een verbinding wordt gevormd als de pre- en postsynaptische neuron tegelijk vuren. Zo is het niet in realiteit en zo is het ook niet bij MacGregorneuronen. In realiteit moet de presynaptische neuron vuren iets voor dat de postsynaptische vuurt, anders treedt geen LTP op. Check hoe het zit bij MacGregorneuronen, als volgt: reset beide layers (functie "reset layer"). Klik op beide knopen en zorg dat ze vuren (klik op het vierkantje achter de parameter "Fire" om het vinkje te laten verschijnen). Doe 1 iteratie waarin zowel de activatie geupdate als geleerd wordt (functie ‘Cycle and Learn’). Check of het gewicht in de connectie tussen de twee knopen is veranderd.

Wanneer leert het model wel?

5.2 Input-Output vs. attractor

a) Open een nieuwe MacGregor-‘workspace’ in Nutshell. Vorm een netwerk van twee lagen van 5 bij 5, en een verbinding van de eerste (input-) laag naar de tweede (output-) laag. Zorg er, als bij 5.1, voor dat beide lagen niet "k-WTA" zijn.

Klik op een laag, klik op de rechtermuisknop, en vervolgens op "Properties" in het menu. Verander de parameter die gevisualiseerd wordt van "Act" naar "Fires". Je ziet nu welke knopen vuren, en als je met je linkmuisknop op een knoop dubbelklikt verander je hem/haar van vuren naar niet-vuren of omgekeerd (ga dit na). Teken, door dubbelklikken, een patroon van vurende knopen op de twee lagen. Leer het patroon zonder activatie-update voor 1 iteratie (hiervoor kan je de "Learn"-functie in het menu gebruiken. Selecteer de inputlaag en ‘clamp’ hem ("clamp"-functie in linkermene): de toestand van de knopen in deze laag blijft nu onveranderd bij het ‘updaten’ van de activatie. Druk op "cycle". Blijft het patroon in de outputlaag actief? Hoe sterk moeten de gewichten in de "tract" van input- naar outputlaag zijn om het patroon actief te houden?

b) Vorm een netwerk van 1 laag van 10 bij 10, en zorg er weer voor dat hij niet k-WTA is. ‘Insert’ een ‘tract’ van de laag naar zichzelf. Klik op de tract, en zet de positieve leerparameter op de waarde die je in opdracht 5.2 a vond. Doe verder hetzelfde als in a: verander de parameter die gevisualiseerd wordt weer van ‘Act’ naar ‘Fires’, teken een patroon van vurende knopen in de laag, leer dit patroon voor 1 iteratie zonder activatie-update (functie ‘learn’). Druk op "cycle". Blijft het patroon bestaan? Waarom of waarom niet? Wat zegt dit al dan niet over het bestaan van attractor-netwerken in het brein?

5.3 Short-term memory

Het korte-termijngeheugen is een concept dat de meesten van jullie al wel opgepikt zullen hebben in jullie studie. Het gaat hier om het korte tijd (enkele seconden tot minuten) actief houden van een paar items in het geheugen. Vaak wordt de beroemde frase van Miller geciteerd: "the magical number seven, plus or minus five" (bijv. , maar als de omvang van het korte-termijngeheugen op andere manieren wordt onderzocht dan rijtjes opzeggen, blijkt het meestal om een capaciteit voor iets als vier ‘chunks’ te gaan.

Hoe werkt korte-termijngeheugen in het brein? Connectionisten namen al in de jaren zeventig aan dat de activatie in hun netwerk gelijk stond aan korte-termijngeheugen, terwijl de gewichten gelijk stonden aan lange-termijngeheugen. En ja, zo lijkt het te zijn. Vooral in de frontale lob –maar ook elders- blijken cellen aanwezig die vuren gedurende een heel interval waarin een item in het korte-termijngeheugen verbleef.

Een recent idee is dat de neuronen in de frontale cortex die betrokken zijn bji het korte-termijngeheugen sterke, specifieke, reciproke verbindingen hebben met neuronen in de thalamus. Met andere woorden: zo’n neuron in de frontale cortex zou zo sterke connecties hebben met een cel in de thalamus en vice versa, dat ze elkaars vuren zouden kunnen onderhouden in een ‘loop’: de frontale neuron vuurt, dat laat de thalamusneuron vuren, die zorgt dat de frontale neuron weer vuurt, etc. hebben deze gedachte uitgebouwd tot een connectionistisch model waarmee ze het korte termijngeheugen simuleren. Dit model, of misschien net een tikje simpeler, gaan jullie hier, nu, nabouwen.

Open het bestand ‘MacScript’. Open de Visual Basic-code. Run het script "MacGregor3ab" (in de module "MacGregor3ab"). Je zult zien dat het script een ‘MacGregor’-workspace opent, een model erin tekent, en dan bij een "breakpoint" stopt (een ‘breakpoint’ is een onderbreker van de code). Stop de code helemaal (je kunt hiervoor ‘Reset’ in het ‘Run’-menu aanklikken of het blauwe vierkant in de taakbalk. Klik naar Nutshell en kijk naar het model.

Het model heeft drie lagen: een ‘frontale’ laag van 6 knopen ("Front." geheten), een thalamuslaag van 3 knopen ("Thal."), en een Globus Palliduslaag van 1 knoop ("Pally"). De Globus Palliduslaag is een ‘resetter’: de laag is inhibitoir; activiteit ervan zorgt ervoor dat de thalamuslaag gedeactiveerd wordt, zodat de thalamocorticale ‘loop’ onderbroken wordt.

De eerste twee frontale knopen moeten verbonden raken (=de connectie moet een groot gewicht krijgen) met thalamusknoop nr. 1, terwijl de derde en vierde frontale knopen met de tweede thalamusknoop verbonden moeten raken, knoop 5 en 6 met de derde thalamusknoop. De connecties van de thalamus terug naar de frontale laag zijn hetzelfde: van Thal. 1 naar Front 1 & 2, etcetera. Zo kunnen zich drie losse, onafhankelijke thalamocorticale loops vormen. De Pallidusknoop moet sterke verbindingen krijgen met beide Thalamusknopen.

Het model werkt als volgt: in alle frontale knopen komen zo af en toe sterke ‘random’ inputs binnen van buiten het model binnen (dit is ingesteld via de parameters…., en stelt de ‘input’ uit de posterieure neocortex voor). Dit zorgt ervoor dat op een gegeven moment een frontale knoop zal vuren. Dit laat de verbonden thalamusknoop vuren, waarop de thalamocorticale loop zichzelf in stand zal houden.

De thalamocorticale knoop kan op twee manieren onderbroken worden. Ten eerste wordt in elke iteratie waarin een knoop vuurt de kaliumconcentratie hoger. Op een gegeven moment zal deze zo hoog zijn dat knopen niet meer kunnen vuren, ook al krijgen ze input binnen in hun ‘loop’. Aangezien, als de ene zijde van de ‘loop’ stopt met vuren de andere geen input meer krijgt, zal de hele ‘loop’ stoppen met vuren. De tweede mogelijkheid is dat het organisme zijn aandacht verlegt en zijn interesse in het in STM vastgehoudene verliest. Op hier niet onderzochte wijze zal dat leiden tot activatie van de globus pallidus-knoop. Die zal de thalamus-knopen allemaal inhiberen, wat de actieve thalamocorticale ‘loops’ zal onderbreken.

a) Schrijf in de module "MacGregor3ab" een stukje script-code dat alle verbindingen aanlegt beschreven in het bovenstaande. Voorbeelden voor de commando’s die je hiervoor nodig hebt staan in appendix 2. Dit kan je rechtstreeks doen door de gewichten aan een zekere waarde gelijk te stellen, of je kunt alle knopen die je wilt verbinden laten vuren, de leerparameter in de te veranderen connecties op de door jou gewenste gewichtssterkte zetten (en alle andere leerparameters op 0) en 1 keer het commando ‘learn’ in de code geven, dan alle lagen te resetten en de knopen voor een andere verbinding aan te zetten. Omdat dit een flinke lap code wordt moet je dit alles in de speciale subprocedure ‘SetAllWeights’ doen die in de hoofdprocedure wordt aangeroepen. Tips voor de gewichtssterktes zijn aanwezig in de subprocedure. Als je alles handig cut ’n paste is het niet veel werk. Test je werk door het script te runnen en de gewichten te controleren.

b) Nu dat alle gewichten er zijn kan je testen of het model werkt. Test de volgende sequentie: bij 1 knoop in de frontale laag stel jij in zodat hij vuurt. Vervolgens laat je het model een heel stel iteraties de activatie opdaten (commando ‘cycle’). Als het goed is wordt de loop waar de frontale knoop deel van is actief. Deze blijft actief net zo lang tot het opgebouwde kalium een knoop ‘velt’. Schrijf een stuk code in het script dat de frontale knoop actief maakt en het model laat ‘cyclen’. Omdat je wel moet kunnen zien wat je doet is de "wait"-subprocedure uit opdracht 4 hier ook aanwezig. Je kunt de aanroep van deze subprocedure overal zetten waar je wat langer wilt kijken wat er gebeurt. Het eerste indexje bepaalt hoeveel seconden het wachten ongeveer duurt (hangt een beetje af van je computer). Hoeveel iteraties duurt het voor de ‘loop’ stopt? Welke laag geeft het eerst op? Waarom?

c) Open de module "MacGregor3c", en paste de code die je voor 5.3a hebt geschreven op de juiste plaats in het script. Er zijn nu twee globale constanten bij gekomen, eentje die de hoeveelheid ‘random’ inputs aan de frontale laag regelt, en eentje die hun sterkte regelt. Verander deze constante van 0 naar een waarde die een knoop echt kan laten vuren. Schrijf een stuk code in het script dat het volgende doet: minstens veertig iteraties lang moet de activatie geupdate worden. Tijdens elke iteratie moet de activatie van alledrie de thalamusknopen in de resultatenmatrix worden weggeschreven. Stel dat je de variabele die het aantal iteraties aanwijst "it" noemt. Stel in elke iteratie results(it,0) gelijk aan de activatie van knoop 1, results(it,1) aan knoop 2, results(it,2) aan knoop 3.

Run het script; als het goed is wordt er nu een excel-sheet aangemaakt waarin de activatie van de drie thalamusknopen (en dus de drie thalamocorticale loops) in de tijd wordt uitgezet. Bespreek de resultaten.

d) Verzin zelf nog iets dat je met het model wilt testen. Schrijf er code voor.

Kijk hoever je komt met opdracht 5.3, vraag om raad als je vast zit en de deadline nog ver is, schrijf er een verslag van, lever dat en de file ‘MacScript’ met je veranderingen in het script voor de deadline bij ons in. Belangrijk: voeg aan je verslag een discussie-sectie toe, waarin je het model evalueert. Voegt dit soort modelleerwerk in jouw opinie veel toe aan de wetenschap?

The model neuron involves three state variables that include transmembrane potential (U), a potassium current () and the neuronal output (S). The evolution of a neuron’s state is described by the following coupled differential equations

(1)

(2)

(3)

in which and (5 ms) are the transmembrane resting potential and time constant respectively. Excitatory () or inhibitory () input drives the potential towards the respective ionic equilibrium values and . is the equilibrium potential of the potassium conductance , the evolution of which is governed by Equation (2). When an output event S occurs, the potassium conductance rises abruptly by a given amount b for excitatory and inhibitory cells respectively), and then decays exponentially with time constant . The potassium conductance parameters are chosen such that the firing rate of inhibitory cells is higher than that of the excitatory ones. Equation (3) is a conventional threshold rule. Unlike in the MacGregor model neuron [ref. MacGregor], we used a fixed threshold value . The values of the equilibrium potentials, the resting potential and the threshold, may be linearly transformed to physiological values (= 0 º -75 mV; =1 º -60 mV; = 7 º 30 mV; = -1 º -90 mV ; =-1 º -90 mV; b = 12 and = 15 ms for pyramidal cells; b = 5 and = 7.5 ms for stellate cells). The conductances of pyramidal cells are

(4)

(5)

in which the excitatory conductance is the sum of synaptic inputs from connected pyramidal cell (Pyr set) and an external input conductance , given by a stochastic spike train with probability of spike event (0.075, with one time of 1 ms) and a strength (0.4). The inhibitory conductance is the weighted sum of synaptic inputs from connected stellate (Stell set) cells.

In deze appendix geven we een aantal voorbeelden van script-commando’s die je nodig hebt om de code te schrijven voor opdracht 5.1. Veel van deze commando’s kan je in elk paradigma gebruiken, maar niet alle. Sommigen zijn specifiek voor ‘MacGregor’.

Het basisprincipe achter de commando’s is simpel: je schrijft uit wat je in het programma zou doen. Als je bijvoorbeeld een laag wilt ‘resetten’, dan moet je de laag selecteren, en vervolgens de functie ‘reset layer’ aanklikken. Tijdens het scripten selecteer je de laag door hem ‘aan te roepen’ (via "workspace.layer(0)" bijvoorbeeld), en dan schrijf je een punt, en de functienaam. De functienamen -en voor de parameternamen geldt hetzelfde- die je bij het scripten gebruikt zijn precies dezelfde als degenen die je in Nutshell ziet, alleen worden de spaties weggelaten. "Reset Layer", de functienaam in Nutshell, wordt zo bijvoorbeeld "resetlayer". Het volledige commando wordt dan: "workspace.layer(0).resetlayer". Klaar.

Instellen van het vuren (nodig om knopen te laten leren):

Stel dat je de eerste knoop van de frontal layer wilt laten vuren. Dan doe je:

frontLayer is hier een variabele die naar de frontale laag verwijst. Zulke variabelen gebruiken is handiger dan de standaardmanier gebruiken waarop nutshell naar lagen verwijst, nl. mte behulp van het laagnummer. Zonder die variabele was het geworden (frontLayer is laag 0):

De meeste computertalen beginnen te tellen bij '0'; de eerste knoop heet dus 'node(0)', de tweede node(1) etc... frontLayer.node(0) verwijst daarom naar de eerste knoop van de frontLayer. Vuren is een ‘booleaanse’ variabele, een variabele die ‘true’ is als de knoop vuurt en ‘false’ als de knoop niet vuurt. Activatie –het membraanpotentiaal- is geen booleaanse variabele maar een getal. Als je in plaats van het vuren de activatie had willen stellen op 0.5, zou je kunnen schrijven:

Instellen van een gewicht

Stel dat je het gewicht van de vierde knoop van de frontale laag naar de tweede knoop van de thalamuslaag wilt instellen op 0.5. Dan geef je als commando:

Connectionisten hebben de wat onintuïtieve afspraak dat de ontvanger eerst komt in de indexen van een gewicht, en dan pas de zender. In Nutshell is dit zo zowel op het niveau van ‘tracts’ (bundel connecties van één laag naar een andere laag) als op het niveau van individuele connecties. "Tracts(thalLayer, frontLayer)" is dus de tract van de frontlayer naar de thalamuslayer, Tracts(thalLayer, frontLayer).connections(2,4) is de connectie van de 4e frontale knoop naar de 2e thalamusknoop. Daar roep je het gewicht van aan, en dat zet je gelijk aan 0.5.

Instellen van de leerrate

Als je de leerparameter ‘mu’ wilt instellen op 0.4 in de ‘tract’ van de frontale laag naar de thalamuslaag schrijf je:

Weer gebruiken we variabelen om naar de lagen te verwijzen. Vergeet niet dat de ontvanger eerst komt in het aanroepen van de ‘tract’, en dan pas de zender. Er is een aparte leerparameter voor elke ‘tract’; d.w.z., voor elke bundel connecties van één laag naar een andere laag. Als je de leerparameter voor de ‘tract’ van laag 1 naar laag 2 verandert, blijft de leerparameter van laag 2 naar laag 3 dus precies hetzelfde – om die te veranderen moet je een nieuw commando geven waarin je die leerparameter verandert.

Er is ook een ‘muneg’ die ‘Long-Term Depression’ regelt. Deze parameter staat in elke ‘tract’ op 0, en dat kan je beter zo houden.

Leren en activatie updaten

Dit zijn commando’s die je doorgeeft aan de ‘workspace’

Zorgt ervoor dat de activatie ge-‘update’ wordt (=uitgerekend voor een nieuwe iteratie), en dat de gewichten aangepast worden. Wel is er een eigenaardigheid aan wanneer de gewichten ge-update worden (zie vraag 5.1c).

Enkel de activatie wordt ge-update, zonder dat er sprake is van leren

Enkel de gewichten worden aangepast. De eigenaardigheid van ‘cycleandlearn’ geldt hier niet: dit is gewoon hebbiaans leren

Resetten van een laag

Boven al uitgelegd. Als je de variabele "frontLayer" weer gebruikt wordt het:

Dit commando zorgt dat alle knopen niet meer vuren, en alle activaties en kaliumconcentraties weer gelijk gezet worden aan 0.

Zien wat er gebeurt

‘Default’ in Nutshell is dat je niet ziet wat er gebeurt als je je script runt. Om op het scherm te zien hoe je simulatie erbij staat moet je een speciaal commando in je code zetten:

Zet dit commando overal in je script waar je wilt zien wat er gebeurt.