mei 2000

Medici was het al lang geleden opgevallen dat een langzame beschadiging aan de hersenen minder effect heeft op gedrag dan een snelle beschadiging – zelfs als de langzame beschadiging uiteindelijk resulteerde in een net zo grote schade. Een goed voorbeeld hiervan is de groei van een hersentumor: pas als de tumor een enorme omvang heeft bereikt en veel weefsel heeft vernietigd, begint de patiënt klachten te ontwikkelen. Dit effect is vertaald naar een experimentele opzet, waarbij snelle en langzame laesies bij dieren worden vergeleken. De snelle beschadiging wordt gerepresenteerd door één grote laesie, de langzame door een serie van kleine laesies. Vandaar de naam ‘Serial Lesion Effect’. Voor de vergelijkbaarheid moeten de kleine beschadigingen samen natuurlijk wel evenveel hersenweefsel omvatten als de ene grote laesie.

Het Serial Lesion Effect is in verschillende hersengebieden voor verschillende dieren gevonden. Bijvoorbeeld bij de rat in de somatosensorische cortex, hippocampus, reticulaire formatie, frontale cortex en amygdala, en bij delen van de visuele cortex, somatosensorische cortex van de aap. Van verschillende variabelen is bekend dat ze het Serial Lesion Effect beïnvloeden. Dit zijn leeftijd (hoe jonger hoe groter het effect; , tijd tussen de verschillende laesies (hoe langer de tussenperiode, hoe groter effect; , de hoeveelheid van sensorische stimulatie waar een subject aan is blootgesteld gedurende de tijd tussen de laesies -hieronder valt ook training , het type hersendeel , temperatuur (proefdieren met seriële laesie presteren slechter onder koude omstandigheden; Bell et al., 1981) en de volgorde van beschadiging van de verschillende hersendelen .

Er zijn verschillende verklaringen voor het Serial Lesion effect. Twee prominente zijn de ‘reduced deficit’- en ‘serial recovery’-hypothese. De eerste houdt in dat de eerste kleine laesie de hersenen al voorbereidt op een volgende laesie, ongeveer zoals een inenting voorbereid tegen bijvoorbeeld een virusinfectie. De virussen in de prik zijn dood of kreupel en maken je niet ziek, maar ze bereiden het immuunsysteem wel voor op het echte virus. Volgens de reduced-deficit hypothese zal een tweede laesie daarom minder effect hebben op gedrag dan een eerste laesie. De tweede verklaring legt de nadruk op herstel dat plaatsvindt tussen de verschillende laesies, waarbij herstel makkelijker wordt geacht als de laesies kleiner zijn.

Bepaalde hemisferische lesies, waarbij een regio in één van beide hemisfeer wordt beschadigd en niet in de ander, hebben onafhankelijke contralaterale effecten (bij een unilaterale laesie in de motorische cortex valt bijvoorbeeld een deel van de spieren aan de andere kant van het lichaam uit). Als nu eerst een regio in de ene hemisfeer wordt beschadigd, en na enige tijd dezelfde regio in de andere hemisfeer, blijken de gevolgen van beide laesies aanvankelijk even ernstig te zijn. Na een gegeven periode verminderen de effecten van beide laesies echter . De reduced deficit hypothese voorspelt dat een tweede laesie, in vergelijking met de eerste laesie, minder grote gevolgen zou hebben, en is dus inconsistent met dit resultaat. Het resultaat is niet inconsistent met de andere verklaring; dat er pas na enige tijd herstel optrad, duidt net op die serial-recovery hypothese.

We zullen er verder vanuit gaan dat de serial recovery hypothese de juiste is. Wat dan interessant wordt, is uit te zoeken wat voor mechanismen tijdens de tijd tussen de operaties ten grondslag liggen aan herstel.

Leren is repareren

Wat zou dat herstel tussen twee operaties kunnen veroorzaken waar de ‘serial recovery’-hypothese van uit gaat? Stel, voor het gemak, dat het gedrag dat getest wordt afhangt van 1 bepaalde representatie (of 1 conglomeraat van representaties). Bij een grote laesie is die representatie geheel verloren, en dat is waarom het dier niet meer de taak kan volbrengen. Als we twee kleine laesies maken die samen even groot zijn als de grote laesie, zou de hele representatie ook weg moeten zijn. Toch kan het dier het gedrag nog vertonen. Kennelijk gebeurt er iets tussen de twee kleine laesies, herleren, reorganisatie, dat ervoor zorgt dat de representatie niet helemaal verdwenen is. De representatie moet gedeeltelijk verhuisd zijn naar een niet geledeerd deel van de cortex.

Hoe gebeurt dat ‘verhuizen’? De vaakst genoemde verklaring is dat representaties continu herleerd worden – en is de oude plek niet meer aanwezig dan worden ze herleerd in een ander deel van de cortex . Het herleren veroorzaakt, in zo’n geval, het repareren van de representatie (‘leren is repareren’ is zelfs de slogan van een AiO-project aan deze faculteit). De representatie kan herleerd worden omdat het organisme opnieuw blootgesteld wordt aan de situatie waar de oorspronkelijke representatie in ontstond, of weer het gedrag vertoont dat in de representatie gecodeerd was. In dat geval kunnen we spreken van training. Het kan ook dat het herleren gebeurt vanuit het brein zelf: dat het brein zelf de representatie activeert, en gedurende deze reactivatie de representatie herleerd wordt. In dat geval wordt meestal gesproken van consolidatie. Consolidatie wordt meestal geassocieerd met slaap: vaak wordt gehypothetiseerd dat herinneringen in slow-wave-sleep of gedurende droomslaap gereactiveerd worden, en dan geleerd.

Knopen vs. verbindingen

Je kunt in een netwerk knopen lederen, en je kunt verbindingen lederen. Het herleren van patronen, boven beschreven en cruciaal voor het verklaren van het serial-lesioneffect, betekent verschillende dingen afhankelijk van of knopen dan wel verbindingen geledeerd worden.

Bij de laesie van verbindingen is het makkelijk wat telt als het herleren van het patroon: dit betekent het herstellen van verbindingen tussen knopen binnen het patroon.

Het ligt moeilijker bij de laesie van knopen. Knopen laten ‘herontstaan’ gaat in tegen het biologisch gegeven dat neuronen in volwassenen maar heel beperkt aangroeien, en als er al nieuwe knopen zouden ontstaan, dan nog zouden ze niet resurrecties zijn van de oude, geledeerde knopen. Daarom bestaat het herleren van een representatie uit het recruteren door de representatie van nieuwe knopen. Als die nieuwe knopen verbonden raken met dezelfde input-en outputpatronen als de oude representatie, is er niets tegen om deze nieuwe knopen te beschouwen als deel van de representatie. Het recruteren bestaat er dus uit dat de nieuwe, te recruteren knopen actief zijn tegelijk met de representatie en zijn input- en outputpatronen. Zo kunnen verbindingen ontstaan tussen de nieuwe knopen en de representatie en, nog belangrijker, tussen de nieuwe knopen en de input- en outputpatronen.

Trainen vs. consolideren

Net werd er al gezegd dat het leren wat repareren veroorzaakt twee dingen kan betekenen: trainen of consolideren. Trainen is leren zoals dat meestal gebeurt in connectionistische netwerken: je zet het gewenste patroon in het netwerk (door knopen in het patroon actief te maken), en je past de gewichten aan het patroon aan. Zo gebeurt ook het ‘initieel leren’, het aan het begin van de simulatie leren van de patronen; initieel leren is dus gewoon het eerste trainen.

Consolidatie is ingewikkelder: de bedoeling bij consolideren is dat het netwerk zelf het patroon genereert dat geleerd moet worden. Meestal wordt in het netwerk een willekeurig patroon ingebracht. Vervolgens mag het netwerk een aantal iteraties lang vrij itereren (activatie updaten). Na de ‘vrije’ iteraties wordt het patroon dat dan actief is geleerd . De hoop is dat het netwerk zich ondertussen naar een attractor toe heeft bewogen, en dat die attractor één van de geleerde patronen is. Met andere woorden, dat één van de bestaande patronen extra geleerd wordt zonder dat inmenging van buitenaf nodig is.

Het netwerk dat je moet gebruiken

Het netwerk dat je moet gebruiken is een ‘TraceLink’-netwerk, d.w.z. een netwerk dat dezelfde knopen gebruikt als het TraceLink model . Voor de geïnteresseerde wordt in appendix 3 uitgelegd hoe deze knopen functioneren, en welke formules hun gedrag bepalen. Appendix 1 legt uit hoe je met het TraceLink-paradigma van Nutshell kunt werken.

Het netwerk waarmee je aan de slag moet bestaat uit drie lagen: een inputlaag, een outputlaag en een middenlaag, associatielaag geheten. Dit netwerk moet een minimodel zijn voor het brein: sensorische gebieden zijn via associatiecortices verbonden met motorische gebieden. De in- en outputlaag zijn zo simpel mogelijk gehouden: ze bestaan uit een kolom knopen met een lengte gelijk aan het aantal patronen, en elk patroon is 1 knoop toegewezen. De associatielaag is vierkant, en veel groter dan de andere twee lagen. Patronen bestaan in deze laag uit een vast aantal knopen.

De simulaties die je moet doen

De simulaties moeten uit de volgende vier fases bestaan:

• de fase van het aanmaken van het netwerk: zorg dat je een netwerk aanmaakt in overeenstemming met de aanwijzingen hierboven.
• de fase van het initieel leren: in deze fase wordt het model patronen aangeleerd
• de fase van de laesies en het herleren: in deze fase worden 1 of meerdere laesies aangebracht, en zijn er tussen de laesies en na de laesies ‘herleertrials’ waarin het model de patronen opnieuw kan leren.
• de testfase: alle patronen worden getest (je kunt na elke laesie testen, en in elk geval aan het eind van de simulatie).

Je moet het serieel laesie-effect onderzoeken in twee condities, die verschillen in of er in een herleertrial getraind wordt (=herleren van een specifiek patroon),of geconsolideerd (=herleren van een patroon dat vanuit een willekeurige beginstaat is bereikt). Verder moet je, om het serieel laesie-effect vast te kunnen stellen, in beide condities een simulatie doen met één grote laesie, en eentje met twee of meer kleine laesies. Zowel bij de ene grote laesie als bij de meerdere kleinere moet uiteindelijk de helft van de knopen van de associatielaag geledeerd worden (dit zal de bovenste helft zijn; zie uitleg ledeerprocedure in appendix 2). Je moet dus minstens vier simulaties uitvoeren:

• een grote laesie en trainen
• kleine laesies en trainen
• een grote laesie en consolideren
• kleine laesies en consolideren.

Om de simulaties vergelijkbaar te houden moeten er evenveel heerleertrials zijn in de condities met één grote laesie als in de condities met meerdere kleine laesies. M.a.w., een grote laesie moet door meer herleertrials gevolgd worden als een kleine laesie, zodat ze uiteindelijk bij hetzelfde aantal herleertrials uitkomen.

Bij het aanmaken van patronen kan je aangeven of het patroon over de hele associatielaag verdeeld is, of dat het patroon geconcentreerd is in een deel van de laag. Patronen kunnen of in de bovenste helft van de laag geconcentreerd zijn, of in de onderste helft. Zo kunnen laesies van de bovenste helft een groter effect hebben op sommige patronen dan op Zorg ervoor dat minstens 1 patroon geheel of grotendeels geconcentreerd is in de helft van de laag die geledeerd wordt (anders hoeft het patroon namelijk helemaal niet te lijden onder de laesies).

Het script dat je moet schrijven

Ondat dit de eindopdracht is moet je nu het script geheel zelf schrijven. Het enige wat wij leveren is een frame dat de workspace opent en het netwerk aan maakt. Verder staan er, als voorbeeld, de aanroepen voor de diverse subprocedures die we voor jullie geschreven hebben. Die subroutines zijn:

• een initieel leren- / patroonaanmaakroutine.
• een trainroutine
• een consolideerroutine
• een laesieroutine
• een testroutine

De aanroepen voor deze subroutines moet je op de juiste plaats zetten, vergezeld van de juiste argumenten. Je kunt meerdere tests doen om door de tijd te volgen hoe de patronen zich ontwikkelen. Bovendien kan je de hele simulatie meerdere keren doen. Het is altijd zinnig om je resultaten te repliceren, dus zet de constante die het aantal replicaties regelt in ieder geval op 2. Wat de constantes zijn, hoe je de subroutines moet aanroepen, en hoe die ongeveer werken, wordt uitgelegd in appendix 2. Als je klem komt te zitten of er dingen onduidelijk zijn, schroom niet ons te mailen.

Wat je moet inleveren

Ten eerste willen we graag de excel-file ontvangen met daarin de code voor de simulaties. Verder dien je een verslagje (3-4 A4) in te leveren met in ieder geval het volgende:

• een inleiding met in je eigen woorden wat je gaat doen en waarom, en verantwoording voor eventuele keuzes die je gemaakt hebt.
• een methode-sectie: een beschrijving van alle simulaties, met wat je precies hebt gedaan.
• een resultaten-sectie: een beschrijving van de resultaten van de simulaties, met een gepaste figuur.
• een discussie-sectie, met je conclusies en een kritische bespreking van je werk.

May 2000

Introduction

TraceLink is a connectionist paradigm introduced in the papers of Murre and Meeter on the TraceLink model of amnesia . This text will focus on how TraceLink is implemented in Nutshell, and gives only a cursory explanation of the paradigm itself; for a detailed treatment see the appendix of [Murre, 1999 #195] The paradigm uses Hebbian learning, and a simple linear integration of inputs. The two distinguishing features of the model are the fact that nodes fire stochastically, and the soft k-Winner-Take-All character of layers in TraceLink networks.

The likelihood with which a node fires is a function of the balance of inhibition and excitation: if a node receives more excitation than inhibition, the likelihood is greater than 0.5, and it is smaller than 0.5 if inhibition dominates excitation. Excitation is the sum of inputs from the other nodes in the network, inhibition is a variable, equal for all nodes in a layer, whose composition will be explained later. The degree of randomness is controlled by the ‘temperature’ parameter. If the temperature is high (e.g., 1), then the nodes fire in a very random way, and the difference between excitation and inhibition must be large to have an impact on the node. If the temperature is low (e.g., 0.1), small differences between excitation and inhibition are enough to result in a very high, or alternatively very low, likelihood of firing.

TraceLink implements a soft k-Winner-Take-All firing regime. Inhibition is regulated in such a way that the fraction of nodes that fires in a given layer is kept as close as possible to the fraction k given by the user. If a fraction bigger than k of the nodes fire, then inhibition is raised so that less nodes will be able to fire in the next iteration. If a fraction smaller than k of the nodes fires, then inhibition is lowered so that more nodes will be able to fire. This process will continue until the fraction of firing nodes reaches a stable state of around k (this process of settling can take between 20 and 200 iterations).

Inhibition is the sum of two amounts: fast inhibition (T) and slow inhibition (tau). Fast inhibition is adjusted, as a name suggests, more rapidly than slow inhibition. Both, however, are adjusted with the objective of bringing the fraction of nodes that is active close to k.

Parameters of the TraceLink paradigm in Nutshell

A node has four parameters: ‘Act’, ‘Net’, ‘Clamped’ and ‘Deactivated’. ‘Act’ stands for ‘Activation’, and can have the values 1 (active, fires) or 0 (inactive). ‘Net’ is the sum of excitatory inputs that the node received in the last iteration. A node is ‘Clamped’ if its activity state is not updated, i.e. the node stays in a its activity state independent of the input it might receive. A ‘Deactivated’ node is lesioned; it does not function anymore.

A connection between two nodes has only one parameter: its ‘weight’. This parameter has the standard connectionist interpretation. Tracts are objects that contain all the connections from all the nodes in one layer to all the nodes in another layer (or all the other nodes in the same layer). They have four parameters. ‘MuPos’ is the positive learning constant, i.e. how much is added to the weight if both the sending and the receiving nodes are active. ‘MuNeg’ is the negative learning constant, the constant associated with the LTD-component of Hebbian learning. If the sending node is active and the receiving node is not, then ‘MuNeg’ is subtracted from the weight. ‘P_Connect’ is the likelihood that two nodes that are not connected get connected if both are active in a given iteration. Connections are assumed to not exist if the weight on the connection is equal to 0. ‘P_Connect’ is thus the likelihood that a weight of 0 will rise to a positive value if Hebbian learning requires that the connection learn. ‘WeightMax’ is the maximum value that a weight in the tract can attain. If ‘WeightMax’ is for example equal to 1, weights will not become higher than 1 (the minimum value a weight can have is always equal to 0).

Layers instantiate many parameters. ‘Width’ and ‘Height’ are the layer widths and heights. ‘Active Nodes’ is the fraction of nodes in the layer that is active (actually, this is a moving average over the last iterations – with always 1/2^nd determined by the last iteration, 1/4^th by the iteration before that etc.). These three parameters cannot be changed. Other parameters can be changed by the user.

‘Inhibition T’ and ‘Inhibition tau’ implement fast and slow inhibition respectively (note that these are separate for every layer). Their magnitude depends on the size of the layer and on the magnitudes of the excitatory weights. Often magnitudes are around 0.05 for ‘T’ and 0.9 for ‘tau’. ‘K’ is the fraction of nodes in the layer that should be active. Inhibition is adjusted at every iteration to bring the fraction of active node (parameter ‘Active Nodes’) closer to K. ‘Temperature’ determines the degree of randomness in the layer (see introduction).

On the workspace level (in the browser: parameters under ‘general’ when one clicks with the right muse button), there is only one parameter: ‘Iteration Length’ (the ‘Energy’ parameter is nonfunctional). ‘Iteration Length’ is the number of iterations that the model runs if you use the ‘Cycle’ or ‘Learn’ methods. If you intend to run many iteration, it might be more efficient to adjust this parameter than to push or call the ‘Cycle’ method n times.

Methods of the TraceLink paradigm in Nutshell

• ‘Insert Layer’ inserts a layer. As arguments you give the width and height that the layer should have.
• ‘Resize Layer’ enables you to change the dimensions of an existing, selected layer.
• ‘Reset Layer’ resets the activity of all nodes in the selected layer to 0. Moreover, deactivated nodes are reactivated and clamped nodes unclamped.
• ‘Reset Tract’ resets the weights of all connections in a selected tract to 0.
• ‘Cycle’ updates the activity of nodes in the whole network for an ‘Iteration Length’ number of iterations.
• ‘Learn’ updates the weights in the whole network on the basis of the current activation for an ‘Iteration Length’ number of iterations.
• ‘Step’ updates the activity of nodes in the whole network for 1 iteration
• ‘Insert Tract’ inserts a tract between selected layers (or, if one layer is active, from the layer to itself).
• ‘Delete Tract’ deletes a selected tract.
• ‘Delete Layer’ deletes a selected layer.
• ‘Clamp Layer’ clamps all nodes in the selected layer. If the first node in the layer is already clamped, the method unclamps all nodes in the layer.
• ‘Deactivate Layer’ deactivates all nodes in the selected layer. If the first node in the layer is already deactivated, the method ‘un-deactivates’ all nodes in the layer.
• ‘Random Activity’ first resets the activity in the selected layer, and then activates k nodes in the layer.
• ‘Count Activity’ sets the parameter ‘Active Nodes’ of the selected layer to the real number of active nodes (normally it is a moving average).
• ‘Perturb Tract’ perturbs the weights in the selected tract. It does this by multiplying each weight with a random factor taken from a distribution determined by a line on the interval [0,1). You can control this distribution by giving the arguments "slope" and "intercept" of the line (a and b in a normal line equation). Values of greater than 1 are interpreted as 1, values lower than 0 as 0.
• ‘Initialize Tract’ initializes the weights in the selected tract. The three arguments are proportion, mean, and spread. ‘Proportion’ is the proportion of weights that are given a value. ‘Mean’ and ‘Spread’ determine the distribution of these weights: this distribution is a uniform distribution ranging from (Mean-Spread) to (Mean + Spread). Weights are clipped to between 0 and ‘MaxWeight’.

(Noot: bij het aanroepen van de meeste subroutines moet je het argument ‘workspace’ doorgeven. Dit is nodig om de subroutine met de workspace te kunnen laten werken; je hoeft niets met dit argument te doen).

• nrOfPatterns : aantal patronen dat je het model in de simulatie laat leren.
• nrOfReplications : aantal keer dat de simulatie gerund wordt
• nrOfTestreplis : aantal keer dat tijdens een test een patroon aangeboden wordt (hoe meer keer je dat doet, hoe kleiner de variantie is in de scores).
• layerSize : hoogte en breedte (worden aan elkaar gelijk gesteld) van de associatielaag
• temperatuur : temperatuur in alle lagen. Stel deze in op een heel lage waarde, zodat je niet teveel last hebt van willekeurig actief wordende knopen.
• numNodes = layerSize ^ 2 : aantal knopen van de associatielaag; wordt afgeleid van de hoogte/breedte van de laag

Bij het initieel leren wordt tegelijk het patroon aangemaakt. Een patroon bestaat uit een inputknoop (met het nummer van de knoop gelijk aan het nummer van het patroon), een outputknoop (met idem nummer), en dan een ‘patternSize’ aantal knopen in de associatielaag. De aanroep van de subprocedure is als volgt:

nrOfPat is het nummer van het patroon (begint bij 0, eindigt bij aantal patronen-1). patternSize is, als gezegd, het aantal knopen in de associatielaag dat bij het patroon hoort. ‘beginNode’ en ‘endNode’ geven het gebied in de laag aan waarin de associatieknopen zich mogen bevinden. Als je voor ‘beginNode’ 0 opgeeft en voor ‘endNode’ 69 (denk aan de –1 omdat 0 steeds meedoet), dan zullen alle associatieknopen in het patroon zich bevinden tussen de eerste 70 knopen in de associatielaag. Als je een laag met 100 knopen hebt, betekent dit dat de knopen zich in de bovenste 70% van de laag zullen bevinden. Geef je 30 en 99 op, dan zullen ze zich in de onderste 70% van de laag bevinden.

Bovenaan de routine staan twee variabelen die de leerconstanten bepalen, eentje voor alle tracts met als beginpunt de inputlaag, en eentje voor alle tracts met als beginpunt de associatielaag (dit verschil is omdat er in de inputlaag steeds maar 1 knoop actief is, en in de associatielaag meerdere; als ze allebei dezelfde leerparameter hadden zouden associatieknopen door hun aantal het altijd winnen van de input). Stel deze in op zinnige waardes.

De trainroutine zorgt ervoor dat een patroon herleerd wordt. Eerst worden de goede input- en outputknopen geactiveerd. Vervolgens wordt er een goed associatie-patroon bij gezocht. Dit gebeurt door het model een aantal iteraties te laten cyclen, net zolang tot de inhibitie goed afgesteld staat en er een aantal knopen ongeveer gelijk aan k actief is (dit wordt niet nagegaan; wat er eigenlijk gebeurt is dat het model 100 iteraties lang cyclet in de subprocedure CycleAndLearn, waarna er hopelijk een goed patroon actief is). Tenslotte wordt het nu ontstane patroon geleerd. Hierbij worden de verbindingen tussen de actieve input- associatie- en outputknopen, en de verbindingen tussen de associatieknopen versterkt. De aanroep is als volgt:

Het enige argument dat je bij trainen in moet voeren is het patroonnummer. Bovenaan de routine staan twee variabelen die de leerconstanten bepalen, eentje voor alle tracts met als beginpunt de inputlaag, en eentje voor alle tracts met als beginpunt. Stel deze in op zinnige waardes.

De consolideerroutine zorgt ervoor dat 1 patroon geconsolideerd wordt. Het model begint vanuit een willekeurige begintoestand. Vervolgens mag het model gedurende 100 iteraties cyclen in de subprocedure CycleAndLearn. De hoop is dat er inmiddels een stabiel patroon actief is geworden. Dit patroon wordt vervolgens geleerd (er is geen controle op of er inderdaad een patroon actief is)

Bovenaan de routine staan twee variabelen die de leerconstanten bepalen, eentje voor alle tracts met als beginpunt de inputlaag, en eentje voor alle tracts met als beginpunt. Stel deze in op zinnige waardes.

Deze routine is enigszins vergelijkbaar met de routine die in het script van opdracht 4 knopen ledeerde. Hier wordt echter geen vierkant geledeerd, maar een gedeelte van eerst de bovenste helft van de Kohonenlaag, daarna van de onderste helft van de Kohonenlaag. Als argument geef je het aantal knopen mee dat geledeerd moet worden. Dat wordt eerst afgerond, vervolgens gaat hij kijken hoeveel van de bovenste helft geledeerd moet worden. Als een aantal knopen groter dan de helft van de laag geledeerd moet worden, ledeert hij eerst de gehele bovenste helft, en vervolgens een deel van de onderste helft. Check een aantal waardes voor het aantal te lederen knopen om te zien hoe dit werkt. De aanroep van de subroutine is als volgt:

Het eerste argument is de laag waarin je knopen wilt lederen, het tweede argument is de lengte van de laag (er wordt uitgegaan van een vierkante laag, dus dat is meteen ook de hoogte), het derde het aantal knopen dat normaal actief is in de laag (k, hier gelijk aan de grootte van een patroon), en tenslotte het vierde argument het aantal knopen dat je geledeerd wilt hebben.

De testroutine kan je op verschillende momenten aanroepen in je simulatie (je moet wel zorgen dat de constante nrOfTestreplis gelijk is aan het aantal testen dat je doet).

‘Results’ is de matrix waarin de resultaten worden opgeslagen. Deze matrix heeft 5 dimensies, die worden uitgelegd daar waar ‘results’ wordt gedeclareerd. Bij ‘testCounter’ moet je invullen hoeveelste test het wordt, en bij ‘replication’ de hoeveelste replicatie het is.

The model is based on binary, stochastic nodes that fire synchronously. The firing thresholds of the nodes in a module are controlled by a 'threshold control' mechanism: inhibition in a module is diminished if there are not enough activated nodes (i.e., less than some target number k) and increased if there are too many. At each iteration, after all node activations have been updated, a learning rule is applied to all connections. The details of these mechanisms are as follows:

A node i has an activation a_i that can take on either of two values: 0 or 1. The probability that node i will 'fire' (i.e., that its activation becomes 1) increases with its net input, as follows:

(1)

where net_i is the total input activation to node i:

net_i = weighted input activation - inhibition (2)

The weighted input activation can be written as:

(3)

where w_ij is the connection weight from node j to node i, a_j is the activation value of node j, and n is the number of nodes in the model (if there is no connection between j and i, w_ij is zero by default). Inhibition is discussed in the next paragraph.

The temperature parameter temp in Eq.1 controls the degree of randomness of the nodes: if temp is near zero the nodes behave as simple threshold devices, if temp is very high the role of the net input is very limited and the node will take on values 0 or 1 randomly. We used a temperature of 0.2 in all simulations.

The total number of activated nodes in a module (called A) is constantly monitored and firing thresholds are adjusted to ensure that this number does not wander too far from the target number k, Each module can have a different k and inhibition control in a module is independent of that in other modules. We assume that one of the functions of inhibition in the brain is to keep the level of activation (i.e., the average number of activated neurons) in a certain region constant. Furthermore, we assume that the total number of activated neurons, k, is relatively low (cf. Abeles, Vaadia, & Bergman, 1990). The effect of the inhibitory system is thus to keep the number of activated nodes A as close as possible to the target number k.

The system achieves this by constantly adjusting two thresholds T and t . Inhibition is the sum of the fast changing threshold T multiplied by the number of active nodes A, and the slow moving threshold t :

inhibition = TA + t (4)

We believe that T reflects the activation of the basket cells and that it is able to change relatively quickly. In addition to the action of inhibitory cells, we assume that there are also slower working processes. These may reflect synaptic changes and growth processes. 'Slow' inhibition is modelled by the threshold t .

The control of fast inhibition, T, is straightforward: If the total activation at time t (A_t) is higher than k, T is increased (more inhibition), if A_t is lower it is decreased. In particular, if A_t is much larger than k, T is increased a lot; if A_t is only a bit larger, T is increased a little. A very simple implementation of the approach is used here:

If A is much (i.e., more than a crit proportion) larger or smaller than k:

if A_t > (1+crit)k (5.a)

else, if A is only a little bit larger or smaller than k:

if A_t > k (5.b)

where crit is the criterion for deciding whether A_t is much larger or smaller, and D _t is the change made to T (crit = 0.20, and D _t = 0.01 works well for the simulations reported here). One disadvantage of this method is that T may change too quickly so that the module starts to oscillate violently. To prevent this, A_t is dampened by making it a moving average of the current activation and the activation of previous iterations. When A*_t is the current level of activation, the value used to compute both the level of inhibition A_tT and the change in the parameter T is:

A_t = 0.5A_t-1 + 0.5A*_t (6)

This precedes calculation of the new threshold T (Eq. 5.a-b).

The slow inhibition process aims to keep the 'slow threshold' t equal to TA. When the equilibrium is disturbed, for example, if the activation is diminished due to a lesion, t slowly decreases to a new equilibrium value. The speed of this change is determined by the parameter D t . Because we envision the adjustment to be slow, D t is chosen low (0.001). The expression for calculating t _t+1 at t+1 is

t _t+1 = (1-D t )t _t + D t TA (7)

The amount of 'fast' inhibition is bounded by a minimum value T^min and a maximum value T^max. If T < T^min it is set to T^min, and if T > T^max it is set to T^max. Similarly, t is also kept between upper and lower bounds: if t < t ^min, t is t ^min; if t > t ^max, t is t ^max. T^min and t ^mi were set to 0. T^max and t ^max were set to such high values that they were never reached in the simulations.

The learning rule is a simple Hebbian rule that also allows decreases in weight, as follows:

D w_ij = m ⁺ a_ia_j - m ^- a_i (1 - a_j), (8)

and

w_ij(t+1) = w_ij(t) + D w_ij (9)

where D w_ij represents the weight change and m ^- and m ⁺ represent the learning rates. Both m ^- and m ⁺ must be larger than 0. The weights are kept within the interval [0,1] by setting w_ij=1 if w_ij >1, and w_ij =0 if w_ij <0.

Learning rate can vary rapidly -due to certain central states (e.g., motivational)- or slowly, (e.g., due to aging). The effects of learning rate variations are studied in various simulations in this paper, but it is kept constant from one iteration to the next (i.e., it only changes when there is a change in learning phase). In a more general version of the model the learning rate would vary continuously (cf. Murre, 1992).