[AI] Hoe neural network ontwerpen?

[BasieP]

Beste mensen,

weet niet zeker of ik hier goed zit of dat het naar WL moest, maar probeer het hier maar even


Ik volg op school het keuzevak 'AI' hierin hebben we in de les een klein beetje over neural networks gehad. Nu wil ik daar graag meer van weten en ben dus wat aan't googlen enzo geslagen

Mijn doel is om uiteindelijk een soort van tekenherkenningsprogramma te maken.
Ik heb op het moment al de code voor een neuron, die dingen kan leren adhv wat parameters (waarheidstabel + gewenste uitkomst)

Nu is dit 1 neuron, en kom ik er achter dat ik dat ding al niet alle mogelijkheden kan leren.

als ik een AND functie wil leren, dan doet ie dat goed, maar wanneer ik een wat andere dingen wil leren blijft ie doorzoeken (wat ik dan na een xx keer proberen weer afvang en daar de conclusie uit trek dat ie dat dus niet kan leren)

even voor de duidelijkheid, ik probeerde hem dus dit te leren:

input 1	input 2	gewenste output
0	0	1
0	1	0
1	0	0
1	1	1

nu neem ik aan dat dat dus niet te leren is dmv 1 neuron, en ik wil dus proberen met meerdere, (hier moet ik uiteindelijk toch naartoe)
Ik moet dus uiteindelijk zo'n soort structuur kijken:

maar nu mijn vragen:

hoe 'bereken' ik hoeveel neuronen ik nodig heb, en hoe deze gekoppelt moeten zijn?

hoe zorg ik voor feedback tussen de neuronen? als er een foute waarde uitkomt, hoe ver wil je dat dan terugvoeren, en welke neuron moet dan aangepast worden?

[ Voor 4% gewijzigd door BasieP op 24-12-2005 13:05 ]

[martijn_brinkers]

Het probleem dat jij wil oplossen staat bekend onder het 'XOR problem'. De AND en OR functie zijn 'linear seperable' maar XOR niet. Je hebt daar een multi-layer netwerk voor nodig. Zie oa: http://www.comp.nus.edu.s...Networks/Perceptrons.html.

Zoeken op 'XOR perceptron' geeft een veelvoud aan informatie over dit 'probleem'

[BestTested!]

Ik heb een aantal jaren geleden een soort gelijk programma moeten schrijven voor mijn studie. Helaas heb ik het bijbehoren verslag niet meer, enkel nog de (lelijke) source-code.
Dat ding kon 10 'vormen' leren (in principe ook wel meer) en die dan herkennen uit ongeziene data.

Met 1 neuron kom je er inderdaad niet, maar om nu meteen naar een Multi-Layered over te springen is in principe niet nodig. De manier die ik heb gebruikt is voor elk symbool een apart neuron trainen. Het neuron met uiteindelijk de beste output kies je als antwoord.

Het aantal hidden neuronen kiezen (als je toch gaat voor Multi-Layered) blijft nog altijd meer een kunst dan een exacte wetenschap. Je wilt je input in ieder geval niet te groot maken. Een hogere dimensionaliteit heeft een slechte uitwerking op je neuraal netwerk. (curse of dimensionality als ik me niet vergis).

De feedback van de neuronen gaat met behulp van een error-functie. Volgens mij levert de term Delta-leer-regel wel de nodige informatie in Google.

Zoals ik al zei... het is allemaal al een tijdje geleden voor mij. Het boek dat ik destijds erbij gebruikte was: Artificial Intelligence, a modern approach (2nd Edition) door Stuart Russell
en Peter Norvig

NB: Had een geschatte ratio (10-fold-cross-validation) van meer dan 95% correct uiteindelijk.

[Eelke Spaak]

Als je iets als patroonherkenning wil doen kom je toch al gauw bij multi-layered netwerken uit. Je kan verder het beste als eerste bepaalde 'features' uit je data destilleren (bv. frequentie van datapunten in bepaalde gebieden; totaal aantal datapunten; w/h ratio, etc.).

Om een antwoord op je vragen te geven:

hoe 'bereken' ik hoeveel neuronen ik nodig heb, en hoe deze gekoppelt moeten zijn?

Hier zijn wel (redelijk ingewikkelde) technieken voor, maar over het algemeen is dit meer een kwestie van vuistregels toepassen. Ik raad je aan uit te gaan van een 3-layered netwerk, dus een netwerk met een input layer, hidden layer, en een output layer. Als je patronen wil herkennen aan de hand van features (zoals ik hier boven al noemde), is het voor de hand liggend om per feature een input unit te maken. De hoeveelheid output units hangt af van hoeveel verschillende outputs je verwacht. Als je bijvoorbeeld handgeschreven cijfers wil herkennen, zijn 10 output units een logische keus (cijfers 0 t/m 9). Het aantal hidden units is doorgaans een probeerwerkje . Gewoon dit aantal variëren totdat je min of meer op een minimum error rate zit.

De architectuur van het netwerk zou ik zo simpel mogelijk houden, zoals ook al in je plaatje wordt geïllustreerd: een volledig verbonden netwerk. Dat wil zeggen, alle input units hebben verbindingen met alle hidden units, en alle hidden units zijn weer verbonden met alle output units.

hoe zorg ik voor feedback tussen de neuronen? als er een foute waarde uitkomt, hoe ver wil je dat dan terugvoeren, en welke neuron moet dan aangepast worden?

Hiervoor moet je inderdaad kijken naar de delta-rule (a.k.a. adaline rule; widrow-hoff rule, LMS rule; wikipedia). Het komt erop neer dat je de bijdrage van elke unit aan de totale fout van het netwerk calculeert (met terugwerken door het netwerk) en de weights tussen de units aan de hand hiervan aanpast.

[BasieP]

thanx mensen, ik ben slecht in wiskunde, dus denk dat ik er lang over ga doen, maar heb nu in ieder geval een aantal 'zoektermen' waarmee ik verder kan werken

ik heb nu me 'neuron' class al dynamisch gebouwd zodat hij elke neuron met 1 output en 1 tot oneindig aantal inputs kan initialiseren.

ikzelf heb zelf ook gedacht aan de mogelijkheid van bestTested! (1 laag, met een boel inputs) maar ik wil natuurlijk uiteindelijk handgeschreven cijfers herkennen, en als 2 mensen een 9 schrijven (bijv) dan moet dat netwerk ze wel allebij herkennen, en niet een van de twee.
dus sowieso zou er dan een layer bij komen (met een berg OR's) die alle mogelijke 9'ens OR't en dan vuurt als 1 van die 9's gevuurt hebben.

maar ik heb het idee dat het verstandiger is om idd patronen te herkennen (dus bijv een rondje) waar ik dan de conclusie trek dat het een 0, 6, 8 of 9 moet zijn ofzo. maar dat moet ik allemaal nog zien

[ Voor 88% gewijzigd door BasieP op 24-12-2005 19:37 ]

[BasieP]

Ik loop nu al tegen een probleempje aan. Omdat ik nog niet zo heel erg op de hoogte was van wat AI allemaal kan enzo, wilde ik eerst wat simpele dingen maken.

Zo ben ik begonnen om op de manier die BestTested aandraagt een CRS te maken wat alleen het getal '3' herkent.
ik heb dus als input nu een lange bit array die staat voor alle 'vakjes' van de '3'
mijn 3 is dus dit:

0110
1001
0001
0110
0001
1001
0110

en zodoende heb ik 4x7 bits
deze 28 vakjes zijn dus mijn 28 inputs voor me neuron. Maar om deze neuron nu iets te leren zal hij dus alle mogelijke combinaties van die 28 bits af moeten gaan.

dat zijn op 2^28 mogelijkheden, en dat zijn er zo'n 4 miliard.. het 4.000.000.000x door een loopje lopen opzich duurt al 2:30 minuten op mijn pc, en ik heb zo het idee dat mijn methode dus niet zo heel erg 'slim' is...

ik heb zitten denken aan een methode die bijv per 2/3 inputs een neuron hebben, en daaraan dan weer 2 neurons etc. maar ben bang dat ik dan mijn dynamiek kwijt raak..

wat zou hier een goede methode zijn?
per regel (4/5 bits) een neuron?
of per 2/3 neurons?(gewoon vlnrvbnb)
of per kolom (6/7 bits)?
of misschien juist veel ingangen per neuron (14 bijv.; komt goed uit)

[ Voor 6% gewijzigd door BasieP op 24-12-2005 19:38 ]

[KopjeThee]

Ik heb hier matlab code voor de train en test functie van een eenvoudig feed forward neuraal netwerk in batch mode er is geen bias. Misschien heb je er iets aan. Het is de opgave van het neurale netwerken practicum aan de VU: http://www.few.vu.nl/~cjong/nn/lesson2.ps De slides staan hier: http://www.cs.vu.nl/~elena/slides03/nn_2light.ppt . De opgave is om 5 verschillende patronen te herkennen. De opgave lijkt erg op wat jij wilt.

De test functie:

code:

function y = ffnn_test(w1, w2, X)
A = sigmoid_func(w1'*X); % H x N
A = sigmoid_func(w2'*A);  % 5 x N
[m y] = max(A);

De train functie (batch mode):

code:

function [w1, w2] = ffnn_train(X, d)
a = 0.1; % Should be same as in sigmoid_func
H = 10;
nr_epochs = 500;
eta = 1;

w1 = rand(100, H);
w2 = rand(H, 5);
[m N] = size(X);

des = zeros(5, N);
for i = 1:N
  des(d(i), i) = 1;
end

for i = 1:nr_epochs
  y1 = sigmoid_func(w1'*X);  % H x N
  y2 = sigmoid_func(w2'*y1);  % 5 x N
    
  delta_output = a.*y2.*(1 - y2).*(des - y2); % 5 x N
  delta_w2_n = eta.*y1*delta_output'; % H x 5

  delta_hidden = a.*y1.*(1 - y1).*(w2*delta_output); % H x N
  delta_w1_n = eta.*X*delta_hidden'; % 100 x H

  w1 = w1 + delta_w1_n;
  w2 = w2 + delta_w2_n;
end

[ Voor 15% gewijzigd door KopjeThee op 24-12-2005 19:55 ]

[Verwijderd]

BasieP schreef op zaterdag 24 december 2005 @ 19:37:
Maar om deze neuron nu iets te leren zal hij dus alle mogelijke combinaties van die 28 bits af moeten gaan.

Hoezo dat? Je geeft 28 inputs een 1 of een 0, je berekent input van alle volgende neuronen, enz., die uitkomst vergelijk je met wat je eigenlijk wilde hebben (bijv. 0.3), je propageert 0.3 terug over je netwerk en zo ga je door tot het verschil met 0.3 en de uitkomst van de 28 inputs klein genoeg is. Je hoeft helemaal geen mogelijkheden af te gaan oid.

[BasieP]

kopjethee schreef op zaterdag 24 december 2005 @ 19:49:
Ik heb hier matlab code voor de train en test functie van een eenvoudig feed forward neuraal netwerk in batch mode er is geen bias. Misschien heb je er iets aan. Het is de opgave van het neurale netwerken practicum aan de VU: http://www.few.vu.nl/~cjong/nn/lesson2.ps De slides staan hier: http://www.cs.vu.nl/~elena/slides03/nn_2light.ppt . De opgave is om 5 verschillende patronen te herkennen. De opgave lijkt erg op wat jij wilt.

De test functie:
[...]
De train functie (batch mode):
[...]

sorry, ik ben helemaal geen wiskundige, en ken matlab ook niet, dus het is al vrij lastig om je code te lezen.
verder vroeg ik me af wat 'sigmoid_func' is? met google krijg ik maar 7 hits, waarvan geen enkele uitsluitsel geeft..

Maareuh, ik zie 2 inputs (dwz 2 weights; w1 w2) en een X (een of andere collection?)

code:

A = sigmoid_func(w1'*X);

als iemand die regel uit kan leggen, kom ik denk ik een stap verder.

iig vroeg ik me af hoe je met 1 neuron met maar 2 inputs (2^2 = 4 mogelijkheden) een 5tal figuren kan ontdekken uit rasters van 10x10 (wat bij mijn weten toch 2^100 = 1267650600228229401496703205376 mogelijkheden heeft..


edit:
de sheets van de VU zijn ook beetje boven mijn niveau qua wiskunde, maar ik doe me best
ik doe (maar) HBO

edit2:
@playroll:
volgens mij snappen we elkaar niet, wat jij bedoelt is volgens mij dat het best kan zijn dat je neuron(ennetwerk) een figuur eerder snapt dan die 4 milard keer, maar in het slechtste geval zal het je laatste mogelijkheid zijn

[ Voor 37% gewijzigd door BasieP op 24-12-2005 20:32 ]

[Verwijderd]

BasieP schreef op zaterdag 24 december 2005 @ 16:53:

ikzelf heb zelf ook gedacht aan de mogelijkheid van bestTested! (1 laag, met een boel inputs) maar ik wil natuurlijk uiteindelijk handgeschreven cijfers herkennen, en als 2 mensen een 9 schrijven (bijv) dan moet dat netwerk ze wel allebij herkennen, en niet een van de twee.
dus sowieso zou er dan een layer bij komen (met een berg OR's) die alle mogelijke 9'ens OR't en dan vuurt als 1 van die 9's gevuurt hebben.

Dat is nu net het hele idee achter je neurale netwerk. Je wilt niet weten hoe het precies werkt, enkel dat het werkt. In principe zou één neuron genoeg moeten zijn.

Om met je voorbeeld van de handgeschreven cijfers te werken. Laten we even denken dat je een raster over het cijfer legt. Hiermee codeer je het cijfer naar een input voor je neurale netwerk.
Je kan vele inputs hebben gegeven dat iedereen anders schrijft. Maar je hebt maximaal 10 outputs.
Je neuron kan door training leren welke input tot welke output moet leiden. Met 1 neuron zal dit nogal foutgevoelig zijn. Door meerdere neuronen te nemen kan je model zich beter aanpassen aan de verschillende situaties. Maar cijfers zijn niet zo heel moeilijk te herkennen.

Meer lagen is dan ook meestal niet strikt nodig. Wél kunnen extra lagen zorgen voor een verhoging van de kwaliteit van het netwerk en het aantal neuronen binnen de perken houden.

deze 28 vakjes zijn dus mijn 28 inputs voor me neuron. Maar om deze neuron nu iets te leren zal hij dus alle mogelijke combinaties van die 28 bits af moeten gaan.

Eh, nee. Deze combinatie van 28 vakjes geef je met een waarderingsfunctie een unieke waarde. Je neurale netwerk moet je daarna aanleren Unieke waarde = 3.
Hoe bereken je de unieke waarde. Je kan je matrix bv als volgt in een getal omzetten

0110
1001
enz

= 0 * 1 + 1 * 2 + 1 * 4 + 0 * 8 + 1 * 16 + 0 *32 + 0 * 64 + 0 * 128 + .....

Als iemand anders de drie bv zo schrijft

1110
1001
0001
0110
0001
1001
1110

is dat een andere unieke waarde die ook aan de drie wordt toegekend. De truc is nu je neurale netwerk de drie te leren herkennen zodat als iemand bv dit schrijft


1110
1001
0001
1110
0001
1001
1110

het neurale netwerk dit als "dichtbij" de drie ziet en een drie retourneert.

[ Voor 54% gewijzigd door Verwijderd op 24-12-2005 20:54 ]

[KopjeThee]

BasieP schreef op zaterdag 24 december 2005 @ 20:29:
[...]

Maareuh, ik zie 2 inputs (dwz 2 weights; w1 w2) en een X (een of andere collection?)

code:

A = sigmoid_func(w1'*X);

als iemand die regel uit kan leggen, kom ik denk ik een stap verder.

code:

function Y = sigmoid_func(X)
a = 0.1;
Y = 1./(1 + exp(-a*X));

w1 is een matrix met alle gewichten van de input laag naar de hidden laag. w2 is een matrix met alle gewichten van de hidden laag naar de output laag. X bevat alle input patronen in de training set. w1'*X is een matrix vermenigvuldiging. De sigmoid functie is de "activatie functie". Het resultaat van die regel is de output van alle hidden neurons voor alle patronen in de training set. Beetje compact, maar werkt wel :-) Kijk ook even in de opgave voor de betekenis van alle variabelen.

[ Voor 6% gewijzigd door KopjeThee op 24-12-2005 21:05 ]

[BasieP]

Verwijderd schreef op zaterdag 24 december 2005 @ 20:35:
*knip*

als ik het dus goed begrijp is het zo dat je bijv voor een 'netwerk' wat 0-9 herkent maar 10 output en minimaal 10 input dingen hebt?

* BasieP was een beetje in de veronderstelling dat je met een neuron alle mogelijkheden moet kunnen maken (dus bitwise, en dan elke 0/1 is een input)

als ik jouw goed begrijp is het zo dat je een int (0*1 + 1*2 + 1*4 + 0*8 + etc.) als input hebt.
dan zou je dus voor herkenning van een exact getal 1 (dus precies die vorm enzo) 1 input en 1 output hebben.
als de input precies het goede getal is, dan vuurt ie, en anders niet..
als je 2 getallen wilt 'herkennen' (1 en 2 bijv.) heb je 2 input's etc.

Zo had mijn docent het niet echt duidelijk gemaakt.. maar het is wel een stuk makkelijker..

kopjethee schreef op zaterdag 24 december 2005 @ 21:03:
w1 is een matrix met alle gewichten van de input laag naar de hidden laag. w2 is een matrix met alle gewichten van de hidden laag naar de output laag. X bevat alle input patronen in de training set. w1'*X is een matrix vermenigvuldiging. De sigmoid functie is de "activatie functie". Het resultaat van die regel is de output van alle hidden neurons voor alle patronen in de training set. Beetje compact, maar werkt wel :-) Kijk ook even in de opgave voor de betekenis van alle variabelen.

ah, een meerdere laags netwerk dus..
dan laat ik dat even rusten, zo ver ben ik nog lang niet

[ Voor 31% gewijzigd door BasieP op 24-12-2005 22:03 ]

[Verwijderd]

BasieP schreef op zaterdag 24 december 2005 @ 22:02:
[...]

als ik het dus goed begrijp is het zo dat je bijv voor een 'netwerk' wat 0-9 herkent maar 10 output en minimaal 10 input dingen hebt?

* BasieP was een beetje in de veronderstelling dat je met een neuron alle mogelijkheden moet kunnen maken (dus bitwise, en dan elke 0/1 is een input)

Nee, iedereen schrijft een drie anders. Je hebt dus N (naar oneindig) mogelijke inputs die de 10 mogelijke outputs (0..9) moeten genereren. Je complete matrix die bij 1 geschreven getal hoort is dus 1 input. (Logisch: het gaat om het handgeschreven getal, niet om de representatie)
Je model moet ook getraind worden en leren dat iets wat op x lijkt waarschijnlijk een drie is. Net zoals jijzelf vrijwel iedere handgeschreven drie kan herkennen maar al die drieen wel net ietsje anders zijn. Dit is dus een beetje "fuzzy". "Het lijkt op een drie dus is het waarschijnlijk een drie"

Het complete neurale netwerk moet van alle mogelijke input, alle mogelijke outputs genereren. Dit kan in één laag, meerdere lagen en met een aantal neuronen naar keuze. Jou matrix 4x7 kan 28! (faculteit) verschillende tekeningen weergeven. Dan kun je zoals je zelf merkt de oplossing niet echt lekker meer exact bepalen. Door je neurale netwerk zo te bouwen dat het geschreven getallen herkent die dicht bij een bepaalde aangeleerde set getallen ligt hoef je het netwerk enkel die trainingsset getallen te leren. De rest kan het model dan "gokken"

als ik jouw goed begrijp is het zo dat je een int (0*1 + 1*2 + 1*4 + 0*8 + etc.) als input hebt.
dan zou je dus voor herkenning van een exact getal 1 (dus precies die vorm enzo) 1 input en 1 output hebben.
als de input precies het goede getal is, dan vuurt ie, en anders niet..
als je 2 getallen wilt 'herkennen' (1 en 2 bijv.) heb je 2 input's etc.

Zo had mijn docent het niet echt duidelijk gemaakt.. maar het is wel een stuk makkelijker..

Als de input "ongeveer" lijkt op een unieke waarde waarvan je weet dat het een drie is, dan retourneer je een drie anders een 0,1,2,4,5,6,7,8 of 9. Je zoekt dus de beste match.
Die unieke waarde heb ik voor het gemak maar even als int gedefinieerd, maar kan ook een string , een set van waarden. (zoals bij aandelen bv de Olieprijs, koers van het aandeel, P/E ratio, beta enz enz of een matrix met eenen en nullen) , of (afgezien dat die niet in een PC passen) een pak melk of een briefje met een geschreven letter zijn. Die unieke waarde heb je puur nodig om de verschillende inputs te kunnen onderscheiden. Belangrijk is dat jij eenvoudig aan die invoer waarde kan komen en je neurale netwerk daar iets mee kan.

Tot slot, dat ik een ander beeld bij neurale netwerken heb dan de meeste ITers zal wel te maken hebben met de studie die ik gedaan heb. Wij zagen neurale netwerken niet als iets "Intelligents" maar gewoon als een vorm van een niet parametrisch model. Op die manier vermijd je in je denken een beetje de hocus pocus sfeer die om de AI heen hangt.

[BasieP]

aha, kijk nu is het idee al een stuk duidelijker. maar de vraag blijft een beetje.

jij stelt dat ik in princiepe met 1 neuron al 0-9 kan herkennen, ik denk dat je hier bedoelt 10 neurons op 1 niveau, want bij mijn weten hebben neuronen maar 1 uitgang.

Zoals ik mijn Neuron class heb gebouwd is het nu alleen mogelijk om een 2dimentionale array (2d matrix) te gebruiken.
Hierin staat niet de goede waarde, maar alle mogelijkheden + het goede antwoord
(zie SP) zo 'leert' mijn neuron dus exact die waarheidstabel (waar mogelijk; zie hier)
Maar dit is dus eigenlijk fout?

Als ik je verhaal begrijp is het dus de bedoeling dat de neuron in mijn geval niet een waarheidstabel, maar alleen het goede antwoord moet krijgen (en misschien het totaal aantal antwoorden)
dus om maar even bij de tot integer omgevormde matrix te blijven:
in geval van mijn 3:

Java:

line = "0110" +
       "1001" +
       "0001" +
       "0110" +
       "0001" +
       "1001" +
       "0110";   //character 3

int temp = 0;
for (int i=0;i<line.length();i++) {
    temp += i * Integer.parseInt(line.copyValueOf(line.toCharArray(),i,1));  //ziehier de ranzigste regel code in me app
}
Neuron n = new Neuron(temp,max);  //waar max hier dus zelfde matrix is al '3' maar dan met alleen 1'en

Ik train nu mijn neuron door alle mogelijkheden (zie waarheidstabel SP) maar als ik hem alleen een goede geef kan ik wel de 'foute' mogelijkheden gaan bedenken, maar dan ben ik weer op het loopje van 4 miljard waar dat ding veel te lang over doet..

Verwijderd schreef op zondag 25 december 2005 @ 12:08:
die tsbel is toch geen AND functie 00 ---> 0 en niet 00 --> 1

ik zeg ook niet dat het een and functie is..

[ Voor 10% gewijzigd door BasieP op 25-12-2005 12:30 ]

[Verwijderd]

die tsbel is toch geen AND functie 00 ---> 0 en niet 00 --> 1