See osa sisaldab linke RuNeti artiklitele selle kohta, mis on närvivõrgud. Paljud artiklid on kirjutatud originaalses, elavas keeles ja väga arusaadavad. Kuid siin võetakse enamasti arvesse ainult põhitõdesid, kõige lihtsamat kujundust. Siit leiate ka viiteid närvivõrke käsitlevale kirjandusele. Õpikud ja raamatud, nagu nad olema peavad, on kirjutatud akadeemilises või sarnases keeles ning sisaldavad hämaraid, abstraktseid näiteid närvivõrkude ehitamisest, nende treenimisest jne. Tuleb meeles pidada, et terminoloogia erinevates artiklites "hõljub", nagu ka võib. näha artiklite kommentaaridest. Seetõttu võib alguses olla "segadus peas".

• Kuidas Jaapani talunik süvaõppe ja TensorFlow abil kurke sorteeris
• Närvivõrgud piltidel: ühest neuronist sügavate arhitektuurideni
• Näide närvivõrgu programmist lähtekoodiga C++ keeles.
• Ühekihilise närvivõrgu – pertseptroni juurutamine sõidukite klassifitseerimise probleemile
• Laadige alla närvivõrkude kohta raamatuid. Terve!
• Börsitehnoloogiad: 10 eksiarvamust närvivõrkude kohta
• Algoritm mitmekihilise närvivõrgu treenimiseks backpropagation meetodil

Närvivõrgud Pythonis

Saate lühidalt lugeda, millised raamatukogud Pythoni jaoks on olemas. Siit võtan testnäiteid, et veenduda, kas vajalik pakett on õigesti installitud.

tensorflow

TensorFlow keskne objekt on andmevoo graafik, mis kujutab arvutust. Graafi tipud tähistavad tehteid ja servad tensoreid (tensor) ( mitmemõõtmelised massiivid, mis on TensorFlow aluseks). Andmevoo graafik tervikuna on täielik kirjeldus arvutused, mida rakendatakse seansi jooksul ja tehakse seadmetes (CPU või GPU). Nagu paljud teised kaasaegsed süsteemid teaduslikuks andmetöötluseks ja masinõpe TensorFlow'l on Pythoni jaoks hästi dokumenteeritud API, kus tensorid on kujutatud tuttavate NumPy ndarray massiividena. TensorFlow teeb arvutusi kõrgelt optimeeritud C++ abil ning toetab ka C ja C++ natiivseid API-sid.

• Sissejuhatus tensorflow abil masinõppesse. Seni on avaldatud vaid esimene artikkel neljast.
• TensorFlow valmistab pettumuse. Google'i sügaval õppimisel puudub "sügavus"
• Masinõpe lühidalt: teksti klassifikatsioon närvivõrkude ja TensorFlow abil
• Google TensorFlow masinõppeteek – esmamuljed ja võrdlus meie enda juurutusega

Tensorflow installimist kirjeldatakse hästi esimese lingi artiklis. Nüüd on aga välja antud Python 3.6.1. Seda ei ole võimalik kasutada. Hetkel vähemalt väävel (03.06.2017). Nõuab versiooni 3.5.3, mille saab alla laadida. Allpool annan järjestuse, mis minu jaoks töötas (veidi erinev Habri artiklist). Pole selge, miks, kuid Python 64-bitine on selle jaoks loodud AMD protsessor vastavalt sellele läheb kõik muu selle alla. Pärast Phytoni installimist ärge unustage seadistada kasutajatele täielikku juurdepääsu, kui Python oli installitud kõigile.

pip install -- upgrade pip
pip install -U pip setuptools
pip3 install -- tensorflow uuendamine
pip3 install -- upgrade tensorflow-gpu
pip install matplotlib /*Laadib alla 8,9 MB ja veel paar väikest faili */
pip installi jupyter

"Alasti Python" võib tunduda ebahuvitav. Seetõttu on allpool toodud juhised Anaconda keskkonda installimiseks. See on alternatiivne ehitus. Python juba sellesse integreeritud.

Saidil on taas Python 3.6 uus versioon, mida uus Google'i toode veel ei toeta. Seetõttu võtsin arhiivist kohe varasema versiooni, nimelt Anaconda3-4.2.0 - see sobib. Ärge unustage märkida Python 3.5 registreerimiskasti. Täpsemalt, enne Anaconda installimist on parem terminal sulgeda, vastasel juhul jätkab see tööd vananenud PATH-iga. Samuti ärge unustage muuta kasutaja juurdepääsuõigusi, vastasel juhul ei tööta midagi.

conda create -n tensorflow
aktiveerida tensorflow
pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/cpu/tensorflow-1.1.0-cp35-cp35m-win_amd64.whl /*Internetist alla laaditud 19,4 MB, seejärel 7 , 7 MB ja veel 0,317 MB*/
pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/gpu/tensorflow_gpu-1.1.0-cp35-cp35m-win_amd64.whl /*Laadi alla 48,6 MB */

Installimiskuva ekraanipilt: Anacondas läheb kõik hästi.

Samamoodi ka teise faili puhul.

Noh, kokkuvõtteks: selleks, et see kõik toimiks, peate installima NVIDEA-st CUDA Toolkitsi paketi (juhul kui GPU kasutamine). Praegune toetatud versioon on 8.0. Samuti peate alla laadima ja CUDA kausta lahti pakkima cuDNN v5.1 teegi, kuid mitte uuemat versiooni! Pärast kõiki neid manipuleerimisi TensorFlow töötab.

Theano

• Korduv närvivõrk kümnes koodireas hindas "Tähesõdade" uue osa vaatajate tagasisidet.

Theano pakett sisaldub Pythoni enda PyPI-s. Iseenesest on see väike - 3,1 MB, kuid see tõmbab veel 15 MB sõltuvusi - scipy. Viimase installimiseks on vaja ka lapacki moodulit... Üldiselt tähendab theano paketi installimine Windowsi alla “tantsu tamburiiniga”. Allpool proovin näidata toimingute jada, et pakett toimiks.

Anaconda kasutamisel pole "tamburiiniga tantsimine" paigaldamise ajal asjakohane. Piisab käsust:

conda install theano

ja protsess toimub automaatselt. Muide, laaditakse ka GCC pakette.

Scikit-Learn

Python 3.5.3 all ainult rohkem kui varajane versioon 0.17.1, mille võite võtta. Seal on tavaline paigaldaja. Kuid see ei tööta otse Windowsi all - vajate scipy raamatukogu.

Abipakettide installimine

Selleks, et ülaltoodud kaks paketti töötaksid (me räägime "alasti" Phytonist), peate tegema mõned eeltoimingud.

SciPy

Scikit-Learni ja Theano käivitamiseks, nagu ülaltoodust juba selgus, peate "tantsima tamburiiniga". Esimene asi, mida Yandex meile annab, on tarkuste ait, kuigi inglise keeles, ressurss stackoverflow.com, kust leiame lingi suurepärasele arhiivile peaaegu kõigi olemasolevate Windowsi jaoks koostatud Pythoni pakettide kohta – lfd.uci.edu

Siin on teile praegu huvipakkuvate pakettide paigaldusvalmis komplektid, mis on koostatud erinevad versioonid Python. Meie puhul on vajalikud failiversioonid, mis sisaldavad oma nimes rida "-cp35-win_amd64", kuna see on täpselt Pythoni pakett paigaldamiseks kasutati. Kui otsite stakowerflow'st, leiate ka "juhised" meie konkreetsete pakettide installimiseks.

pip install -- upgrade --ignore-installed http://www.lfd.uci.edu/~gohlke/pythonlibs/vu0h7y4r/numpy-1.12.1+mkl-cp35-cp35m-win_amd64.whl
pip install -- upgrade --ignore-insalled http://www.lfd.uci.edu/~gohlke/pythonlibs/vu0h7y4r/scipy-0.19.0-cp35-cp35m-win_amd64.whl
pip -- upgrade -- ignoreeri installitud pandasid
pip install -- upgrade -- ignoreeri installitud matplotlib

Viimased kaks pakki ilmusid minu ketti teiste inimeste "tamburiiniga tantsimise" tõttu. Ma ei märganud neid installitud pakettide sõltuvustes, kuid ilmselt on mõned nende komponendid tavapärase installiprotsessi jaoks vajalikud.

Lapack/Blas

Neid kahte seotud madala taseme teeki, mis on kirjutatud Fortranis, on vaja Theano paketi installimiseks. Scikit-Learn võib töötada ka nendega, mis on juba teistesse pakettidesse "varjatult" installitud (vt ülalt). Tegelikult, kui Theano versioon 0.17 on installitud exe-failist, töötab see ka. Vähemalt Anacondas. Neid raamatukogusid võib aga leida ka Internetist. Näiteks . Uuemad ehitused. Et valmis pakett toimiks eelmine versioon See sobib. Uue paketi loomiseks on vaja uusi versioone.

Samuti tuleb märkida, et Anaconda täiesti värskes versioonis installitakse Theano pakett palju lihtsamalt - ühe käsuga, kuid ausalt öeldes mind ei huvita selles etapis(null) närvivõrkude valdamine meeldis mulle TensorFlow rohkem, kuid see pole veel Pythoni uute versioonidega sõbralik.

Programmeerimine

• Tõlge

Millest artikkel räägib?

Isiklikult õpin kõige paremini väikese töötava koodiga, millega saan mängida. Selles õpetuses õpime tagasilevimise algoritmi, kasutades näitena Pythonis realiseeritud väikest närvivõrku.

Anna mulle kood!

X = np.massiivi([ ,,, ]) y = np.massiivi([]).T syn0 = 2*np.random.random((3,4)) - 1 syn1 = 2*np.random.random ((4,1)) - 1 j jaoks xvahemikus (60000): l1 = 1/(1+np.exp(-(np.dot(X,syn0)))) l2 = 1/(1+np. exp(-(np.dot(l1,syn1)))) l2_delta = (y - l2)*(l2*(1-l2)) l1_delta = l2_delta.dot(syn1.T) * (l1 * (1-l1) )) syn1 += l1.T.dot(l2_delta) syn0 += X.T.dot(l1_delta)

Liiga kokkusurutud? Jagame selle lihtsamateks osadeks.

1. osa: Väikese mänguasja närvivõrk

Tagasi levitamise teel koolitatud närvivõrk püüab kasutada sisendandmeid väljundandmete ennustamiseks.

Oletame, et peame sisendandmete põhjal ennustama, milline väljundveerg välja näeb. Selle probleemi saab lahendada nendevahelise statistilise vastavuse arvutamisega. Ja me näeksime, et vasak veerg on 100% korrelatsioonis väljundiga.

Backpropagation arvutab oma lihtsaimal juhul sarnase statistika mudeli loomiseks. Proovime.

Närvivõrk kahes kihis

import numpy as np # Sigmoid def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x) )) # sisendandmete kogum X = np.massiiv([ , , , ]) # väljundandmed y = np.massiivi([]).T # do juhuslikud arvud täpsem np.random.seed(1) # initsialiseeri kaalud juhuslikult keskmise 0-ga syn0 = 2*np.random.random((3,1)) - 1 iter xrange(10000): # edasi levimine l0 = X l1 = nonlin(np.dot(l0,syn0)) # kuidas me eksisime? l1_error = y - l1 # korrutage see sigmoidi # kaldega, võttes aluseks l1 väärtused l1_delta = l1_error * nonlin(l1,True) # !!! # värskenda kaalusid syn0 += np.dot(l0.T,l1_delta) # !!! print "Väljund pärast treeningut:" print l1

Väljund pärast treeningut: [[ 0,00966449] [ 0,00786506] [ 0,99358898] [ 0,99211957]]

Muutujad ja nende kirjeldused.

"*" - elemendipõhine korrutamine - kaks sama suurusega vektorit korrutavad vastavad väärtused ja väljundiks on sama suur vektor
"-" – vektorite elemendipõhine lahutamine
x.dot(y) – kui x ja y on vektorid, siis on väljundiks skalaarkorrutis. Kui need on maatriksid, siis on tulemuseks maatrikskorrutis. Kui maatriks on ainult üks neist, on see vektori ja maatriksi korrutis.

• võrrelge l1 pärast esimest iteratsiooni ja pärast viimast
• vaadake nonlin funktsiooni.
• vaadake, kuidas l1_error muutub
• parsi rida 36 - siin on kogutud peamised salajased koostisosad (märgitud!!!)
• parsi rida 39 - kogu võrk valmistub täpselt selleks toiminguks (märgitud!!!)

Jaotame koodi ridade kaupa

import numpy as np

Impordib numpy, lineaarse algebra raamatukogu. Meie ainus sõltuvus.

Def nonlin(x,deriv=False):

Meie mittelineaarsus. See konkreetne funktsioon loob "sigmoidi". See sobitab mis tahes arvu väärtusega 0 kuni 1 ja teisendab arvud tõenäosusteks ning sellel on ka mitmeid muid närvivõrkude treenimiseks kasulikke omadusi.

Kui(tuletis==True):

See funktsioon võib tekitada ka sigmoidi tuletise (deriv=True). See on üks selle kasulikke omadusi. Kui funktsiooni väljund on out-muutuja, on tuletis out * (1-out). Tõhus.

X = np.massiiv([ , …

Sisendandmete massiivi initsialiseerimine numbilise maatriksina. Iga rida on koolitusnäide. Veerud on sisendsõlmed. Lõppkokkuvõttes saame võrgus 3 sisendsõlme ja 4 koolitusnäidet.

Y = np.massiiv([]).T

Lähtestab väljundandmed. ".T" – ülekandefunktsioon. Pärast tõlkimist on y-maatriksis 4 rida ühe veeruga. Nagu sisendandmete puhul, on iga rida koolitusnäide ja iga veerg (meie puhul üks) on väljundsõlm. Selgub, et võrgul on 3 sisendit ja 1 väljund.

Np.random.seed(1)

Tänu sellele on juhuslik jaotus iga kord sama. See võimaldab meil pärast koodi muutmist võrku hõlpsamini jälgida.

Syn0 = 2*np.random.random((3,1)) – 1

Võrgu kaalumaatriks. syn0 tähendab "sünapsi null". Kuna meil on ainult kaks kihti, sisend ja väljund, vajame ühte kaalumaatriksit, mis need ühendaks. Selle mõõde on (3, 1), kuna meil on 3 sisendit ja 1 väljund. Teisisõnu, l0 suurus on 3 ja l1 suurus 1. Kuna me ühendame kõik l0 sõlmed kõigi l1 sõlmedega, vajame mõõtmete (3, 1) maatriksit.

Pange tähele, et see lähtestatakse juhuslikult ja keskmine on null. Selle taga on üsna keeruline teooria. Praegu võtame seda lihtsalt soovitusena. Pange tähele ka seda, et meie närvivõrk on just see maatriks. Meil on "kihid" l0 ja l1, kuid need on ajutised väärtused, mis põhinevad andmekogumil. Me ei säilita neid. Kõik treeningud on salvestatud syn0-sse.

Iter in xrange (10000):

Siit algab peamine võrgukoolituse kood. Koodisilmust korratakse mitu korda ja see optimeerib võrku andmekogumi jaoks.

Esimene kiht l0 on lihtsalt andmed. X sisaldab 4 koolitusnäidet. Töötleme neid kõiki korraga – seda nimetatakse rühmatreeninguks. Kokku on meil 4 erinevad jooned l0, kuid võite neid mõelda ühe koolitusnäitena - praeguses etapis pole see oluline (saate laadida 1000 või 10000 neist ilma koodi muutmata).

L1 = nonlin(np.dot(l0,syn0))

See on ennustamise samm. Lasime võrgul proovida sisendi põhjal väljundit ennustada. Siis vaatame, kuidas ta seda teeb, et saaksime seda paremaks muuta.

Igal real on kaks sammu. Esimene korrutab l0 ja syn0 maatrikskorrutise. Teine juhib väljundi läbi sigmoidi. Nende mõõtmed on järgmised:

(4 x 3) punkt (3 x 1) = (4 x 1)

Maatrikskorrutamine eeldab, et mõõtmed oleksid võrrandi keskel samad. Viimases maatriksis on sama arv ridu kui esimesel ja sama palju veerge kui teisel.

Laadisime 4 treeningnäidet ja saime 4 oletust (4x1 maatriks). Iga väljund vastab võrgu hinnangule antud sisendi kohta.

L1_viga = y - l1

Kuna l1 sisaldab oletusi, saame nende erinevust tegelikkusega võrrelda, lahutades õigest vastusest y l1. l1_error on positiivsete ja negatiivsete arvude vektor, mis iseloomustab võrku "miss".

Ja siin on salajane koostisosa. Seda rida tuleb osade kaupa sõeluda.

Esimene osa: tuletis

Nonlin (l1,tõene)

L1 tähistab neid kolme punkti ja kood loob allpool näidatud joonte kalde. Pange tähele, et suurte väärtuste (nt x=2.0 (roheline punkt)) ja väga väikeste väärtuste (nt x=-1.0 (lilla) puhul on joontel väike kalle. Suurim nurk punktis x=0 (sinine). See muudab suure erinevuse. Pange tähele, et kõik tuletised on vahemikus 0 kuni 1.

Täisavaldis: veaga kaalutud tuletis

L1_delta = l1_error * nonlin(l1,tõene)

Matemaatiliselt on täpsemaid meetodeid, aga meie puhul sobib ka see. l1_error on (4,1) maatriks. nonlin(l1,True) tagastab (4,1) maatriksi. Siin korrutame need elemendi kaupa ja väljundis saame ka maatriksi (4,1), l1_delta.

Korrutades tuletised vigadega, vähendame suure usaldusväärsusega tehtud ennustuste vigu. Kui joone kalle oli väike, siis võrk sisaldas kas väga suurt või väga väikest väärtust. Kui võrgu oletus on nullilähedane (x=0, y=0,5), siis pole see eriti kindel. Värskendame neid ebakindlaid ennustusi ja jätame suure usaldusväärsusega ennustused rahule, korrutades need nullilähedaste väärtustega.

Syn0 += np.dot(l0.T,l1_delta)

Oleme valmis võrku uuendama. Vaatame ühte koolituse näidet. Selles värskendame kaalusid. Värskenda vasakpoolsemat kaalu (9,5)

Kaalu_värskendus = sisendväärtus * l1_delta

Vasakpoolseima kaalu puhul oleks see 1,0 * l1_delta. Eeldatavasti tõstab see 9,5 vaid veidi. Miks? Sest ennustus oli juba üsna enesekindel ja ennustused läksid praktiliselt paika. Väike viga ja joone kerge kalle tähendab väga väikest uuendust.

Aga kuna teeme rühmatreeningut, siis kordame ülaltoodud sammu kõigi nelja treeningnäite puhul. Seega näeb see välja väga sarnane ülaltoodud pildiga. Mida siis meie liin teeb? See loendab iga raskuse ja iga treeningnäite kaaluvärskendused, teeb need kokku ja värskendab kõiki raskusi – kõik ühel real.

Pärast võrgu värskenduse jälgimist pöördume tagasi oma treeningandmete juurde. Kui nii sisend kui väljund on 1, suurendame nende vahelist kaalu. Kui sisend on 1 ja väljund on 0, vähendame kaalu.

Sisend Väljund 0 0 1 0 1 1 1 1 1 0 1 1 0 1 1 0

Seega meie neljas koolituse näited allpool esimese sisendi kaal väljundi suhtes kas suureneb või jääb konstantseks ning ülejäänud kaks kaalu suurenevad ja vähenevad olenevalt näidetest. See efekt aitab kaasa võrguõppele, mis põhineb sisend- ja väljundandmete korrelatsioonidel.

2. osa: keerulisem ülesanne

Sisend Väljund 0 0 1 0 0 1 1 1 1 0 1 1 1 1 1 0

Proovime prognoosida väljundandmeid kolme sisendandmete veeru põhjal. Ükski sisendveerg ei ole väljundiga 100% korrelatsioonis. Kolmas veerg ei ole üldse mitte millegagi seotud, kuna see sisaldab neid tervenisti. Siin on aga näha muster – kui ühes kahest esimesest veerust (kuid mitte mõlemast korraga) on 1, siis võrdub ka tulemus 1-ga.

See on mittelineaarne kujundus, kuna veergude vahel puudub otsene üks-ühele vastavus. Sobivus põhineb sisendite, veergude 1 ja 2 kombinatsioonil.

Huvitaval kombel on mustrituvastus väga sarnane ülesanne. Kui teil on 100 pilti sama suurusega jalgratastest ja torudest, ei ole teatud pikslite olemasolu teatud kohtades otseselt korrelatsioonis jalgratta või toru olemasoluga pildil. Statistiliselt võib nende värv olla juhuslik. Kuid mõned pikslite kombinatsioonid ei ole juhuslikud – need, mis moodustavad jalgratta (või toru) kujutise.

strateegia

Pikslite ühendamiseks millekski, millel võib olla väljundiga üks-ühele vastavus, peate lisama veel ühe kihi. Esimene kiht ühendab sisendi, teine ​​määrab väljundile vaste, kasutades sisendina esimese kihi väljundit. Pöörake tähelepanu lauale.

Sisend (l0) Varjatud kaalud (l1) Väljund (l2) 0 0 1 0,1 0,2 0,5 0,2 0 0 1 1 0,2 0,6 0,7 0,1 1 1 0 1 0,3 0,2 0,3 0,9 1 0,01 .30 1 0,21 .

Juhuslikult kaalude määramisel saame kihi nr 1 peidetud väärtused. Huvitaval kombel on teisel peidetud kaalude veerul juba väike korrelatsioon väljundiga. Pole ideaalne, aga seal. Ja see on ka võrgustiku koolitusprotsessi oluline osa. Treening ainult tugevdab seda korrelatsiooni. See värskendab syn1, et määrata selle vastendus väljundandmetele, ja syn0, et sisendandmeid paremini hankida.

Närvivõrk kolmes kihis

import numpy as np def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x)) X = np.massiiv([, , , ]) y = np.massiiv([, , , ]) np.random.seed(1) # initsialiseerige kaalud juhuslikult, keskmiselt - 0 syn0 = 2*np.random. juhuslik ((3,4)) - 1 syn1 = 2*np.random.random((4,1)) - 1 j jaoks in xrange(60000): # liigu edasi läbi kihtide 0, 1 ja 2 l0 = X l1 = nonlin(np.dot(l0,syn0)) l2 = nonlin(np.dot(l1,syn1)) # kui palju me nõutava väärtuse osas eksisime? l2_error = y - l2 if (j% 10000) == 0: print "Error:" + str(np.mean(np.abs(l2_error))) # kummale poole peaksite liikuma? # kui olime ennustuses kindlad, siis me ei pea seda palju muutma l2_delta = l2_error*nonlin(l2,deriv=True) # kui palju l1 väärtused mõjutavad l2 vigu? l1_error = l2_delta.dot(syn1.T) # mis suunas peaksime liikuma, et jõuda punkti l1? # kui olime ennustuses kindlad, siis ei pea me seda palju muutma l1_delta = l1_error * nonlin(l1,deriv=True) syn1 += l1.T.dot(l2_delta) syn0 += l0.T.dot (l1_delta)

Viga:0.496410031903 Viga:0.00858452565325 Viga:0.00578945986251 Viga:0.00462917677677 Viga:0.003958765or5280271025or528028.

Muutujad ja nende kirjeldused

X on sisendandmete kogumi maatriks; stringid - koolitusnäited
y – väljundandmestiku maatriks; stringid - koolitusnäited
l0 – sisendandmetega määratletud esimene võrgukiht
l1 – võrgu teine ​​kiht ehk peidetud kiht
l2 on viimane kiht, see on meie hüpotees. Harjutades peaksite õigele vastusele lähemale jõudma.
syn0 – kaalude esimene kiht Synapse 0 ühendab l0 ja l1.
syn1 – Teine raskuste kiht, Synapse 1, ühendab l1 ja l2.
l2_error – võrgu viga kvantitatiivselt
l2_delta – võrguviga, olenevalt ennustuse usaldusväärsusest. Peaaegu identne veaga, välja arvatud enesekindlad ennustused
l1_error – kaaludes l2_delta kaaludega alates syn1, arvutame vea keskmises/peidetud kihis
l1_delta – võrgu vead alates l1, skaleeritud prognooside usaldusväärsusega. Peaaegu identne l1_error-ga, välja arvatud kindlad ennustused

Kood peaks olema üsna selge – see on lihtsalt võrgu eelmine teostus, mis on laotud kahes kihis üksteise peale. Esimese kihi l1 väljund on teise kihi sisend. Midagi uut on alles järgmises reas.

L1_error = l2_delta.dot(syn1.T)

Kasutab l1 vea arvutamiseks l2 prognooside usaldusväärsusega kaalutud vigu. Võib öelda, et saame panustega kaalutud vea - arvutame, kui palju sõlmede l1 väärtused aitavad kaasa l2 vigadele. Seda sammu nimetatakse tagasipaljundamine vead. Seejärel värskendame syn0, kasutades sama algoritmi nagu kahekihiline närvivõrk.

Keras- populaarne raamatukogu sügav õppimine, mis on andnud suure panuse süvaõppe kommertsialiseerimisse. Kerast on lihtne kasutada ja see võimaldab luua närvivõrke vaid mõne Pythoni koodirea abil.

Sellest artiklist saate teada, kuidas Kerast kasutada närvivõrgu loomiseks, mis ennustab, kuidas kasutajad oma arvustuste põhjal toodet hindavad, jagades selle kahte kategooriasse: positiivne või negatiivne. Seda ülesannet nimetatakse sentiment analüüs (sentiment analysis), ja lahendame selle filmiarvustuste saidi IMDb abil. Meie ehitatavat mudelit saab pärast väiksemaid muudatusi rakendada ka muude probleemide lahendamiseks.

Pange tähele, et me ei käsitle Kerast ja süvaõpet üksikasjalikult. Selle postituse eesmärk on anda Keras skeem ja tutvustada selle rakendamist.

• Mis on Keras?
• Mis on sentimentianalüüs?
• Andmekogum IMDB
• Andmete uurimine
• Andmete ettevalmistamine
• Mudeli loomine ja koolitus

Mis on Keras?

Keras on avatud lähtekoodiga Pythoni teek lähtekood, mis teeb närvivõrkude loomise lihtsaks. Teek ühildub Microsoft Cognitive Toolkiti, Theano ja MXNetiga. Tensorflow ja Theano on süvaõppealgoritmide arendamiseks kõige sagedamini kasutatavad Pythoni arvraamistikud, kuid neid on üsna raske kasutada.

Masinõppe raamistike populaarsuse hindamine 7 kategoorias

Keras seevastu pakub lihtsat ja mugavat võimalust süvaõppe mudelite loomiseks. Selle looja François Chollet töötas selle välja, et kiirendada ja lihtsustada nii palju kui võimalik närvivõrkude loomise protsessi. Ta keskendus laiendatavusele, modulaarsusele, minimalismile ja Pythoni toele. Kerast saab kasutada koos GPU ja CPU-ga; see toetab nii Python 2 kui ka Python 3. Keras Google on andnud suure panuse süvaõppe kommertsialiseerimisse ja kuna see sisaldab tipptasemel süvaõppe algoritme, mis varem polnud mitte ainult kättesaamatud, vaid ka kasutuskõlbmatud.

Mis on sentimentanalüüs (sentimentanalüüs)?

Tundeanalüüsi abil saab määrata inimese suhtumise (st meeleolu) teksti, suhtlusse või sündmusesse. Seetõttu kuulub sentimentide analüüs töötlemise valdkonda loomulik keel, milles teksti tähendus tuleb lahti mõtestada, et sellest tonaalsust ja sentimenti välja tõmmata.

Sentimentianalüüsi skaala näide

Meeleoluspekter jaguneb tavaliselt positiivne, negatiivne ja neutraalne kategooriad. Sentimentanalüüsi abil saate näiteks nende kirjutatud arvustuste põhjal ennustada klientide arvamusi ja nende suhtumist tootesse. Seetõttu kasutatakse sentimentianalüüsi laialdaselt arvustuste, küsitluste, tekstide ja palju muu jaoks.

IMDb andmestik

Arvustused IMDb-s

IMDb andmestik koosneb 50 000 kasutajate filmiarvustusest, mis on märgistatud positiivseteks (1) ja negatiivseteks (0).

• Arvustused on eeltöödeldud ja igaüks neist on kodeeritud täisarvudena sõnaindeksite jadaga.
• Ülevaadetes olevad sõnad on indekseeritud nende üldise esinemissageduse alusel andmekogumis. Näiteks täisarv "2" kodeerib teist kõige sagedamini kasutatavat sõna.
• 50 000 arvustust on jagatud kahte komplekti: 25 000 koolituseks ja 25 000 testimiseks.

Andmestiku lõid Stanfordi ülikooli teadlased ja see esitati 2011. aasta artiklis, milles saavutatud ennustustäpsus oli 88,89%. Andmestikku kasutati ka Keggle'i kogukonna võistluse osana "Sõnakott kohtub popkorni kottidega" aastal 2011.

Sõltuvuste importimine ja andmete toomine

Alustame andmete eeltöötlemiseks ja mudeli koostamiseks vajalike sõltuvuste importimisest.

% matplotlib tekstisisene import matplotlib import matplotlib.pyplot as plt import numpy kui np saidilt keras.utils import to_categorical kerasest import mudelid kerase impordikihtidest

Laadime IMDb andmestiku, mis on juba Kerasse sisse ehitatud. Kuna me ei soovi omada 50/50 treening- ja testimisandmeid, ühendame need andmed kohe pärast laadimist hilisemaks jagamiseks vahekorras 80/20:

Alates keras.datasets importige imdb (treeningu_andmed, koolituse_eesmärgid), (testimise_andmed, testimise_eesmärgid) = imdb.load_data(sõnade_arv=10000) data = np.concatenate((treeningu_andmed, testimise_andmed), axis=0) targets =ingtatarna , testimise_sihtmärgid), telg=0)

Andmete uurimine

Uurime oma andmestikku:

Print("Kategooriad:", np.unique(targets)) print("Unikaalsete sõnade arv:", len(np.unique(np.hstack(data)))) Kategooriad: Unikaalsete sõnade arv: 9998 pikkus = print ("Keskmine läbivaatuse pikkus:", np.mean(length)) print("Standardhälve:", round(np.std(length))) Keskmine ülevaate pikkus: 234,75892 Standardhälve: 173,0

Näete, et kõik andmed jagunevad kahte kategooriasse: 0 või 1, mis tähistab ülevaate suhtumist. Kogu andmestik sisaldab 9998 unikaalset sõna, keskmine arvustuse suurus on 234 sõna standardhälbega 173.

Vaatame lihtsat õppimisviisi:

Print("Silt:", sihtmärgid) Silt: 1 print(andmed)

Siin näete andmestiku esimest arvustust, mis on märgitud positiivseks (1). Järgmine kood toodab pöördkonversioon indekseerib sõnadesse, et saaksime neid lugeda. Selles asendatakse iga tundmatu sõna tähega #. Seda tehakse funktsiooni abil hanki_sõna_indeks().

Index = imdb.get_word_index() reverse_index = dict([(väärtus, võti) jaoks (võti, väärtus) in index.items()]) decoded = " ".join() print(decoded) # see film oli lihtsalt suurepärane casting asukohaga stsenaariumi loo režissöör sobib kõigile väga sellele rollile, mida nad mängisid ja võite ette kujutada, et Robert # on suurepärane näitleja ja nüüd on sama lavastaja # isa pärit samalt Šoti saarelt nagu minagi, nii et mulle meeldis see, et seal oli tõeline seos selle filmiga Vaimukad märkused kogu filmi jooksul olid suurepärased, see oli lihtsalt nii suurepärane, et ostsin filmi kohe, kui see välja tuli, ja soovitan seda kõigil vaadata ja kärbsepüük oli hämmastav. lõpp, see oli nii kurb ja teate, mida nad ütlevad, kui filmi juures nutad, see pidi kindlasti hea olema ja see oli kindlasti ka # kahele poisile, kes mängisid Normani ja Pauli # nad olid lihtsalt geniaalsed lapsed minu arvates # nimekirjast välja jäetud sest staarid, kes neid kõiki täiskasvanuna mängivad, on kogu filmi jaoks nii suur profiil, kuid need lapsed on hämmastavad ja neid tuleks nende tehtu eest kiita, kas sa arvad, et kogu lugu oli nii armas, sest see oli tõsi ja oli kellegi oma elu pärast seda, mida meie kõigiga jagati

Andmete ettevalmistamine

On aeg andmed ette valmistada. Peame iga ülevaate vektoriseerima ja täitma selle nullidega, nii et vektoris oleks täpselt 10 000 numbrit. See tähendab, et täidame nullidega kõik arvustused, mis on lühemad kui 10 000 sõna. Seda tehakse seetõttu, et kõige suurepärane arvustus on peaaegu sama suur ja iga meie närvivõrgu sisendandmete element peaks olema sama suur. Samuti peate muutma muutujad tüübiks ujuk.

Def vektoriseerimine(järjestused, dimensioon = 10000): tulemused = np.nullid((len(jadad), dimensioon)) i jaoks, järjestus loenda(jadades): tulemused = 1 tagasta tulemuste andmed = vektoriseeri(andmed) sihtmärgid = np. array(targets).astype("float32")

Jagame andmekogumi treening- ja testimiskomplektideks. Koolituskomplekt hakkab koosnema 40 000 arvustusest, testimise komplekt 10 000 arvustusest.

Test_x = andmed[:10000] test_y = sihtmärgid[:10000] rong_x = andmed rongi_y = sihtmärgid

Mudeli loomine ja koolitus

Nüüd saate luua lihtsa närvivõrgu. Alustuseks määratleme mudeli tüübi, mida tahame luua. Kerases on saadaval kahte tüüpi mudeleid: järjestikune ja funktsionaalne API.

Seejärel tuleb lisada sisend-, peidetud ja väljundkihid. Ülepaigutamise vältimiseks kasutame nende vahel erandit ( "välja kukkuma"). Pange tähele, et peaksite alati kasutama välistamismäära vahemikus 20% kuni 50%. Iga kiht kasutab funktsiooni "tihe" kihtide täielikuks ühendamiseks üksteisega. Peidetud kihtides kasutame "relu", sest see viib peaaegu alati rahuldavate tulemusteni. Ärge kartke katsetada teiste aktiveerimisfunktsioonidega. Väljundkihis kasutame sigmoidfunktsiooni, mis normaliseerib väärtused vahemikus 0 kuni 1. Pange tähele, et seadsime sisendandmestiku elementide suuruseks 10 000, kuna meie ülevaated on kuni 10 000 täisarvu suurused. Sisendkiht aktsepteerib elemente suurusega 10 000 ja väljastab elemente suurusega 50.

Lõpetuseks laske Kerasel printida äsja loodud mudeli lühike kirjeldus.

# Input - Layer model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Hidden - Layers model.add(layers.Dropout(0.3, noise_shape=None, seed=none) ) model.add(layers.Dense(50, activation = "relu") model.add(layers.Dropout(0.2, noise_shape=None, seed=None)) model.add(layers.Dense(50, activation = "relu" ")) # Väljund- Layer model.add(layers.Dense(1, activation = "sigmoid"))model.summary() model.summary() ___________________________________________________________________ Kiht (tüüp) Väljundkuju parameeter # ======= ==================================================== === ======== tihe_1 (Tihe) (Puudub, 50) 500050 __________________________________________________________________ väljalangevus_1 (Väljalangevus) (Puudub, 50) 0 ____________________________________________________________________________ tihe_2 (tihe) (tihe) (_______________________________________ tihe_2 (tihe) (Tihe)_________________2 (________________2, ______________________2 ropout) (Puudub , 50) 0 _______________________________________________________________________ tihe_3 (tihe) (puudub, 50) 2550 __________________________________________________________________ tihe_4 (tihe) (puudub, 1) 51 ===================== ========================== Parameetrid kokku: 505 201 treenitavad parameetrid: 505 201 mittekoolitavad parameetrid: 0 ___________________________________________________________________________

Nüüd peame oma mudeli koostama ehk sisuliselt koolituse jaoks seadistama. Me kasutame optimeerija "adam". Optimeerija on algoritm, mis muudab treeningu ajal raskusi ja eelarvamusi. Nagu kaotusfunktsioonid Hindamismõõdikuna kasutame binaarset ristentroopiat (kuna töötame binaarse klassifikatsiooniga), täpsust.

Model.comile(optimizer = "adam", loss = "binary_crossentropy", mõõdikud = ["täpsus"])

Nüüd saame oma mudelit koolitada. Teeme seda partii suurusega 500 ja ainult kahe epohhiga, nagu ma sellest teada sain mudel hakkab ümberõppima, kui treenite seda kauem. Partii suurus määrab elementide arvu, mis jaotatakse kogu võrgus, ja epohh on üks kogu andmestiku elementide läbimine. Tavaliselt suurem suurus partii viib kiirema õppimiseni, kuid mitte alati kiire lähenemiseni. Väiksem partii treenib aeglasemalt, kuid võib kiiremini läheneda. Ühe või teise valik sõltub kindlasti lahendatava probleemi tüübist ja parem on proovida igaüks neist. Kui olete selle kasutaja jaoks uus, soovitan teil seda esmalt kasutada partii suurus 32, mis on omamoodi standard.

Tulemused = model.fit(train_x, train_y, epochs = 2, batch_size = 500, validation_data = (test_x, test_y)) Treenige 40 000 prooviga, kinnitage 10 000 prooviga Epoch 1/2 40000/4000= = =======================] - 5 s 129us/samm - kaotus: 0,4051 - acc: 0,8212 - val_loss: 0,2635 - val_acc: 0,8945 Epoch 2/2 40000 /40000 [=============================] - 4 s 90us/samm - kaotus: 0,2122 - acc: 0,9190 - val_loss: 0,2598 - val_acc: 0,8950

Hindame mudeli jõudlust:

Print(np.mean(tulemused.ajalugu["val_acc"])) 0,894750000536

Suurepärane! Meie lihtne mudel on juba 2011. aasta artiklis ületanud täpsusrekordi postituse alguses mainitud. Katsetage julgelt võrguparameetrite ja kihtide arvuga.

Täielik mudelikood on toodud allpool:

Import numpy as np from keras.utils import to_categorical from keras import mudelid kerasest impordi kihid saidilt keras.datasets import imdb (treeningu_andmed, koolituse_eesmärgid), (testing_data, testing_targets) = imdb.load_data(num_words=10000) data (treeningu_andmed, testimise_andmed), telg=0) eesmärgid = np.concatenate((treeningu_sihtmärgid, testimise_eesmärgid), telg=0) def vektoriseerimine(järjestused, dimensioon = 10000): tulemused = np.zeros((len(järjed), dimensioon) ) i jaoks jada loendis (järjestustes): tulemused = 1 tagastab tulemused andmed = vektoriseeri(andmed) targets = np.array(targets).astype("float32") test_x = andmed[:10000] test_y = sihtmärgid[:10000 ] train_x = data train_y = targets model = models.Sequential() # Input - Layers model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Hidden - Layers model.add( layers.Dropout(0.3, noise_shape=Puudub, seed=Puudub)) model.add(layers.Dense(50, activation = "relu")) model.add(layers.Dropout(0.2, noise_shape=Puudub, seed=puudub) ) model.add(layers.Dense(50, activation = "relu")) # Väljund- Layer model.add(layers.Dense(1, activation = "sigmoid")) model.summary() # mudeli mudeli koostamine. kompile(optimizer = "adam", loss = "binary_crossentropy", mõõdikud = ["täpsus"]) tulemused = model.fit(rong_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) print( "Test-Accuracy:", np.mean(results.history["val_acc"]))

Tulemused

Saite teada, mis on sentimentide analüüs ja miks on Keras üks populaarsemaid süvaõppe raamatukogusid.

Lõime lihtsa kuue kihiga närvivõrgu, mis suudab 89% täpsusega arvutada filmiarvustajate meeleolu. Nüüd saate seda mudelit kasutada binaarsete tunnete analüüsimiseks teistes allikates, kuid selleks peate muutma nende suuruseks 10 000 või muutma sisendkihi parameetreid.

Seda mudelit (väikeste muudatustega) saab rakendada muude masinõppeprobleemide puhul.

Tehisnärvivõrgud (ANN) on matemaatilised mudelid, samuti nende tarkvara- või riistvararakendused, mis on üles ehitatud bioloogiliste närvivõrkude – elusorganismi närvirakkude võrgustike – organiseerimise ja toimimise põhimõttele.

ANN-id on ühendatud ja interakteeruv süsteem lihtsad protsessorid(kunstlikud neuronid).

Närvivõrke ei programmeerita selle sõna tavapärases tähenduses, neid treenitakse. Õppimisvõime on närvivõrkude üks peamisi eeliseid traditsiooniliste algoritmide ees. wikipedia

Närvivõrgud olid inspireeritud meie enda ajust. Standardne neuronimudel leiutati enam kui viiskümmend aastat tagasi ja koosneb kolmest põhiosast:

• Dentriit(id)- vastutab sissetulevate signaalide kogumise eest;
• Soma- vastutab signaalide põhitöötluse ja summeerimise eest;
• Axon- vastutab signaalide edastamise eest teistele dendriitidele.

Neuronite tööd võib kirjeldada umbes nii: dendriidid koguvad teistelt neuronitelt saadud signaale, seejärel sooritavad somad signaalide ja andmete summeerimise ja arvutamise ning lõpuks saavad nad töötlemise tulemuse põhjal aksonitele “käsku” edastada signaali edasi. Ülekanne sõltub veel paljudest teguritest, kuid me saame seda käitumist modelleerida ülekandefunktsioonina, mis võtab sisendeid, töötleb neid ja valmistab ette väljundid, kui ülekandefunktsiooni omadused on täidetud.

Bioloogiline neuron on keeruline süsteem, matemaatiline mudel mis pole veel täielikult välja ehitatud. Kasutusele on võetud palju mudeleid, mille arvutuslik keerukus ja sarnasus reaalse neuroniga on erinev. Üks olulisemaid on formaalne neuron (FN). Vaatamata funktsionaalse funktsiooni lihtsusele võivad sellistest neuronitest ehitatud võrgud moodustada väljundis suvalise mitmemõõtmelise funktsiooni (allikas: Zaentsev I.V. Neuraalvõrgud: põhimudelid).

Neuron koosneb kaalutud liitjast ja mittelineaarsest elemendist. Neuronite toimimine määratakse järgmiste valemitega:

Neuronil on mitu sisendit x ja üks väljundsignaal VÄLJAS. Neuroni talitlust määravad parameetrid on: kaalude vektor w, lävitase θ ja aktiveerimisfunktsiooni tüüp F.

Närvivõrgud tõmbavad tähelepanu järgmiste võimaluste tõttu:

• oskab lahendada raskesti vormistatavaid probleeme;
• on omane paralleelne tööpõhimõte, mis on väga oluline suurte andmemahtude töötlemisel;
• õppimisvõime ja üldistusvõime;
• tolerantsus vigade suhtes;

Närvivõrkude peamised omadused on järgmised:

Õppimisvõime. Närvivõrke ei programmeerita, vaid neid õpetatakse näidete abil. Kui sisendsignaalid on esitatud (võimalik, et koos nõutavate väljunditega), kohandab võrk oma parameetreid, et anda nõutud vastus.

Üldistus. Võrgu reaktsioon pärast treeningut võib olla sisendsignaalide väikeste muutuste suhtes mõnevõrra tundetu. See loomupärane võime "näha" mustrit läbi müra ja moonutuste on mustrituvastuse jaoks väga oluline. Oluline on märkida, et tehisnärvivõrk teeb üldistusi automaatselt tänu oma disainile, mitte kasutades "intelligentsi" spetsiaalselt kirjutatud arvutiprogrammide kujul.

Paralleelsus. Võrgu infot töödeldakse paralleelselt, mis võimaldab teostada üsna keerulist andmetöötlust suure hulga lihtsate seadmete abil.

Kõrge töökindlus. Võrk võib korralikult toimida isegi siis, kui mõned neuronid ebaõnnestuvad, kuna arvutused tehakse lokaalselt ja paralleelselt.

Algoritm ülesannete lahendamiseks mitmekihilise pertseptroni abil(allikas: Zaentsev I.V. Neuraalvõrgud: põhimudelid)

Mitmekihilise perceptroni ehitamiseks peate valima selle parameetrid. Kõige sagedamini nõuab raskuste ja lävede väärtuste valimine treenimist, s.t. samm-sammult muudatused kaalukoefitsiendid ja lävetasemed.

Üldine lahendusalgoritm:

1. Määrake, mis tähendus on sisendvektori komponentidele pandud x. Sisendvektor peab sisaldama ülesande formaliseeritud tingimust, s.t. kogu vastuse saamiseks vajalik teave.
2. Valige väljundvektor y nii, et selle komponendid sisaldaksid ülesande täielikku vastust.
3. Valige neuronite mittelineaarsuse tüüp (aktiveerimisfunktsioon). Sel juhul on soovitav arvestada ülesande eripäraga, sest Hea valik vähendab treeninguaega.
4. Valige kihtide ja neuronite arv kihis.
5. Seadistage sisendite, väljundite, kaalude ja lävitasemete muudatuste vahemik, võttes arvesse valitud aktiveerimisfunktsiooni väärtuste komplekti.
6. Määrake algväärtused kaaludele ja lävetasemetele ning lisaparameetrid(näiteks aktiveerimisfunktsiooni järsus, kui seda treeningu ajal reguleeritakse). Algväärtused ei tohiks olla suured, et neuronid ei küllastu (aktiveerimisfunktsiooni horisontaalses osas), vastasel juhul on õppimine väga aeglane. Algväärtused ei tohiks olla liiga väikesed, et enamiku neuronite väljundid ei oleks nulliga võrdsed, vastasel juhul aeglustub ka õppimine.
7. Viia läbi koolitusi, s.o. probleemi lahendamiseks valige võrguparameetrid parim viis. Kui koolitus on lõppenud, on võrgustik valmis lahendama seda tüüpi probleeme, mille jaoks see välja õpetati.
8. Esitage probleemi tingimused võrgusisendisse vektori kujul x. Arvutage väljundvektor y, mis annab probleemile ametliku lahenduse.

Probleemid, mida tuleb lahendada

Närvivõrkude abil lahendatud probleemid ().

Piltide klassifikatsioon. Ülesanne on näidata tunnusvektoriga esindatud sisendkujutise (näiteks kõnesignaali või käsitsi kirjutatud märgi) kuuluvust ühte või mitmesse etteantud klassi. Märkimisväärsed rakendused hõlmavad tähetuvastust, kõnetuvastust, elektrokardiogrammi signaalide klassifikatsiooni ja vererakkude klassifikatsiooni.

Klasterdamine/kategoriseerimine. Klasterdamisprobleemi lahendamisel, mida tuntakse ka kui järelevalveta kujutiste klassifitseerimist, puudub klassi siltidega koolituskomplekt. Klasterdamisalgoritm põhineb kujutiste sarnasusel ja paigutab sarnased pildid ühte klastrisse. Teadmiste kogumiseks, andmete tihendamiseks ja andmete atribuutide uurimiseks kasutatakse klastrite kasutamise juhtumeid.

Funktsiooni lähendamine. Oletame, et on olemas treeningnäidis ((x1,y1), (x2,y2)..., (xn,yn)) (sisend-väljundandmepaarid), mille genereerib tundmatu funktsioon (x), mida rikub müra. Lähenduse ülesanne on leida hinnang tundmatu funktsiooni (x) jaoks. Funktsioonide lähendamine on vajalik paljude inseneri- ja teaduslike modelleerimisprobleemide lahendamisel.

Ennustus/prognoos. Olgu järjestikustel ajahetkedel t1, t2,..., tn antud n diskreetset valimit (y(t1), y(t2)..., y(tn)). Ülesandeks on ennustada y(tn+1) väärtus mingil tulevasel ajahetkel tn+1. Ennustamine/prognoosimine mõjutab oluliselt otsuste tegemist äris, teaduses ja tehnoloogias. Börsihindade ennustamine ja ilmaennustamine on ennustamis-/ennustustehnikate tüüpilised rakendused.

Optimeerimine. Optimeerimisprobleemideks võib pidada arvukaid probleeme matemaatikas, statistikas, inseneriteaduses, loodusteadustes, meditsiinis ja majanduses. Optimeerimisalgoritmi ülesanne on leida lahendus, mis rahuldab piirangute süsteemi ja maksimeerib või minimeerib sihtfunktsioon. Rändmüüja probleem, mis kuulub NP-täieliku klassi, on klassikaline näide optimeerimisülesandest.

Sisu adresseeritav mälu. Von Neumanni arvutusmudelis pääseb mällu ligi ainult aadressi kaudu, mis on mälu sisust sõltumatu. Veelgi enam, kui aadressi arvutamisel tehakse viga, võib leida hoopis teistsugust teavet. Assotsiatiivne mälu, või sisu-aadresseeritav mälu, on juurdepääsetav etteantud sisu määramisega. Mälu sisu saab meelde tuletada isegi osalise sisendi või rikutud sisu korral. Assotsiatiivne mälu on multimeedia teabeandmebaaside loomisel äärmiselt soovitav.

Kontroll. Mõelgem dünaamiline süsteem, määratud hulgaga (u(t), y(t)), kus u(t) on sisendi juhtimistoiming ja y(t) on süsteemi väljund ajahetkel t. Juhtsüsteemides koos võrdlusmudel Juhtimise eesmärk on arvutada sisendtegevus u(t) nii, et süsteem järgiks võrdlusmudeli dikteeritud soovitud trajektoori. Näiteks on optimaalne mootori juhtimine.

Arhitektuuri tüübid

Närvivõrgu arhitektuur- organiseerimis- ja suhtlemisviis üksikud elemendid närvivõrk (neuronid). Arhitektuurilised erinevused neuronite endi vahel seisnevad peamiselt erinevate aktiveerimis- (ergastavate) funktsioonide kasutamises. Ühenduste arhitektuuri alusel võib närvivõrgud jagada kahte klassi: edasisuunalised võrgud ja korduvad võrgud.

Tehisnärvivõrkude klassifikatsioon nende arhitektuuri järgi on näidatud alloleval joonisel.

Sarnane klassifikatsioon, kuid veidi laiendatud

Edasisignaali jaotusvõrk (edastusvõrk)- närvivõrk ilma tagasisideta (silmused). Sellises võrgus on infotöötlus ühesuunaline: signaal edastatakse kihist kihti suunas närvivõrgu sisendkihist väljundkihti. Väljundsignaal (võrgu vastus) on tagatud eelnevalt kindlaksmääratud sammude arvuga (võrdne kihtide arvuga). Tagasisidevõrke on lihtne rakendada ja hästi uuritud. Keeruliste probleemide lahendamiseks on vaja suurt hulka neuroneid.

võrdlustabel mitmekihiline tajuja Ja RBF võrgud

Mitmekihiline pertseptron	RBF võrgud
Otsustuspiir on hüpertasandite ristumiskoht	Otsustuspiir on hüpersfääride ristumiskoht, mis määrab keerulisema kujuga piiri
Neuronite ja kihtide vaheliste ühenduste kompleksne topoloogia	Lihtne 2-kihiline närvivõrk
Keeruline ja aeglaselt koonduv õppealgoritm	Kiire koolitusprotseduur: võrrandisüsteemi lahendamine + klasterdamine
Väikese koolitusnäidise kallal töötamine	Vastuvõetava tulemuse saavutamiseks on vaja märkimisväärset hulka treeningandmeid
Rakenduse universaalsus: rühmitamine, lähendamine, juhtimine jne.	Tavaliselt ainult funktsioonide lähendamine ja rühmitamine

Tuletise väärtust on lihtne väljendada funktsiooni enda kaudu. Kiire tuletise arvutamine kiirendab õppimist.

Gaussi kõver

Seda kasutatakse juhtudel, kui neuronite vastus peaks olema mingi konkreetse NET-väärtuse korral maksimaalne.

Pythoni moodulid närvivõrkude jaoks

Lihtne näide

Näitena toon lihtsa närvivõrgu (lihtne pertseptron), mis pärast treeningut suudab ära tunda lendavaid objekte, mitte kõiki, vaid ainult kajakas:), tuvastatakse kõik muud sisendpildid kui UFO.

# encoding=utf8 impordi juhuslik klass NN: def __init__(self, lävi, suurus): """ Määrake esialgsed parameetrid. """ self.threshold = lävi self.size = suurus self.init_weight() def init_weight(self) : """ Initsialiseerige kaalude maatriks juhuslike andmetega. """ self.weights = [ j jaoks xrange(self.size)] def check(self, sample): """ Näidispildi väljundsignaali lugemine. Kui vsum > ise. lävi, siis võime eeldada, et valim sisaldab kajaka kujutist. """ vsum = 0 i jaoks xvahemikus(self.size): j puhul xvahemikus(self.size): vsum += self .weights[i][j] * sample[i][j] if vsum > self.threshold: return Tõene else: return Väär def teach(self, sample): """ Närvivõrgu treenimine. """ i jaoks in xrange(self.size): for j in xrange(self.size): self.weights[i][j] += sample[i][j] nn = NN(20, 6) # Treeni närvivõrku. tsample1 = [ , , , , , , ] nn.teach(tsample1) tsample2 = [ , , , , , , ] nn.teach(tsample2) tsample3 = [ , , , , , , ] nnsample3 =)(tsample3 =) [ , , , , , , ] nn.teach(tsample4) # Kontrollime, mida suudab närvivõrk. # Edastame kajaka kujutise, mis on ligikaudu sarnane sellega, millest pertseptron teab. wsample1 = [ , , , , , , ] prindi u"kajakas", kui nn.check(wsample1) else u"UFO" # Saada tundmatu pilt. wsample2 = [ , , , , , , ] prindi u"kajakas" if nn.check(wsample2) else u"UFO" # Edastame kajaka kujutise, mis on ligikaudu sarnane sellega, mida pertseptron teab. wsample3 = [ , , , , , , ] prindi u"kajakas", kui nn.check(wsample3) muidu u"UFO"