Werking van de CAM-Brain machine - Ghent...
108
Universiteit Gent Faculteit Toegepaste Wetenschappen Vakgroep Electronica en Informatiesystemen Voorzitter: Prof. Dr. Ir. J. VAN CAMPENHOUT Analyse van de CAM-Brain Machine door Pieter Van Der Helst Promotor: Prof. Dr. Ir. J. VAN CAMPENHOUT Thesisbegeleider: Dr. Ir. H. VAN MARCK SCRIPTIE ingediend tot het behalen van de academische graad van licentiaat informatica Academiejaar 2000-2001
Transcript of Werking van de CAM-Brain machine - Ghent...
Universiteit Gent
Faculteit Toegepaste Wetenschappen
Vakgroep
Electronica en Informatiesystemen
Voorzitter: Prof. Dr. Ir. J. VAN CAMPENHOUT
Analyse van de CAM-Brain Machine door
Pieter Van Der Helst
Promotor: Prof. Dr. Ir. J. VAN CAMPENHOUT
Thesisbegeleider: Dr. Ir. H. VAN MARCK
SCRIPTIE ingediend tot het behalen van de academische graad van licentiaat informatica
Academiejaar 2000-2001
Deze scriptie zou nooit tot stand gekomen zijn zonder de hulp van zowel de promotor,
Prof. Dr. Ir. J. Van Campenhout als de thesisbegeleider, Dr. Ir. H. Van Marck.
Ik zou dan ook beiden willen bedanken voor de vele richtlijnen en hulp die ze boden.
De auteur geeft de toelating deze scriptie voor consultatie beschikbaar te stellen en delen
van de scriptie te kopiëren voor persoonlijk gebruik.
Elk ander gebruik valt onder de beperkingen van het auteursrecht, in het bijzonder met
betrekking tot de verplichting de bron uitdrukkelijk te vermelden bij het aanhalen van de
resultaten uit deze scriptie.
28 mei 2001
Analyse van de CAM-Brain Machine door
Pieter Van Der Helst SCRIPTIE ingediend tot het behalen van de academische graad van licentiaat informatica Academiejaar 2000-2001 Promotor: Prof. Dr. Ir. J. VAN CAMENHOUT Thesisbegeleider: Dr. Ir. H. VAN MARCK Faculteit Toegepaste Wetenschappen Universiteit Gent Vakgroep Elektronica en Informatiesystemen Voorzitter: Prof. Dr. Ir. J. VAN CAMPENHOUT
Samenvatting
De CAM-Brain Machine is een hardware implementatie van een neuraal netwerk. Deze scriptie geeft een schatting van de rekenkracht van deze machine, meer bepaald hoeveel sneller deze hardware implementatie is ten opzichte van een simulatie van deze machine in een Pentium computer. In het eerste hoofdstuk wordt de logische werking van de machine uitgelegd. In een volgend hoofdstuk wordt een methode ontwikkeld om een schatting te kunnen maken van de benodigde rekenkracht. Er wordt een onder- en bovengrens berekend en hieruit blijkt dat de rekenkracht sterk afhankelijk is van het programma dat draait op de machine. In het derde hoofdstuk worden een aantal patroonherkenners gebouwd voor deze machine, en de rekenkracht nodig om deze patroonherkenners te simuleren wordt berekend. Op deze manier wordt een beeld gegeven van de rekenkracht die men kan verwachten wanneer deze machine in de praktijk gebruikt wordt. Er wordt aangetoond dat de rekenkracht van de CAM-Brain, in tegenstelling tot wat zijn makers beweren, onder de 10.000 Pentiums ligt. En er worden inzichten gegeven voor het bouwen van handgeschreven machines in de CAM-Brain. Trefwoorden:
CAM-Brain, neuraal netwerk, patroonherkenner
1. DOELSTELLING ........................................................................................................ 1
2. WERKING VAN DE CAM-BRAIN MACHINE ...................................................... 32.1. WAT IS EEN NEURAAL NETWERK? ........................................................................... 32.2. DE CAM-BRAIN ..................................................................................................... 52.3. OPBOUW VAN EEN MODULE .................................................................................... 7
2.3.1. Axon ............................................................................................................... 92.3.2. Neuron .......................................................................................................... 102.3.3. Invoer- en uitvoercellen ............................................................................... 12
2.4. IMPLICATIES VAN DE OPBOUW ............................................................................... 15
3. BEREKENING VAN DE REKENKRACHT .......................................................... 173.1. DE COMPILER ........................................................................................................ 17
3.1.1. Een Axon ...................................................................................................... 203.1.2. Een Neuron .................................................................................................. 22
3.2. ONDERGRENS ........................................................................................................ 253.3. BOVENGRENS ........................................................................................................ 26
4. PATROONHERKENNER ........................................................................................ 284.1. INLEIDING ............................................................................................................. 284.2. EERSTE MACHINE .................................................................................................. 31
4.2.1. Geheugen ..................................................................................................... 314.2.2. Klokpuls ....................................................................................................... 324.2.3. Het patroon vergelijken met de invoerstroom .............................................. 334.2.4. Aantal overeenkomsten tellen ...................................................................... 344.2.5. De waarde van de accumulator uitlezen ...................................................... 36
4.2.5.1. De waarde uitlezen en accumulator weer op nul zetten ....................... 364.2.5.2. Uitleeswaarde onderscheiden van andere uitvoer en vice versa .......... 39
4.2.6. Volledige machine ........................................................................................ 484.2.7. Rekenkracht analyse van deze machine ....................................................... 49
4.2.7.1. Geheugen ............................................................................................. 494.2.7.2. Leespuls ............................................................................................... 504.2.7.3. Patroon vergelijken met invoerstroom ................................................. 504.2.7.4. Aantal overeenkomsten tellen .............................................................. 504.2.7.5. Rekenkracht analyse ............................................................................ 51
4.2.8. Analyse van de eerste patroonherkenner ..................................................... 544.3. TWEEDE MACHINE ................................................................................................. 55
4.3.1. De pulstrein splitsen ..................................................................................... 564.3.2. De waarde van de accumulator uitlezen ...................................................... 594.3.3. Volledige machine ........................................................................................ 634.3.4. Rekenkrachtanalyse van deze machine ........................................................ 68
4.3.4.1. De pulstreinsplitser .............................................................................. 684.3.4.2. Aantal overeenkomsten tellen .............................................................. 704.3.4.3. Rekenkracht analyse ............................................................................ 72
4.4. DERDE MACHINE ................................................................................................... 754.4.1. De klem ........................................................................................................ 764.4.2. De leespuls ................................................................................................... 774.4.3. De pulstrein splitsen ..................................................................................... 784.4.4. De waarde van de accumulator uitlezen ...................................................... 794.4.5. Volledige machine ........................................................................................ 86
4.4.6. Rekenkrachtanalyse van deze machine ........................................................ 874.4.6.1. Pulstreinsplitser .................................................................................... 874.4.6.2. Aantal overeenkomsten tellen .............................................................. 874.4.6.3. Rekenkracht analyse ............................................................................ 89
4.5. MACHINES ZONDER GEHEUGEN ............................................................................. 91
5. CONCLUSIE .............................................................................................................. 93
APPENDIX A: BENADERINGEN VOOR MACHINE 2 ........................................ 95
APPENDIX B: STRUCTUUR VAN DE .GNT FILE ................................................ 97
APPENDIX C: INHOUD VAN DE CD-ROM ......................................................... 100
1
1. Doelstelling In dit afstudeerwerk ga ik proberen de rekenkracht van de CAM-Brain te analyseren. In
een document over de CAM-Brain wordt er gezegd dat “CBM’s*
Deze omschrijving dient uiteraard opgevat te worden als een zeer grove en waarschijnlijk
optimistische schatting, en heeft ongetwijfeld meer zin als marketinguitspraak dan als
wetenschappelijke stelling.
computational power in
implementing cellular automata based neural networks is on the order of 10.000 Pentium
III 500 Mhz. computers running identical algorithms in software”.[1]
In het eerste deel van dit eindwerk (Hoofdstuk 2) ga ik uitleggen wat de CAM-Brain is en
hoe deze machine logisch gezien werkt, gevolgd door de implicaties die zijn structuur heeft
op het bouwen van machines en het berekenen van zijn rekenkracht.
In het tweede deel (Hoofdstuk 3) wordt een methode voorgesteld om de rekenkracht van de
CAM-Brain met die van een PC te vergelijken. En er wordt een boven- en ondergrens
berekend. Er zal blijken dat deze rekenkracht zeer sterk afhankelijk is van de machine, die
beschouwd wordt.
Daarom ga ik in het derde deel (Hoofdstuk 4) een aantal machines (patroonherkenners)
bouwen en de rekenkracht van deze machines analyseren.
* CBM = Cam Brain Machine
2
Legende bij de tekeningen
3
2. Werking van de CAM-Brain machine
2.1. Wat is een neuraal netwerk? Neurale netwerken zijn gegroeid uit het artificiële intelligentie domein, in een poging om
de fouttolerantie en leercapaciteit van biologische neurale systemen na te bootsen. Dit
wordt bekomen door het modelleren van het brein op een laag niveau.
Het brein bestaat uit een zeer groot aantal neuronen, die zeer sterk geconnecteerd zijn
(typisch tien miljard neuronen, met een gemiddelde van vele duizenden interconnecties per
neuron).
Een neuron is een gespecialiseerde cel, die een elektrochemische puls kan propageren. Een
neuron heeft een vertakte invoerstructuur (de dendrieten), een cel-lichaam, en een vertakte
uitvoerstructuur (de axonen). De axonen van een cel zijn verbonden met de dendrieten van
een andere via synapsen.
Als een neuron actief is vuurt het via zijn axonen, door de synapsen, in de andere neuronen
waarmee het verbonden is. Deze neuronen kunnen op zich dan weer vuren. De sterkte van
het vuursignaal, dat een neuron ontvangt (en dus de kans dat het zelf vuurt) hangt af van de
doeltreffendheid van de synapsen.
Donald Hebb*
beweerde dat leren in principe neerkomt op het wijzigen van de “sterkte”
van de synaptische verbindingen. Met als typisch voorbeeld het Pavlov principe: de hond
associeert het belsignaal met eten, wat erop neerkomt dat de synaptische verbindingen
tussen het passende deel van de auditieve cortex en het gedeelte van het brein dat de
speekselklieren stuurt versterkt worden. Hierdoor begint de hond te kwijlen als de bel gaat,
nog voordat er eten aan te pas komt.
* Donald Hebb (°1904 †1985), een vooraanstaand wetenschapper op het gebied van neurologisch onderzoek met als belangrijkste werk The Organization of Behavior (1949)
4
De essentie van deze biologische principes wordt gevat in een artificieel neuraal netwerk.
De basis van zo een artificieel neuraal netwerk is een artificieel neuron.
• Het neuron ontvangt een aantal signalen (ofwel van de originele data, ofwel
van een ander neuron).
• Elke invoer komt via een connectie met een zeker gewicht. Deze gewichten
komen overeen met de synaptische sterkte in een biologisch neuron. .
• De gewogen som van de ingangen wordt genomen
• Elk neuron beschikt ook over een drempelwaarde. Deze drempelwaarde
wordt van de gewogen som afgetrokken om de activatie*
• Dit activatiesignaal wordt aan de activatiefunctie doorgegeven om te
bepalen of het neuron vuurt of niet.
van het neuron te
bepalen.
De gewichten kunnen zowel positief als negatief zijn. Bij positieve gewichten spreekt men
van een versterkende synaps, in het andere geval spreekt men van een belemmerende
synaps.
De neuronen worden met elkaar verbonden en vormen zo een netwerk. Naast de neuronen
bevat zo een netwerk ook een aantal ingangen, respectievelijk uitgangen, die informatie
ontvangen uit, respectievelijk sturen naar de buitenwereld. In een biologisch systeem
komen de ingangen overeen met de zintuigen en de uitgangen met signalen, die naar de
spieren gestuurd worden.
Tot nu toe werden neurale netwerken vooral gesimuleerd. Een nadeel hierbij is dat
computers slechts over een beperkt, of geen, parallellisme beschikken, waar een biologisch
brein de vele miljarden neuronen in parallel evalueert. Dit heeft als gevolg dat de artificiële
neurale netwerken binnen een redelijke tijd slechts een beperkt aantal neuronen kunnen
evalueren.
De CAM-Brain probeert deze beperkingen, althans gedeeltelijk, op te lossen. Het is een
machine die een artificiëel neuraal netwerk in hardware implementeert, en die in staat is
om duizenden neuronen zeer snel in parallel te verwerken.
* Activatie wordt ook Post Synaptische Potentiaal genoemd (PSP)
5
2.2. De CAM-Brain
De CAM-Brain machine bestaat uit zeven verschillende onderdelen
• de herconfigureerbare hardware module
• het fenotype / genotypegeheugen
• een eenheid die de invoer en uitvoer van een module regelt
• een eenheid om informatie tussen de verschillende modules door te geven
• een eenheid om de fitnessberekening te doen
• een centrale verwerkingseenheid
• een computer die als interface met de buitenwereld gebruikt wordt
Het neuraal netwerk wordt in een module opgeslagen en deze wordt geëvalueerd door de
hardware module.
De geheugencapaciteit laat toe om 64.640 fenotypes van een module op te slaan. De
hardware module kan echter slechts één zo een module tegelijk evalueren.
6
Om netwerken van meerdere modules te evalueren wordt er gebruik gemaakt van time-
sharing. Een time-slice duurt 96 klokcycli.
Hier treed een eerste beperking op van de rekenkracht van de CAM-Brain. Als er twee
modules (A en B) na elkaar geëvalueerd worden, wordt tijdens de uitvoering van module
A, module B in het geheugen geladen. Dit heeft als gevolg dat de uitvoer van module A
niet als invoer voor module B kan gebruikt worden. De uitvoer is namelijk niet gekend op
het moment dat module B geladen wordt.
Dit kan enkel opgelost worden door er een lege module tussen te plaatsen, of een andere
module, die onafhankelijk is van module A.
In de rest van deze thesis wordt telkens binnen één module gewerkt.
7
2.3. Opbouw van een module Elke module in de CAM-Brain bestaat uit verschillende cellen.
Er zijn twee soorten cellen. Enerzijds zijn er de neuronen, die in hoofdzaak de
berekeningen doen; anderzijds zijn er de axonen, die vooral gebruikt worden om signalen
van verschillende neuronen aan elkaar door te geven.*
Een module bevat 13.824 zulke cellen, geordend in een driedimensionele 24x24x24
matrix.
Niet elke cel kan de rol van neuron spelen. Er is slecht één neuron per twaalf cellen.
Namelijk elke cel met coördinaten x modulo 3 = 2, y modulo 2 = 1, z modulo 2 = 0.†
Elke cel heeft in dat rooster zes zijden (noord, zuid, top, bodem, west, oost). Een cel kan
verbonden worden met maximum zes naburige cellen via in- en uitgangen. Er zijn geen
grenzen aan een module. Dit wil zeggen dat bijvoorbeeld een cel aan de bovenkant (z-
coördinaat gelijk aan drieëntwintig) via zijn top-uitgang verbonden is met de cel met
dezelfde x- en y-coördinaten en z-coördinaat gelijk aan nul.
Elke cel kan slechts informatie doorgeven aan een aangrenzende cel als de ene cel een
ingang en de andere een uitgang heeft aan de zijde waar ze grenzen. Om dus informatie
door te geven tussen twee niet aangrenzende cellen moet de informate via andere cellen
doorgegeven worden. Er is geen verbinding tussen twee cellen als ze aan elkaar grenzen
via twee in- of uitgangen.
* In de CAM-Brain machine is er geen onderscheid tussen een axon en een dendriet, deze cellen zullen als axonen gerefereerd worden in de rest van deze thesis † De nummering van de cellen begint bij nul
8
Alle cellen van een module werken in parallel. De machine beschikt over een klok. Bij
elke klokpuls wordt de toestand van elke cel aangepast door te kijken naar de ingangen van
de cel.
Bij het laden van een module wordt de configuratie van een module ingeladen. Deze
configuratie bepaalt welke rol elke cel zal spelen, en waar hij in- en uitgangen heeft. Ook
de invoer, die via de invoercellen aan de machine wordt doorgegeven, wordt bij het laden
van een module vastgelegd.
Een module wordt ondubbelzinnig beschreven door de toestanden van al zijn cellen
(inclusief invoer- en uitvoercellen) en een bepaald tijdstip in de evaluatie.
We gaan nu dieper in op het verschillende gedrag van axonen en neuronen.
9
2.3.1. Axon Een axon kan zich in twee toestanden bevinden vuren of niet vuren. Als een axon vuurt zal
dit vuursignaal aan al zijn uitgangen doorgegeven worden.
De toestand van een axon wordt bepaald door de signalen die het ontvangt aan zijn
ingangen. Als een axon één vuursignaal ontvangt via één van zijn ingangen zal het axon in
de toestand vuren komen. In alle andere gevallen komt het in de toestand niet vuren.
In formulevorm*
:
{ }{ }
{ }
∈∀≠
==
∈∈
∑
∑
=−
=−
5,..,0 ,1:0
1:1
tijdstipopuitvoer 1 ,0 tijdstipop invoer 1 ,0
5
01
5
01
jI
IU
tUtiI
i
it
i
it
t
t
it
Merk op dat een axon in theorie zes ingangen kan hebben, maar aangezien een cel zonder
uitgangen geen invloed uitoefent op de rest van de machine dient zo een cel niet
geëvalueerd te worden.
Er wordt in dit eindwerk geen onderscheid gemaakt tussen dendrieten en axonen. In
sommige verhandelingen in verband met de CAM-Brain wordt dit onderscheid wel
gemaakt.[2]
Daar wordt een dendriet opgevat als een cel met vijf ingangen en één uitgang en een axon
als een cel met vijf uitgangen en één ingang. Aangezien er in de machines vaak cellen
voorkomen met bijvoorbeeld twee ingangen en drie uitgangen is dit onderscheid weinig
zinvol en zullen de cellen gewoon axonen genoemd worden.
* Een 1 komt overeen met een vuursignaal, een 0 met niet vuren
10
2.3.2. Neuron Een neuron kan zich net zoals een axon in de toestanden vuren en niet vuren bevinden.
Echter, anders dan bij een axon, beschikt een neuron intern over een pijplijn. Als een
neuron zich in de toestand vuren bevindt zal het vuursignaal pas na twee tijdseenheden het
neuron verlaten, terwijl dat bij een axon al bij de volgende tijdseenheid het geval is.
De volgende toestand van het neuron wordt bepaald door accumulatie van de signalen die
het ontvangt. Daartoe beschikt het neuron intern over een accumulator, die een waarde
bevat tussen min acht en plus zeven. Het neuron kan zowel signalen met een positief als
signalen met een negatief gewicht ontvangen via zijn ingangen.
Als een neuron een vuursignaal met positief gewicht ontvangt wordt de waarde van zijn
accumulator met één verhoogd. Een vuursignaal met negatief gewicht zorgt ervoor dat de
waarde van de accumulator met één verlaagd wordt.
Als de waarde van de accumulator groter dan of gelijk aan twee is komt het neuron in de
toestand vuren, en zet het zijn accumulator terug op nul. Een neuron met waarde min acht
dat een negatief signaal krijgt zal zichzelf terug op nul zetten. (uiteraard zonder te vuren)
In formulevorm:
{ }{ }
{ }{ }
<≥
=
−<∨=
−≥∧≠+=
∈∈
−∈−∈
−
−
=−+
=−+−
∑
∑
2 :02 :1
81 :.
81 :.
tijdstipopuitvoer 1 ,0 tijdstipop invoer 1 ,0
tijdstipopr accumulato de van waarde 7 ,..,8 ingangmet rdgeassocieegewicht 1 ,1
2
2
5
011
5
0111
t
tt
itt
it
i
itt
it
it
t
t
it
t
i
AccAcc
U
AccUIw
AccUIwAccAcc
tUtiI
tAcciw
11
Bij het laden van de configuratie van een module kunnen er zich speciale gevallen
voordoen. De accumulator van een neuron kan bijvoorbeeld de waarde zeven bevatten en
nog een positief vuursignaal ontvangen. In deze gevallen zal het neuron gewoon vuren en
zijn accumulator terug op nul zetten.
Ook de situatie waarbij de accumulator bijvoorbeeld de waarde min twee bevat en het
neuron het volgende tijdstip zal vuren kan zich voordoen bij het laden van de machine.
Deze ongewone situaties, die zich enkel bij het laden van de machine kunnen voordoen,
hebben verder geen consequenties, de CBM zal zich altijd na één tijdseenheid in een
consistente toestand bevinden.
12
2.3.3. Invoer- en uitvoercellen Een module heeft 192 invoer- en uitvoercellen, die de verbinding met de buitenwereld
vormen. Vier van deze cellen zijn uitvoercellen. De andere 188 cellen zijn invoercellen.
Aangezien er geen grenzen aan een module zijn (een cel op de rand is verbonden met een
cel aan de andere kant), zijn er logisch gezien slechts drie vlakken aan een module. Elk van
deze vlakken beschikt over één uitgang en het XZ-vlak heeft één extra uitgang.
Elke invoercel vuurt telkens in twee cellen, en een uitvoercel krijgt zijn invoer van twee
cellen op voorwaarde dat er in- en uitgangen zijn in de richting van de in- en uitvoercellen.
De twee cellen waarmee een in- en uitvoercel verbonden is, zijn de twee cellen die aan
weerszijden van een module liggen.
Dit heeft als gevolg dat als een invoercel gebruikt wordt, en dus één van de aangrenzende
cellen een ingang heeft in de richting van de invoercel, de cel aan de andere kant van de
module ofwel ook dit invoersignaal zal ontvangen (als het een ingang heeft in de richting
van de invoercel) ofwel zal de cel een uitgang hebben in de richting van de invoercel, in dit
geval zal de cel dus ook vuren in de cel aan de andere kant van de module.
13
De uitvoercellen zijn nu de cel met nummer vier, tweeëndertig, zesennegentig en
honderdzestig.
Oorspronkelijk was het de bedoeling om als uitvoer de cel nul, en telkens de cel in het
midden van een vlak te nemen (cellen met nummer zesendertig, honderd en
honderdvierenzestig), met als doel de verschillende uitvoercellen zo ver mogelijk uit elkaar
te positioneren. Maar bij de implementatie van de machine is er een fout gemaakt zodat de
uitvoercellen zich niet in het midden van elk vlak bevinden maar aan de rand.
14
De coördinaten van de cellen, die aan de invoer- en uitvoercellen gehecht zijn, worden als
volgt bepaald:
(met i het nummer van de invoer/uitvoercel)
In het XZ-vlak:
x = 1 + 3.(i modulo 8)
y = 0 en y = 23
8 / i3. 1 z +=
In het YZ-vlak:
x = 0 en x = 23
y = 1 + 3.(i modulo 8)
8 / 64) - (i3. 1 z +=
In het XY-vlak:
x = 1 + 3.(i modulo 8)
8 / 128) - (i3. 1 y +=
z = 0 en z = 23
15
2.4. Implicaties van de opbouw Door de plaatsing van de cellen in de CAM-Brain (op een driedimensionaal rooster) is de
lengte n van het pad tussen twee verbonden cellen, indien men enkel gebruik maakt van
axonen, gelijk aan de (kortste) afstand d tussen die twee cellen, plus een even getal 2.k (de
lengte van de omweg):
n = d + 2.k
met
n, d uitgedrukt in roosterspatiëring
en 212121 zzyyxxd −+−+−=
met (x1,y1,z1),(x2,y2,z2
) de coördinaten van de twee verbonden cellen
De vertraging die een signaal ondergaat door het doorlopen van een aantal cellen is dus
ook steeds onder de vorm d + 2.k. Als een vertraging van de vorm d + 2.k + 1 gewenst is,
kan dit niet bekomen worden door enkel gebruik te maken van axonen.
16
Men moet dan gebruik maken van een neuron, aangezien deze intern over een pijplijn
beschikt, die een vuursignaal met één tijdseenheid vertraagt.
Als de puls van axon A naar axon B het pad van de roze lijn neemt, heeft de puls drie
tijdseenheden nodig om neuron B te bereiken.
Via het andere pad (de rode lijn) wordt de puls eerst gesplitst, waarna hij via twee
ingangen met een positief gewicht de accumulator van het neuron op twee zet (dit duurt
twee tijdseenheden). Daarna komt de puls, met nog een extra vertraging als gevolg van de
interne pijplijn, in neuron B. In totaal duurt dit dus vier tijdseenheden.
Deze eigenschap heeft als gevolg dat als een neuron gebruikt wordt, om welke reden ook,
andere signalen, die synchroon moeten lopen, ook via een ander neuron moeten passeren.
Aangezien de neuronen niet overal kunnen voorkomen maakt het gebruik van een neuron
het vaak noodzakelijk om vele extra cellen te gebruiken om de synchroniciteit te bewaren.
17
3. Berekening van de rekenkracht Om de rekenkracht van de CAM-Brain te berekenen wordt er eerst een compiler
geïntroduceerd die een machine omzet naar Pentium assembler code. Op basis van deze
code wordt er dan een schatting gemaakt van de tijd, die de machine nodig heeft om
uitgevoerd te worden op een Pentium PC.
3.1. De compiler De invoer voor de compiler is een configuratie van een machine. Om het gedrag van de
CAM-Brain te kunnen simuleren moet de toestand van elk axon en neuron opgeslagen
worden.
Voor een axon wordt er ook een accumulator geïntroduceerd. Deze accumulator moet als
volgt opgevat worden: telkens een andere cel (neuron of axon) in het axon vuurt wordt de
accumulator met één verhoogd. Als de accumulator van het axon op één staat, zal het axon
de volgende tijdseenheid vuren. De accumulator van een axon wordt bij het begin van elke
tijdseenheid op nul gezet.
Aangezien een axon elke tijdseenheid maximaal zes vuursignalen kan ontvangen, en de
waarde van de accumulator dus altijd tussen nul en zes ligt, kan de accumulator in drie bits
opgeslagen worden.
De accumulator van een neuron is altijd tussen min acht en zeven, in principe zijn vier bits
dus voldoende. Maar aangezien er underflow kan optreden kan de waarde van de
accumulator, tijdens de evaluatie van een tijdseenheid, tot min dertien zakken. Er zijn dus
minimaal vijf bits nodig. Een neuron beschikt over een interne pijplijn, er moet dus ook
nog opgeslagen worden of het neuron de volgende tijdseenheid zal vuren of niet.
Zowel de accumulator als de byte, die bepaald of een neuron de volgende tijdseenheid zal
vuren, worden tweemaal opgeslagen. Dit is nodig omdat men niet elke cel in parallel kan
verwerken. Stel bijvoorbeeld dat cel (0,0,0) in cel (1,0,0) vuurt en cel (1,0,0) zich in de
toestand niet vuren bevindt. Indien nu cel (0,0,0) eerst verwerkt wordt, moet de
accumulator van cel (1,0,0) met één verhoogd worden. Cel (1,0,0) moet dan weten dat hij
18
voor deze tijdseenheid niet vuurt en dat de waarde van zijn accumulator voor de volgende
tijdseenheid op één staat. Elke cel moet dus zijn toestand kennen voor twee tijdseenheden.
Voor een axon wordt één byte gebruikt, waar de eerste vier bits gebruikt worden voor de
ene tijdseenheid en de laatste vier bits voor de volgende tijdseenheid. Voor een neuron
wordt er voor de accumulator een byte gebruikt voor elke tijdseenheid, plus nog een extra
byte waarin opgeslagen wordt of het neuron de volgende tijdseenheid zal vuren of niet,
voor beide tijdseenheden.
De compiler genereert op basis van de configuratie code voor twee volledige
tijdseenheden.
Code voor een volledige tijdseenheid genereren heeft als voordeel dat er direkt van de
configuratie van elke individuele cel kan uitgegaan worden en er dus geen code nodig is
om te testen in welke richtingen een cel een in- en uitgang heeft.
Door code voor twee tijdseenheden te genereren wordt vermeden dat de informatie over de
accumulatoren moet gekopieerd worden. De code voor de eerste tijdseenheid kan
bijvoorbeeld kijken naar de eerste vier bits van de accumulator van een axon, en de code
voor de tweede tijdseenheid dan naar de laatste vier bits. Indien er slechts code voor één
tijdseenheid zou gegenereerd worden zouden de laatste vier bits telkens in de eerste vier
bits moeten gekopieerd worden tussen elke twee tijdseenheden. Dezelfde redenering geldt
uiteraard voor de bytes die gebruikt worden om de accumulator van een neuron in op te
slaan.
Er worden maximaal 13.824 cellen van een module gebruikt, waarvan er 1.152 de rol van
neuron kunnen spelen.
Er zijn dus ten hoogste 13824 + (2.1152) = 16.128 bytes geheugen nodig om de informatie
voor de verschillende cellen op te slaan. Aangezien de Pentium 3 over een datacache van
16 KB beschikt past de machine dus volledig in de cache.
19
In de compiler zoals hierna beschreven wordt voor elke cel gekeken of hij zal vuren of
niet, en indien de cel vuurt wordt dit vuursignaal naar de buren waarin de cel vuurt
gepropageerd.
Een alternatieve benadering is om voor elke cel naar de buren te kijken die in deze cel
vuren en op basis van de naburige cellen te bepalen of deze cel zal vuren of niet.
Enerzijds zullen er in deze alternatieve benadering meer instructies per cel nodig zijn
indien ze meer dan één uitgang heeft, voor elke cel zal moeten nagegaan worden of ze
vuurt of niet. Anderzijds kan het in deze alternatieve benadering voorkomen dat niet alle
buren van een cel moeten geëvalueerd worden. Indien een axon twee vuursignalen
ontvangt, kan de evaluatie van dit axon gestopt worden aangezien het dan altijd niet vuurt.
Dit controleren vergt echter ook extra instructies.
Uit de machines die in hoofdstuk 4 gebouwd worden blijkt dat cellen met veel ingangen
zeer weinig voorkomen, bovendien vuren cellen veel vaker niet dan wel.
Er zullen wel zeer specifieke machines kunnen geconstrueerd worden waarvoor de
alternatieve benadering efficiënter is, maar in praktisch bruikbare machines zal ze
ongetwijfeld slechter presteren.
20
3.1.1. Een Axon Een axon moet in elk van zijn uitgangen vuren als de waarde van zijn accumulator juist één
is. Er is bij het laden van de machine geweten in welke cellen elk axon vuurt. Nadat de
compiler geheugen heeft toegewezen voor elke cel, is geweten met welke
geheugenadressen elke cel, waarin het axon vuurt, overeenkomt en kan dit rechtstreeks in
de code ingeënt worden.
De accumulator wordt tweemaal opgeslagen, eenmaal in de eerste vier bits en eenmaal in
de laatste vier bits van de byte met adres Ai,j,k
voor axon (i, j ,k).
Eerst moet elk axon geïnitialiseerd worden. Dit gebeurt door twee MOV operaties.
MOV Ai,j,k
of MOV A
, 0 Indien de cel initiëel niet vuurt
i,j,k
, 1 Indien de cel initiëel wel vuurt
En voor elke cel Ai,j,k
met minstens één uitgang:
MOV AL, 15 (1)
AND AL, Aijk
CMP BYTE PTR AL, 1 (3)
(2)
AND Aijk
JNE volgende_cel (5)
, 240 (4)
ADD Axyz
INC BYTE PTR B
, 16 (6)
abc
DEC BYTE PTR B
(7)
abc
(8)
In lijn (1) en (2) wordt een logische en genomen van de byte die gebruikt wordt voor de
accumulator van het axon en de waarde 00001111, zodat enkel de laatste vier bits van de
accumulator gebruikt worden.
De volgende instructie zal kijken of het axon vuurt, enkel indien de waarde van de
accumulator exact één is zal het axon vuren.
Lijn (4) zal de waarde van de accumulator op nul zetten, dit wordt gedaan door de logische
en te nemen van de byte en 11110000.
21
Op lijn (5) zal er naar de volgende cel gesprongen worden indien dit axon niet vuurt.
Indien het axon wel vuurt, zullen er nog een aantal lijnen volgen die het axon laten vuren
in de naburige cellen waarnaar het een uitgang heeft. Voor elk axon waarin het axon vuurt
komt regel 6 voor, door zestien (00010000) op te tellen bij de waarde van de accumulator
van het axon waarin gevuurd wordt, worden de eerste vier bits van de accumulator met één
verhoogd.
Indien het axon via een ingang met positief gewicht in een neuron vuurt wordt de
accumulator van het neuron met één verhoogd, indien het via een ingang met negatief
gewicht vuurt wordt de accumulator van dit neuron met één verlaagd.
De volgende tijdseenheid moeten de rollen omgedraaid worden, voor het neuron waarin
(eventueel) het axon eventueel vuurt, wordt de accumulator Aabc dan gebruikt in plaats van
de accumulator Babc
En de waarden één (00000001) en zestien (00010000) moeten omgewisseld worden,
alsook de waarden vijftien (00001111) en tweehonderdveertig (11110000).
.
Uit de code blijkt dat het aantal uitgangen die een axon heeft en of het axon vuurt of niet
bepalend zijn voor de uitvoeringstijd.
Een MOV, AND, CMP en JNE operatie duurt één klokcyclus en een ADD, INC en DEC
drie klokcycli in een Pentium.
De uitvoeringstijd van een axon kan dus als volgt samengevat worden.
Aantal uitgangen het axon vuurt het axon vuurt niet
1 8 5
2 11 5
3 14 5
4 17 5
5 20 5
Hoewel een axon met zes uitgangen theoretisch kan bestaan, kan deze enkel de eerste
tijdseenheid vuren, een goede compiler zal deze cellen verwijderen en indien ze de eerste
tijdseenheid vuren de initiële configuratie aanpassen.
22
3.1.2. Een Neuron Een neuron wordt als volgt geïnitialiseerd: MOV Ai,j,k
MOV B , X (met –8 ≤ X ≤ 7)
i,j,k
MOV C , 0
i,j,k
, 0 of 1
Met X gelijk aan de initiële waarde van de accumulator. Bi,j,k bevat de waarde die per
tijdseenheid bij de accumulator wordt opgeteld en is dus initieel nul. Ci,j,k
is nul of één, al
naargelang het neuron de volgende tijdseenheid zal vuren of niet.
Een neuron evalueren gaat als volgt:
ADD Aijk, Bijk
MOV AL, A
(1)
ijk
CMP AL, 2 (3)
JL Underfl (4)
(2)
ADD Cijk
Underfl: CMP AL, -8 (7)
, 16 (5)
JMP Reset (6)
JGE Fire (8)
Reset: MOV BYTE PTR Aijk
Fire: MOV BL, 15 (10)
, 0 (9)
AND BL, Cijk
CMP BYTE PTR BL, 1 (12)
(11)
JNZ volgende_cel (13)
AND Cijk
# voor elke uitgang naar een cel (x,y,z)
, 240 (14)
ADD Axyz
, 16 (15)
Op lijn (1) wordt de accumulator aangepast met de waarden die het de vorige tijdseenheid
ontving van zijn buren.
Een neuron vuurt enkel indien de waarde van de accumulator groter dan of gelijk aan twee
is, lijnen (2) en (3) gaan na of het neuron de volgende tijdseenheid zal vuren.
23
Indien het neuron zal vuren wordt de C-variabele verhoogt met 16 (00010000) (lijn (5)), zo
wordt aangegeven dat het neuron de volgende tijdseenheid zal vuren. Als het neuron vuurt
moet de waarde van de accumulator terug op nul gezet worden. (lijn (7))
Indien het neuron niet vuurt zou het kunnen dat de waarde van de accumulator kleiner dan
min acht is, ook in dit geval moet de waarde van de accumulator terug op nul gezet
worden. (lijnen (7) en (9))
Er moet altijd nagegaan worden of het neuron deze tijdseenheid vuurt. Het neuron zal
vuren als de C-variabele op één staat, met andere woorden als de vorige tijdseenheid de
waarde van de accumulator groter dan of gelijk aan twee was.
Of het neuron deze tijdseenheid vuurt wordt bepaald door de laatste vier bits van C. Om
deze bits te bekijken wordt een logische en genomen van C en vijftien (00001111). Indien
de waarde van C gelijk is aan één moeten de laatste vier bits terug op nul gezet worden. Dit
gebeurt door een logische en te nemen van C en tweehonderdveertig (11110000). Ook de
variabele van elk axon waarin het neuron vuurt moet aangepast worden. Deze laatste
operatie is identiek aan die van een axon dat vuurt in een ander axon.
Net zoals bij een axon moet in de code voor de volgende tijdseenheid de zestien
(00010000) uit lijnen 5 en 15 vervangen worden door een één (00000001). De vijftien
(00001111) uit lijn 10 moet tweehonderdveertig (11110000) worden en de
tweehonderdveertig uit lijn 14 een vijftien.
Een CMP- (register – constante), JL-, JGE-, JNZ-, AND- en MOV-instructie duurt één
klokcyclus en een ADD-instructie duurt drie klokcycli in een Pentium.
Aantal uitgangen het neuron vuurt het neuron vuurt niet*
1 17 12
2 20 12
3 23 12
4 26 12
5 29 12 * Indien de accumulator op min acht staat en de waarde van de accumulator terug op nul moet gezet worden zal dit 11 klokcycli duren.
24
Merk op dat er in principe een onderscheid moet gemaakt worden tussen een cel die noch
deze tijdseenheid, noch de volgende vuurt; een cel die deze tijdseenheid niet vuurt maar de
volgende tijdseenheid wel; een cel die deze tijdseenheid vuurt maar de volgende niet en
een cel die beide tijdseenheden vuurt.
Maar voor elk neuron geldt uiteraard dat als ze op tijdstip t vuurt, ze op tijdstip t-1 de
volgende tijdseenheid ging vuren. Zodat, over verschillende tijdseenheden, twee
toestanden voldoende zijn: namelijk de cel vuurt of de cel vuurt niet.
25
3.2. Ondergrens De machine die het minst aantal berekeningen vergt voor deze compiler is een lege
machine. Zo een machine zal compileren tot een leeg programma.
Een ondergrens voor het aantal Pentiums nodig om de CAM-Brain te simuleren is dus nul.
26
3.3. Bovengrens Een machine die, voor de compiler uit 3.1, het hoogste aantal berekeningen vergt, is een
machine waarbij elke cel gebruikt wordt, elke cel vijf uitgangen heeft, elke cel elke
tijdseenheid vuurt en elk mogelijk neuron een neuron is.
Zo een machine kan in de praktijk niet bestaan, het is onmogelijk dat elke cel vijf
uitgangen heeft en het is onmogelijk dat elke cel elke tijdseenheid vuurt in een cel met
zoveel uitgangen.
In een machine heeft elke uitgang die gebruikt wordt als gevolg dat de naburige cel, waarin
de cel met de uitgang vuurt, een ingang heeft op deze plaats. Zodat een strictere
bovengrens bekomen wordt door het maximaal aantal uitgangen gedeeld door twee te
beschouwen.
Een cel zonder uitgangen heeft geen invloed op het gedrag van de machine, zodat deze
weggeoptimaliseerd worden. Elke cel moet dus minstens één uitgang hebben, voor elke
extra uitgang die een cel heeft, zijn er altijd drie klokcycli nodig in een Pentium, zowel
voor een axon als voor een neuron.
Om de rekenkracht te berekenen zal een machine beschouwd worden waarbij elke cel drie
uitgangen en drie ingangen heeft. Merk op dat een machine waar bijvoorbeeld de helft van
de cellen vijf uitgangen heeft en de andere helft één, exact evenveel rekentijd nodig heeft,
er bestaat met andere woorden geen machine met evenveel in- als uitgangen die meer
rekentijd nodig heeft dan de machine waar alle cellen drie in- en uitgangen hebben.
Het kan eenvoudig ingezien worden dat deze machine nog steeds niet kan bestaan in de
praktijk. Aangezien elke cel initieel vuurt en elke cel meer dan één ingang heeft zullen de
axonen de volgende tijdseenheid niet vuren.
Deze machine is echter wel zeker een bovengrens en het is niet eenvoudig om een machine
te vinden die in de praktijk kan bestaan en die zeker een bovengrens is.
Exhaustief zoeken is niet haalbaar. Om de redenering te vereenvoudigen wordt ervan
uitgegaan dat elke cel een axon is, neuronen gebruiken maakt het aantal machines die
moeten beschouwd worden enkel groter. Elke cel die gebruikt wordt kan zich in
27
honderdachtentwintig initiële toestanden bevinden (vuren - niet vuren en aan elke zijde een
in- of uitgang), er zijn dus 12813824 mogelijke, volledig gevulde, machines. Om een
vergelijking te kunnen maken moet elke machine tot een tijdstip t geëvalueerd worden
zodat de toestand op tijdstip t dezelfde toestand is als op een tijdstip kleiner dan t.
Aangezien er 13824 cellen zijn en elke cel altijd vuurt of niet is t begrensd door 213824
Bovendien kan de bovengrensmachine evengoed een machine zijn waarin één of meerdere
cellen niet gebruikt worden, zodat het totaal aantal machines die moeten beschouwd
worden resulteert in
.
∑=
−−
−
13823
0
)13824()13824( 2.128.)!13824!.(
!13824i
ii
ii
Hoewel er in de praktijk minder machines zullen moeten geëvalueerd worden (het is
uitgesloten dat een machine waar bijvoorbeeld maar twee cellen gebruikt worden de
bovengrensmachine is), geeft deze formule toch aan dat exhaustief zoeken praktisch niet
haalbaar is.
De machine waarbij elke cel drie uitgangen heeft, en die elke tijdseenheid vuurt, zal wel
zeker een bovengrens vormen.
Deze machine zal dan 12672 . 14 + 1152 .22 = 202752 klokcycli nodig hebben voor het
verwerken van één tijdseenheid.
Om een vergelijking te maken tussen de CAM-Brain en een Pentium 3 zullen telkens tien
miljoen tijdseenheden beschouwd worden. Dit getal is arbitrair, zolang het maar groot
genoeg is, er wordt gekozen voor tien miljoen omdat de CAM-Brain signalen aan tien
megahertz verwerkt, en dus juist één seconde nodige heeft om tien miljoen tijdseenheden
te verwerken.
Voor deze theoretische machine resulteert dit dan in 202,752.1010
klokcycli, de
vergelijking wordt gemaakt met een vijfhonderd megahertz Pentium 3, zodat een Pentium
3 dus maximaal 4055,04 maal zo traag is als de CAM-Brain.
28
4. Patroonherkenner
4.1. Inleiding Zoals reeds aangehaald is de vergelijking van de rekenkracht van de CAM-Brain met die
van een Pentium sterk afhankelijk van de machine die beschouwd wordt.
Er zijn drie factoren die een rol spelen voor de rekenkracht die nodig is om een machine te
simuleren, namelijk het aantal cellen die gebruikt worden, hoeveel cellen er als neuron
gebruikt worden en het aantal uitgangen waarin gevuurd wordt.
Er is geen monotoon verband tussen het aantal neuronen die gebruikt worden en de
rekenkracht die nodig is om een machine te simuleren. Een neuron heeft wel een grotere
rekenkracht nodig, zowel wanneer het vuurt als wanneer het niet vuurt, maar door het
verschillend gedrag dat een neuron heeft kan men niet met zekerheid zeggen dat een
machine waar meer cellen als neuronen gebruikt worden en waar de rest van de machine
identiek blijft, meer rekenkracht nodig heeft dan dezelfde machine waar minder neuronen
gebruikt worden.
Neem bijvoorbeeld een axon met twee ingangen en vier uitgangen waar de twee ingangen
om beurten vuren, dit axon zal elke tijdseenheid vuren in vier uitgangen. Indien dit axon
vervangen wordt door een neuron waarbij met de ene ingang een positief gewicht wordt
geassociëerd en met de andere ingang een negatief gewicht, dan zal dit neuron nooit vuren
en benodigde rekenkracht zal dus dalen.
Stel anderzijds dat beide ingangen elke tijdseenheid vuren, het axon zal nu nooit vuren.
Indien het axon vervangen wordt door een neuron en beide ingangen krijgen een positief
gewicht, dan zal het neuron elke tijdseenheid in vier uitgangen vuren. In dit geval is de
benodigde rekenkracht gestegen.
Aangezien er altijd rekenkracht nodig is om een cel te simuleren, zowel indien ze vuurt als
indien ze niet vuurt, zal de rekenkracht die nodig is om een machine te simuleren stijgen
indien het aantal cellen stijgt. Dit geldt uiteraard enkel indien de extra cellen niet tot gevolg
hebben dat vuursignalen elkaar opheffen en de machine dus minder vuurt.
29
Een cel die in een uitgang, en dus in een andere cel, vuurt zal een invloed uitoefenen op de
benodigde rekenkracht. Indien het aantal uitgangen waarin gevuurd wordt stijgt zal de
benodigde rekenkracht stijgen.
Merk op dat enkel de combinatie vuren – uitgangen de benodigde rekenkracht doet stijgen.
Enkel het aantal uitgangen laten stijgen of enkel het aantal cellen die vuren leidt niet
noodzakelijk tot een grotere nodige rekenkracht om de machine te simuleren. Zowel het
aantal uitgangen laten stijgen als het aantal cellen die vuren kan tot gevolg hebben dat de
vuursignalen elkaar opheffen en er dus uiteindelijk in minder uitgangen gevuurd wordt en
er dus minder rekenkracht nodig is.
Omdat de berekende onder- en bovengrens uit hoofdstuk 3 sterk uit elkaar liggen zal ik een
“typische” applicatie ontwerpen en hiervoor de rekenkracht berekenen.
Er wordt gekozen voor een patroonherkenner, aangezien dit een applicatie is waarvoor
neurale netwerken traditoneel vaak gebruikt worden.
Uiteindelijk maakt de keuze van de applicatie niet zoveel uit. Het gedrag van de CAM-
Brain wordt toch gesimuleerd in de Pentium. Het is enkel belangrijk een indicatie te
krijgen van het aantal in- en uitgangen die elke cel heeft, hoeveel cellen er niet gebruikt
worden, hoeveel cellen er als neuron gebruikt worden, en hoe vaak een cel vuurt in een
typische CAM-Brain machine, aangezien dit de factoren zijn die een invloed hebben op de
vergelijking CAM-Brain – Pentium.
De patroonherkenner heeft een n-bit geheugen, waarin het patroon opgeslagen wordt. Het
patroon in dit geheugen kan geschreven worden bij het laden van de machine en nadien
gewijzigd worden via één van de invoercellen.
Via een andere invoercel komt de invoerstroom van bits binnen in de machine. Het patroon
zal elke n tijdseenheden met deze invoerstroom vergeleken worden.
De uitvoer zal bestaan uit n2log bits. Deze bits stellen een binair getal voor dat het
aantal overeenkomsten aangeeft tussen het patroon en de invoerstroom.
30
Ik heb driemaal een dergelijke machine gebouwd. De eerste machine is een rechtsreekse
implementatie van deze patroonherkenner. Deze machine bleek vrij inefficiënt te zijn.
Door de inefficiënties in deze eerste machine te lokaliseren en te verbeteren ben ik tot een
tweede en derde machine gekomen, die efficiënter zijn.
Voor elk van de machines zullen telkens eerst de deelmachines besproken worden
(geheugen, patroon vergelijken, overeenkomsten tellen), waarna het samenstellen van deze
delen besproken wordt.
31
4.2. Eerste machine
4.2.1. Geheugen
Een geheugen kan in de CAM-Brain gebouwd worden als een cyclische aaneenschakeling
van axonen met telkens één ingang en één uitgang. Een bitpatroon wordt dan voorgesteld
door een opeenvolging van vurende en niet-vurende cellen. Deze vuursignalen gaan dan
van de ene cel in de andere tot ze weer aan het begin komen.
Schrijven naar, respectievelijk lezen uit zo’n geheugen wordt bekomen door een extra
ingang, respectievelijk een extra uitgang aan één (of meerdere) cel(len) in het geheugen
aan te leggen.
Een geheugen, dat op deze manier gebouwd wordt, is altijd een geheugen dat een even
aantal bits bevat. Indien men een geheugen wil voor een oneven aantal bits dient men
gebruik te maken van een neuron.
Een geheugen voor een even aantal bits is minimaal vier bits groot; een geheugen voor een
oneven aantal bits minimaal zeven.
Merk op dat kleinere geheugens ook mogelijk zijn. Indien men bijvoorbeeld een geheugen
van drie bits wil bekomen kan men een zes bit geheugen gebruiken en hierin tweemaal
dezelfde drie bit sequentie opslaan. Het wijzigen van de inhoud van dit soort geheugens is
wel lastiger.
32
4.2.2. Klokpuls We zullen vaak gebruik kunnen maken van een periodiek signaal, dat we een klokpuls
zullen noemen. Om een klokpuls te bekomen met periode n wordt er een geheugen
gemaakt van n bits, waarbij één bit in dit geheugen op één gezet wordt (of dus één cel in de
toestand vuren) en alle andere nul zijn.
33
4.2.3. Het patroon vergelijken met de invoerstroom Dit kan in de CAM-Brain erg eenvoudig geïmplementeerd worden.
Een axon met slechts twee ingangen gedraagt zich als de inverse van een exclusieve of-
poort. Men dient dus gewoon het patroon en de invoerstroom in een axon te laten vuren en
nadien deze uitvoer te inverteren.
Dit inverteren kan dan gebeuren door een constante één pulstroom in een axon te laten
vuren tesamen met de te inverteren bitstroom.
34
4.2.4. Aantal overeenkomsten tellen De invoer van deze deelmachine zal bestaan uit een continue pulstrein, waarin het aantal
vuursignalen (of dus het aantal overeenkomsten tussen de invoerstroom en het patroon) per
n-tijdseenheden moet geteld worden.
Het omzetten van deze pulstrein naar een binair getal dat het aantal overeenkomsten
voorstelt, kan gebeuren door deze pulstrein in een rij van neuronen te laten vuren.
Deze neuronen worden in serie geschakeld, waarbij elk neuron juist één ingang heeft met
positief gewicht.
Een neuron uit deze serie kan gezien worden als een 1-bit teller met carry, waarbij de carry
aan het volgende neuron doorgegeven wordt.
Als de waarde van de accumulator van de neuronen initieel op nul staat zal de waarde van
de accumulator van het eerste neuron op één staan indien er een oneven aantal
vuursignalen in dit neuron gevuurd hebben of m.a.w. de waarde van deze accumulator is
gelijk aan (x modulo 2), met x gelijk aan het aantal vuursignalen in de pulstrein die in dit
neuron gevuurd hebben.
De waarde van de accumulator van het tweede neuron zal één zijn indien het eerste neuron
een oneven aantal keer gevuurd heeft. De waarde van deze accumulator is dus gelijk aan
2mod2
x
Op een analoge manier kan ingezien worden dat de waarde van de accumulator van neuron
k in deze rij van neuronen voldoet aan:
2mod2
k
x
35
Met andere woorden, de waarden van de accumulatoren van de neuronen in deze rij zullen
een binair getal vormen, dat het aantal overeenkomsten tussen het patroon en de
invoerstroom voorstelt. Waarbij de waarde van de accumulator van het laatste neuron in de
rij het meest significante bit voorstelt.
Om het aantal vuursignalen in een pulstrein van n bits te kunnen tellen moet het aantal
neuronen m voldoen aan nm 2log≥ .
Om deze constructie in de machine te kunnen gebruiken moet er nu nog een manier
gevonden worden om de waarde van deze neuronen uit te lezen. En het is dit deel dat
verschilt in de drie verschillende machines.
36
4.2.5. De waarde van de accumulator uitlezen Het is de bedoeling een deelmachine te maken, die een vuursignaal als uitvoer heeft als de
waarde van de accumulator van een neuron één is en die niet vuurt in alle andere gevallen.
Na het uitlezen moet de waarde van de accumulator op nul staan, zodat een volgende
pulstrein kan verwerkt worden.
4.2.5.1. De waarde uitlezen en accumulator weer op nul zetten
We wensen de waarde van de accumulator van neuron 1 uit te lezen, waarbij deze waarde
altijd nul of één is. Dit kan gebeuren door een signaal via een ingang met positief gewicht
(via axon A) in het neuron te laten vuren. Indien de waarde van de accumulator één is, zal
het neuron vuren en zal de waarde van zijn accumulator op nul gezet worden. Indien de
waarde van de accumulator nul is, zal deze waarde op één gezet worden, zonder dat het
neuron vuurt.
37
Dit heeft tot gevolg dat dit leessignaal direkt gevolgd moet worden door een signaal dat via
een ingang met negatief gewicht vuurt in neuron 1. Anders zal de waarde van de
accumulator van het neuron niet op een bepaald tijdstip uitgelezen worden maar over een
bepaald tijdsinterval.
Stel bijvoorbeeld dat de invoer voor het neuron bestaat uit 0 – 0 – 0 – 1 en dat men de
waarde van de accumulator van het neuron de derde tijdseenheid wenst uit te lezen. Op dat
moment zal de waarde van de accumulator gelijk zijn aan nul. De leespuls zal als gevolg
hebben dat deze waarde op één komt te staan.
Indien nu de vierde tijdseenheid geen signaal via een ingang met negatief gewicht in het
neuron vuurt, zal het vuursignaal van de invoer als gevolg hebben dat het neuron vuurt en
er dus verkeerdelijk een één wordt uitgelezen.
Om een puls op twee opeenvolgende tijdstippen in een cel te krijgen moet men gebruik
maken van een neuron*
Rekening houdend met de plaatsing van de neuronen in de CAM-Brain
. Een signaal vanuit axon C, via axon A, zal neuron 1 bereiken na
vier tijdseenheden. Via axon B zal dit signaal het neuron bereiken na vijf tijdseenheden.
†
Merk op dat dit enkel geldt in de Y- en Z-richting. Als men deze constructie in de X-
richting wil bouwen zullen er twee extra axonen nodig zijn, aangezien de neuronen in de
X-richting verder uit elkaar liggen.
, is de kleinst
mogelijke constructie om een neuron op een bepaald tijdstip te bekijken zoals aangegeven
in de figuur.
Het signaal dat in het neuron vuurt via een ingang met negatief gewicht heeft dan weer als
gevolg dat de waarde van de accumulator, indien er een één wordt uitgelezen, na het
uitlezen op min één komt te staan.
Om er voor te zorgen dat de waarde van de accumulator altijd op nul komt te staan na het
uitlezen moet men dus de uitvoer terugschakelen en weer in het neuron laten vuren via een
ingang met positief gewicht. Dit gebeurt door de uitvoer van het neuron via axon D en
axon A weer in het neuron te laten vuren.
Dit heeft dan weer tot gevolg dat het interval tussen twee opeenvolgende leespulsen meer
dan vijf moet zijn. Indien het de periode van de leespuls kleiner dan vijf is, is het neuron
nog niet terug in zijn begintoestand gezet. Indien de periode exact vijf is heffen de leespuls
* zie 2.4 Implicaties van de opbouw, pagina 15 † zie 2.3 Opbouw van een module, pagina 7
38
en het teruggeschakelde signaal elkaar op in axon A. Dit laatste kan vermeden worden
door het signaal terug te schakelen via een andere ingang, maar indien de periode van de
leespuls groter dan vijf is, is deze methode efficiënter.
Deze eerste deelmachine zal de waarde van de accumulator correct uitlezen, en de waarde
van de accumulator van het neuron zal vier tijdseenheden na het uitlezen weer op nul staan.
Als we deze deelmachine echter nuttig willen gebruiken, zal het neuron dat we willen
uitlezen nog andere ingangen moeten hebben zodat er een waarde in het neuron kan
geschreven worden.
Nu stelt zich het probleem dat de waarden van axonen B en D altijd dezelfde waarde zullen
bevatten. Waar het de bedoeling is dat het neuron enkel zou vuren in axon B als gevolg van
een signaal afkomstig van axon A, en dat het enkel zou vuren in axon D als gevolg van een
signaal afkomstig uit axon C. De uitvoer dient m.a.w. op één of andere manier aan de
invoer gelinkt te worden.
Bovendien zal het neuron ook vuursignalen via axon B ontvangen als het vuurde als gevolg
van signalen afkomstig van axon C, m.a.w. de waarde van de accumulator wordt verhoogd
zonder dat dit nodig was. Deze constructie is dus in de praktijk niet bruikbaar.
39
Om een onderscheid te kunnen maken tussen vuursignalen als gevolg van de leespuls en
vuursignalen als gevolg van pulsen via de andere ingang(en) wordt de volgende machine
gebouwd.
4.2.5.2. Uitleeswaarde onderscheiden van andere uitvoer en vice versa Neem als basis de constructie uit het vorige deel. De idee is nu als volgt: om de uitvoer van
het neuron aan de leespuls te linken worden beide tegelijkertijd naar een nieuw neuron
gestuurd.
Indien men ervoor zorgt dat zowel het vuursignaal van axon A als het vuursignaal van
neuron 1, dat een gevolg is van het vuursignaal van axon A, via een ingang met positief
gewicht in neuron 2 vuren, direkt gevolgd door een vuursignaal via een ingang met
negatief gewicht, dan zal neuron 2 enkel vuren indien neuron 1 vuurde als gevolg van een
puls afkomstig uit axon A.
40
Er onderscheiden zich vier gevallen:
• Indien geen van beide vuurt, zal neuron 2 uiteraard ook niet vuren.
• Indien axon A vuurt en dit niet als gevolg heeft dat neuron 1 vuurt (de waarde van
de accumulator van neuron 1 was dus nul), dan zal de waarde van de accumulator
van neuron 2 op één gezet worden en de volgende tijdseenheid weer op nul gezet
worden. Neuron 2 zal dus niet vuren.
• Indien neuron 1 vuurt, niet als gevolg van een vuursignaal uit axon A maar als
gevolg van een andere invoer, zal de waarde van de accumulator van neuron 2 weer
op één gezet worden en nadien weer op nul gezet worden. En dus ook in dit geval
zal neuron 2 niet vuren
• Indien neuron 1 vuurt als gevolg van een vuursignaal uit axon A, zullen beide
tegelijkertijd in neuron 2 vuren. De waarde van de accumulator van neuron 2 wordt
dus twee en dit neuron zal dan vuren. De volgende tijdseenheid wordt de waarde
van de accumulator dan op min twee gezet.
Dit in de praktijk implementeren blijkt echter iets lastiger.
Om zowel axon A als neuron 1 in twee opeenvolgende tijdseenheden via een ingang met
positief en een ingang met negatief gewicht te laten vuren, is telkens een extra neuron
nodig.
41
Nu moet nog axon A met axon D verbonden worden en neuron 1 met axon C op een
zodanige manier dat een signaal vertrekkend van axon A, dat via axon B en neuron 1 axon
C bereikt, er even lang over doet dan het signaal dat van axon A vertrekt en axon D
bereikt.
Indien er enkel axonen gebruikt worden om de verbindingen te maken bereikt een signaal
vanuit axon A axon C in 7+2k tijdseenheden, en bereikt dat signaal axon D in 4+2j
tijdseenheden. Er zal dus nog een extra neuron moeten toegevoegd worden.
42
Als men de constructie gebruikt zoals in bovenstaande figuur zal een puls, vanuit axon A,
via axon D neuron 2 bereiken na 13 tijdseenheden. Dezelfde puls zal via axon B ook
neuron 2 bereiken in 13 tijdseenheden.
De deelmachine tot nu toe gebouwd, heeft reeds als eigenschap dat 15 tijdseenheden na het
vuren van de leespuls uit axon A, neuron 2 zal vuren indien de waarde van de accumulator
van neuron 1 gelijk was aan één, en dat neuron 2 niet zal vuren indien de waarde van deze
accumulator gelijk was aan nul.
De correcte waarde wordt dus reeds uitgelezen, maar na het uitlezen wordt deze
deelmachine nog niet terug in zijn begintoestand gezet (i.e. de waarden van de
accumulatoren van alle neuronen gelijk aan nul).
Indien de waarde van de accumulator van neuron 1 gelijk is aan nul, zullen na het uitlezen
van deze waarde alle accumulatoren de waarde nul bevatten. Ze hoeven met andere
woorden niet aangepast te worden.
Indien de waarde één wordt uitgelezen, zal na het uitlezen de waarde van de accumulator
van neuron 1 op min één staan, en die van neuron 2 op min twee.
43
Dit kan opgelost worden door de uitvoer van neuron 2 terug te schakelen en tweemaal via
een ingang met positief gewicht in neuron 2 te laten vuren, en éénmaal via een ingang met
positief gewicht in neuron 1.
Het signaal van neuron 2 terugschakelen naar neuron 1 duurt zeven extra tijdseenheden,
zodat het in totaal tweeëntwintig tijdseenheden duurt om het neuron uit te lezen en de
deelmachine terug in zijn begintoestand te brengen.
De periode tussen twee leespulsen moet dus minstens tweeëntwintig zijn, anders is het niet
gegarandeerd dat er een correct resultaat wordt uitgelezen.
Deze deelmachine zal op een correcte manier de waarde van de acumulator van neuron 1
uitlezen. Indien er een extra ingang aan neuron 1 aangelegd wordt om dit neuron te
beschrijven, zal de machine enkel een puls als uitvoer hebben indien neuron 1 vuurt als
gevolg van een puls van axon A, en niet als gevolg van twee pulsen afkomstig van de
nieuwe ingang.
Deze deelmachine kan echter nog niet gebruikt worden in de rij van neuronen om de
waarden van deze neuronen uit te lezen. Niet alleen is er niet genoeg plaats rond neuron 1
om zowel een extra ingang als een extra uitgang aan te leggen, bovendien zal het uitlezen
van het neuron nog steeds interfereren met de signalen die de rij van neuron passeren.
44
Om dit op te lossen is er gelukkig niet nog zo een deelmachine nodig. Het is veel
eenvoudiger (en dus efficiënter) om elke neuron uit de rij van neuronen te klonen en de
waarde van deze kloon uit te lezen.
De rij van neuronen bevindt zich op de as gevormd door de axonen E en F. Neuron 1 en
neuron 3 zijn klonen. Ze zullen altijd dezelfde waarde bevatten, zij het dat neuron 1 deze
waarde twee tijdseenheden later bevat.
Neuron 1 of neuron 3 uitlezen komt dus op hetzelfde neer, indien het uitlezen van neuron 1
relatief gezien twee tijdseenheden later gebeurt.
Indien een één wordt uitgelezen zal de accumulator van neuron 3 na het uitlezen nog steeds
de waarde één bevatten. Om dit neuron terug in zijn begintoestand te brengen wordt het
uitvoersignaal van neuron 2 verder teruggeschakeld naar neuron 3, waar het via een ingang
met negatief gewicht in vuurt. Indien de waarde van de accumulator nul was, en er dus een
45
nul wordt uitgelezen, zal de waarde nul blijven. Indien de waarde één was, wordt ze op nul
gezet.
Hoewel deze deelmachine een correct gedrag vertoont wanneer ze gebruikt wordt om één
neuron te bekijken, loopt het mis als ze gebruikt wordt in de rij van neuronen.
De reden is dat informatie van verschillende pulsrijen van lengte n met elkaar interfereren.
Nadat de laatste puls van segment met lengte n het neuron 3 bereikt zal het drieëntwintig
tijdseenheden duren voordat neuron 3 terug in zijn begintoestand wordt gezet. Ondertussen
kunnen pulsen van het volgende segment reeds in dit neuron vuren en gaat er zich
verkeerde informatie door het netwerk propageren.
Stel bijvoorbeeld dat na een segment van n pulsen de waarde van neuron 3 gelijk is aan
één. Indien er nu een vuursignaal optreedt in de eerste drieëntwintig tijdseenheden van het
volgende segment, zal het neuron vuren, terwijl het correcte gedrag zou zijn dat de waarde
van de accumulator op één gezet wordt.
De eenvoudigste manier om dit op te vangen bestaat erin om de signalen die neuron 3
bereiken te vertragen met drieëntwintig tijdseenheden en dit tussen elke twee neuronen in
de rij van neuronen. De vertraging is oneven, dus er zal een neuron moeten gebruikt
worden om dit te bereiken.
Dit heeft dan weer als gevolg dat ook de leespuls moet vertraagd worden, aangezien deze
synchroon moet lopen met de pulstrein die door de rij van neuronen gaat. Er zijn twee
axonen tussen elk neuron in de rij van neuronen. Het neuron zelf vertraagt de puls nog met
één tijdseenheid (interne pijplijn). Het duurt dus vier tijdseenheden eer een puls van een
neuron naar een ander neuron kan gaan. Dan wordt de puls nog eens drieëntwintig
tijdseenheden vertraagd. In totaal moet de leespuls er dus zevenentwintig tijdseenheden
over doen om van het ene neuron naar het andere te gaan.
46
Deze machine heeft nu nog één beperking. Indien er op het moment dat de leespuls neuron
1 bereikt er ook een vuursignaal van de invoerstroom in dit neuron vuurt kan de machine
verkeerde resultaten geven.
Dan is het namelijk mogelijk dat de waarde van de accumulator van neuron 1 op drie komt
te staan en dan zal de machine een identiek gedrag vertonen als wanneer de waarde van de
accumulator op twee komt te staan.
Afhankelijk van de interpretatie is de fout als volgt: indien men het signaal van de
invoerstroom beschouwt als een deel van de pulsrij die men wenst uit te lezen met de
leespuls, zal er verkeerdelijk een één worden uitgelezen. De waarde van de accumulator
stond op één en wordt met één verhoogd, m.a.w. de deelmachine moet een nul uitlezen.
Maar omdat het neuron vuurt op het moment dat de leespuls toekomt zal de deelmachine
als uitvoer een één hebben.
47
Indien men het signaal van de invoerstroom beschouwt als een deel van de volgende pulsrij
zal het neuron correct een één uitvoeren, maar zal na het uitlezen de waarde van de
accumulator van neuron 1 verkeerdelijk op nul staan.
Dit kan niet eenvoudig binnen deze deelmachine opgevangen worden. Het is echter wel
redelijk eenvoudig om vooraf te testen of er op dat tijdstip een overeenkomst optreedt
tussen de invoerstroom en het patroon (en er dus een vuursignaal is) en dit signaal altijd op
nul te zetten.
De tweede en derde machine zullen dit probleem niet hebben.
48
4.2.6. Volledige machine
Een deelcomponent van de laatste deelmachine (die gebruikt wordt om de waarde van de
accumulatoren van de neuronen uit de rij van neuronen uit te lezen) past in een 3x9x6 blok.
Aangezien deze deelcomponenten ook met elkaar moeten verbonden worden, en rekening
houdend met de plaatsing van de neuronen, passen er zes zo een deelcomponenten in de x-
richting. In de y-richting passen er twee en in de z-richting vier.
Deze deelmachine beperkt dus de grootte van het patroon dat kan vergeleken worden tot
2(6.2.4) = 248
Aangezien de CAM-Brain maar 24
bits. Nu moet er nog plaats gemaakt worden voor het geheugen en de leespuls.
Men kan ervan uitgaan dat de deelmachine die het patroon vergelijkt met de invoerstroom
past in de lege ruimte die gecreëerd is om de deelmachines die de neuronen uitlezen aan
elkaar te koppelen. 3
of 13824 cellen ter beschikking heeft, is het grootste
patroon dat kan vergeleken worden beperkt tot 6812 bits. (er zijn twee even grote
geheugens nodig, één voor het patroon en één voor de leespuls).
Indien de deelmachine die het aantal overeenkomsten telt met één deelcomponent
verkleind wordt, komt er één achtenveertigste of 288 cellen van de machine vrij, of dus
144 per geheugen. Het grootst mogelijk patroon die deze machine kan verwerken wordt
gegeven door i in de volgende vergelijking te minimaliseren.
ii .144248 ≥−
De grootst mogelijke i is 35, het grootst mogelijke patroon die de deelmachine, die het
aantal overenkomsten telt, kan verwerken is dan 213 of 8192 bits. Er zijn dan 5040 bits vrij
voor elk van de geheugens.
49
4.2.7. Rekenkracht analyse van deze machine Zoals reeds aangehaald hangt de rekenkracht, die nodig is om een machine binnen een
Pentium te simuleren, onder andere af van het aantal uitgangen van elke cel en van het
aantal vuursignalen binnen de machine.
Elke tijdseenheid moet elke cel geëvalueerd worden. Indien deze cel vuurt zal ze echter
meer tijd in beslag nemen om gesimuleerd te worden in een Pentium, en dit afhankelijk
van het aantal uitgangen die de cel heeft. Daarom zal voor elk van de deelmachines
nagegaan worden hoe vaak elke cel vuurt en met hoeveel uitgangen.
Om de vergelijking te kunnen maken worden de volgende variabelen geïntroduceerd:
• A1 tot A5
• N
: tijd nodig om axonen te laten vuren in één tot vijf uitgangen
1 tot N5
• x: aantal overeenkomsten tussen de invoer en het patroon
: tijd nodig om neuronen te laten vuren in één tot vijf uitgangen
• y: aantal vuursignalen in het patroon
• n: aantal tijdseenheden
• g: grootte van het geheugen
Het aantal vuursignalen in de invoerstroom hebben ook een invloed, maar deze is zo
beperkt dat ze buiten beschouwing gelaten wordt. De invoerstroom vuurt namelijk slechts
in een zeer beperkt aantal cellen, en wordt direct vergeleken met het patroon, zodat vooral
het aantal overeenkomsten en het aantal vuursignalen in het patroon een rol spelen.
4.2.7.1. Geheugen Indien het geheugen bestaat uit g axonen, dan hebben g-1 axonen één uitgang, en enkel de
cel waar het patroon uitgelezen wordt heeft twee uitgangen. Voor n tijdseenheden
resulteert dit in
yAAggn ).).1(( 21 +−
50
4.2.7.2. Leespuls De leespuls is identiek aan het geheugen voor het patroon. Alleen is er bij de leespuls
telkens slechts één cel die vuurt, m.a.w. y is gelijk aan één.
)).1(( 21 AAggn
+−
4.2.7.3. Patroon vergelijken met invoerstroom Het vier-bit geheugen met alle bits op één bestaat uit drie axonen met één uitgang en één
axon met twee uitgangen. Elk van deze vier cellen vuurt elke tijdseenheid.
Dan zijn er nog twee cellen die enkel vuren indien er een overeenkomst is tussen het
patroon en de invoerstroom.
2.A1.x + (4.A1 + A2
).n
4.2.7.4. Aantal overeenkomsten tellen De deelmachine die het aantal overeenkomsten telt bestaat uit twaalf deelcomponenten.
Elke component is opgebouwd uit zesentachtig axonen en acht neuronen.
Een signaal doet er zevenentwintig tijdseenheden over om van de ene component naar de
volgende te gaan. Voor elk vuursignaal zullen er per deelcomponent vierentwintig axonen
met één uitgang vuren, twee axonen met twee uitgangen en één neuron met één uitgang.
Dit resulteert in:
( ) xNAA ..2.24 121 ++
De eerste deelcomponent zal voor elke overeenkomst een vuursignaal ontvangen (dus x
vuursignalen). De tweede deelcomponent enkel voor elke twee vuursignalen die de eerste
component passeren, enzovoort.
In totaal:
∑=
++
12
0121 ).2.24.(
2ii NAAx
51
Elk tweede vuursignaal dat in een deelcomponent toekomt heeft al gevolg dat het neuron
en een aantal andere cellen zullen vuren. Meer bepaald zullen er acht axonen met één
uitgang vuren, één axon met twee uitgangen en drie neuronen met één uitgang.
∑=
+++
12
01211 ).3.8.(
2ii NAAx
Per leespuls zullen er vierendertig axonen met één uitgang vuren, zeven axonen met twee
uitgangen en drie neuronen met één uitgang. Een leespuls treed elke g tijdseenheden op.
Indien er een één wordt uitgelezen komen daar nog zestien axonen met één uitgang, vier
axonen met twee uitgangen en drie neuronen met één uitgang bij. Er wordt een één uit de
eerste deelcomponent uitgelezen indien x modulo 2 gelijk is aan één, enzovoort*
)).3.4.16).(2mod2
().3.7.34.(( 121
12
0121 NAAxNAA
gn
ii ++
+++
∑=
4.2.7.5. Rekenkracht analyse Al de voorgaande formules geven de extra rekenkracht aan die nodig is wanneer de cellen
vuren. Er is ook nog rekenkracht nodig wanneer een cel niet vuurt, het aantal axonen en
neuronen in de machine moet dus ook gekend zijn.
Zowel het geheugen voor het patroon als het geheugen voor de leespuls bestaan uit g
axonen. De deelmachine die het patroon vergelijkt met de invoerstroom bestaat uit zeven
axonen.
Een deelcomponent van de deelmachine die het aantal overeenkomsten telt bestaat uit
achtentachtig axonen en acht neuronen. In de machine zoals ze hier gebouwd werd is g
gelijk aan 5040 en zijn er dertien deelcomponenten, zodat er in totaal dus 11231 axonen en
104 neuronen gebruikt worden.
* zie 4.2.4 Aantal overeenkomsten tellen, pagina 34
52
Er zijn uiteraard ook nog een aantal axonen nodig om al de verschillende deelcomponenten
met elkaar te verbinden, maar aangezien dit telkens axonen met één uitgang betreft, en hun
aantal beperkt is, worden ze buiten beschouwing gelaten.
De rekenkracht is afhankelijk van twee veranderlijken: x, het aantal overeenkomsten tussen
de invoer en het patroon en y, het aantal vuursignalen in het patroon.
Aangezien een cel die vuurt altijd meer rekenkracht nodig heeft dan een cel die niet vuurt
zal de machine een minimum bereiken indien zowel x als y nul zijn, en een maximum
indien ze beiden 5040 zijn.
Voor zowel x als y nul is de rekenkracht van 1142,187 Pentiums nodig om deze machine te
simuleren. Indien ze beide 5040 zijn is er een rekenkracht van 1442,25 nodig.
0
500
1000
1500
Aantal Pentiums
Machine 1
1000-1500500-10000-500
Uit de grafiek valt vooral op dat de x-waarde slechts een zeer kleine rol speelt. Uit de
berekeningen blijkt dat voor een gelijke y en enerzijds x gelijk aan nul en anderzijds x
gelijk aan 5040, de toename in aantal Pentiums slechts 0,003 is.
Merk op dat y enkel een rol speelt binnen het geheugen voor het patroon, waar x vooral een
rol speelt bij de eenheid die het aantal overeenkomsten telt.
53
Indien de rekenkracht bekeken wordt in functie van de vier grote delen in de machine,
namelijk het geheugen voor het patroon, het geheugen voor de leespuls, de
patroonvergelijker, en de eenheid die het aantal overeenkomsten telt, dan bekomt men
gemiddeld het volgende.
Totaal: 1292,218
51%39%
0% 10%
PatroonLeespulsVergelijkenTellen
Hoewel deze verhoudingen variëren in functie van x en vooral y, geeft het gemiddelde een
goede indicatie.
Uit deze grafiek blijkt dat de eenheid die het aantal overeenkomsten telt, het deel
afhankelijk van x, toch een significant deel van de rekenkracht bepaald.
De discrepantie tussen het aandeel van dit deel in het totaal (10%) en de zeer beperkte
invloed van de variatie van x (0,0002%) op het totaal kan verklaard worden uit het feit dat
dit deel een zeer constant gedrag vertoont.
De meeste cellen in dit deel vuren het grootste deel van de tijd niet, en als ze vuren is dit
vaak een gevolg van de (constante) leespuls.
54
4.2.8. Analyse van de eerste patroonherkenner Zowel het geheugen, de klokpuls als de deelmachine die het patroon vergelijkt zijn vrij
efficiënt. Om deze machine te optimaliseren zal dan ook vooral het laatste deel (dat een
neuron uitleest) moeten geoptimaliseerd worden.
Het valt direct op dat een aantal van de neuronen enkel gebruikt worden om een vertraging
van één tijdseenheid te bekomen (vijf van de acht neuronen). Dit heeft als gevolg dat er
een flink aantal cellen nodig zijn als verbinding met deze neuronen, als gevolg van de
ligging van de neuronen.
Dit alles maakt de deelmachine relatief groot, zodat het ook een flink aantal tijdseenheden
duurt vooraleer de deelmachine in zijn begintoestand kan gezet worden. Dit heeft dan weer
tot gevolg dat er een aanzienlijk aantal cellen nodig zijn om zowel de pulstrein als de
leespuls te vertragen.
Dit alles is een gevolg van het feit dat de timing van de verschillende signalen erg strikt is.
Indien de verschillende pulsen, die eerst via een ingang met positief gewicht en de
volgende tijdseenheid via een ingang met negatief gewicht in een neuron vuren, dit ook
twee tijdseenheden later zouden mogen doen, zou de machine al veel minder cellen
gebruiken aangezien er dan geen neuronen meer nodig zijn om de vertragingen te
bekomen. Dit zal in de volgende machine uitgewerkt worden.
55
4.3. Tweede machine Het is de bedoeling een machine te bouwen, die een vergelijkbaar gedrag vertoont als de
eerste machine, maar die dit efficiënter implementeert. Zowel het geheugen, de leespuls als
de patroonvergelijker zijn hetzelfde. Deze machine zal enkel van de eerste machine
verschillen in het deel, dat het aantal overeenkomsten telt, meer bepaald het deel dat de
waarde van de accumulator van een neuron uitleest. Er wordt dus nog altijd gebruikt
gemaakt van een rij van neuronen om het aantal overeenkomsten te tellen.
Zoals reeds aangehaald zou de machine veel efficiënter zijn indien de vertragingen van één
tijdseenheid niet nodig zouden zijn. Dit kan bekomen worden door ervoor te zorgen dat er
tussen elke twee pulsen een tijdseenheid niets is.
Het is niet mogelijk om op bepaalde tijdstippen de pulstrein te laten wachten. Dit kan
echter wel bekomen worden door de pulstrein te splitsen.
56
4.3.1. De pulstrein splitsen
Deze deelmachine heeft als invoer een pulstrein en de uitvoer bestaat uit twee (of
meerdere) pulstreinen. Stel dat de uitvoer uit n pulstreinen bestaat, dan heeft elke pulstrein
i op positie i + k.n een nul of één, gelijk aan de waarde die de oorspronkelijke pulstrein
had op die positie. De overige n-1 posities zijn dan nul.
Stel bijvoorbeeld dat de invoer bestaat uit 1 – 1 – 0 – 1 – 0 – 0 – 1, en dat deze pulstrein in
drie delen wordt opgesplitst.
De eerste pulstrein bevat dan: 1 – 0 – 0 – 1 – 0 – 0 – 1
De tweede pulstrein: 0 – 1 – 0 – 0 – 0 – 0 – 0
De derde pulstrein: 0 – 0 – 0 – 0 – 0 – 0 – 0
Om dit te bekomen wordt de pulstrein eerst gekloond. Dit kan gebeuren door een axon met
één ingang en meerdere uitgangen.
Nadien wordt bij elke kloon per n signalen er één doorgelaten.
57
Axon A bevat (de kloon van) de pulstrein. Deze vuurt, met behulp van een neuron, op twee
opeenvolgende tijdseenheden in neuron 1. Eerst via een ingang met positief gewicht,
gevolgd door een puls via een ingang met negatief gewicht.
Axon D krijgt van een klein geheugen elke n tijdseenheden een puls. (in de tekening elke
acht tijdseenheden). Deze puls vuurt dan ook in twee opeenvolgende tijdseenheden via een
ingang met positief gewicht en een ingang met negatief gewicht in neuron 1.
Enkel wanneer zowel axon D als axon A tegelijkertijd een puls bevatten zal neuron 1
vuren, m.a.w. elke n tijdseenheden zal neuron 1 vuren, en enkel indien axon A vuurde.
Indien axon A geen vuursignaal bevat op het moment dat axon D vuurt zal de waarde van
de accumulator van neuron 1 na het doorlaten van deze nul op nul staan. Indien beide
tegelijkertijd vuren zal nadat het vuursignaal werd doorgelaten de waarde van de
accumulator van neuron 1 op min twee staan.
58
De uitvoer wordt dan teruggeschakeld naar neuron 1 en vuurt tweemaal via een ingang met
positief gewicht in dit neuron. Op deze manier wordt het neuron terug in zijn begintoestand
gezet. Dit duurt zeven tijdseenheden, deze machine kan dus enkel gebruikt worden om een
pulstrein in zeven of meer delen te splitsen.
Voor machine drie zal een andere pulstrein splitser gebouwd worden die dit probleem niet
heeft
Door een pulstreinsplitser te gebruiken verandert het gedrag van de machine. De uitvoer
zal nu niet langer een binair getal zijn, dat het aantal overeenkomsten weergeeft maar een
aantal binaire getallen, voor elk gesplitst deel één, waarvan de som het aantal
overeenkomsten weergeeft.
59
4.3.2. De waarde van de accumulator uitlezen Het principe is identiek aan dat uit de eerste machine. Het neuron waarvan de waarde
wordt uitgelezen wordt eerst gekloond. Deze kloon wordt uitgelezen met een leespuls en
de uitvoer van de kloon wordt dan naar een nieuw neuron gestuurd, hetwelk enkel zal
vuren indien de kloon vuurde als gevolg van de leespuls.
De rij van neuronen bevindt zich op de as gevormd door axon A en neuron 3. Zoals in de
eerste machine wordt de inhoud van neuron 3 gekloond in neuron 1, en zal deze kloon
uitgelezen worden.
Er kunnen zich twee gevallen voordoen: er wordt een één uitgelezen of er wordt een nul
uitgelezen. Om de bespreking te vereenvoudigen worden de beide gevallen apart
besproken.
In het eerste geval, waar er een één wordt uitgelezen, zal de waarde van de accumulator
van neuron 1 en van neuron 3 initieel gelijk zijn aan één. De waarde van de accumulator
van neuron 2 is gelijk aan nul.
60
De leespuls komt de deelmachine binnen via axon B en zal vuren in neuron 1, en zo de
waarde van de accumulator van dit neuron op twee zetten. Eén tijdseenheid later zal
neuron 1 in de toestand vuren komen en dus zal de waarde van de accumulator van neuron
1 op nul gezet worden. Tegelijkertijd bevindt het vuursignaal vanuit axon B zich in de
axonen C, D en F. De volgende tijdseenheid vuurt axon D in neuron 2 via een ingang met
positief gewicht en zet zo de waarde van de accumulator van neuron 2 op één.
Tegelijkertijd zal neuron 1 in axon E vuren. Op dit moment zal ook axon C in neuron 1
vuren via een ingang met negatief gewicht en zal zo de waarde van de accumulator van dit
neuron op min één zetten.
Eén tijdseenheid later zal axon E in neuron 2 vuren, en de waarde van zijn accumulator op
twee zetten, en zal het ook in axon G vuren. Op hetzelfde moment zal axon H een
vuursignaal ontvangen (vanuit axon B via axon F).
De volgende tijdseenheid zal neuron 2 in de toestand vuren komen. Het vuursignaal vanuit
axon H zal de waarde van de accumulator van neuron 2 op min één zetten en het signaal
vanuit axon G komt in axon H.
De tijdseenheid daarna zal neuron 2 in axon I vuren (er wordt dus een één uitgelezen) en
zal het vuursignaal vanuit axon H de waarde van de accumulator van neuron 2 op min twee
zetten.
In het tweede geval zal de waarde van de accumulator van zowel neuron 1, neuron 2 als
neuron 3 nul zijn.
Axon B vuurt in neuron 1 en zal zo de waarde van de accumulator op één zetten.
Twee tijdseenheden later zal de waarde van de accumulator van dit neuron weer op nul
gezet worden, via axon C. Tegelijkertijd zal het vuursignaal via axon D de waarde van
accumulator 2 op één zetten.
Merk op dat hoewel de waarde van accumulator 1 twee tijdseenheden op één staat als
gevolg van de leespuls, dit niet als gevolg heeft dat de waarde van dit neuron over een
tijdsinterval wordt uitgelezen, aangezien de pulstrein die via axon A deze deelmachine
bereikt gesplitst was en er dus één (of meer) nullen tussen elk vuursignaal voorkomen.
Nog twee tijdseenheden later zal het vuursignaal vanuit axon B via axon F en H in neuron
2 vuren via een ingang met negatief gewicht en zo de waarde van de accumulator van dit
neuron weer op nul zetten.
Er is dus een nul uitgelezen en de waarde van de accumulatoren van de drie neuronen is
telkens nul.
61
Het kan eenvoudig ingezien worden dat deze deelmachine enkel zal vuren als gevolg van
een leespuls. Indien axon A meerdere malen in neuron 1 vuurt (met telkens minstens een
nul tussen elke twee vuursignalen, aangezien de pulstrein gesplitst is), zal neuron 1 in
neuron 2 vuren. Telkens langs axon E via een ingang met positief gewicht, twee
tijdseenheden later gevolgd door een puls lang axon H via een ingang met negatief
gewicht.
Aangezien er minstens drie nullen zijn tussen twee opeenvolgende pulsen vanuit neuron 1
zal neuron 2 dus nooit vuren. (Opdat neuron 1 tweemaal zou vuren moet het vier
vuursignalen ontvangen. Tussen elk vuursignaal vanuit axon A is er minstens één nul,
zodat er minstens drie nullen zijn tussen elk vuursignaal vanuit neuron 1)
Nu moeten de neuronen nog terug in hun begintoestand geplaatst worden indien er een één
wordt uitgelezen. Dit gebeurt weer door het uitvoersignaal terug te schakelen.
62
De uitvoer van neuron 2 vuurt via axon I en axon D en J tweemaal in neuron 2 via een
ingang met positief gewicht en zet zo de accumulator van dit neuron terug op nul indien dit
neuron vuurde.
Via axon K vuurt de uitvoer via een ingang met positief gewicht in neuron 1 en via axon L
vuurt de uitvoer via een ingang met negatief gewicht in neuron 3, zodat de accumulatoren
van alle neuronen terug op nul komen te staan.
Hetzelfde probleem als bij de eerste machine doet zich weer voor: de invoerstroom moet
vertraagd worden zodat verschillende pulsrijen van n bits niet met elkaar interfereren.
Een signaal, dat via axon A de deelmachine binnenkomt, doet er vijftien tijdseenheden
over om door de deelmachine verwerkt te worden en teruggeschakeld te worden via axon I
en axon L naar neuron 3.
De vertraging, die het signaal vanuit axon A moet ondergaan vooraleer het neuron 3
bereikt, hangt in deze machine echter ook af van hoe de oorspronkelijke pulstrein gesplitst
was. Indien de pulstrein in n delen gesplitst was zullen er telkens minimum n-1 nullen
voorkomen tussen twee vuursignalen, zodat het signaal vanuit axon A telkens 15-(n-1) of
dus 16-n tijdseenheden moet vertraagd worden.
De leespuls moet weer evenveel vertraagd worden om synchroon te blijven met de
invoerstroom.
Het probleem waar de invoerstroom en de leespuls tegelijkertijd in neuron 1 vuren treed
hier ook op. Men kan het op dezelfde manier opvangen als bij de eerste machine, maar
indien men ervoor zorgt dat de periode van de leespuls een veelvoud is van het aantal delen
waarin de invoerstroom gesplitst werd, kan men er eenvoudig voor zorgen dat beide nooit
tegelijkertijd in neuron 1 aankomen.
63
4.3.3. Volledige machine
Bij de deelcomponent, die een waarde van een accumulator uitleest, moeten er nog extra
cellen toegevoegd worden voor de vertragingen, afhankelijk van het aantal delen waarin de
pulstrein gesplitst wordt. Zoals reeds aangehaald is dit minimaal in zeven delen (anders
werkt de splitser niet correct). Indien de invoerstroom in zestien of meer delen gesplitst
wordt is een vertraging niet meer nodig.
Wanneer men de deelcomponent uit 3.3.2 opvat als een 3x2x6 blok is er geen plaats vrij
voor deze vertraging. Er moeten hiervoor dus nog extra cellen gereserveerd worden. Zowel
de leespuls als de invoerstroom moeten vertraagd worden. Door de plaatsing van de cellen
binnen de deelcomponent is het niet mogelijk om de machine in de Z-richting uit te
breiden en de vertragingen binnen deze vrijgekomen cellen te plaatsen.
Indien de deelcomponent in de Y-richting wordt uitgebreid wordt de dimensie van de
deelcomponent minstens 3x4x6, dit als gevolg van de plaatsing van de neuronen. Er komen
m.a.w. zesendertig cellen vrij. Aangezien de vertraging 16-n is (met n het aantal delen
waarin de pulstrein wordt gesplitst) en de pulstrein minimum in zes delen moet gesplitst
worden, is dit genoeg om de vertragingen in te passen, onafhankelijk van het aantal delen
waarin de pulstrein wordt gesplitst.
Indien de deelcomponent in de X-richting wordt uitgebreid wordt de dimensie 6x2x6. Er
komen dan ook zesendertig cellen vrij voor de vertraging.
Indien we met een 3x4x6 deelcomponent werken, passen er in de X-richting acht zulke
componenten in de CAM-Brain, in de Y-richting zes en in de Z-richting vier. In totaal dus
8.6.4 of honderdtweeënnegentig deelcomponten. Indien er gebruik gemaakt wordt van een
6x2x6 passen er in de X-richting vier componenten, in de Y-richting twaalf en in de Z-
richting vier. In totaal dus 4.12.4 of ook honderdtweeënnegentig deelcomponenten.
De vertragingen in de X- of Y-richting plaatsen maakt dus geen enkel verschil voor de
mogelijkheden van de machine. Er wordt gekozen voor een uitbreiding in de Y-richting.
64
Elke aaneenschakeling van deelcomponenten, die één deel van de pulstrein verwerkt moet
even lang zijn. Het is zo dat in hoe minder delen de pulstrein gesplitst wordt, hoe meer bits
de machine kan verwerken; aangezien men dan de verschillende deelmachines langer kan
maken en het aantal bits dat elke deelmachine verwerkt exponentieel stijgt in functie van
de lengte, terwijl het aantal bits dat verwerkt kan worden slechts lineair stijgt in functie van
het aantal deelmachines.
Het aantal delen waarin de pulstrein gesplitst wordt heeft ook een invloed op de
rekenkracht van de machine in vergelijking met een Pentium.
Enerzijds dalen het aantal cellen die gebruikt worden indien men de pulstrein in meerdere
delen splitst, aangezien er dan minder cellen voor de vertraging nodig zijn. Anderzijds
hebben meer delen tot gevolg dat de leespuls meerdere malen door de machine
gepropageerd wordt.
Merk op dat wanneer de pulstrein in zestien of meer delen gesplitst wordt er weliswaar
geen cellen voor vertragingen nodig zijn, dit heeft als gevolg dat een deelcomponent in een
3x2x6 blok past, en er dus meer deelcomponenten in de machine passen. Het aantal cellen
die gebruikt worden daalt dus niet langer wanneer de pulstrein in zestien of meer delen
wordt gesplitst.
Elk deel bestaat uit een pulstreinsplitser gevolgd door een aantal deelcomponenten. Indien
dit aantal gelijk aan d gesteld wordt, kan elke deelmachine 2d – 1 bits verwerken. De
volledige machine kan dan (2d
Er moet nu, voor elke s, een d gevonden worden zodat de machine zo goed mogelijk
gevuld is en er nog genoeg plaats over is voor de geheugens.
– 1).s bits verwerken.
Voor s gelijk aan zes tot vijftien geldt dezelfde redenering. De splitser zelf past in een
3x6x5 blok, een deelcomponent in 3x4x6. In de X- en Z-richting hebben ze met andere
woorden ongeveer dezelfde dimensie. Daarom zullen de deelcomponenten in de Y-richting
aan elkaar geschakeld worden. Er passen acht deelcomponenten in de X-richting. In de Y-
richting passen een splitser en vier deelcomponenten. In elke volgende rij (in de Y-
richting) passen er dan zes deelcomponenten.
In de Z-richting passen vier deelcomponenten.
65
Om nu d te kunnen vinden moet er eerst nagegaan worden hoeveel bits de machine kan
verwerken voor elke s (geen rekening houdend met de ruimte nodig voor de geheugens).
Waarna er ruimte kan vrijgemaakt worden voor de geheugens door d te verminderen.
Aangezien alle s aaneenschakeling van deelcomponenten even lang moeten zijn is het niet
altijd mogelijk om de volledige machine op te vullen met deelcomponenten.
Er passen tweeëndertig rijen van aaneenschakelingen van deelcomponenten in de CAM-
Brain, zodat het aantal rijen die elk deel maximaal kan gebruiken gegeven is door
Aantal rijen per deel =
s32
Waarbij de eerste rij bestaat uit vier deelcomponenten en elke volgende rij uit zes.
Het aantal lege cellen wordt dan gegeven door de rest na deling van tweeëndertig door s
vermenigvuldigd met het aantal cellen in een rij. Een rij heeft als dimensie 3x24x6 er
passen met andere woorden 432 cellen in een rij.
Het aantal bits die elke machine maximaal kan verwerken, zonder rekening te houden met
de geheugens, is dan
−
−
+
12.132.64
ss
Er wordt in deze formule, terecht, vanuitgegaan dat er minstens een rij kan gevormd
worden voor elk deel.
Om nu plaats te maken voor de geheugens moeten de verschillende rijen van
deelcomponenten ingekort worden. Indien ze één deelcomponent korter gemaakt worden
komen er, aangezien elke rij even lang moet zijn, s.(3.4.6) of 72.s cellen vrij.
66
De correcte waarde voor d kan dan gevonden worden door in de volgende vergelijking i te
maximaliseren.
s
is Ciss +≥
−
−
−
+
..3612.132.64
Met Cs
het aantal lege cellen als gevolg van het feit dat het niet altijd mogelijk is de
volledige machine op te vullen met deelcomponenten.
Indien de pulstrein in zestien delen gesplitst wordt verloopt de redenering anders. De
splitser neemt nog steeds een 3x6x5 blok in, maar een deelcomponent neemt nu slechts een
3x2x6 blok in. Zodat er in de eerste rij een splitser en acht deelcomponenten passen en in
elke volgende rij twaalf deelcomponenten.
De formule wordt dan (met s gelijk aan zestien)
ii .57616214 ≥−−
De volgende tabel geeft de resultaten aan voor de verschillende waarden van s. Naast het
aantal bits (i.e. 36.s.i + Cs
) die verwerkt wordt, wordt ook het aantal deelcomponenten in
elke deelmachine vermeld. Deze waarde wordt later gebruikt bij het berekenen van de
rekenkracht.
67
Aantal delen Aantal bits Aantal deelcomponenten
7 3888 10
8 3736 9
9 3348 9
10 2951 9
11 2566 9
12 2592 9
13 2232 8
14 1872 8
15 1497 8
16 1728 7
Uit de tabel blijkt dat er geen monotoon verband is tussen het aantal delen waarin de
pulstrein gesplitst wordt en het aantal bits die kunnen verwerkt worden. Dit is een gevolg
van het feit dat alle s de deelmachines die het aantal overeenkomsten tellen even lang
moeten zijn. Het aantal deelcomponenten in elke deelmachine daalt dus niet noodzakelijk
indien het aantal delen waarin gesplitst wordt stijgt.
68
4.3.4. Rekenkrachtanalyse van deze machine Dezelfde afkortingen als in 4.2.7 worden gebruikt.*
Er komt echter een nieuwe variabele bij:
• s: aantal delen waarin de pulstrein gesplitst wordt
Aangezien zowel het geheugen, de leespuls als de patroonvergelijker identiek zijn aan die
uit de eerste machine zullen ze ook dezelfde rekenkracht vereisen. Uiteraard dient wel de
waarde van g, met name de grootte van het geheugen, aangepast te worden.
4.3.4.1. De pulstreinsplitser
De pulstreinsplitser, zoals beschreven in 4.3.1, is niet echt een splitser. Het is namelijk niet
zo dat deze deelmachine als invoer een pulstrein krijgt en als uitvoer verschillende andere
pulstreinen genereert.
Indien men een pulstrein in s delen wenst te splitsen zijn er s zo’n splitsers nodig.
Het is het eenvoudigst om alle s pulstreinsplitsers tesamen te beschouwen. Dan kan er
uitgegaan worden van het aantal overeenkomsten tussen de pulstrein en het patroon
(m.a.w. x), onafhankelijk van de positie waarop de overeenkomsten voorkomen.
De grootte van het gedeelte met het s-bit geheugen en de cellen die dit verbinden met het
neuron dat het splitsen doet is uiteraard afhankelijk van s.
Aantal delen Axonen Neuronen
6 12 1
7 20 1
8 14 1
9 24 1
10 16 1
11 28 1
* zie 4.2.7 Rekenkracht analyse van deze machine. pagina 49
69
12 18 1
13 32 1
14 20 1
15 36 1
16 22 1
Door dit gedeelte zal slechts elke s tijdseenheden een vuursignaal passeren, aangezien er
slechts één van de s bits uit het geheugen op één staat.
Er zijn echter s pulstreinsplitsers zodat dit reeds resulteert in
).3).3(( 121 NAAAn s ++−
Met As
Van het resterende gedeelte zal er door het deel voor het neuron dat het splitsen doet voor
elke overeenkomst een vuursignaal passeren, en dit voor alle s de pulstreinsplitsers. Door
het deel voorbij het neuron zal, voor alle s pulstreinsplitsers tesamen, er voor elke
overeenkomst één vuursignaal passeren.
gelijk aan het aantal axonen in de tabel.
)).2.4.(.2.3( 121121 NAAsNAAn +++++
70
4.3.4.2. Aantal overeenkomsten tellen
Er zijn s identieke deelmachines, die elk bestaan uit een aantal deelcomponenten, stel dat
dit aantal gelijk is aan ks
Het is voor deze machine niet langer mogelijk om exacte formules op te stellen voor het
aantal axonen en neuronen die vuren in functie van het aantal overeenkomsten.
(deze waarde is afhankelijk van s).
De posities van de vuursignalen hebben een invloed op het aantal axonen en neuronen die
vuren. Stel bijvoorbeeld dat er negen overeenkomsten zijn, dat de periode van de leespuls
zestien is en dat de invoerstroom in vier delen gesplitst wordt. Dan is het mogelijk dat er in
het eerste en tweede deel vier overeenkomsten zijn, in het derde deel één overeenkomst en
in het laatste deel geen enkele, dan bevatten de verschillende deelmachines de waarden:
100, 100, 001, 000. Er heeft dan zes maal een deelcomponent twee vuursignalen ontvangen
en er worden drie enen uitgelezen. Indien er echter in de eerste drie delen drie
overeenkomsten voorkomen en in het laatste geen, dan bevatten de verschillende
deelmachines de waarden: 011, 011, 011, 000. Dan hebben de deelcomponenten tesamen
drie maal twee vuursignalen ontvangen en worden er zes enen uitgelezen.
Om toch een analyse te kunnen geven van deze machine onafhankelijk van de precieze
invoer worden er benaderingen gebruikt.
Per vuursignaal zullen er in één van de deelmachines twee axonen met één uitgang vuren,
één axon met twee uitgangen en nog 16 – s axonen met één uitgang (deze vormen de
vertraging).
∑=
+−
sk
ii AAsx
021 )).18.((
2
Deze formule is analoog aan die voor machine 1, ze veronderstelt met andere woorden dat
er slechts één deelmachine is. Voor i = 0 is ze correct, aangezien voor elke overeenkomst
één van de deelmachines dit signaal zal ontvangen. Voor alle andere waarden van i is het
slechts een benadering, maar wel zeker een bovengrens.
Dat het een bovengrens is kan eenvoudig ingezien worden. De x signalen worden over s
deelmachines verdeeld, stel dat elke deelmachine xi
Aangezien steeds geldt dat
signalen ontvangt, met 1 ≤ i ≤ s.
71
∑∑==
≥
=
s
iki
s
iki
k
xxx11 222
met k en elke xi
natuurlijke getallen, zal de gebruikte formule dus een bovengrens zijn.
Per twee vuursignalen die een deelcomponent ontvangt komen daar nog eens twee axonen
met één uitgang, één axon met twee uitgangen en één neuron met één uitgang bij.
Het aantal keer dat een deelcomponent twee vuursignalen ontvangt wordt benaderd door
het aantal te gebruiken dat men bekomt indien de pulstrein niet gesplitst wordt. Met andere
woorden hetzelfde aantal als in machine 1.
Dit aantal is weer een bovengrens, en dit kan op dezelfde manier ingezien worden als bij
de vorige formule.
).2.(2 121
01 NAAxsk
ii ++
∑
=+
Per leespuls zal er één axon met drie uitgangen vuren, één axon met twee uitgangen, zes
axonen met één uitgang en nog een 16 – s axonen met één uitgang als gevolg van de
vertraging. Een leespuls komt elke g tijdseenheden voor, in elk van de s deelmachines.
∑=
++−
sk
iAAAs
gxs
0321 )).22.((.
Deze formule is onafhankelijk van de verdeling het aantal overeenkomsten over de
verschillende deelmachines en is dus geen benadering maar een exacte weergave van het
aantal axonen die vuren.
Indien er een één wordt uitgelezen komen daar nog eens twee neuronen met één uitgang
bij, vier axonen met twee uitgangen en zeven axonen met één uitgang bij.
72
Een voldoende goede benadering voor het aantal enen die uitgelezen worden is gegeven
door*
+ )1(log. 2 s
xs
Deze benadering is altijd een bovengrens voor het aantal enen dat zal uitgelezen worden.
Gebruik makend van deze benadering bekomt men dan:
)247).()1(log.( 1212 NAAsxs ++
+
De fout die gemaakt wordt door beide benaderingen te gebruiken in plaats van de exacte
waarden is relatief klein, en speelt geen grote rol zoals zal blijken uit de berekening van de
rekenkracht van deze machine.
4.3.4.3. Rekenkracht analyse Al de voorgaande formules geven de extra rekenkracht aan die nodig is wanneer de cellen
vuren. Er is ook nog rekenkracht nodig wanneer een cel niet vuurt, het aantal axonen en
neuronen in de machine moet dus ook gekend zijn.
Zowel het geheugen voor het patroon als het geheugen voor de leespuls bestaan uit g
axonen. De deelmachine die het patroon vergelijkt met de invoerstroom bestaat uit zeven
axonen.
Het aantal cellen in de pulstreinsplitser is afhankelijk van het aantal delen waarin de
pulstrein wordt gesplitst†
Een deelcomponent van de deelmachine die het aantal overeenkomsten telt bestaat uit
negenentwintig axonen en drie neuronen. Het aantal deelcomponenten per deelmachine is
, er zijn s zulke pulstreinsplitsers in de machine.
* zie appendix A voor de uitwerking van deze formule, pagina 95 † zie 4.3.4.1 De pulstreinsplitser, pagina 68
73
afhankelijk van het aantal delen waarin de pulstrein wordt gesplitst. Voor elk deel waarin
de pulstrein gesplitst wordt is er een deelmachine.
Aantal delen Axonen Neuronen
7 10023 231
8 9760 240
9 9360 270
10 8782 300
11 8432 330
12 8664 360
13 8039 351
14 7426 378
15 7179 405
16 6942 354
Voor machine 2 wordt een maximum bereikt indien de de invoer in zeven delen gesplitst
wordt en zowel x als y maximaal zijn (i.e. gelijk aan 3888). Dan is er de rekenkracht van
1278,259 Pentiums nodig om de machine te simuleren.
Een minimum voor deze machine wordt bereikt indien de invoer in zestien delen wordt
gesplitst en indien x en y gelijk zijn aan nul. In dat geval is er een rekenkracht van 908,52
Pentiums nodig om de machine te simuleren.
De rekenkracht die nodig is om de machine te simuleren is, min of meer, omgekeerd
evenredig met het aantal delen waarin de invoer gesplitst wordt. Het is namelijk zo dat in
hoe minder delen de invoer gesplitst wordt, hoe meer cellen er nuttig gebruikt kunnen
worden (zie bovenstaande tabel). En dus zal ook de nodige rekenkracht hoger liggen als de
invoer in minder delen gesplitst wordt, voor een gelijke x en y.
Indien de invoer in zeven delen gesplitst wordt, en de rekenkracht in functie van x en y
berekend wordt, bekomt men de volgende grafiek.
74
0
200
400
600
800
1000
1200
1400
Aantal Pentiums
Machine 2
1200-14001000-1200800-1000600-800400-600200-4000-200
Net zoals bij machine 1 is er weer nauwelijks variatie in functie van x.
Indien de rekenkrachtverdeling voor de verschillende deelmachines bekeken wordt, blijkt
dat het grootste deel van de rekenkracht nodig is om het geheugen en de leespuls te
simuleren, die beiden onafhankelijk van x zijn.
Totaal: 1164,23
51%39%
0% 10% 0%PatroonLeespulsVergelijkenTellenSplitser
De verdeling is identiek aan die uit machine 1, alleen is er nu ook een deel dat de invoer
splitst. De bijdrage van dit deel is zeer klein.
75
4.4. Derde machine Hoewel de tweede machine reeds efficiënter is dan de eerste kampt ze nog steeds met het
probleem dat een aanzienlijk aantal cellen gebruikt worden om zowel de invoerstroom als
de leespuls te vertragen.
Dit kan enkel vermeden worden door de machine compacter te maken, of dus door minder
neuronen te gebruiken.
Deze derde machine zal geen gebruik meer maken van neuronen om een neuron in de rij
van neuronen uit te lezen en dit met behulp van een nieuwe deelmachine: de klem.
Deze deelmachine zal ook kunnen gebruikt worden om zowel de klokpuls als het splitsen
van een pulstrein efficiënter te maken.
76
4.4.1. De klem De klem is een zeer kleine machine, slechts vier axonen, en laat toe om signalen in een
pulstrein al dan niet door te laten.
De klem zelf wordt gevormd door de axonen A, B, C en D. Indien een signaal axon A
bereikt, zal dit zich splitsen in de axonen B en C. De volgende tijdseenheid zullen beide
axonen in axon D vuren, zodat dit axon altijd twee vuursignalen ontvangt en het dus niet
zal vuren, onafhankelijk van wat axon E doet.
77
4.4.2. De leespuls Deze klem kan, in sommige gevallen, een leespuls efficiënter maken.
In plaats van één n-bit geheugen te gebruiken waarbij één cel vuurt, worden nu twee
kleinere geheugens gebruikt van k en m bits waarbij kgv(m,k) = n. In één van deze twee
kleinere geheugens vuurt één cel (stel: geheugen van m bits). In het andere geheugen vuurt
één cel niet (stel: geheugen met k bits).
Indien men het geheugen waar één cel niet vuurt via een klem verbindt met een uitvoer van
het andere geheugen, zal er slechts elke k tijdseenheden een signaal doorgelaten worden.
Het andere geheugen vuurt echter slechts elke m tijdseenheden zodat de totale deelmachine
elke kgv(m,k) tijdseenheden zal vuren.
Deze manier van werken wordt pas efficiënter als n groot genoeg is (in de figuur worden er
bijvoorbeeld meer dan twaalf cellen gebruikt). Bovendien dient opgemerkt te worden dat
een klem gebruiken voor dit doeleinde enkel efficiënter is voor de CAM-Brain (er worden
minder cellen gebruikt). Aangezien er veel meer cellen vuren zal het simuleren van deze
deelmachine in een Pentium minder efficiënt zijn dan wanneer een n-bit geheugen waarbij
één cel vuurt gesimuleerd wordt.
78
4.4.3. De pulstrein splitsen De klem kan ook gebruikt worden om een efficiëntere pulstreinsplitser te bouwen.
De pulstrein die men wenst te splitsen loopt langs axon A. De klem vanuit axon B op A zal
ervoor zorgen dat er slechts elke n tijdseenheden een vuursignaal wordt doorgelaten.
Dit wordt bekomen door een geheugen van n bits met axon B te verbinden, waarbij in dit
geheugen slechts één axon niet vuurt.
Aangezien deze deelmachine geen gebruik maakt van een neuron en er dus ook geen
neuron terug in zijn begintoestand moet gezet worden en aangezien er geheugens voor elk
mogelijk aantal bits mogelijk zijn zal deze deelmachine, in tegenstelling tot de
pulstreinsplitser van machine twee, een pulstrein in elk mogelijk aantal nieuwe pulstreinen
kunnen splitsen.
79
4.4.4. De waarde van de accumulator uitlezen
Het uitlezen van de waarde van een neuron, indien deze waarde nul of één is, kan
eenvoudig gebeuren door een signaal aan een positieve ingang aan te leggen. Het neuron
zal vuren indien de waarde van zijn accumulator één was, en zal niet vuren indien het nul
was. M.a.w. de uitvoer is gelijk aan de waarde van de accumulator.
Binnen de gehele machine dient men dit deel als volgt te situeren: de as A-B is de as
waarop de verschillende neuronen liggen, die gebruikt worden om het aantal vuursignalen
te tellen in de bitstroom die voor elke overeenkomst tussen het patroon en de invoer een
één bevat. Aan axon C wordt de leespuls aangelegd. Axon D zal de uitleeswaarde bevatten.
Er zijn verscheidene redenen waarom deze eenvoudige constructie niet rechtstreeks
bruikbaar is.
Vooreerst worden de verschillende axonen, waarin een neuron vuurt niet gelinkt aan een
invoer. De axonen B en D zullen altijd dezelfde waarde bevatten, waar het de bedoeling is
dat de waarde van axon B enkel één is als een gevolg van twee vuursignalen afkomstig van
axon A (en niet als gevolg van een vuursignaal afkomstig van axon C).
80
En axon D mag enkel de waarde één bevatten als de accumulator van het neuron op één
staat en het een vuursignaal ontving van C (en dus niet als gevolg van twee vuursignalen
afkomstig van axon A)
Daarnaast zal de waarde van de accumulator van het neuron na het uitlezen niet altijd op
nul staan. En dus kan men deze constructie niet meerdere malen na elkaar gebruiken.
Om het eerste probleem op te lossen wordt gebruik gemaakt van de klem.
Indien axon E vuurt, zal de uitvoer van het neuron in axon B drie tijdseenheden later altijd
nul zijn. (een axon dat meer dan één vuursignaal ontvangt heeft altijd nul als uitvoer).
Als het neuron vuurt als gevolg van een vuursignaal in axon C, zal dit vuursignaal axon B
drie tijdseenheden later bereiken. (door de extra vertraging binnen een neuron).
Dus indien axonen C en E altijd dezelfde waarde bevatten, zal axon B enkel een
vuursignaal ontvangen als gevolg van twee vuursignalen van axon A, op voorwaarde dat
axon C niet gelijktijdig vuurt met axon A.
81
Dit stelt echter een nieuw probleem. Er ligt namelijk geen enkele cel op gelijke afstand van
C en E indien men enkel gebruik maakt van axonen. Het is dus enkel mogelijk om een
signaal gelijktijdig in beide cellen te laten toekomen door gebruik te maken van een
neuron.
Een extra neuron gebruiken is spijtig genoeg een erg kostelijke ingreep. De plaatsing van
de neuronen maakt dat het signaal dan erg vertraagd wordt voor het de axonen C en E
bereikt. Dit heeft dan weer als gevolg dat de signalen op de as A-B ook vertraagd dienen te
worden, om de synchroniciteit te bewaren.
Het is namelijk zo dat de leespuls in axon C voor elk van de neuronen in de rij van
neuronen relatief ten opzichte van de bitstroom op de as A-B op hetzelfde moment moet
toekomen. Anders is er niet gegarandeerd dat de waarde van de accumulatoren van de
verschillende neuronen de juiste waarde bevatten.
Om deze problemen te omzeilen heb ik ervoor gekozen om de leespuls tweemaal mee te
sturen met de rij van neuronen. De leespuls wordt via twee assen evenwijdig aan de as A-
B, één as door axon C en één door axon D, meegestuurd met de rij van neuronen. Op deze
manier is er slecht één extra neuron nodig, aan het begin van de rij. En treedt er dus ook
slecht één maal een vertraging op.
Om ervoor te zorgen dat axon D enkel de waarde één kan krijgen als gevolg van een
vuursignaal uit axon C wordt een gelijkaardige constructie gebruikt.
82
De cyclus gevormd door de axonen G, H, I en J vormen een vier bit geheugen, waarvan
alle bits op één staan. Hierdoor krijgt de klem vanuit axon G op axon D constant
vuursignalen, zodat axon D constant twee éénsignalen ontvangt en dus nooit zal vuren.
Om er nu voor te zorgen dat een signaal als gevolg van een vuursignaal in axon C toch
doorgelaten wordt moet deze vuurcyclus onderbroken worden. Dit gebeurt met behulp van
een vuursignaal, dat via axon F twee tijdseenheden later axon G bereikt. Dit vuursignaal
zal axon G in de toestand niet vuren brengen (G had twee vuursignalen als invoer, een van
axon F afkomstig, en één afkomstig van axon J) Nog eens twee tijdseenheden later zal
axon D dan geen vuursignalen van de klem ontvangen.
Een vuursignaal afkomstig van axon F heeft dus als gevolg dat vier tijdseenheden later het
uitvoersignaal van het neuron doorgelaten wordt.
Er is reeds aangehaald dat axon C en E steeds op hetzelfde moment dienen te vuren (opdat
de uitvoer in axon B correct zou zijn). Het vuursignaal in E zal één tijdseenheid daarvoor
zich in axon F bevinden. Een vuursignaal van axon C zal axon D na drie tijdseenheden
bereiken (twee cellen afstand en één extra tijdseenheid vertraging door de interne pijplijn
van het neuron).
83
De uitvoer van het neuron in axon D zal dus enkel doorgelaten indien deze uitvoer
ontstond op het moment dat axon C vuurde.
Nu bevat het geheugen gevormd door de axonen G, H, I en J wel drie énen en één nul.
Vanaf nu zal met andere woorden elke vier tijdseenheden de uitvoer in axon D doorgelaten
worden.
Dit wordt opgelost door het signaal vanuit axon F via axon K in het geheugen te laten
vuren. Een vuursignaal vanuit axon F via axon G heeft vijf tijdseenheden nodig om axon J
te bereiken. Hetzelfde vuursignaal via axon K heeft ook vijf tijdseenheden nodig om axon
J te bereiken. Het geheugen zal dus weer vier énen bevatten en er zal slechts één signaal
doorgelaten worden.
Daarmee is de uitvoer in axon B respectievelijk axon D reeds gelinkt aan axon A
respectievelijk axon C. Nu dient de waarde van de interne accumulator op nul gezet te
worden na het uitlezen van deze waarde.
Indien de waarde één uitgelezen wordt zal de waarde van de accumulator nadien op nul
staan en indien de waarde nul uitgelezen wordt zal de waarde van de accumulator nadien
op één staan.
De waarde wordt nu op nul gezet door altijd een vuursignaal via een ingang met negatief
gewicht in het neuron te laten vuren en de uitvoer van het neuron via een ingang met
positief gewicht te laten vuren.
84
Het vuursignaal in axon E zal via een ander axon in het neuron vuren via een ingang met
negatief gewicht. Aangezien axon C en E telkens op hetzelfde moment vuren zal dit
signaal met negatief gewicht één tijdseenheid na het signaal vanuit axon C toekomen.
Indien het neuron nu vuurt als gevolg van een vuursignaal van axon C en dus de
accumulator van het neuron op min één kwam door het signaal met negatief gewicht, zal
axon D vuren, en via axon L en C de accumulator weer op nul zetten.
Dit gebeurt zes tijdseenheden na het vuursignaal van axon C, dat het vuren van het neuron
als gevolg had.
Dit heeft als bijkomend gevolg dat er op de as gevormd door axon C en N een extra puls
komt. Deze as is één van de twee assen langs dewelke de leespuls met de rij van neuronen
meegestuurd wordt.
Om te voorkomen dat het volgende neuron in de rij van neuronen een extra leespuls krijgt
wordt de uitvoer van axon D via axon M naar axon N geleid. De afstand van D tot N via
axon L en via axon M is telkens drie, zodat beide vuursignalen elkaar zullen opheffen.
Wanneer men al deze componenten samenvoegt, ziet deze deelmachine er als volgt uit:
85
Deze machine heeft een aantal inherente beperkingen.
Vooreerst mag er nooit een signaal vanuit axon A en vanuit axon C op hetzelfde moment
het neuron bereiken. Indien dit wel gebeurt, zal het neuron altijd vuren (want de waarde
van de accumulator wordt twee of drie, of dus zeker groter dan of gelijk aan twee) en
nadien zal dus de waarde van de accumulator altijd op nul staan. Er wordt dus geen
onderscheid gemaakt tussen de situatie waar de waarde van de accumulator nul was, en de
situatie waar deze waarde één was.
Dit kan opgelost worden door het signaal te splitsen alvorens het naar deze rij van
neuronen te sturen. En dan deze gesplitste pulstreinen in parallel te verwerken.
Daarnaast moet de periode van de leespuls groter dan of gelijk aan zes zijn, aangezien deze
constructie ten hoogste zes tijdseenheden nodig heeft om de waarde van de accumulator
van het neuron te herstellen indien dit neuron vuurde.
Het feit dat de waarde van de accumulator gedurende zes tijdseenheden verkeerd is, legt
geen beperking op aan de pulstrein vanuit axon A.
Bovendien dient opgemerkt te worden dat deze deelmachine niet rechtstreeks in serie kan
geschakeld worden. Aangezien een neuron intern over een pijplijn beschikt zullen de
signalen op de as A-X en de as C-Y niet synchroon lopen.
Synchroniciteit forceren tussen deze twee assen zou vereisen dat de signalen op de as C-Y
(en op de andere as met de leespuls, gevormd door E-F) per neuron dat ze passeren één
tijdseenheid vertraagd worden. Een signaal één tijdseenheid vertragen kan enkel door
gebruik te maken van een neuron en dit is, zoals reeds aangehaald, een erg dure operatie.
Daarom werd ervoor gekozen om te zorgen dat er tussen elke pulstrein zeker twee nullen
voorkomen, zodat men twee tijdseenheden de tijd heeft om de waarde van de accumulator
van het neuron uit te lezen. Dan dient de leespuls per twee neuronen twee tijdseenheden
vertraagd te worden. Dit kan eenvoudig gebeuren door gebruik te maken van twee axonen.
Garanderen dat er twee nullen tussen elke pulstrein voorkomen kan weer gebeuren door
het signaal te splitsen.
86
4.4.5. Volledige machine
Om de deelmachine uit 4.4.4 te kunnen gebruiken moet de pulstrein minimum in drie delen
gesplitst worden. De pulstrein in meer delen splitsen zal enkel leiden tot een machine die
minder bits kan verwerken, aangezien minder delen als gevolg heeft dat elk deel langer kan
gemaakt worden en het aantal bits dat kan verwerkt worden exponentieel stijgt in functie
van de lengte van de deelmachine.
In tegenstelling tot machine 2 zijn er nu geen cellen nodig voor een vertraging, zodat de
dalende trend van het aantal bits die kunnen verwerkt worden zich hier gewoon zou
doorzetten en niet zou verdwijnen indien men de pulstrein in een specifiek aantal delen
splitst.
Eén deelcomponent van de deelmachine, die het aantal overeenkomsten telt, past nu in een
3x4x4 blok indien men de verschillende deelcomponten in de X-richting in serie schakelt.
De deelcomponenten in de Y- of Z-richting aan elkaar schakelen heeft als gevolg dat er
een 4x4x4 blok nodig is, omwille van de plaatsing van de neuronen. Er wordt dus gekozen
om ze in de X-richting te schakelen. De pulstreinsplitser past in een 3x2x2 blok. Zodat de
eerste rij bestaat uit een pulstreinsplitser gevolgd door zeven deelcomponenten en elke
volgende rij bestaat uit acht deelcomponenten. Zowel in de Y- als Z-richting passen zes
rijen, met andere woorden zesendertig rijen in totaal of dus twaalf rijen per deel.
In totaal bestaat een rij dus maximaal uit 11.8 + 7 of 95 deelcomponenten. Aangezien nu
ook elke rij even lang moet zijn, zal de rijen verkorten met één deelcomponent als gevolg
hebben dat er 3.(3.4.4) of 96 cellen vrij komen.
Het aantal bits, die deze machine maximaal kan verwerken, wordt dan gegeven door i te
maximaliseren in de volgende vergelijking
ii .48)12.(3 95 ≥−−
Voor i gelijk aan vierentachtig wordt er een maximum bereikt. De machine kan dus
maximaal 4032 bits verwerken.
87
4.4.6. Rekenkrachtanalyse van deze machine
4.4.6.1. Pulstreinsplitser Aangezien de pulstrein in drie delen gesplitst wordt is er een zes bit geheugen nodig
waarin constant vier axonen vuren*
De klem bestaat uit twee axonen met één uitgang en één axon met twee uitgangen. Elke
drie tijdseenheden zullen deze cellen tweemaal vuren.
. Per drie tijdseenheden zullen er twee tijdseenheden
drie axonen vuren met één uitgang en één axon met twee uitgangen en één tijdseenheid
vier axonen met één uitgang.
De draad die de pulstrein bevat die gesplitst wordt bestaat uit drie axonen met één uitgang.
( ) ( )( ) 121121 ..2.2.4.3.2.3
AyAAAAAn+++++
4.4.6.2. Aantal overeenkomsten tellen
Het is, net zoals bij machine 2, niet mogelijk formules op te stellen die enkel uitgaan van
het aantal overeenkomsten, onafhankelijk van de posities in de pulstrein van deze
overeenkomsten.
Daarom worden er weer benaderingen gebruikt, die analoog zijn aan die uit machine 2.
Per vuursignaal dat een van de deelmachines ontvangt zullen er twee axonen met één
uitgang vuren.
1..2 Ax
Per twee vuursignalen die één van de deelmachines ontvangt zal in deze deelmachine één
neuron met één uitgang vuren. Het aantal keer dat dit gebeurt kan niet exact afgeleid
worden uit het aantal overeenkomsten x (analoog aan machine 2)†
* zie 4.2.1 Geheugen, pagina 31 en 4.4.3 De pulstrein splitsen, pagina 78
† zie 4.3.4.2 Aantal overeenkomsten tellen, pagina 71
88
Er wordt een gelijkaardige benadering gebruikt aan die uit machine 2, i.e. de waarde die
men bekomt indien de pulstrein niet gesplitst wordt, wordt gebruikt. Dit is, net zoals bij
machine 2, een bovengrens.
∑=
11
11.
2ii Nx
Per leespuls zullen er acht axonen met één uitgang vuren, vier axonen met twee uitgangen
en één axon met drie uitgangen. De leespuls komt in alle drie de deelmachines voor, elke g
tijdseenheden.
).4.8.(.3 321 AAAgn
++
Indien er een één wordt uitgelezen vuren er vijf axonen met één uitgang, één axon met
twee uitgangen en één axon met drie uitgangen.
Er wordt weer dezelfde benadering gebruikt als voor machine 2, zie appendix A voor
details.
).5.(13
log.3 3212 AAAx++
+
In elke deelcomponent zijn er ook nog een aantal cellen die bijna constant vuren, met name
het kleine geheugen en de klem die ervoor zorgen dat enkel de uitleeswaarde doorgelaten
wordt.
Dit gedeelte bestaat uit drie axonen met één uitgang en twee axonen met twee uitgangen,
ze zullen elke tijdseenheid vuren, behalve als er een leespuls in de deelcomponent vuurt,
dan zal als gevolg van deze leespuls elke cel één tijdseenheid niet vuren.
( )21 .2.3..11.3 AAgnn +
−
89
4.4.6.3. Rekenkracht analyse Al de voorgaande formules geven de extra rekenkracht aan die nodig is wanneer de cellen
vuren. Er is ook nog rekenkracht nodig wanneer een cel niet vuurt, het aantal axonen en
neuronen in de machine moet dus ook gekend zijn.
Zowel het geheugen voor het patroon als het geheugen voor de leespuls bestaan uit 4032
axonen. De deelmachine die het patroon vergelijkt met de invoerstroom bestaat uit zeven
axonen.
Een pulstreinsplitser bestaat uit twaalf axonen, er zijn drie zulke splitsers in de machine, in
totaal dus zesendertig axonen.
Er zijn drie identieke deelmachines om het aantal overeenkomsten te tellen, elke
deelmachine bestaat uit elf deelcomponenten. Een deelcomponent bestaat uit vijfentwintig
axonen en één neuron. In totaal dus 825 axonen en 33 neuronen.
Alles tesamen geeft dit 8932 axonen en 33 neuronen.
Er zijn uiteraard ook nog een aantal axonen nodig om al de verschillende deelcomponenten
met elkaar te verbinden, maar aangezien dit telkens axonen met één uitgang betreft, en hun
aantal beperkt is, worden ze buiten beschouwing gelaten.
Voor machine 3 wordt weer een minimum bereikt voor x en y gelijk aan nul. In dat geval is
er de rekenkracht van 1091,77 Pentiums nodig om de machine te simuleren. Het
maximum, voor x en y gelijk aan 4032, resulteert in een rekenkracht van 1331,837
Pentiums.
0
500
1000
1500
Aantal Pentiums
Machine 3
1000-1500500-10000-500
90
Het aantal Pentiums nodig om de machine te simuleren in functie van x en y is volledig
analoog aan machine 1 en 2. Weer heeft x een zeer beperkte invloed op deze waarde, en er
geldt dezelfde verklaring.
Totaal: 1212,467
50%
40%
0% 10% 0%PatroonLeespulsVergelijkenTellenSplitser
Ook de relatieve bijdragen van de verschillende delen zijn analoog met die uit machine 1.
Al is er bij machine 3 uiteraard ook een deel dat de invoer splitst, dit deel is zeer klein en
oefent nauwelijks een invloed uit op de benodigde rekenkracht.
91
4.5. Machines zonder geheugen De drie patroonherkenners hebben elk de eigenschap dat een groot deel van de machine als
geheugen gebruikt wordt. Uit de rekenkrachtanalyse blijkt bovendien dat deze geheugens
een zeer groot deel van de benodigde rekenkracht om de machine te simuleren op zich
nemen.
Een geheugen in de CAM-Brain heeft als eigenschap dat de vullingsgraad honderd procent
is, dat elke cel een axon is en dat elke cel juist één uitgang heeft.*
Zoals blijkt uit de opbouw van de andere delen van de machines zijn dit alles behalve
typische eigenschappen voor machines in de CAM-Brain.
Omdat er ongetwijfeld vele zinvolle machines kunnen bedacht worden voor de CAM-
Brain die geen (groot) geheugen nodig hebben, is het interessant om een idee te hebben
van de rekenkracht die nodig is om een machine zonder geheugen te simuleren.
Om een beeld te kunnen vormen van deze benodigde rekenkracht hebt ik voor de drie
machines enkel het deel beschouwd dat het rekenwerk doet, en deze delen geëxtrapoleerd
naar een volledige machine.
Ik beschouw met andere woorden machines die volledig gevuld zijn met de deelmachines
die het rekenwerk verrichten.
Omdat deze machines in de praktijk niet (zinvol) werken, is het ook onmogelijk om een
invoer te beschouwen en de rekenkracht in functie van deze invoer te berekenen zoals
gedaan werd in de voorgaande hoofdstukken.
Daarom wordt er voor elke machine berekend wat de benodigde rekenkracht is indien geen
enkele cel vuurt, en wat de benodigde rekenkracht is indien elke cel elke tijdseenheid
vuurt.
* zie 4.2.1 Geheugen, pagina 31
92
Voor de drie machines worden dan de volgende waarden bekomen
Minimum Maximum
Machine 1 856,74 1421,65
Machine 2 1013,76 1774,08
Machine 3 617,47 1110,53
Uit de tabel blijkt dat zelfs indien elke cel elke tijdseenheid vuurt de benodigde
rekenkracht voor machine 1 en 3 nog lager ligt dan bij de machines met geheugen.
De reden kan gevonden worden bij de minima, die enkel afhangen van de vullingsgraad en
het aantal neuronen, machines zonder geheugen halen een veel kleinere vullingsgraad en
om ze te simuleren is dus minder rekenkracht nodig.
93
5. Conclusie
Indien de CAM-Brain gesimuleerd wordt op een Pentium heeft hij duidelijk niet een
rekenkracht die vergelijkbaar is met tienduizend Pentiums.
In hoofdstuk 3 is aangetoond dat de theoretische bovengrens rond de vierduizend Pentiums
ligt. In hoofdstuk 4 werd een indicatie gegeven dat de rekenkracht van machines die in de
praktijk gebruikt worden veeleer rond de duizendvijfhonderd Pentiums ligt.
Het grote verschil tussen de berekende bovengrens en de rekenkracht bij de ontworpen
machines kan verklaard worden door te kijken naar de drie factoren die een rol spelen voor
de rekenkracht, namelijk het aantal cellen die als neuron gebruikt worden, de vullingsgraad
en het aantal uitgangen waarin gevuurd wordt.
Het aantal cellen die als neuron gebruikt worden heeft geen noemenswaardige invloed op
de rekenkracht. Vooreerst is het aantal mogelijke neuronen beperkt (slechts 1152 van de
13824 cellen) en bovendien is ook de extra rekenkracht die een neuron vereist ten opzichte
van een axon eerder klein.
De vullingsgraad speelt wel een rol, maar in de praktijk haalden de machines een
vullingsgraad van 70 – 80%. De vullingsgraad geeft dus geen verklaring voor het grote
verschil tussen de rekenkracht die nodig is om machines te simuleren en de berekende
bovengrens.
De rol van de vullingsgraad is eerder indirekt, gemiddeld zal een machine die meer cellen
bevat ook meer uitgangen bevatten waarin gevuurd wordt.
Het gemiddeld aantal uitgangen waarin gevuurd wordt, ligt wel veel lager bij de
zelfgebouwde machines dan bij de bovengrens. Er dient opgemerkt te worden dat deze
bovengrens louter theoretisch is (i.e. een machine kan in de praktijk nooit in zoveel
uitgangen vuren), maar dit geeft slechts een gedeeltelijke verklaring.
Het gedrag van een axon speelt een grote rol, een axon dat meer dan één vuursignaal
ontvangt zal zelf niet vuren, dit maakt het onwaarschijnlijk dat in een machine met veel
axonen die gemiddeld veel uitgangen hebben, de cellen vaak vuren.
94
De zelf gebouwde machines bevestigen dit, het overgrote deel van de axonen heeft slechts
één ingang; axonen met drie ingangen zijn al zeer uitzonderlijk en axonen met vier en vijf
ingangen kwamen niet voor.
Bij het bouwen van machines viel vooral op dat het gebruik van een neuron best zo veel
mogelijk vermeden wordt. Hoewel de interne pijplijn van een neuron de mogelijkheden
van de CAM-Brain verhoogt (oneven vertragingen zijn mogelijk), heeft ze vaak tot gevolg
dat de synchroniciteit van twee signalen die met elkaar interageren verloren gaat.
Dit leidt dan weer tot de noodzaak om voor het andere signaal een neuron te gebruiken en,
omwille van de plaatsing van de neuronen, een aantal extra axonen. Extra cellen gebruiken
heeft dan weer tot gevolg, zoals geïllustreerd in machine 1, dat de verwerking van signalen
meer tijd in beslag neemt en de machine weer in zijn begintoestand brengen vereist dan
ook meer cellen.
95
Appendix A: Benaderingen voor machine 2
Het is de bedoeling een benadering te vinden voor het aantal enen, die uitgelezen worden
in machine 2 en voor het aantal keer er twee enen in een deelcomponent vuren en dit
gebaseerd op x*
Deze x zal door de machine voorgesteld worden als s
onafhankelijk van de positie van de overeenkomsten.
†
verschillende binaire getallen, zodat
de som van deze s getallen gelijk is aan x.
Het aantal enen in deze binaire getallen is het aantal enen die uitgelezen worden.
Indien elk van deze getallen van de vorm 2n
Dat het een bovengrens is kan eenvoudig ingezien worden. Indien men het aantal enen van
deze getallen wil laten stijgen moeten er meer enen toegevoegd worden dan er verwijderd
worden. Aangezien de getallen van de vorm 2
– 1 is en n zo gekozen wordt dat de som van
deze getallen groter dan of gelijk aan x is zal s.n een goede benadering zijn van het aantal
enen, die uitgelezen worden (indien n geminimaliseerd wordt) en zal het bovendien een
bovengrens zijn voor dit aantal.
n
– 1 zijn, hebben ze de n minst significante
bits op één staan. Door enen op bepaalde posities weg te laten en op andere posities toe te
voegen zal de som van s getallen altijd stijgen, en aangezien s.n reeds groter dan of gelijk
aan x is, kan het ontbinden van x in s binaire getallen dus nooit leiden tot getallen die
tesamen meer enen bevatten dan s.n.
Elk van de getallen is van de vorm 2n
– 1 en de som van deze getallen moet groter dan of
gelijk aan x zijn, met andere woorden:
+=⇒
+≥⇔
≥−
1log
1log
)12.(
2
2
sxn
sxn
xs n
* x: aantal overeenkomsten tussen het patroon en de pulstrein † s: aantal delen waarin de pulstrein gesplitst is
96
Merk op dat s per definitie altijd positief is, en aangezien n een natuurlijk getal is geeft de
laatste vergelijking het minimum voor n waarbij aan de voorwaarde voldaan is.
Het aantal enen is dan:
+1log. 2 s
xs
97
Appendix B: Structuur van de .gnt file
Een configuratie van de CAM-Brain wordt beschreven in een .gnt*
bestand.
# commentaar begint met # en loopt door tot het einde # van een regel Module Data File Format <n> Fill Zero NumModules <n> StartModule # 24x24x24 NumCells <n>
met <n> telkens een natuurlijk getal.
De eerste regel geeft aan welke versie van het gnt bestandsformaat gebruikt wordt. Alle
machines die ik gebouwd heb zijn geschreven in formaat 1.
De tweede regel geeft aan hoe de machine moet opgevuld worden, i.e. hoe cellen die niet
expliciet beschreven zijn moeten geïnterpreteerd worden. Voor de handgeschreven
machines die ik gemaakt heb gebruik ik steeds “Zero”, dit geeft aan dat alle bits die de cel
beschrijven op nul gezet worden. Andere opties zijn Random, One en Blank.
De derde regel geeft aan uit hoeveel modules de machine bestaat. De machines in deze
thesis zijn telkens binnen één module geconstrueerd.
De vierde regel geeft de start van de module aan. Na het commentaar teken volgt de
dimensie. Dit is enkel van belang binnen simulatoren. De dimensie van een module in de
CAM-Brain is altijd 24x24x24, maar binnen een simulator kan uiteraard voor een andere
dimensie geopteerd worden. Deze dimensie moet dan expliciet vermeld worden.
Aangezien er geen grenzen zijn aan een module kan een machine die bijvoorbeeld in een
6x6x6 module past een ander gedrag vertonen binnen een 6x6x6 module dan binnen een
24x24x24 module.
De vijfde regel geeft het aantal cellen aan die expliciet beschreven worden.
Nadien volgt er een regel voor elke cel waarin deze cel expliciet beschreven wordt.
Voor een axon ziet die er als volgt uit. x 2 y 0 z 0 000000 001000 0
* gnt komt van genotype
98
De x, y en z gevolgd door een nummer geven de coördinaten van de cel aan. Nadien volgen
er zes bits die enkel van belang zijn voor de genetische groeieenheid, en die dus voor
handgeschreven machines altijd op nul staan.
De volgende zes bits geven aan in welke richtingen de cel een ingang of uitgang heeft. Een
1 duidt op een uitgang, en een 0 op een ingang. De zes richtingen worden in de volgorde
Noord – Zuid – Top – Bodem – West – Oost beschreven.
De laatste bit geeft aan of het axon zich initiëel in de toestand vuren bevindt of niet. Een 0
duidt op niet vuren, een 1 op vuren.
Voor een neuron komen er een aantal extra bits bij
x 2 y 1 z 0 000000 110000 0 010000 1 0 0000 000000
Het eerste gedeelte is identiek aan een axon.
De volgende zes bits geven het gewicht aan voor de verschillende ingangen. Indien er een
1 staat heeft de neuron een positief gewicht op deze positie. Een 0 duidt op een negatief
gewicht.
De volgende bit geeft aan of deze cel al dan niet als neuron moet opgevat worden. Een 1
geeft aan dat ze een neuron is.
De volgende bit geeft aan of het neuron de volgende tijdseenheid zal vuren, dit heeft
hetzelfde effect als wanneer de accumulator hoger dan twee gezet wordt en deze bit is dus
eigenlijk redundant.
De vier bits daarna worden gebruikt om de accumulator een initiële waarde te geven. De
laatste drie bits komen overeen met een decimale waarde van nul (000) tot zeven (111).
Indien de eerste bit een 1 is moet er acht afgetrokken worden van deze waarde. Op deze
manier komen deze vier bits steeds overeen met een waarde tussen min acht en zeven.
De volgende zes bits geven aan of het neuron de volgende tijdseenheid een vuursignaal zal
ontvangen of niet, deze zijn enkel van belang binnen de hardware. In de machines die ik
geschreven heb en die binnen een simulator geëvalueerd werden, staan ze steeds op nul.
99
Aangezien er in het gnt formaat geen beschrijving mogelijk is voor in- en uitvoercellen en
aangezien een simulator meer mogelijkheden biedt dan de machine, heb ik een aantal extra
definities zelf toegevoegd.
Elk van deze regels beginnen met een dubbel comentaarteken (##), zodat deze bestanden
correct zullen geïnterpreteerd worden in de machine of in andere simulators.
## I <n> <bitrij>
Een regel die begint met ## I duidt op een invoercel, <n> geeft het nummer van de invoer
aan. <bitrij> bestaat uit een serie nullen en enen. <bitrij> moet minstens uit één 0 of 1
bestaan en wordt afgesloten door een newline karakter.
## O <n>
Deze regel geeft aan dat de uitvoer <n> gebruikt wordt, en dat de simulator dus de bitrij
die deze uitvoer passeert moet uitvoeren.
## CW x <n> y <n> z <n>
CW, afkorting voor ‘Cell Watch’, wordt gebruikt om de cel met coördinaten x,y en z als
uitvoer op te vatten. In een simulator kan men, in tegenstelling tot de machine, uiteraard de
toestand van elke cel over het gehele tijdsverloop bekijken.
Deze instructie is vooral nuttig bij het debuggen van machines.
100
Appendix C: Inhoud van de CD-ROM
De CD-ROM bevat een aantal .gnt bestanden die de configuratie van de verschillende
(deel)machines uit deze thesis bevatten, samen met de .wrl bestanden die een 3D-
voorstelling van deze machines bevatten in VRML. Om deze .wrl bestanden te bekijken is
een browser nodig met een VRML plug-in.*
De volledige machines hebben geen .wrl bestand. Deze bestanden zijn vrij groot en mijn
computer crashte steeds toen ik ze probeerde te openen. Een van de programma’s die ik
geschreven heb, zet .gnt bestanden om in .wrl bestanden. Dus u kan eenvoudig zelf de .wrl
bestanden aanmaken en ze proberen te openen.
Naast de verschillende .gnt en .wrl bestanden voor de verschillende machines bevat de CD-
ROM ook een aantal programma’s die geschreven zijn voor deze thesis.
Alle programma’s zijn console-applicaties geschreven in C++. De gebruiker van de
programma’s wordt niet echt ‘beschermd’. (Indien er bijvoorbeeld een uitvoerbestand
gespecifieerd wordt, wordt er niet gecontroleerd of dit bestand reeds bestaat, maar wordt
het automatisch overschreven). Opletten dus.
Simulator (Cbm) De simulator genereert op basis van een .gnt file, met de modificaties zoals beschreven in
appendix B, een uitvoerfile waar de waarden van de verschillende (uitvoer)cellen die
bekeken worden voor het gehele tijdsverloop in uitgeprint worden.
De simulator is vooral geschreven met het oog op ontwerpen en debuggen van machines en
dus niet met snelheidsoverwegingen in het achterhoofd.
Het algoritme dat gebruikt wordt is vrij eenvoudig. Voor elke cel wordt een accumulator
bijgehouden, alsook in welke richting ze in- en uitgangen heeft en of ze de volgende
tijdseenheid zal vuren of niet. Voor neuronen wordt, omwille van de interne pijplijn,
tweemaal bijgehouden of het zal vuren of niet.
De CAM-Brain zelf wordt voorgesteld als een driedimensionale matrix van cellen.
* een VRML plug-in kan gratis afgehaald worden op bijvoorbeeld http://www.parallelgraphics.com/products/cortona
101
Een tijdseenheid evalueren gebeurt in twee fasen. In een eerste fase wordt elke cel van de
CAM-Brain bekeken. Indien de cel gebruikt wordt, worden de accumulatoren van al zijn
buren aangepast indien de cel vuurt.
In de tweede fase wordt naar elke cel die gebruikt wordt gekeken en indien de cel de
volgende tijdseenheid moet vuren wordt de variabele, die aangeeft of de cel zal vuren,
aangepast.
De functies die aangeven waar de invoer- en uitvoercellen zich bevinden, zitten in een
aparte file. De reden is dat er verwarring bestond over de precieze locatie van deze invoer-
en uitvoercellen op het moment dat ik dit programma schreef.*
Op deze manier kon het
programma eenvoudig aangepast worden.
Gnt bestanden samenstellen (CbmMix) Dit programma kan gebruikt worden om twee (of meerdere) .gnt bestanden samen te
voegen tot één .gnt bestand. En er is de mogelijkheid om de verschillende .gnt bestanden te
verschuiven in de CAM-Brain.
Dit programma werd gebruikt om, vertrekkende van de verschillende deelmachines, de
volledige machines op te bouwen.
Gnt bestanden omzetten naar Wrl bestanden (CbmVrml) Het programma heeft als invoer een .gnt bestand en als uitvoer een .wrl bestand. Waar dit
wrl bestand een 3D voorstelling is van de machine beschreven in het gnt bestand.
Indien er op een cel of een verbinding tussen twee cellen geklikt wordt in de vrml
voorstelling, dan wordt de component doorzichtig gemaakt.
Verder kan in de statusbalk gezien worden wat de coördinaten van een cel zien indien de
muis over een cel stilgehouden wordt.
* zie 2.3.3 Invoer- en uitvoercellen, pagina 13
102
Twee cellen verbinden in een Gnt bestand (GntConnect) Dit programma heeft als invoer een gnt bestand en de coördinaten van twee cellen in dit
bestand. Het probeert de twee cellen met elkaar te verbinden.
De twee cellen die verbonden worden, moeten gedefinieerd zijn in het gnt bestand. Het
programma is niet bijster intelligent. Indien er altijd een omweg moet gemaakt worden om
de twee cellen te verbinden zal het programma er niet in slagen en aangeven waar er een
obstakel was. Dit kan omzeild worden door zelf een derde cel in te voegen en dan beide
cellen met deze derde cel te verbinden.
Er gebeurt slechts weinig controle in dit programma. De gebruiker moet er bijvoorbeeld
voor zorgen dat er geen cellen aan deze nieuwe verbinding grenzen die een uitgang hebben
naar deze verbinding. Standaard staat een in- of uitgang steeds als ingang (een nul), zodat
deze aangrenzende cellen ook in de verbinding zullen vuren, waar dit niet de bedoeling is.
In de praktijk is dit niet echt een probleem, bij het bouwen van de machines wordt in
principe een uitgang enkel gedefinieerd indien hij effectief gebruikt wordt. Cellen hebben
normaal steeds nullen (en dus ingangen) in de richtingen van cellen die (nog) niet gebruikt
worden.
Een geheugen bouwen (GntGeh) Dit programma krijgt als invoer de coördinaten van twee cellen, die de overstaande hoeken
van een kubus definiëren. Het programma zal deze kubus zo goed mogelijk opvullen met
een geheugen (cyclische aaneenschakeling van cellen met telkens één in- en uitgang)
103
Bibliografie
[1] M. KORKIN, G. FEHR, G. JEFFERY, Evolving Hardware on a Large Scale.
[2] F. GERS, H. DE GARIS, M. KORKIN, “CoDi 1-bit” A Cellular Automata based
neural net model simple enough to be implemented in evolvable hardware
[3] F. GERS, H. DE GARIS, M. KORKIN, CoDi-1Bit: A Simplified Cellular
Automata Based Neuron Model
[4] F. GERS, H. DE GARIS, Evolution of Neural Structures Based on Cellular
Automata
[5] F. GERS, H. DE GARIS, CAM-Brain: A New Model for ATR’s Cellular Automata
Based Artificial Brain Project
[6] H. DE GARIS, F. GERS, M. KORKIN, A. AGAH, N. NAWA, Building an
Artificial Brain Using an FPGA Based “CAM-Brain Machine”
[7] M. KORKIN, H. DE GARIS, F. GERS, H. HEMMI, “CBM (CAM-Brain
Machine)” a Hardware Tool which Evolves a Neural Net Module in a Fraction of a
Second and Runs a Million Neuron Artificial Brain in Real Time
[8] M. KORKIN, Programming the CAM-Brain Machine
[9] M. KORKIN, CBM Tool Suit Tutorial
[10] Z. MICHALEWICZ, Genetic Algorithms + Data Structures = Evolution Programs,
3th edition, Springer-Verlag (1999)
[11] S. RUSSEL, P. NORVIG, Artificial Intelligence; a Modern Approach, Prentice
Hall (1995)
