Ovaj dio sadrži poveznice na članke iz RuNeta o tome što su neuronske mreže. Mnogi su članci napisani izvornim, živim jezikom i vrlo su razumljivi. Međutim, ovdje se uglavnom razmatraju samo osnove, najjednostavniji dizajni. Ovdje možete pronaći i poveznice na literaturu o neuronskim mrežama. Udžbenici i knjige, kao što bi i trebali biti, napisani su akademskim ili sličnim jezikom i sadrže opskurne, apstraktne primjere izgradnje neuronskih mreža, njihove obuke itd. Treba imati na umu da terminologija u različitim člancima „lebdi“, kao što vidi se iz komentara na članke. Zbog toga u početku može biti "nered u glavi".

• Kako je japanski farmer sortirao krastavce koristeći duboko učenje i TensorFlow
• Neuronske mreže u slikama: od jednog neurona do dubokih arhitektura
• Primjer programa neuronske mreže s izvornim kodom u C++.
• Implementacija jednoslojne neuronske mreže - perceptrona za problem klasifikacije vozila
• Preuzmite knjige o neuronskim mrežama. Zdrav!
• Tehnologije burze: 10 zabluda o neuronskim mrežama
• Algoritam za treniranje višeslojne neuronske mreže metodom povratnog širenja

Neuronske mreže u Pythonu

Možete ukratko pročitati koje biblioteke postoje za Python. Odavde ću uzeti testne primjere kako bih bio siguran da je traženi paket ispravno instaliran.

tenzorski tok

Središnji objekt TensorFlowa je graf toka podataka koji predstavlja izračun. Vrhovi grafa predstavljaju operacije, a bridovi tenzore (tenzor) ( višedimenzionalni nizovi, koji su osnova TensorFlowa). Graf protoka podataka u cjelini je puni opis izračuni koji se implementiraju unutar sesije i izvode na uređajima (CPU ili GPU). Kao i mnogi drugi moderni sustavi za znanstveno računalstvo i strojno učenje TensorFlow ima dobro dokumentiran API za Python, gdje su tenzori predstavljeni kao poznati nizovi NumPy ndarray. TensorFlow izvodi izračune koristeći visoko optimizirani C++ i također podržava izvorne API-je za C i C++.

• Uvod u strojno učenje s tensorflowom. Do sada je objavljen samo prvi članak od četiri najavljena.
• TensorFlow je razočaravajući. Googleovom dubokom učenju nedostaje "dubina"
• Strojno učenje na prvi pogled: Klasifikacija teksta s neuronskim mrežama i TensorFlow
• Google TensorFlow biblioteka strojnog učenja – prvi dojmovi i usporedba s našom vlastitom implementacijom

Instalacija tensorflowa je dobro opisana u članku na prvom linku. Međutim, sada je objavljen Python 3.6.1. Neće ga biti moguće koristiti. Barem sumpor u ovom trenutku (03.06.2017.). Zahtijeva verziju 3.5.3, koja se može preuzeti. U nastavku ću dati slijed koji je kod mene radio (malo drugačije od članka s Habra). Nije jasno zašto, ali Python 64-bit je stvoren za AMD procesor sukladno tome, sve ostalo ide pod to. Nakon instaliranja Phytona, ne zaboravite postaviti puni pristup za korisnike ako je Python instaliran za sve.

pip instaliraj --nadogradi pip
pip install -U alati za postavljanje pip-a
pip3 instaliraj --nadogradi tensorflow
pip3 instalacija --nadogradnja tensorflow-gpu
pip install matplotlib /*Preuzima 8,9 MB i još par malih datoteka */
pip instaliraj jupyter

"Goli Python" se može činiti nezanimljivim. Stoga su u nastavku upute za instalaciju u okruženju Anaconda. Ovo je alternativna konstrukcija. Python već integrirani u njega.

Stranica ponovno sadrži novu verziju za Python 3.6, koju novi Google proizvod još ne podržava. Stoga sam odmah uzeo prethodnu verziju iz arhive, naime Anaconda3-4.2.0 - prikladna je. Ne zaboravite označiti okvir za registraciju Python 3.5. Naime, prije instaliranja Anaconde, bolje je zatvoriti terminal, inače će nastaviti raditi sa zastarjelim PATH-om. Također, ne zaboravite promijeniti korisnička prava pristupa, inače ništa neće raditi.

conda stvoriti -n tenzorski tok
aktivirati tensorflow
pip install --ignore-installed --upgrade https://storage.googleapis.com/tensorflow/windows/cpu/tensorflow-1.1.0-cp35-cp35m-win_amd64.whl /*Preuzeto s interneta 19,4 MB, zatim 7 , 7 MB i još 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 /*Preuzmi 48,6 MB */

Snimka zaslona instalacijskog zaslona: sve ide dobro u Anacondi.

Isto tako i za drugu datoteku.

Pa, u zaključku: da bi sve ovo radilo, trebate instalirati paket CUDA Toolkits od NVIDEA (u slučaju Upotreba GPU-a). Trenutna podržana verzija je 8.0. Također ćete morati preuzeti i raspakirati biblioteku cuDNN v5.1 u mapu CUDA, ali ne noviju verziju! Nakon svih ovih manipulacija, TensorFlow će raditi.

Theano

• Rekurentna neuronska mreža u 10 redaka koda procijenila je povratne informacije gledatelja nove epizode "Ratova zvijezda"

Theano paket uključen je u Pythonov vlastiti PyPI. Sam po sebi je mali - 3,1 MB, ali vuče još 15 MB ovisnosti - scipy. Za instalaciju potonjeg potreban vam je i lapack modul... Općenito, instalacija theano paketa pod Windowsima značit će “plesanje uz tamburicu”. U nastavku ću pokušati prikazati redoslijed radnji kako bi paket funkcionirao.

Kada koristite Anacondu, "ples s tamburinom" tijekom instalacije nije relevantan. Dovoljna je naredba:

conda instalirati theano

a proces se odvija automatski. Usput, učitavaju se i GCC paketi.

Scikit-Learn

Pod Python 3.5.3, samo više od rana verzija 0.17.1 koji možete uzeti. Postoji normalan instalater. Međutim, neće raditi izravno u sustavu Windows - potrebna vam je biblioteka scipy.

Instaliranje pomoćnih paketa

Kako bi gornja dva paketa radila (govorimo o “golom” Phytonu), morate napraviti neke preliminarne korake.

SciPy

Da biste pokrenuli Scikit-Learn i Theano, kao što je već postalo jasno iz gore navedenog, morat ćete "plesati s tamburinom". Prvo što nam Yandex daje je skladište mudrosti, doduše na engleskom, resurs stackoverflow.com, gdje nalazimo poveznicu na izvrsnu arhivu gotovo svih postojećih Python paketa kompiliranih za Windows - lfd.uci.edu

Ovdje se nalaze sklopovi spremni za instalaciju paketa koji vas trenutno zanimaju, kompilirani za njih različite verzije Piton. U našem slučaju potrebne su verzije datoteka koje u nazivu sadrže redak "-cp35-win_amd64" jer je to upravo ono Python paket korišten je za instalaciju. Na stakowerflowu, ako pretražujete, također možete pronaći “upute” za instaliranje naših posebnih paketa.

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

Zadnja dva paketa pojavila su se u mom lancu zbog tuđeg "plesa uz tamburicu". Nisam ih primijetio u ovisnostima instaliranih paketa, ali očito su neke od njihovih komponenti potrebne za normalan proces instalacije.

Lapak/Blas

Ove dvije povezane biblioteke niske razine, napisane u Fortranu, potrebne su za instalaciju paketa Theano. Scikit-Learn također može raditi na onima koji su već instalirani "skriveno" u drugim paketima (vidi gore). Zapravo, ako je Theano verzija 0.17 instalirana iz exe datoteke, također će raditi. Barem u Anacondi. No, te se knjižnice mogu naći i na internetu. Na primjer . Novije verzije. Da bi gotov paket radio prethodna verzija Prikladan je. Izrada novog paketa će zahtijevati nove verzije.

Također treba napomenuti da se u potpuno svježoj verziji Anaconde paket Theano instalira puno lakše - jednom naredbom, ali da budem iskren, nije me briga u ovoj fazi(nula) svladavajući neuronske mreže, više mi se svidio TensorFlow, ali još nije prijateljski raspoložen s novim verzijama Pythona.

Programiranje

• Prijevod

O čemu je članak?

Osobno najbolje učim s malim radnim kodom s kojim se mogu igrati. U ovom vodiču naučit ćemo algoritam povratnog širenja koristeći malu neuronsku mrežu implementiranu u Pythonu kao primjer.

Daj mi šifru!

X = np.array([ ,,, ]) y = np.array([]).T syn0 = 2*np.random.random((3,4)) - 1 syn1 = 2*np.random.random ((4,1)) - 1 za j u xrange(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)

Previše komprimiran? Podijelimo ga na jednostavnije dijelove.

Dio 1: Neuralna mreža malih igračaka

Neuronska mreža uvježbana povratnim širenjem pokušava upotrijebiti ulazne podatke za predviđanje izlaznih podataka.

Recimo da trebamo predvidjeti kako će izlazni stupac izgledati na temelju ulaznih podataka. Ovaj bi se problem mogao riješiti izračunavanjem statističke korespondencije između njih. I vidjeli bismo da je lijevi stupac 100% u korelaciji s izlazom.

Širenje unatrag, u svom najjednostavnijem slučaju, izračunava slične statistike za stvaranje modela. Pokušajmo.

Neuronska mreža u dva sloja

import numpy kao np # Sigmoid def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x) )) # ulazni skup podataka X = np.array([ , , , ]) # izlazni podaci y = np.array([]).T # do slučajni brojevi specifičnije np.random.seed(1) # nasumično inicijalizira težine s prosječnom 0 syn0 = 2*np.random.random((3,1)) - 1 za iter u xrange(10000): # širenje naprijed l0 = X l1 = nonlin(np.dot(l0,syn0)) # koliko smo bili u krivu? l1_greška = y - l1 # pomnožite ovo sa nagibom sigmoide # na temelju vrijednosti u l1 l1_delta = l1_greška * nonlin(l1,True) # !!! # ažurirajte težine syn0 += np.dot(l0.T,l1_delta) # !!! print "Rezultat nakon treninga:" print l1

Učinak nakon treninga: [[ 0,00966449] [ 0,00786506] [ 0,99358898] [ 0,99211957]]

Varijable i njihovi opisi.

"*" - elementno množenje - dva vektora iste veličine množe odgovarajuće vrijednosti, a izlaz je vektor iste veličine
"-" – elementno oduzimanje vektora
x.dot(y) – ako su x i y vektori, tada će izlaz biti skalarni produkt. Ako su to matrice, rezultat je množenje matrica. Ako je matrica samo jedna od njih, to je množenje vektora i matrice.

• usporedite l1 nakon prve iteracije i nakon posljednje
• pogledajte nonlin funkciju.
• pogledajte kako se l1_error mijenja
• parse line 36 - glavni tajni sastojci su prikupljeni ovdje (označeno!!!)
• parse line 39 - cijela mreža se priprema upravo za ovu operaciju (označeno!!!)

Raščlanimo kod redak po redak

uvezi numpy kao np

Uvozi numpy, biblioteku linearne algebre. Naša jedina ovisnost.

Def nonlin(x,deriv=False):

Naša nelinearnost. Ova posebna funkcija stvara "sigmoid". Spaja bilo koji broj s vrijednošću od 0 do 1 i pretvara brojeve u vjerojatnosti, a također ima nekoliko drugih svojstava korisnih za obuku neuronskih mreža.

If(deriv==True):

Ova funkcija također može proizvesti derivaciju sigmoide (deriv=True). Ovo je jedno od njegovih korisnih svojstava. Ako je izlaz funkcije izlazna varijabla, tada će derivat biti out * (1-out). Učinkovito.

X = np.array([ , …

Inicijaliziranje niza ulaznih podataka kao numpy matrice. Svaki je redak primjer obuke. Stupci su ulazni čvorovi. Na kraju imamo 3 ulazna čvora u mreži i 4 primjera obuke.

Y = np.niz([]).T

Inicijalizira izlazne podatke. ".T" – prijenosna funkcija. Nakon translacije, y matrica ima 4 retka s jednim stupcem. Kao i kod ulaznih podataka, svaki red je primjer za obuku, a svaki stupac (jedan u našem slučaju) je izlazni čvor. Ispada da mreža ima 3 ulaza i 1 izlaz.

Np.random.seed(1)

Zahvaljujući tome, nasumična distribucija će svaki put biti ista. To će nam omogućiti lakši nadzor mreže nakon što izvršimo izmjene koda.

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

Matrica mrežne težine. syn0 znači "nula sinapse". Budući da imamo samo dva sloja, ulaz i izlaz, potrebna nam je jedna težinska matrica koja će ih povezati. Njegova dimenzija je (3, 1), jer imamo 3 ulaza i 1 izlaz. Drugim riječima, l0 ima veličinu 3, a l1 ima veličinu 1. Budući da povezujemo sve čvorove u l0 sa svim čvorovima u l1, potrebna nam je matrica dimenzije (3, 1).

Imajte na umu da se inicijalizira nasumično i da je srednja vrijednost nula. Iza toga stoji prilično složena teorija. Za sada ćemo ovo uzeti samo kao preporuku. Također imajte na umu da je naša neuronska mreža upravo ova matrica. Imamo "slojeve" l0 i l1, ali to su privremene vrijednosti temeljene na skupu podataka. Ne skladištimo ih. Sva obuka je pohranjena u syn0.

Za iter u xrange(10000):

Ovdje počinje glavni mrežni kod za obuku. Petlja koda se ponavlja mnogo puta i optimizira mrežu za skup podataka.

Prvi sloj, l0, samo su podaci. X sadrži 4 primjera obuke. Obradit ćemo ih sve odjednom – to se zove grupni trening. Ukupno imamo 4 različite linije l0, ali o njima možete razmišljati kao o jednom primjeru obuke - u ovoj fazi to nije važno (mogli biste ih učitati 1000 ili 10000 bez ikakvih promjena u kodu).

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

Ovo je korak predviđanja. Dopuštamo mreži da pokuša predvidjeti izlaz na temelju ulaza. Zatim ćemo vidjeti kako ona to radi pa je možemo prilagoditi za poboljšanje.

Postoje dva koraka po redu. Prvi radi matrično množenje l0 i syn0. Drugi prolazi izlaz kroz sigmoidu. Njihove dimenzije su sljedeće:

(4 x 3) točka (3 x 1) = (4 x 1)

Množenje matrica zahtijeva da dimenzije budu iste u sredini jednadžbe. Konačna matrica ima isti broj redaka kao prva i isti broj stupaca kao druga.

Učitali smo 4 primjera obuke i dobili 4 pogađanja (4x1 matrica). Svaki izlaz odgovara pretpostavci mreže za dati ulaz.

L1_greška = y - l1

Budući da l1 sadrži pretpostavke, njihovu razliku sa stvarnošću možemo usporediti oduzimanjem l1 od točnog odgovora y. l1_error je vektor pozitivnih i negativnih brojeva koji karakterizira "promašaj" mreže.

A evo i tajnog sastojka. Ovu liniju treba raščlaniti dio po dio.

Prvi dio: izvedenica

Nelin(l1,Istina)

L1 predstavlja ove tri točke, a kod proizvodi nagib linija prikazanih u nastavku. Imajte na umu da za velike vrijednosti kao što je x=2,0 (zelena točka) i vrlo male vrijednosti kao što je x=-1,0 (ljubičasta) linije imaju blagi nagib. Najveći kut u točki x=0 (plavo). Ovo čini veliku razliku. Također imajte na umu da su sve derivacije u rasponu od 0 do 1.

Potpuni izraz: derivacija ponderirana greškom

L1_delta = l1_greška * nonlin(l1,True)

Matematički, postoje preciznije metode, ali u našem slučaju ova je također prikladna. l1_greška je (4,1) matrica. nonlin(l1,True) vraća (4,1) matricu. Ovdje ih množimo element po element, a na izlazu također dobijemo matricu (4,1), l1_delta.

Množenjem izvedenica pogreškama smanjujemo pogreške predviđanja napravljenih s velikom pouzdanošću. Ako je nagib linije bio mali, tada je mreža sadržavala vrlo veliku ili vrlo malu vrijednost. Ako je pretpostavka mreže blizu nule (x=0, y=0,5), tada nije osobito pouzdana. Ažuriramo ova nesigurna predviđanja i ostavljamo predviđanja visoke pouzdanosti na miru tako što ih množimo s vrijednostima blizu nule.

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

Spremni smo ažurirati mrežu. Pogledajmo jedan primjer treninga. U njemu ćemo ažurirati težine. Ažuriranje krajnje lijeve težine (9.5)

Ažuriranje_težine = ulazna_vrijednost * l1_delta

Za krajnju lijevu težinu to bi bilo 1,0 * l1_delta. Vjerojatno će to samo malo povećati 9,5. Zašto? Jer predviđanje je već bilo prilično pouzdano, a predviđanja su bila praktički točna. Mala greška i blagi nagib linije znače vrlo malo ažuriranje.

Ali budući da radimo grupni trening, ponavljamo gornji korak za sva četiri primjera treninga. Dakle, izgleda vrlo slično gornjoj slici. Dakle, što radi naša linija? Broji ažurirane težine za svaku težinu, za svaki primjer treninga, zbraja ih i ažurira sve težine - sve u jednom retku.

Nakon promatranja ažuriranja mreže, vratimo se našim podacima o treningu. Kada su i ulaz i izlaz 1, povećavamo težinu između njih. Kada je ulaz 1, a izlaz 0, smanjujemo težinu.

Ulaz Izlaz 0 0 1 0 1 1 1 1 1 0 1 1 0 1 1 0

Dakle, u našoj četiri primjeri obuke ispod, težina prvog ulaza u odnosu na izlaz će se ili povećati ili ostati konstantna, a druga dva pondera će se povećavati i smanjivati ​​ovisno o primjerima. Ovaj učinak pridonosi mrežnom učenju na temelju korelacija ulaznih i izlaznih podataka.

2. dio: teži zadatak

Ulaz Izlaz 0 0 1 0 0 1 1 1 1 0 1 1 1 1 1 0

Pokušajmo predvidjeti izlazne podatke na temelju tri stupca ulaznih podataka. Nijedan od ulaznih stupaca nije 100% u korelaciji s izlazom. Treći stupac uopće nije povezan s ničim, jer sadrži jedinice do kraja. Međutim, ovdje možete vidjeti uzorak - ako jedan od prva dva stupca (ali ne oba odjednom) sadrži 1, tada će rezultat također biti jednak 1.

Ovo je nelinearni dizajn jer ne postoji izravna korespondencija jedan na jedan između stupaca. Podudaranje se temelji na kombinaciji unosa, stupaca 1 i 2.

Zanimljivo je da je prepoznavanje uzoraka vrlo sličan zadatak. Ako imate 100 slika bicikala i cijevi iste veličine, prisutnost određenih piksela na određenim mjestima nije u izravnoj korelaciji s prisutnošću bicikla ili cijevi na slici. Statistički, njihova se boja može činiti nasumičnom. Ali neke kombinacije piksela nisu nasumične - one koje tvore sliku bicikla (ili zračnice).

Strategija

Da biste kombinirali piksele u nešto što može imati korespondenciju jedan na jedan s izlazom, trebate dodati još jedan sloj. Prvi sloj kombinira ulaz, drugi dodjeljuje podudaranje izlazu koristeći izlaz prvog sloja kao ulaz. Obratite pozornost na tablicu.

Ulaz (l0) Skriveni ponderi (l1) Izlaz (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 1 1 1 0.2 0.1 0.3 0.8 0

Nasumičnim dodjeljivanjem težina dobivamo skrivene vrijednosti za sloj br.1. Zanimljivo je da drugi skriveni stupac težine već ima malu korelaciju s rezultatom. Nije idealno, ali postoji. A ovo je također važan dio procesa mrežnog treninga. Trening će samo ojačati ovu korelaciju. Ažurirat će syn1 kako bi svoje mapiranje dodijelio izlaznim podacima, a syn0 radi boljeg dobivanja ulaznih podataka.

Neuronska mreža u tri sloja

import numpy kao np def nonlin(x,deriv=False): if(deriv==True): return f(x)*(1-f(x)) return 1/(1+np.exp(-x)) X = np.array([, , , ]) y = np.array([, , , ]) np.random.seed(1) # nasumično inicijalizirati težine, u prosjeku - 0 syn0 = 2*np.random. random ((3,4)) - 1 syn1 = 2*np.random.random((4,1)) - 1 za j u xrange(60000): # idi naprijed kroz slojeve 0, 1 i 2 l0 = X l1 = nonlin(np.dot(l0,syn0)) l2 = nonlin(np.dot(l1,syn1)) # koliko smo griješili u vezi tražene vrijednosti? l2_greška = y - l2 if (j% 10000) == 0: print "Greška:" + str(np.mean(np.abs(l2_error))) # u kojem smjeru se trebate pomaknuti? # ako smo bili sigurni u predviđanje, onda ga ne trebamo puno mijenjati l2_delta = l2_error*nonlin(l2,deriv=True) # koliko vrijednosti l1 utječu na pogreške u l2? l1_error = l2_delta.dot(syn1.T) # u kojem smjeru se trebamo kretati da dođemo do l1? # ako smo bili sigurni u predviđanje, onda ga ne trebamo puno mijenjati l1_delta = l1_error * nonlin(l1,deriv=True) syn1 += l1.T.dot(l2_delta) syn0 += l0.T.dot (l1_delta)

Pogreška:0.496410031903 Pogreška:0.00858452565325 Pogreška:0.00578945986251 Pogreška:0.00462917677677 Pogreška:0.00395876528027 Pogreška:0.00351012256786

Varijable i njihovi opisi

X je matrica ulaznog skupa podataka; žice - primjeri obuke
y – matrica izlaznog skupa podataka; žice - primjeri obuke
l0 – prvi mrežni sloj definiran ulaznim podacima
l1 – drugi sloj mreže, ili skriveni sloj
l2 je završni sloj, ovo je naša hipoteza. Kako vježbate, trebali biste se približiti točnom odgovoru.
syn0 – prvi sloj utega, Synapse 0, kombinira l0 s l1.
syn1 – Drugi sloj utega, Synapse 1, kombinira l1 s l2.
l2_error – greška mreže u kvantitativnom smislu
l2_delta – greška mreže, ovisno o pouzdanosti predviđanja. Gotovo identično pogrešci, osim sigurnih predviđanja
l1_error – vaganjem l2_delta s težinama iz syn1, izračunavamo grešku u srednjem/skrivenom sloju
l1_delta – mrežne pogreške iz l1, skalirane prema pouzdanosti predviđanja. Gotovo identičan l1_error, osim pouzdanih predviđanja

Kod bi trebao biti prilično jasan - to je samo prethodna implementacija mreže, složena u dva sloja, jedan na vrhu drugog. Izlaz prvog sloja l1 je ulaz drugog sloja. Tek u sljedećem retku ima nešto novo.

L1_greška = l2_delta.dot(syn1.T)

Koristi pogreške ponderirane pouzdanošću predviđanja iz l2 za izračun pogreške za l1. Dobivamo, moglo bi se reći, grešku ponderiranu doprinosima - izračunavamo koliko vrijednosti u čvorovima l1 doprinose greškama u l2. Ovaj korak se zove širenje unazad pogreške. Zatim ažuriramo syn0 koristeći isti algoritam kao dvoslojna neuronska mreža.

Keras- popularna knjižnica duboko učenje, koji je dao velik doprinos komercijalizaciji dubokog učenja. Keras je jednostavan za korištenje i omogućuje vam stvaranje neuronskih mreža sa samo nekoliko redaka Python koda.

U ovom ćete članku naučiti kako koristiti Keras za stvaranje neuronske mreže koja predviđa kako će korisnici ocijeniti proizvod na temelju njihovih recenzija, klasificirajući ga u dvije kategorije: pozitivne ili negativne. Ovaj zadatak se zove analiza sentimenta (analiza sentimenta), a mi ćemo to riješiti uz pomoć stranice za recenzije filmova IMDb. Model koji ćemo izgraditi također se može primijeniti za rješavanje drugih problema nakon manjih izmjena.

Imajte na umu da nećemo ići u detalje o Kerasu i dubokom učenju. Ovaj post je namijenjen pružanju sheme u Kerasu i predstavljanju njegove implementacije.

• Što je Keras?
• Što je analiza sentimenta?
• Skup podataka IMDB
• Istraživanje podataka
• Priprema podataka
• Izrada modela i obuka

Što je Keras?

Keras je Python biblioteka otvorenog koda izvorni kod, što olakšava stvaranje neuronskih mreža. Knjižnica je kompatibilna s , Microsoft Cognitive Toolkit, Theano i MXNet. Tensorflow i Theano su najčešće korišteni Python numerički okviri za razvoj algoritama dubokog učenja, ali ih je prilično teško koristiti.

Procjena popularnosti okvira strojnog učenja u 7 kategorija

Keras, s druge strane, pruža jednostavan i praktičan način za stvaranje modela dubokog učenja. Njegov tvorac, François Chollet, razvio ju je kako bi što više ubrzao i pojednostavio proces stvaranja neuronskih mreža. Fokusirao se na proširivost, modularnost, minimalizam i podršku za Python. Keras se može koristiti s GPU i CPU; podržava i Python 2 i Python 3. Keras Google je dao veliki doprinos komercijalizaciji dubokog učenja i zato što sadrži najsuvremenije algoritme dubokog učenja koji su prije bili ne samo nedostupni, već i neupotrebljivi.

Što je analiza sentimenta (analiza sentimenta)?

Analiza osjećaja može se koristiti za određivanje stava (tj. raspoloženja) osobe prema tekstu, interakciji ili događaju. Stoga analiza sentimenta pripada području obrade prirodni jezik, u kojem se značenje teksta mora dešifrirati kako bi se iz njega izvukao tonalitet i osjećaj.

Primjer ljestvice analize osjećaja

Spektar raspoloženja obično se dijeli na pozitivno, negativno i neutralno kategorije. Pomoću analize sentimenta možete, primjerice, predvidjeti mišljenja kupaca i njihov stav prema proizvodu na temelju recenzija koje pišu. Stoga se analiza sentimenta naširoko primjenjuje na recenzije, ankete, tekstove i još mnogo toga.

IMDb skup podataka

Recenzije na IMDb-u

IMDb skup podataka sastoji se od 50 000 korisničkih recenzija filmova, označenih kao pozitivne (1) i negativne (0).

• Recenzije se prethodno obrađuju i svaka je kodirana nizom indeksa riječi kao cijelih brojeva.
• Riječi u recenzijama indeksirane su prema ukupnoj učestalosti pojavljivanja u skupu podataka. Na primjer, cijeli broj "2" kodira drugu najčešće korištenu riječ.
• 50 000 pregleda podijeljeno je u dva skupa: 25 000 za obuku i 25 000 za testiranje.

Skup podataka izradili su istraživači sa Sveučilišta Stanford i predstavili ga u radu iz 2011., u kojem je postignuta točnost predviđanja bila 88,89%. Skup podataka također je korišten kao dio natjecanja Keggle zajednice "Vrećica riječi susreće vrećice kokica" u 2011.

Uvoz ovisnosti i dohvaćanje podataka

Počnimo s uvozom potrebnih ovisnosti za prethodnu obradu podataka i izgradnju modela.

%matplotlib inline import matplotlib import matplotlib.pyplot as plt import numpy as np from keras.utils import to_categorical from keras import models from keras import layers

Učitajmo IMDb skup podataka, koji je već ugrađen u Keras. Budući da ne želimo imati 50/50 podatke o obuci i testiranju, odmah ćemo spojiti ove podatke nakon učitavanja za kasnije dijeljenje u omjeru 80/20:

Iz keras.datasets uvezite imdb (podaci_osposobljavanja, ciljevi_obuke), (podaci_testiranja, ciljevi_testiranja) = imdb.load_data(broj_riječi=10000) podaci = np.concatenate((podaci_obuke, podaci_testiranja), os=0) ciljevi = np.concatenate((ciljevi_obuke) , ciljevi_testiranja), os=0)

Istraživanje podataka

Proučimo naš skup podataka:

Print("Kategorije:", np.unique(targets)) print("Broj jedinstvenih riječi:", len(np.unique(np.hstack(data)))) Kategorije: Broj jedinstvenih riječi: 9998 length = print ("Prosječna duljina pregleda:", np.mean(dužina)) print("Standardna devijacija:", round(np.std(duljina))) Prosječna duljina pregleda: 234,75892 Standardna devijacija: 173,0

Možete vidjeti da svi podaci spadaju u dvije kategorije: 0 ili 1, što predstavlja osjećaj recenzije. Cijeli skup podataka sadrži 9998 jedinstvenih riječi, prosječna veličina pregleda je 234 riječi sa standardnom devijacijom od 173.

Pogledajmo jednostavan način učenja:

Ispis("Oznaka:", ciljevi) Oznaka: 1 ispis(podaci)

Ovdje vidite prvu recenziju iz skupa podataka, koja je označena kao pozitivna (1). Sljedeći kod proizvodi inverzna konverzija indeksira u riječi kako bismo ih mogli čitati. U njemu je svaka nepoznata riječ zamijenjena sa "#". To se radi pomoću funkcije get_word_index().

Index = imdb.get_word_index() reverse_index = dict([(value, key) for (key, value) in index.items()]) decoded = " ".join() print(decoded) # ovaj film je bio jednostavno sjajan izbor lokacija scenografija priča režija svima je stvarno odgovarala uloga koju su igrali i možete samo zamisliti da ste tamo robert # je nevjerojatan glumac i sada je isti kao režiser # otac je došao s istog škotskog otoka kao i ja pa mi se svidjela činjenica da postoji prava povezanost s ovim filmom duhovite primjedbe u cijelom filmu bile su sjajne bilo je jednostavno toliko briljantno da sam kupio film čim je izašao za # i preporučio bih ga svima za gledanje i mušičarenje je bilo nevjerojatno stvarno sam plakao na na kraju je bilo tako tužno i znaš kako kažu ako plačeš na filmu, mora da je bilo dobro i ovo je definitivno bilo # za dvojicu dječaka koji su igrali # Normana i Paula oni su bili samo briljantna djeca često izostavljen s popisa # mislim jer zvijezde koje ih igraju sve su odrasle tako veliki profil za cijeli film, ali ova su djeca nevjerojatna i treba ih pohvaliti za ono što su učinili, zar ne mislite da je cijela priča bila tako lijepa jer je bila istinita i bila je nečija život nakon svega što je podijeljeno sa svima nama

Priprema podataka

Vrijeme je za pripremu podataka. Moramo vektorizirati svaku recenziju i ispuniti je nulama tako da vektor sadrži točno 10 000 brojeva. To znači da svaku recenziju koja je kraća od 10.000 riječi ispunjavamo nulama. To se radi jer najviše odlična recenzija je gotovo iste veličine, a svaki element ulaznih podataka u našu neuronsku mrežu trebao bi biti iste veličine. Također morate pretvoriti varijable u vrstu plutati.

Def vectorize(sequences, dimension = 10000): results = np.zeros((len(sequences), dimension)) za i, niz u enumerate(sequences): results = 1 return results data = vectorize(data) targets = np. niz(ciljevi).astype("float32")

Podijelimo skup podataka na skupove za obuku i skupove za testiranje. Skup za obuku sastojat će se od 40.000 pregleda, skup za testiranje od 10.000.

Test_x = podaci[:10000] test_y = ciljevi[:10000] train_x = podaci train_y = ciljevi

Izrada modela i obuka

Sada možete stvoriti jednostavnu neuronsku mrežu. Počnimo s definiranjem vrste modela koji želimo stvoriti. U Kerasu su dostupne dvije vrste modela: sekvencijalni i funkcionalni API.

Zatim trebate dodati ulazne, skrivene i izlazne slojeve. Kako bismo spriječili prekomjerno opremanje, koristit ćemo iznimku između njih ( "napustiti"). Imajte na umu da biste uvijek trebali koristiti stopu isključenja između 20% i 50%. Svaki sloj koristi funkciju "gusto" kako bi se slojevi međusobno potpuno povezali. U skrivenim slojevima koje ćemo koristiti "relu", jer to gotovo uvijek dovodi do zadovoljavajućih rezultata. Nemojte se bojati eksperimentirati s drugim funkcijama aktivacije. Na izlaznom sloju koristimo sigmoidnu funkciju koja ponovno normalizira vrijednosti u rasponu od 0 do 1. Imajte na umu da smo postavili veličinu elemenata ulaznog skupa podataka na 10 000 jer su naši pregledi veličine do 10 000 cijelih brojeva. Ulazni sloj prihvaća elemente veličine 10 000, a izlazi elemente veličine 50.

Na kraju, neka Keras ispiše kratki opis modela koji smo upravo izradili.

# Ulaz - Sloj model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Hidden - Slojevi 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 ")) # Izlazni sloj model.add(layers.Dense(1, activation = "sigmoid"))model.summary() model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ======= ==================================================== === ======== dense_1 (Dense) (Ništa, 50) 500050 _________________________________________________________________ dropout_1 (Dropout) (Ništa, 50) 0 _________________________________________________________________ dense_2 (Dense) (Ništa, 50) 2550 _________________________________________________________________ dropout_2 (Dropout) (Ništa) , 50) 0 _________________________________________________________________ gusto_3 (Gusto) (Nijedan, 50) 2550 _________________________________________________________________ gusto_4 (Gusto) (Nijedno, 1) 51 ============= ============ =========================== Ukupno parametara: 505,201 Parama koji se mogu trenirati: 505,201 Parama koji se ne mogu trenirati: 0 _________________________________________________________________

Sada moramo sastaviti naš model, odnosno, u biti ga postaviti za obuku. Koristit ćemo se optimizator "adam". Optimizator je algoritam koji mijenja težine i pristranosti tijekom treninga. Kao funkcije gubitka Koristimo binarnu kros-entropiju (budući da radimo s binarnom klasifikacijom), točnost kao metriku procjene.

Model.compile(optimizer = "adam", loss = "binary_crossentropy", metrics = ["accuracy"])

Sada možemo trenirati naš model. Učinit ćemo ovo s veličinom serije od 500 i samo dvije epohe kako sam saznao model se počinje prekvalificirati, ako ga duže trenirate. Veličina paketa određuje broj elemenata koji će biti raspoređeni kroz mrežu, a epoha je jedan prolaz kroz sve elemente skupa podataka. Obično veće veličine batch dovodi do bržeg učenja, ali ne uvijek do brze konvergencije. Manja veličina serije trenira se sporije, ali može konvergirati brže. Odabir jednog ili drugog svakako ovisi o vrsti problema koji se rješava, a bolje je isprobati svaki od njih. Ako ste novi u ovome, predlažem da prvo upotrijebite veličina parcele 32, što je svojevrsni standard.

Rezultati = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) Obuka na 40000 uzoraka, validacija na 10000 uzoraka Epoha 1/2 40000/40000 [======= =======================] - 5s 129us/korak - gubitak: 0,4051 - acc: 0,8212 - val_loss: 0,2635 - val_acc: 0,8945 Epoha 2/2 40000 /40000 [=============================] - 4s 90us/korak - gubitak: 0,2122 - acc: 0,9190 - val_loss: 0,2598 - val_acc: 0,8950

Procijenimo izvedbu modela:

Ispis(np.mean(results.history["val_acc"])) 0,894750000536

Sjajno! Naše jednostavan model već je oborio rekord točnosti u članku iz 2011. godine navedeno na početku posta. Slobodno eksperimentirajte s mrežnim parametrima i brojem slojeva.

Potpuni kod modela naveden je u nastavku:

Import numpy kao np iz keras.utils import to_categorical iz keras import modeli iz keras import slojevi iz keras.datasets import imdb (training_data, training_targets), (testing_data, testing_targets) = imdb.load_data(num_words=10000) data = np.concatenate( (trening_data, testing_data), axis=0) targets = np.concatenate((training_targets, testing_targets), axis=0) def vectorize(sequences, dimension = 10000): results = np.zeros((len(sequences), dimension) ) za i, niz u enumerate(sequences): results = 1 return results data = vectorize(data) targets = np.array(targets).astype("float32") test_x = data[:10000] test_y = targets[:10000 ] train_x = podaci train_y = targets model = models.Sequential() # Input - Layer model.add(layers.Dense(50, activation = "relu", input_shape=(10000,))) # Hidden - Layers model.add( layers.Dropout(0.3, noise_shape=Ništa, seed=Ništa)) model.add(layers.Dense(50, activation = "relu")) model.add(layers.Dropout(0.2, noise_shape=Ništa, seed=Ništa) ) model.add(layers.Dense(50, activation = "relu")) # Izlazni sloj model.add(layers.Dense(1, activation = "sigmoid")) model.summary() # kompajliranje modela modela. compile(optimizer = "adam", loss = "binary_crossentropy", metrics = ["accuracy"]) results = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) print( "Test-Accuracy:", np.mean(results.history["val_acc"]))

Rezultati

Naučili ste što je analiza sentimenta i zašto je Keras jedna od najpopularnijih knjižnica za duboko učenje.

Stvorili smo jednostavnu neuronsku mrežu sa šest slojeva koja može izračunati raspoloženje filmskih recenzenata s 89% točnosti. Sada možete koristiti ovaj model za analizu binarnih osjećaja u drugim izvorima, ali da biste to učinili, morat ćete njihovu veličinu podesiti na 10 000 ili promijeniti parametre ulaznog sloja.

Ovaj model (uz manje izmjene) može se primijeniti na druge probleme strojnog učenja.

Umjetne neuronske mreže (ANM) su matematički modeli, kao i njihove softverske ili hardverske implementacije, izgrađene na principu organizacije i funkcioniranja bioloških neuronskih mreža – mreža živčanih stanica živog organizma.

ANN su sustav povezanih i međusobno povezanih jednostavni procesori(umjetni neuroni).

Neuronske mreže nisu programirane u uobičajenom smislu te riječi, one se treniraju. Sposobnost učenja jedna je od glavnih prednosti neuronskih mreža u odnosu na tradicionalne algoritme. wikipedija

Neuronske mreže inspirirane su našim vlastitim mozgom. Standardni model neurona izumljen je prije više od pedeset godina i sastoji se od tri glavna dijela:

• Dentrit(i)- odgovoran za prikupljanje dolaznih signala;
• Soma- odgovoran za glavnu obradu i zbrajanje signala;
• Akson- odgovoran je za prijenos signala drugim dendritima.

Rad neurona može se opisati otprilike ovako: dendriti skupljaju signale primljene od drugih neurona, potom somi vrše zbrajanje i izračunavanje signala i podataka, i na kraju, na temelju rezultata obrade, mogu "reći" aksonima da prenose signalizirati dalje. Prijenos nadalje ovisi o brojnim čimbenicima, ali ovo ponašanje možemo modelirati kao prijenosnu funkciju koja uzima ulaze, obrađuje ih i priprema izlaze ako su svojstva prijenosne funkcije zadovoljena.

Biološki neuron je složen sustav, matematički model koja još nije u potpunosti izgrađena. Uvedeni su mnogi modeli koji se razlikuju po računskoj složenosti i sličnosti sa stvarnim neuronom. Jedan od najvažnijih je formalni neuron (FN). Unatoč jednostavnosti funkcionalne funkcije, mreže izgrađene od takvih neurona mogu formirati proizvoljnu višedimenzionalnu funkciju na izlazu (izvor: Zaentsev I.V. Neuronske mreže: osnovni modeli).

Neuron se sastoji od ponderiranog zbrajala i nelinearnog elementa. Funkcioniranje neurona određeno je formulama:

Neuron ima višestruke ulaze x i jedan izlazni signal VAN. Parametri neurona koji određuju njegov rad su: vektor težina w, razinu praga θ i vrstu aktivacijske funkcije F.

Neuronske mreže privlače pažnju zbog sljedećih mogućnosti:

• sposobni su rješavati probleme koje je teško formalizirati;
• inherentno je paralelno načelo rada, što je vrlo važno pri obradi velikih količina podataka;
• sposobnost učenja i sposobnost generalizacije;
• tolerancija na pogreške;

Glavna svojstva neuronskih mreža uključuju:

Sposobnost učenja. Neuronske mreže nisu programirane, već se treniraju na primjerima. Nakon što su ulazni signali prikazani (moguće zajedno sa potrebnim izlazima), mreža prilagođava svoje parametre kako bi pružila traženi odgovor.

Generalizacija. Mrežni odgovor nakon treninga može biti donekle neosjetljiv na male promjene u ulaznim signalima. Ova inherentna sposobnost da se "vidi" uzorak kroz šum i izobličenje vrlo je važna za prepoznavanje uzoraka. Važno je napomenuti da umjetna neuronska mreža automatski radi generalizacije zbog svog dizajna, a ne korištenjem "ljudske inteligencije" u obliku posebno napisanih računalnih programa.

Paralelizam. Informacije na mreži obrađuju se paralelno, što omogućuje dosta složenu obradu podataka pomoću velikog broja jednostavnih uređaja.

Visoka pouzdanost. Mreža može ispravno funkcionirati čak i ako neki neuroni zakažu, zbog činjenice da se izračuni izvode lokalno i paralelno.

Algoritam za rješavanje problema pomoću višeslojnog perceptrona(izvor: Zaentsev I.V. Neuralne mreže: osnovni modeli)

Da biste izgradili višeslojni perceptron, morate odabrati njegove parametre. Najčešće, odabir vrijednosti težina i pragova zahtijeva obuku, tj. promjene korak po korak težinski koeficijenti i razine pragova.

Opći algoritam rješenja:

1. Odredite koje je značenje stavljeno u komponente ulaznog vektora x. Ulazni vektor mora sadržavati formalizirani uvjet problema, tj. sve informacije potrebne za dobivanje odgovora.
2. Odaberite izlazni vektor g na način da njegove komponente sadrže cjelovit odgovor na zadatak.
3. Odaberite vrstu nelinearnosti u neuronima (aktivacijska funkcija). U ovom slučaju, preporučljivo je uzeti u obzir specifičnosti zadatka, jer Dobar izbor će smanjiti vrijeme treninga.
4. Odaberite broj slojeva i neurona u sloju.
5. Postavite raspon promjena u ulazima, izlazima, težinama i razinama praga, uzimajući u obzir skup vrijednosti odabrane aktivacijske funkcije.
6. Dodijelite početne vrijednosti težinama i razinama praga i dodatni parametri(na primjer, strmina funkcije aktivacije ako se prilagođava tijekom treninga). Početne vrijednosti ne bi trebale biti velike kako se neuroni ne bi zasitili (u vodoravnom dijelu aktivacijske funkcije), inače će učenje biti vrlo sporo. Početne vrijednosti ne smiju biti premale kako rezultati većine neurona ne bi bili jednaki nuli, inače će se i učenje usporiti.
7. Provesti obuku, tj. odaberite mrežne parametre tako da se problem riješi najbolji način. Nakon što je obuka završena, mreža je spremna za rješavanje problema one vrste za koju je obučena.
8. Pošaljite uvjete problema na mrežni ulaz u obliku vektora x. Izračunajte izlazni vektor g, koji će dati formalizirano rješenje problema.

Problemi koje treba riješiti

Problemi riješeni pomoću neuronskih mreža ().

Klasifikacija slika. Zadatak je naznačiti pripadnost ulazne slike (na primjer, govornog signala ili rukom pisanog znaka), predstavljene vektorom značajki, jednoj ili više unaprijed definiranih klasa. Značajne primjene uključuju prepoznavanje slova, prepoznavanje govora, klasifikaciju signala elektrokardiograma i klasifikaciju krvnih stanica.

Klasterizacija/kategorizacija. Prilikom rješavanja problema klasteriranja, koji je također poznat kao nenadzirana klasifikacija slika, ne postoji set za obuku s oznakama klase. Algoritam grupiranja temelji se na sličnosti slika i smješta slične slike u jedan klaster. Poznati su slučajevi korištenja klasteriranja za izdvajanje znanja, komprimiranje podataka i proučavanje svojstava podataka.

Aproksimacija funkcije. Pretpostavimo da postoji uzorak za obuku ((x1,y1), (x2,y2)..., (xn,yn)) (input-output data parovi) koji je generiran nepoznatom funkcijom (x) oštećenom šumom. Problem aproksimacije je pronaći procjenu za nepoznatu funkciju (x). Aproksimacija funkcija nužna je u rješavanju brojnih inženjerskih i znanstvenih problema modeliranja.

Predviđanje/Prognoza. Neka je n diskretnih uzoraka (y(t1), y(t2)..., y(tn)) dano u uzastopnim trenucima vremena t1, t2,..., tn. Zadatak je predvidjeti vrijednost y(tn+1) u nekom budućem vremenu tn+1. Predviđanje/predviđanje ima značajan utjecaj na donošenje odluka u poslovanju, znanosti i tehnologiji. Predviđanje cijena dionica i vremenska prognoza tipične su primjene tehnika predviđanja/prognoziranja.

Optimizacija. Brojni problemi u matematici, statistici, inženjerstvu, znanosti, medicini i ekonomiji mogu se smatrati problemima optimizacije. Zadatak optimizacijskog algoritma je pronaći rješenje koje zadovoljava sustav ograničenja i maksimizira ili minimizira ciljna funkcija. Problem trgovačkog putnika, koji pripada klasi NP-kompletnih, klasičan je primjer optimizacijskog problema.

Adresabilna memorija sadržaja. U von Neumannovom modelu računalstva, memoriji se pristupa samo preko adrese, koja je neovisna o sadržaju memorije. Štoviše, ako se napravi pogreška u izračunavanju adrese, mogu se pronaći potpuno različite informacije. Asocijativno pamćenje, ili sadržajno adresabilna memorija, dostupna je specificiranjem danog sadržaja. Sadržaj memorije može se pozvati čak i djelomičnim unosom ili oštećenim sadržajem. Asocijativna memorija iznimno je poželjna pri izradi multimedijskih baza podataka.

Kontrolirati. Razmotrimo dinamički sustav, određen skupom (u(t), y(t)), gdje je u(t) ulazna kontrolna radnja, a y(t) je izlaz sustava u trenutku t. U sustavima upravljanja sa referentni model Cilj upravljanja je izračunati ulazno djelovanje u(t) tako da sustav slijedi željenu putanju koju diktira referentni model. Primjer je optimalna kontrola motora.

Vrste arhitekture

Arhitektura neuronske mreže- način organizacije i komunikacije pojedinačni elementi neuronska mreža (neuroni). Arhitektonske razlike između samih neurona leže uglavnom u korištenju različitih aktivacijskih (ekscitacijskih) funkcija. Na temelju arhitekture povezivanja, neuronske mreže mogu se podijeliti u dvije klase: feedforward mreže i rekurentne mreže.

Klasifikacija umjetnih neuronskih mreža prema njihovoj arhitekturi prikazana je na donjoj slici.

Slična klasifikacija, ali malo proširena

Mreža za distribuciju signala (mreža za prijenos)- neuronska mreža bez povratne sprege (petlje). U takvoj mreži obrada informacija je jednosmjerna: signal se prenosi od sloja do sloja u smjeru od ulaznog sloja neuronske mreže do izlaznog sloja. Izlazni signal (odziv mreže) zajamčen je kroz unaprijed određeni broj koraka (jednak broju slojeva). Feedforward mreže jednostavne su za implementaciju i dobro su proučene. Za rješavanje složenih problema potreban im je velik broj neurona.

usporedna tablica višeslojni perceptorn I RBF mreže

Višeslojni perceptron	RBF mreže
Granica odluke je sjecište hiperravnina	Granica odluke je sjecište hipersfera, koje definira granicu složenijeg oblika
Složena topologija veza između neurona i slojeva	Jednostavna dvoslojna neuronska mreža
Složen i sporo konvergirajući algoritam učenja	Brzi postupak obuke: rješavanje sustava jednadžbi + grupiranje
Rad na malom uzorku za obuku	Za prihvatljiv rezultat potrebna je značajna količina podataka o treningu
Univerzalnost primjene: grupiranje, aproksimacija, kontrola itd.	Obično samo aproksimacija funkcija i grupiranje

Vrijednost derivacije lako se izražava kroz samu funkciju. Brzo izračunavanje izvoda ubrzava učenje.

Gaussova krivulja

Koristi se u slučajevima kada odgovor neurona treba biti maksimalan za neku specifičnu NET vrijednost.

Python moduli za neuronske mreže

Jednostavan primjer

Kao primjer dat ću jednostavnu neuronsku mrežu (jednostavna perceptron), koji će nakon obuke moći prepoznati leteće objekte, ne sve, već samo galeb:), sve ostale ulazne slike bit će prepoznate kao NLO.

# encoding=utf8 import random class NN: def __init__(self, threshold, size): """ Postavite početne parametre. """ self.threshold = prag self.size = size self.init_weight() def init_weight(self) : """ Inicijalizirajte matricu težina nasumičnim podacima. """ self.weights = [ for j in xrange(self.size)] def check(self, sample): """ Očitajte izlazni signal za uzorak slike. Ako je vsum > self. prag tada možemo pretpostaviti da uzorak sadrži sliku galeba. """ vsum = 0 za i u xrange(self.size): za j u xrange(self.size): vsum += self .weights[i][j] * sample[i][j] if vsum > self.threshold: return True else: return False def teach(self, sample): """ Uvježbavanje neuronske mreže. """ za i u xrange(self.size): za j u xrange(self.size): self.weights[i][j] += sample[i][j] nn = NN(20, 6) # Uvježbajte neuronsku mrežu. tsample1 = [ , , , , , , ] nn.teach(tsample1) tsample2 = [ , , , , , , ] nn.teach(tsample2) tsample3 = [ , , , , , , ] nn.teach(tsample3) tsample4 = [ , , , , , , ] nn.teach(tsample4) # Provjerimo što neuronska mreža može. # Prenesimo sliku galeba, koja je približno slična onoj za koju perceptron zna. wsample1 = [ , , , , , , ] print u"galeb" if nn.check(wsample1) else u"UFO" # Prijenos nepoznate slike. wsample2 = [ , , , , , , ] print u"galeb" if nn.check(wsample2) else u"UFO" # Prenijet ćemo sliku galeba, koja je približno slična onoj za koju perceptron zna. wsample3 = [ , , , , , , ] print u"galeb" if nn.check(wsample3) else u"UFO"