ne ural net work

[kkeemmss]

Sagribējās nedaudz paspēlēties ar neural networking.
veiksmīgi uzrakstiju tīklu ar 2 input, 2 hiden 1 output + bios,
treniņdatiem lietoju to pašu Xor kur [1,1] vai [0,0] dod [0], bet [1,0] vai [0,1] dod [1]
apmācībai tas pats back propaganda, un ilgi pagāja kāmēr sapratu kā atvasināt sigmoid funkciju. bet nu beigu beigās pēc 500 apmācības cikliem, autput kļūda nau lielāka kā pacmit procentiem, un pēc pāris tūkstošu apmācības cikliem, kļūda tuvojas dažiem procentiem

Problēma tāda pamācībā kuru lietoju netika izskatīti gadijumi, ja man ir vairāk kā viens autput neirons. un nu esmu ieprūdis. Godīgi sakot es nebūtu sapratis tās formulas, ja tutorialī viņš uzreiz līdzi formulām nerakstītu reālus skaitliskus piemērus, un visu uzreiz neizreikinātu. Nu jā, un daudzās citās literatūtās tās formulas izskatās kā no zinātniskās fantastikas filmas.

Labi konkrēti pie piemēra. Delta Error es reikināju Fprim(W_sum) * (ideal-fact)
kur Fprim ir simoid atvasinājums, W_sum ir visu ienākošo vērtību summa,
Ideāl protams ir treniņ datu pareizā atbilde, un Fact ir tas ko izreikina mans tīkls.

tālāk lai izreikinātu Hiden neirona delta Error, vaidzēja lietot output neirona Delta error, un kāmār tāds bij tikai 1. vis skaidrs, bet ja piemēram 2 vai vairāk outputi, vai man viņu delta errorus skaitīt kopā vai kā savādāk?

Varbūt var ieteikt kādu labu lieratūru, kur priekšzināšanās nau obligāta augstākā matemātika.
(daudzi tutoriāli pieņem ka tu no galvasz zināsi kā atvasināt sigmoid funkciju)

[bubu]

Output slāņa neironi jau ne ar ko īpašu neatšķiras, no vidējā, vai sākuma slāņa neironiem. T.i. tu ar outputiem dari tieši to pašu, ko ar vidējā, vai sākuma slāņa neironu outputiem.
Respektīvi, tu izskaitļo visas Delta = VēlamaisRezultāts - IegūtaisRezultāts.
Un tad svaru koriģējamais lielums (kas jāpieskaita "learning rate" koeficientu nākamajā iterācijā) svaram W[k,i] ir Inputs[k] * Sum(i=0..N, Delta*W[k,i])*F'.
Ceru, ka nenokļūdījos formulās ;)

Par matemātikas zināšanām - bez tām te nu nekādīgi. Mākslīgie neironu tīkli ir matemātika, tur neko nepadarīt. Tāpat kā raksīt programmas nevar bez iemācīšanās programmēt.
Jā, un ja nemāki atvasināt, tā nav liela bēda. Mūsdienās atvasināšau tīri labi veic dators :) Piemēram: http://www.wolframalpha.com/input/?i=de ... Be%5E-x%29

[kkeemmss]

Ja es pareizi saprotu ko tu uzrakstiji tajā formulā, tad tu tur jau raksti kā apreiķināt gradientu, un kā to gradientu izmantot lai koriģētu smagumus.

savā pirmajā projektā es gradientus ieguvu novisiem četriem treniņdatiem saskaitiju kopā, un tad reizināju ar lerning rate, un vēl skaitiju klāt alfa (momentum) * iepriekšējās itarācijas grdienti.

Bet savā otrajā projektā es netieku līdz gradientiem, kāmēr neesmu izreikinājis ' Layer delta ' or 'node delta'

vēlreiz noskatijos to tutoriāļa daļu http://www.youtube.com/watch?v=p1-FiWjT ... ure=relmfu (aperam 8 minūte)
un no tā tutoriāļa es saprotu ka outputa neironam tas grieķu burts delta reiķinās pēc vienas formulas, bet vissi pārējie slaņi tuvāk inputam pēc mazliet savādākas.



pēc šitā vaidētu būt skaidrs par kādu Delta eroru es runāju.

Man te pašam bij doma ka varētu visu inputu delta eroru absolūtās vērtības saskaitīt un izdalīt ar outputu skaitu, bet nezinu vai tas kko dotu.

[bubu]

Es laikam īsti nesaprotu, ko tu nesaproti.

Pieņemsim, ka tev ir:
1) N inputi un M outputi
1) trīs slāņi - ar I, un K un M neironiem
2) ieejas dati - input
3) I'tā slāņa svari - wI[n,i]
4) K'tā slāņa svari - wK[i,k]
5) M'tā slāņa svari - wM[k,m]

Pieņemsim, ka tev nav inputa, kas vienmēr padot 1 nākamajam slānim, bet ja tas ir, tad to nav grūti ielikt formulās zemāk.

Lai rēķinātu outputu, tu dari šo:
1) izrēķini I'tā slāņa outputu Iout = F( sum(n, wI[n,i] * input[n]) )
2) izrēķini K'tā slāņa outputu Kout[k] = F( sum(i, wK[i, k] * Iout) )
3) izrēķini M'tā slāņa outputu Mout[m] = F( sum(k, wM[k, m] * Kout[m]) )
Pareizi? sum(x, a[t,x]) man nozīmē a[t,0] + a[t,1] + ... + a[t,X], kur X ir max vērtība (n gadījumā N, i gadījumā I, utt)

Tagad vajag taisīt backpropogate. Pieņemsim, ka tu zini output Out[m], kuru gribi panākt.
Tad tu dari sekojošo (Fp ir F atvasinājums):
1) izrēķini M'tā slāņa korekcijas Mcorr[m] = Fp(Mout[m]) * (Out[m] - Mout[m])
2) izrēķini K'tā slāņa korekcijas: Kcorr[k] = Fp(Kout[k]) * sum(m, Mcorr[m] * wM[k, m])
3) izrēķini I'tā slāņa korekcijas: Icorr = Fp(Iout) * sum(k, Kcorr[k] * wK[i, k])
Un tad tu koriģē svaru vērtības:
4) I'tajam slānim wI[n,i] += eta * Icorr * input[n] - visiem n,i
5) K'tajam slānim wK[i,k] += eta * Kcorr[k] * Iout - visiem i,k
6) M'tajam slānim wM[k,m] += eta * Mcorr[m] * Kout[k] - visiem k,m

Ja intersē, tad reku: https://gist.github.com/3037153 ir mans ļoti vecs Delphi kods, kurā šo realizēju. Programma ir universāla, tā ļauj izveidot patvaļīga skaita slēpto slāņu vai inputu vai outputu. Tb to to vari izmanto lai mācītu darīt jebko.
Tajā par aktivācijas funkciju izmantoju F(x) = 1 / (1 + e^(-h*x)), kur h ir twīkojama konstante.

Piemēram, lai to apmācītu veikt Xor ar slēpto slāni ar 3 neironiem, tad nnet.ini failā jāieliek sekojošais:

Code: Select all

[Parametri]
Skaits=2
Slanis0=2
Slanis1=3
Slanis2=1
h=5
eps=1e-5
eta0=0.01
eta1=0.001
maxiter=500000

nnet.learn failā jāieliek apmācības dati:

Code: Select all

4
0 1

0 0
0

0 1
1

1 0
1

1 1
0

Jāpalaiž nnet.exe learn, outputā dabūs informāciju, ka programma mācas:

Code: Select all

Apmaaciiba:
  Ielasu paraugus.
  Apmaacu tiiklu.
  Iteraacija=25000 (5%)  Kljuuda=0.0004300169
  Iteraacija=50000 (10%)  Kljuuda=0.0002055528
  Iteraacija=75000 (15%)  Kljuuda=0.0001366471
  Iteraacija=100000 (20%)  Kljuuda=0.0001034704
  Iteraacija=125000 (25%)  Kljuuda=0.0000840593
  Iteraacija=150000 (30%)  Kljuuda=0.0000713815
  Iteraacija=175000 (35%)  Kljuuda=0.0000624972
  Iteraacija=200000 (40%)  Kljuuda=0.0000559623
  Iteraacija=225000 (45%)  Kljuuda=0.0000509855
  Iteraacija=250000 (50%)  Kljuuda=0.0000470975
  Iteraacija=275000 (55%)  Kljuuda=0.0000440024
  Iteraacija=300000 (60%)  Kljuuda=0.0000415054
  Iteraacija=325000 (65%)  Kljuuda=0.0000394728
  Iteraacija=350000 (70%)  Kljuuda=0.0000378106
  Iteraacija=375000 (75%)  Kljuuda=0.0000364509
  Iteraacija=400000 (80%)  Kljuuda=0.0000353440
  Iteraacija=425000 (85%)  Kljuuda=0.0000344531
  Iteraacija=450000 (90%)  Kljuuda=0.0000337508
  Iteraacija=475000 (95%)  Kljuuda=0.0000332170
  Iteraacijas=500000  Kljuuda=0.0000328371
  Saglabaaju tiikla datus!
  Pabeigts

Tad var sagatavot nnet.use failu ar ieejas datiem:

Code: Select all

0 0
0 1
1 0
1 1
0.5 0.5

Un palaist nnet.exe use, lai tā izrēķina uz šiem ieejas datiem outputu. Outputs saglabāsies nnet.rez failā

Code: Select all

0.00153 
0.99568 
0.99605 
0.00540 
0.01306

Kā redzams 0.5 ^ 0.5 = 0.01305 :)

Failā nnet.net būs saglabāti svaru koeficienti katram slānim (komentāri šeit uzrakstīti forumā, failā tādu nebūs)

Code: Select all

2 // slāņu skaits
2 3 1 // iejas un katra slāņa inpuu skaits
 5.00000000000000E+0000 // koeficients h - nāk no nnet.ini faila
 0.00000000000000E+0000  1.00000000000000E+0000 // min un max vērtības no nnet.learn faila

// vidējā slānī ir 3 neironi (tātad 3 kolonnas) ar 2 ieejām no ieejas slāņa (tātad 2+1 = 3 rindas)
 1.46983130311730E+0000  9.72643372927935E-0001  1.09200681622792E+0000 
-8.46786605199368E-0001 -1.50376547825500E+0000  1.18190673473932E+0000 
 2.19503490460772E-0001 -3.40476350837246E-0001 -2.56239673758643E-0001 

// output slānī ir 1 neirons (tātad 1 kolonna), ar 3 ieejām no vidējā slāņa (tātad 3+1 = 4 rindas)
-2.30403202222133E+0000 
 2.32834158094236E+0000 
 1.43873143920066E+0000 
-2.40900803520035E-0001

Ieejas no iepriekšējā slāņa ir +1, jo man tur ir dummy ieeja, kas vienmēr padod vērtību 1 inputā.

Ja tev nav Delphi, tad šis kods gan jau ka kompilēsies arī ar FreePascal. Vai arī varu iedot exe failu, ja vajag.

[kkeemmss]

Hehe, godīgi sakot arī bubu formilās līdz galam neiebraucu.
bet nu darbā sēžot nogāja garām gudrs cilvēks, kas ar neironiem neko nau darijis. Paskatijās un manu postu, un formulu, paskatijās uz bubu formulām un izdomāja pareizo atbildi.

Kcorr[k] = Fp(Kout[k]) * sum(m, Mcorr[m] * wM[k, m])

šitā bij aclēga, tur kur es 1. variantā ar 1 autputu, reizināju deltu ar linka svaru,
tur otrā gadijumā (2 autputi) bij nevis jāsumē visi linki un tad kaut kā japierizina delta, bet
jāsumē linka un tam atbilstošās deltas reizinājums.

pirmajam projektam es daudzko rakstiju ar roku, pirmēram :

di1h1 = Eps*gi1h1 + alp*di1h1p
di1h2 = Eps*gi1h2 + alp*di1h2p
di2h1 = Eps*gi2h1 + alp*di2h1p
di2h2 = Eps*gi2h2 + alp*di2h2p
db1h1 = Eps*gb1h1 + alp*db1h1p
db1h2 = Eps*gb1h2 + alp*db1h2p
dh1o1 = Eps*gh1o1 + alp*dh1o1p
dh2o1 = Eps*gh2o1 + alp*dh2o1p
db2o1 = Eps*gb2o1 + alp*db2o1p

tā varēja kamēr man bij 9 linki, un jau tad tas bij apnicīgi.

Tālak tikai laika jautājums kāmēr es uzrakstiju labāk organizētu kodu, kas linkus starp neironiem pats uzgenerē. Un tas nu beidzot ir pabeigts un strādā.

nākamais es plānoju 7 segmentu displeju,
(7 inputi/Outputi) x (pacmit hiden) x (10 autputi/inputi).
redzēs kas no tā sanāks.

[kkeemmss]

Nez vai man vaidzētu pārcelties uz sadaļu tavi projekti, jo šis jau vairs nau matemātiskas dabas jautājums, bet nu it kā jau turpinu to pašu tēmu.

Ciparnīca strādā kā pulkstenis, man par lielu pārsteigumu, pat tad kad Hiden slānī atstāju tikai 3 neironus. (sāku ar 14)

otrs eksperiments bij tikai ar 1 inputu kura vērtības bij no 1-9 veseli skaitļi.
rezultātā tas algoritms ātri sazīmēja pimos 4 un brīžiem pat 5 un 6 bet tālāk gan netika.


Ir kādas idejas nākamam projektam izmantojot šitos neuronus.
varētu meiģināt programmu kas atpazīst ar roku rakstītus drukātus ciparus.
piem 32X32 pikseļu image..

[bubu]

Ar roku rakstītam tekstam būs ķēpīgi ar neironu tīkliem. Tur labāk strādā kautkādi feature detection algoritmi.
Ja gribi tam pielietot neironu tīklus, tad iesaku pielietot vispirms FFT analīzi un laist neironu tīklus uz frekvenču domēnā. Iespējams varētu arī sadalīt bildi pa fragmentiem, un katru apstrādāt individuāli, tas varētu dot labāku precizitāti (bet neesmu drošs).

[spicausis]

Droši uz priekšu, jo eksperimenti ar cipariem ir forši, un tīkls ar vienu slēpto slāni ar 25 unitiem atliektiem galiem pietiek, lai sekmīgi klasificētu lielāko daļu MNISTa 20x20px cipariņu (http://yann.lecun.com/exdb/mnist/), bez papildus preprocesēšanām, dekompozīcijām, etc.