Primjer neuronske mreže u python kodu. Naučite neuronske mreže u četiri koraka

Programiranje

• Prijevod

O čemu je članak

Osobno najbolje učim s malo radnog koda 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.niz([ ,,, ]) y = np.niz([]).T syn0 = 2*np.random.random((3,4)) - 1 syn1 = 2*np.random.random ((4,1)) - 1 za j u xrasponu (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 += XTdot(l1_delta)

Previše sažeto? Razdvojimo ga na jednostavnije dijelove.

Dio 1: Mala igračka neuronska mreža

Neuronska mreža uvježbana kroz propagaciju unatrag pokušava koristiti ulaz za predviđanje izlaza.

Pretpostavimo da trebamo predvidjeti kako će stupac "izlaz" izgledati na temelju ulaznih podataka. Taj se problem može riješiti izračunavanjem statističke korespondencije između njih. I vidjeli bismo da je lijevi stupac 100% koreliran s izlazom.

Propagacija unatrag, u svom najjednostavnijem slučaju, izračunava sličnu statistiku za stvaranje modela. Pokušajmo.

Neuronska mreža u dva sloja

import numpy kao np # Sigmoid def nonlin(x,deriv=False): if(deriv==True): vrati f(x)*(1-f(x)) return 1/(1+np.exp(-x) )) # skup ulaznih podataka X = np.array([ , , , ]) # izlazni podaci y = np.array([]).T # učiniti slučajne brojeve preciznijim np.random.seed(1) # inicijalizirati težine na slučajna srednja vrijednost 0 syn0 = 2*np.random.random((3,1)) - 1 za iter u xrange(10000): # širenje naprijed l0 = X l1 = nonlin(np.dot(l0,syn0)) # kako jesmo li u krivu? l1_error = y - l1 # pomnožite ovo sa sigmoidnim nagibom # na temelju vrijednosti u l1 l1_delta = l1_error * nonlin(l1,True) # !!! # ažuriranje težine syn0 += np.dot(l0.T,l1_delta) # !!! ispis "Izlaz nakon treninga:" ispis l1

Rezultat nakon treninga: [[ 0,00966449] [0,00786506] [0,99358898] [0,99211957]]

Varijable i njihovi opisi.

"*" - množenje po elementima - dva vektora iste veličine množe odgovarajuće vrijednosti, a izlaz je vektor iste veličine
"-" – element po element oduzimanje vektora
x.dot(y) - ako su x i y vektori, onda će izlaz biti točkasti proizvod. Ako su to matrice, onda dobivamo množenje matrice. Ako je matrica samo jedna od njih, ovo je množenje vektora i matrice.

• usporedi l1 nakon prve i nakon zadnje
• pogledajte nelinsku funkciju.
• pogledajte kako se mijenja l1_error
• 36. redak parse - ovdje se skupljaju glavni tajni sastojci (označeno!!!)
• raščlanjivanje reda 39 - cijela se mreža priprema za ovu konkretnu operaciju (označeno !!!)

Rastavimo kod red po redak

import 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". Preslikava bilo koji broj na vrijednost od 0 do 1 i pretvara brojeve u vjerojatnosti, a ima i nekoliko drugih korisnih svojstava za treniranje neuronskih mreža.

If(deriv==True):

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

X = np.niz([ , ...

Inicijalizacija niza ulaznih podataka kao numpy matrice. Svaka linija je primjer treninga. Stupci su ulazni čvorovi. Dobivamo 3 ulazna čvora u mreži i 4 primjera obuke.

Y = np.niz([]).T

Inicijalizira izlaz. ".T" – prijenosna funkcija. Nakon prijevoda, y matrica ima 4 reda s jednim stupcem. Kao i kod ulaznih podataka, svaki redak je primjer treninga, a svaki stupac (jedan u našem slučaju) je izlazni čvor. Ispostavilo se da mreža ima 3 ulaza i 1 izlaz.

np.random.seed(1)

Zbog toga će nasumična raspodjela svaki put biti ista. To će nam omogućiti da lakše pratimo izvedbu mreže nakon izmjena koda.

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

Mrežna matrica težine. syn0 znači "nula sinapse". Budući da imamo samo dva sloja, ulazni i izlazni, potrebna nam je jedna matrica težine koja će ih povezati. Njegova dimenzija je (3, 1) budući da 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 dimenzija (3, 1).

Imajte na umu da se inicijalizira nasumično i da je srednja vrijednost nula. Iza ovoga stoji prilično složena teorija. Za sada ćemo to shvatiti 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. Sav trening je pohranjen u syn0.

Za iter u xrange(10000):

Ovdje počinje glavni mrežni kod za obuku. Ciklus s kodom 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čita l0 niza, ali ih možemo smatrati jednim primjerom obuke - u ovoj fazi nije važno (bilo je moguće učitati 1000 ili 10000 njih 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. Onda ćemo vidjeti kako će ona to učiniti kako bismo to mogli dotjerati u smjeru poboljšanja.

Linija sadrži dva koraka. Prvi radi matrično množenje l0 i syn0. Drugi prolazi izlaz kroz sigmoid. Njihove dimenzije su sljedeće:

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

Množenje matrice zahtijeva da se dimenzije podudaraju u sredini jednadžbe. Dobivena matrica ima isti broj redaka kao prva i isti broj stupaca kao i druga.

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

L1_pogreška = y - l1

Budući da l1 sadrži nagađanja, možemo usporediti njihovu razliku sa stvarnošću oduzimanjem l1 od ispravnog odgovora y. l1_error je vektor pozitivnih i negativnih brojeva koji karakteriziraju "promašaj" mreže.

A evo i tajnog sastojka. Ovaj redak treba raščlaniti u dijelovima.

Prvi dio: izvedenica

Nonline (l1, True)

L1 predstavlja ove tri točke, a kod daje nagib dolje prikazanih linija. Primijetite da pri velikim vrijednostima poput x=2,0 (zelena točka) i vrlo malim vrijednostima poput x=-1,0 (ljubičasta) linije imaju blagi nagib. Najveći kut je u točki x=0 (plava). Ovo je od velike važnosti. Također imajte na umu da su sve izvedenice između 0 i 1.

Puni izraz: derivacija ponderirana pogreškom

L1_delta = l1_error * nonlin(l1,True)

Matematički, postoje točniji načini, ali u našem slučaju je i ovaj prikladan. l1_error je (4,1) matrica. nonlin(l1,True) vraća matricu (4,1). Ovdje ih množimo element po element, a na izlazu dobivamo i matricu (4,1), l1_delta.

Množenjem izvedenica s pogreškama, smanjujemo pogreške predviđanja napravljenih s visokim povjerenjem. Ako je nagib linije bio mali, tada mreža sadrži ili vrlo veliku ili vrlo malu vrijednost. Ako je nagađanje u mreži blizu nule (x=0, y=0,5), onda nije osobito sigurno. Ažuriramo ova neizvjesna predviđanja i ostavljamo predviđanja s visokom pouzdanošću množeći ih vrijednostima blizu nule.

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

Spremni smo za nadogradnju mreže. Razmotrimo jedan primjer treninga. U njemu ćemo ažurirati težine. Ažurirajte najlijevu težinu (9.5)

težina_ažuriranja = ulazna_vrijednost * l1_delta

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

No, 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žuriranja 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 jednaki 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ša četiri primjera treninga u nastavku, težina prvog ulaza u odnosu na izlaz će se stalno povećavati ili ostati konstantna, a druga dva težine će se povećavati i smanjivati ​​ovisno o primjerima. Ovaj učinak pridonosi učenju mreže na temelju korelacije ulaznih i izlaznih podataka.

2. dio: zadatak je teži

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 ulazna stupca podataka. Nijedan od ulaznih stupaca ne korelira 100% s izlazom. Treći stupac uopće se ne odnosi ni na što, jer sadrži jedinice cijelim putem. Međutim, ovdje možete vidjeti shemu - ako jedan od prva dva stupca (ali ne oba odjednom) sadrži 1, tada će rezultat također biti 1.

Ovo je nelinearna shema jer ne postoji izravna korespondencija jedan na jedan između stupaca. Podudaranje se temelji na kombinaciji ulaznih podataka, stupaca 1 i 2.

Zanimljivo je da je prepoznavanje uzoraka vrlo sličan zadatak. Ako imate 100 slika jednake veličine bicikala i lula za pušenje, prisutnost određenih piksela na određenim mjestima nije izravno povezana s prisutnošću bicikla ili lule na slici. Statistički, njihova boja može izgledati slučajna. No neke kombinacije piksela nisu slučajne – one koje tvore sliku bicikla (ili cijevi).

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 pažnju na tablicu.

Ulaz (l0) Skriveni utezi (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 .0.2

Nasumično dodjeljivanjem težina dobivamo skrivene vrijednosti za sloj #1. Zanimljivo je da drugi stupac skrivenih pondera već ima malu korelaciju s izlazom. Nije idealno, ali postoji. I ovo je također važan dio procesa mrežne obuke. Trening će samo pojačati ovu korelaciju. Ažurirat će syn1 kako bi odgovarao izlazu, a syn0 kako bi bolje dobio ulaz.

Neuronska mreža u tri sloja

import numpy kao np def nonlin(x,deriv=False): if(deriv==True): vrati f(x)*(1-f(x)) return 1/(1+np.exp(-x)) X = np.array([, , , ]) y = np.array([, , , ]) np.random.seed(1) # randomiziraj težine, prosjek 0 syn0 = 2*np.random.random ((3 ,4)) - 1 syn1 = 2*np.random.random((4,1)) - 1 za j u xrange(60000): # ide naprijed kroz slojeve 0, 1 i 2 l0 = X l1 = nonlin(np .dot(l0,syn0)) l2 = nonlin(np.dot(l1,syn1)) # koliko griješimo u vezi željene vrijednosti? l2_error = y - l2 if (j% 10000) == 0: ispiši "Error:" + str(np.mean(np.abs(l2_error))) # na koji način da se krećemo? # ako smo bili sigurni u predviđanje, onda ga ne trebamo puno mijenjati l2_delta = l2_error*nonlin(l2,deriv=True) # koliko l1 vrijednosti utječu na pogreške u l2? l1_error = l2_delta.dot(syn1.T) # u kojem smjeru bismo se trebali kretati da bismo došli do l1? # ako smo bili sigurni u predviđanje, onda ga nema potrebe 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

Varijable i njihovi opisi

X je matrica ulaznog skupa podataka; žice – primjeri treninga
y je matrica skupa izlaznih podataka; žice – primjeri treninga
l0 je prvi sloj mreže definiran ulaznim podacima
l1 - drugi sloj mreže, ili skriveni sloj
l2 je završni sloj, ovo je naša hipoteza. Dok vježbate, trebali biste se približiti točnom odgovoru.
syn0 - prvi sloj utega, Synapse 0, kombinira l0 sa l1.
syn1 - drugi sloj utega, Synapse 1, kombinira l1 s l2.
l2_error - promašaj mreže u kvantitativnom smislu
l2_delta je mrežna pogreška, ovisno o sigurnosti predviđanja. Gotovo identično pogrešci, osim jakih predviđanja
l1_error - ponderiranjem l2_delta s ponderima iz syn1 izračunavamo pogrešku u srednjem/skrivenom sloju
l1_delta - mrežne pogreške od l1, skalirane po pouzdanosti predviđanja. Gotovo isto kao l1_error, osim sigurnih predviđanja

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

L1_error = l2_delta.dot(syn1.T)

Koristi pogreške ponderirane pouzdanošću predviđanja iz l2 za izračunavanje pogreške za l1. Dobivamo, moglo bi se reći, grešku ponderiranu doprinosima - izračunavamo koliki doprinos greškama u l2 daju vrijednosti na čvorovima l1. Ovaj korak se zove backpropagation. Zatim ažuriramo syn0 koristeći isti algoritam kao u dvoslojnoj neuronskoj mreži.

Sada doživljavamo pravi procvat neuronskih mreža. Koriste se za prepoznavanje, lokalizaciju i obradu slike. Neuronske mreže već su u stanju učiniti mnoge stvari koje ljudima nisu dostupne. Moramo se upustiti u ovaj posao! Razmislite o neutronskoj mreži koja će prepoznati brojeve na ulaznoj slici. Sve je vrlo jednostavno: samo jedan sloj i funkcija aktivacije. To nam neće omogućiti da prepoznamo apsolutno sve testne slike, ali možemo podnijeti veliku većinu. Kao podatke koristit ćemo poznatu zbirku podataka MNIST-a u svijetu prepoznavanja brojeva.

Za rad s njim, Python ima biblioteku python-mnist. Instalirati:

Pip instalirajte python-mnist

Sada možemo učitati podatke

Iz mnist import MNIST mndata = MNIST("/path_to_mnist_data_folder/") tr_images, tr_labels = mndata.load_training() test_images, test_labels = mndata.load_testing()

Morate sami učitati arhive s podacima i odrediti put do direktorija s njima do programa. Sada varijable tr_images i test_images sadrže slike za mrežni trening i testiranje. A varijable tr_labels i test_labels su oznake s ispravnom klasifikacijom (tj. brojevi sa slika). Sve slike su veličine 28x28. Postavimo varijablu s veličinom.

img_shape = (28, 28)

Pretvorimo sve podatke u numpy nizove i normalizirajmo ih (dovedite ih na veličinu od -1 do 1). To će povećati točnost izračuna.

Uvezi numpy kao np za i u rasponu(0, len(test_images)): test_images[i] = np.array(test_images[i]) / 255 za i u rasponu(0, len(tr_images)): tr_images[i] = np.array(tr_images[i]) / 255

Napominjem da iako je uobičajeno slike predstavljati kao dvodimenzionalni niz, mi ćemo koristiti jednodimenzionalni, lakši je za izračune. Sada morate razumjeti "što je neuronska mreža"! A ovo je samo jednadžba s puno koeficijenata. Imamo na ulazu niz od 28*28=784 elemenata i još 784 težine za određivanje svake znamenke. Tijekom rada neuronske mreže, trebate pomnožiti vrijednosti ulaza s težinama. Zbrojite primljene podatke i dodajte pomak. Pošaljite rezultat funkciji aktivacije. U našem slučaju to će biti Relu. Ova funkcija je nula za sve negativne argumente i argument za sve pozitivne.

Postoji mnogo više aktivacijskih funkcija! Ali ovo je najjednostavnija neuronska mreža! Definirajte ovu funkciju pomoću numpy

Def relu(x): vrati np.maximum(x, 0)

Sada, da biste izračunali sliku na slici, morate izračunati rezultat za 10 skupova koeficijenata.

Def nn_calculate(img): resp = lista(raspon(0, 10)) za i u rasponu(0,10): r = w[:, i] * img r = relu(np.sum(r) + b[ i]) resp[i] = r vratiti np.argmax(resp)

Za svaki skup dobit ćemo izlazni rezultat. Izlaz s najvećim rezultatom najvjerojatnije je naš broj.

U ovom slučaju, 7. To je to! Ali ne ... Uostalom, te iste koeficijente trebate uzeti negdje. Moramo trenirati našu neuronsku mrežu. Za to se koristi metoda povratnog širenja. Njegova je bit izračunati izlaze mreže, usporediti ih s ispravnim, a zatim od koeficijenata oduzeti brojeve potrebne da bi rezultat bio točan. Treba imati na umu da je za izračun ovih vrijednosti potrebna derivacija aktivacijske funkcije. U našem slučaju jednaka je nuli za sve negativne brojeve i 1 za sve pozitivne. Koeficijente određujemo nasumično.

W = (2*np.random.rand(10, 784) - 1) / 10 b = (2*np.random.rand(10) - 1) / 10 za n u rasponu(len(tr_images)): img = tr_images[n] cls = tr_labels[n] #forward propagation resp = np.zeros(10, dtype=np.float32) za i u rasponu(0,10): r = w[i] * img r = relu( np.sum(r) + b[i]) resp[i] = r resp_cls = np.argmax(resp) resp = np.zeros(10, dtype=np.float32) resp = 1.0 #povratno širenje true_resp = np. nule(10, dtype=np.float32) true_resp = 1.0 pogreška = resp - true_resp delta = pogreška * ((resp >= 0) * np.ones(10)) za i u rasponu (0,10): w[i ] -= np.dot(img, delta[i]) b[i] -= delta[i]

U procesu učenja koeficijenti će postati malo slični brojevima:

Provjerimo točnost rada:

Def nn_calculate(img): resp = lista(raspon(0, 10)) za i u rasponu(0,10): r = w[i] * img r = np.maximum(np.sum(r) + b[ i], 0) #relu resp[i] = r vrati np.argmax(resp) ukupno = len(test_images) valjano = 0 nevažeće = za i u rasponu(0, ukupno): img = test_images[i] predviđeno = nn_izračunaj (img) true = test_labels[i] ako je predviđeno == true: valjano = valjano + 1 ostalo: invalid.append(("image":img, "predicted":predicted, "true":true)) print("točnost ()".format(važeće/ukupno))

Dobio sam 88%. Nije tako cool, ali vrlo zanimljivo!

Keras je popularna knjižnica dubokog učenja koja je dala veliki doprinos komercijalizaciji dubokog učenja. Knjižnica Keras jednostavna je 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 korisničke ocjene proizvoda na temelju njihovih recenzija, razvrstavajući ga u dvije kategorije: pozitivne ili negativne. Ovaj zadatak se zove analiza osjećaja (analiza osjećaja), a mi ćemo to riješiti na IMDb stranici za pregled filmova. Model koji gradimo može se primijeniti i na druge probleme uz manje izmjene.

Imajte na umu da nećemo ulaziti u detalje Kerasa i dubokog učenja. Ovaj post ima za cilj pružiti shemu u Kerasu i upoznati vas s njenom implementacijom.

• Što je Keras?
• Što je analiza osjećaja?
• IMDB skup podataka
• Istraživanje podataka
• Priprema podataka
• Izgradnja i obuka modela

Što je Keras?

Keras je Python biblioteka otvorenog koda koja 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 numerički Python okviri za razvoj algoritama dubokog učenja, ali su prilično teški za korištenje.

Ocijenite popularnost okvira za strojno učenje u 7 kategorija

Keras, s druge strane, pruža jednostavan i praktičan način za izgradnju modela dubokog učenja. Njegov tvorac, François Chollet, osmislio ga je kako bi proces izgradnje neuronskih mreža bio što brži i lakši. Fokusirao se na proširivost, modularnost, minimalizam i podršku za Python. Keras se može koristiti s GPU-om i CPU-om; podržava i Python 2 i Python 3. Googleov Keras dao je veliki doprinos komercijalizaciji dubokog učenja i zato što sadrži najsuvremenije algoritme dubokog učenja koji su prije bili ne samo nedostupni nego i neupotrebljivi.

Što je analiza osjećaja (analiza osjećaja)?

Uz pomoć analize osjećaja može se odrediti stav (na primjer, raspoloženje) osobe prema tekstu, interakciji ili događaju. Dakle, analiza osjećaja spada u područje obrade prirodnog jezika, u kojem se značenje teksta mora dešifrirati kako bi se iz njega izvukao osjećaj i sentiment.

Primjer skale analize osjećaja

Spektar raspoloženja obično se dijeli na pozitivno, negativno i neutralno kategorije. Koristeći analizu osjećaja, možete, na primjer, predvidjeti mišljenja i stavove kupaca o proizvodu na temelju njihovih recenzija. Stoga se analiza osjećaja široko primjenjuje na ankete, 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 su unaprijed obrađene i svaka je kodirana nizom indeksa riječi kao cijeli brojevi.
• Riječi u recenzijama indeksirane su prema njihovoj ukupnoj učestalosti pojavljivanja u skupu podataka. Na primjer, cijeli broj "2" kodira drugu najčešće korištenu riječ.
• 50.000 recenzija 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 je također korišten kao dio Keggle Community Contest "Vreća riječi susreće vrećice kokica" u 2011.

Uvezite ovisnosti i dohvatite podatke

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 iz keras.utils import to_categorical iz keras import modela iz keras import slojeva

Skinimo IMDb skup podataka koji je već ugrađen u Keras. Budući da ne želimo imati podatke o obuci i testiranju u omjeru 50/50, te ćemo podatke odmah spojiti nakon učitavanja radi kasnijeg dijeljenja. u omjeru 80/20:

Iz keras.datasets uvezite imdb (podaci_treninga, ciljevi_treninga), (testing_data, testing_targets) = imdb.load_data(num_words=10000) data = np.concatenate((training_data, testing_data), axis=0) targeting_cate(strain_target(np. , testing_targets), os=0)

Istraživanje podataka

Pogledajmo naš skup podataka:

Print("Kategorije:", np.unique(ciljevi)) print("Broj jedinstvenih riječi:", len(np.unique(np.hstack(data)))) Kategorije: Broj jedinstvenih riječi: 9998 dužina = ispis ("Prosječna duljina recenzije:", np.srednja(dužina)) print("Standardna devijacija:", okrugla(np.std(length))) Prosječna duljina recenzije: 234,75892 Standardna devijacija: 173,0

Vidi se da svi podaci pripadaju dvije kategorije: 0 ili 1, što predstavlja raspoloženje recenzije. Cijeli skup podataka sadrži 9998 jedinstvenih riječi, prosječna veličina pregleda je 234 riječi sa standardnom devijacijom od 173.

Razmotrite jednostavan način učenja:

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

Ovdje vidite prvu recenziju iz skupa podataka, koja je označena pozitivno (1). Sljedeći kod pretvara indekse natrag u riječi kako bismo ih mogli čitati. U njemu se svaka nepoznata riječ zamjenjuje s "#". To se radi pomoću funkcije get_word_index().

Index = imdb.get_word_index() reverse_index = dict([(vrijednost, ključ) za (ključ, vrijednost) u index.items()]) decoded = " ".join() print(decoded) # ovaj film je bio samo briljantan casting lokacija scenografija režija priče svi su stvarno odgovarali ulozi koju su igrali i mogli ste samo zamisliti da ste tamo Robert # je nevjerojatan glumac, a sada isti kao redatelj # otac dolazi s istog škotskog otoka kao i ja pa mi se svidjela činjenica da postoji stvarna povezanost s ovim filmom, duhovite primjedbe u cijelom filmu bile su sjajne da je bio toliko briljantan da sam kupio film čim je izašao za # i preporučio bih ga svima za gledanje, a ribolov na mušicu je bio nevjerojatan stvarno plakao na na kraju, bilo je tako tužno i znaš što kažu ako plačeš na filmu mora da je bio dobar i ovo je definitivno bilo # za dva dječaka koji su glumili # Normana i Paula bili su samo briljantna djeca su često izostavljen s popisa # mislim jer zvijezde koje ih igraju sve gro wn up su tako veliki profil za cijeli film, ali ova djeca su nevjerojatna i treba ih pohvaliti za ono što su napravili zar ne mislite da je cijela priča bila tako lijepa jer je bila istinita i bila je nečiji život nakon svega što je podijeljeno mi svi

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 je svaka recenzija kraća od 10.000 riječi ispunjena nulama. To je zato što je najveći pogled gotovo iste veličine, a svaki element našeg ulaza neuronske mreže mora biti iste veličine. Također morate pretvoriti varijable u tip plutati.

Def vectorize(sekvencije, dimenzija = 10000): rezultati = np.zero((len(sekvence), dimenzija)) za i, slijed u enumerate(sekvence): rezultati = 1 povratak rezultata podaci = vektoriziranje(podaci) ciljevi = np. niz(ciljevi).astype("float32")

Podijelimo skup podataka na skupove za obuku i testiranje. Set za obuku sastojat će se od 40.000 pregleda, a testni set od 10.000.

test_x = podaci[:10000] test_y = ciljevi[:10000] vlak_x = podatkovni vlak_y = ciljevi

Izgradnja i obuka modela

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

Zatim morate dodati ulazne, skrivene i izlazne slojeve. Kako bismo spriječili prekomjerno uklapanje, koristit ćemo iznimku između njih ( napustiti). Imajte na umu da uvijek trebate koristiti stopu isključenja između 20% i 50%. Svaki sloj ima funkciju "gusto" kako bi se slojevi u potpunosti povezali jedan s drugim. U skrivenim slojevima koristit ćemo se "relu", pa gotovo uvijek dovodi do zadovoljavajućih rezultata. Slobodno eksperimentirajte s drugim funkcijama aktivacije. Na izlaznom sloju koristimo sigmoidnu funkciju koja renormalizira vrijednosti u rasponu od 0 do 1. Imajte na umu da smo postavili veličinu ulaznih elemenata skupa podataka na 10.000 jer su naši pogledi veličine do 10.000 cijelih brojeva. Ulazni sloj prihvaća elemente veličine 10.000, a izlazi veličine 50.

Na kraju, neka Keras iznese kratak opis modela koji smo upravo stvorili.

# 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, aktivacija = "relu") model.add(layers.Dropout(0.2, noise_shape=None, seed=None)) model.add(layers.Dense(50, activation = "relu) ")) # Output- Layer model.add(layers.Dense(1, activation = "sigmoid"))model.summary() model.summary() _________________________________________________________________ Layer (type) Output Shape Param # ======= =================================================== 0 0 ________________________________________________________________ gusto_3 (Gusto ) (Ništa, 50) 2550 ________________________________________________________________ gusto_4 (Gusto) (Nema, 1) 51 ================================ ================================== Ukupni parametri: 505.201 Parametri koji se mogu trenirati: 505.201 Parametri koji se ne mogu trenirati: 0

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

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

Sada možemo trenirati naš model. Radit ćemo to s veličinom serije od 500 i samo dvije epohe kako sam saznao model se počinje prekvalificirati ako ga duže treniraš. Veličina serije određuje broj elemenata koji će biti raspoređeni po mreži, a epoha je jedan prolaz svih elemenata skupa podataka. Obično veća veličina serije dovodi do bržeg učenja, ali ne uvijek brze konvergencije. Manja veličina serije trenira se sporije, ali može brže konvergirati. Odabir jedne ili druge opcije definitivno ovisi o vrsti problema koji se rješava, a bolje je isprobati svaku od njih. Ako ste novi u ovoj stvari, savjetovao bih vam da prvo upotrijebite veličina partije 32, što je neka vrsta standarda.

Rezultati = model.fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) Vježbajte na 40000 uzoraka, potvrdite 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 400 /40000 [=============================] - 4s 90us/korak - gubitak: 0,2122 - acc: 0,9190 - val_loss: 0,2598 - val_acc: 0,8950

Procijenimo performanse modela:

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

Fino! Naš jednostavni model već je oborio rekord točnosti u radu iz 2011. godine. spomenuto na početku posta. Slobodno eksperimentirajte s mrežnim parametrima i brojem slojeva.

Kompletan kod modela prikazan je u nastavku:

Uvezi numpy kao np iz keras.utils import to_categorical iz keras uvozi modele iz keras import slojeva iz keras.datasets import imdb (training_data, training_targets), (testing_data, testing_targets) = imdb.load_data(num_wordscon data=10000.) (podaci_treninga, podaci_testiranja), os=0) ciljevi = np.udružiti((ciljevi_treninga, ciljevi_testiranja), os=0) def vectorize(sekvencije, dimenzija = 10000): rezultati = np.nula((len(sekvencije), dimenzija) ) za i, slijed u enumerate(sekvence): rezultati = 1 vraćanje rezultata podaci = vektorizacija(podaci) ciljevi = np.array(targets).astype("float32") test_x = podaci[:10000] test_y = ciljevi[:10000 ] train_x = podaci train_y = ciljni model = modeli.Sequential() # Ulaz - Sloj model.add(layers.Dense(50, aktivacija = "relu", input_shape=(10000,))) # Skriven - 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")) # Output- Layer model.add(layers.Dense(1, activation = "sigmoid")) model.summary() # kompajliranje modela model.compile(optimizer = "adam", gubitak = "binary_crossentropy", metrics = ["accuracy"]) rezultati = model. fit(train_x, train_y, epochs= 2, batch_size = 500, validation_data = (test_x, test_y)) print("Test- Točnost:", np.mean(results.history["val_acc"]))

Rezultati

Naučili ste što je analiza osjećaja i zašto je Keras jedna od najpopularnijih knjižnica dubokog učenja.

Stvorili smo jednostavnu neuronsku mrežu sa šest slojeva koja može izračunati raspoloženje recenzenta filmova s ​​točnošću od 89%. Sada možete koristiti ovaj model za analizu binarnih osjećaja u drugim izvorima, ali za to ćete morati postaviti njihovu veličinu na 10.000 ili promijeniti parametre ulaznog sloja.

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

Neuronske mreže se stvaraju i treniraju uglavnom u Pythonu. Stoga je vrlo važno imati osnovno razumijevanje kako pisati programe na njemu. U ovom članku ću kratko i jasno govoriti o osnovnim konceptima ovog jezika: varijablama, funkcijama, klasama i modulima.

Materijal je namijenjen osobama koje ne poznaju programske jezike.

Prvo morate instalirati Python. Zatim morate postaviti prikladno okruženje za pisanje programa u Pythonu. Ova dva koraka posvećena su portalu.

Ako je sve instalirano i konfigurirano, možete početi.

Varijable

Varijabilna- ključni koncept u bilo kojem programskom jeziku (i ne samo u njima). Varijablu je najlakše zamisliti kao okvir s oznakom. Ovaj okvir sadrži nešto (broj, matricu, objekt, ...) što nam je vrijedno.

Na primjer, recimo da želimo stvoriti varijablu x koja bi trebala pohraniti vrijednost 10. U Pythonu bi kod za stvaranje ove varijable izgledao ovako:

S lijeve strane mi objaviti varijabla pod nazivom x . To je jednako činjenici da smo na kutiju zalijepili osobnu naljepnicu. Slijedi znak jednakosti i broj 10. Znak jednakosti ovdje igra neobičnu ulogu. To ne znači da je "x 10". Jednakost u ovom slučaju stavlja broj 10 u okvir. Točnije rečeno, mi dodijeliti varijabla x broj 10.

Sada, u kodu ispod, možemo pristupiti ovoj varijabli i izvoditi razne radnje s njom.

Možete jednostavno prikazati vrijednost ove varijable na ekranu:

X=10 ispisa(x)

Natpis print(x) je poziv funkcije. Razmotrit ćemo ih dalje. Sada je važno da ova funkcija ispisuje na konzolu ono što se nalazi između zagrada. Imamo x između zagrada. Prije smo x dodijelili vrijednost 10. To je točno 10 koje se prikazuje u konzoli ako pokrenete gornji program.

S varijablama koje pohranjuju brojeve možete izvoditi razne jednostavne operacije: zbrajati, oduzimati, množiti, dijeliti i podizati na stepen.

X = 2 y = 3 # Dodaj z = x + y print(z) # 5 # Razlika z = x - y print(z) # -1 # Proizvod z = x * y print(z) # 6 # Podijeli z = x / y print(z) # 0,66666... ​​# Eksponencijacija z = x ** y print(z) # 8

U gornjem kodu prvo kreiramo dvije varijable koje sadrže 2 i 3. Zatim kreiramo varijablu z koja pohranjuje rezultat operacije na x i y i ispisuje rezultate na konzolu. Ovaj primjer jasno pokazuje da varijabla može promijeniti svoju vrijednost tijekom izvršavanja programa. Dakle, naša varijabla z mijenja svoju vrijednost čak 5 puta.

Funkcije

Ponekad postaje potrebno izvršiti iste radnje više puta. Na primjer, u našem projektu često moramo prikazati 5 redaka teksta.

"Ovo je vrlo važan tekst!"
"Ovaj tekst se ne može pročitati"
"Greška u gornjoj liniji je napravljena namjerno"
"Zdravo i doviđenja"
"Kraj"

Naš kod će izgledati ovako:

X = 10 y = x + 8 - 2 print("Ovo je vrlo važan tekst!") print("Ovaj tekst se ne smije čitati") print("Namjerno je došlo do greške u gornjem retku") print( "Bok i ćao") print ("Kraj") z = x + y print("Ovo je vrlo važan tekst!") print("Ovaj tekst se ne može pročitati") print("Došlo je do pogreške u gornjem retku namjerno") print("Bok i ćao") print ("Kraj") test = z print("Ovo je vrlo važan tekst!") print("Ovaj tekst se ne može pročitati") print("Pogreška u gornji red je napravljen namjerno") print("Bok i ćao") print(" Kraj")

Sve to izgleda vrlo suvišno i nezgodno. Također, postoji greška u drugom redu. Može se popraviti, ali morat će se popraviti na tri mjesta odjednom. A ako se u našem projektu ovih pet redaka pozove 1000 puta? I sve to na različitim mjestima i datotekama?

Posebno u slučajevima kada je potrebno često izvršavati iste naredbe, programski jezici mogu kreirati funkcije.

Funkcija- zaseban blok koda koji se može nazvati imenom.

Funkcija je definirana pomoću ključne riječi def. Nakon toga slijedi naziv funkcije, zatim zagrade i dvotočka. Zatim, uvučeno, trebate navesti radnje koje će se izvesti kada se funkcija pozove.

Def print_5_lines(): print("Ovo je vrlo važan tekst!") print("Ovaj tekst se ne može pročitati") print("Gornji red je namjerno bio pogrešan") print("Zdravo i ćao") print(" Kraj")

Sada smo definirali funkciju print_5_lines(). Sada, ako u našem projektu još jednom trebamo umetnuti pet redaka, onda jednostavno pozivamo našu funkciju. Automatski će izvršiti sve radnje.

# Definirajte funkciju def print_5_lines(): print("Ovo je vrlo važan tekst!") print("Ovaj tekst se ne može pročitati") print("Pogreška u gornjem retku je napravljena namjerno") print("Bok i bok") print(" Kraj") # Naš kod projekta x = 10 y = x + 8 - 2 print_5_lines() z = x + y print_5_lines() test = z print_5_lines()

Zgodno, zar ne? Ozbiljno smo poboljšali čitljivost koda. Osim toga, funkcije su također dobre jer ako želite promijeniti neku od radnji, onda je dovoljno dotjerati samu funkciju. Ova promjena će raditi na svim mjestima na kojima se poziva vaša funkcija. To jest, možemo popraviti pogrešku u drugom retku izlaznog teksta (“nije dopušteno” > “nije dopušteno”) u tijelu funkcije. Ispravna varijanta automatski će biti pozvana na svim mjestima našeg projekta.

Funkcije s parametrima

Naravno, zgodno je samo ponavljanje nekoliko koraka. Ali to nije sve. Ponekad želimo prenijeti neku varijablu našoj funkciji. Dakle, funkcija može primati podatke i koristiti ih u procesu izvršavanja naredbi.

Pozivaju se varijable koje prosljeđujemo funkciji argumentima.

Napišimo jednostavnu funkciju koja zbraja dva data broja i vraća rezultat.

Def zbroj(a, b): rezultat = a + b vraća rezultat

Prvi redak izgleda gotovo isto kao i obične funkcije. Ali između zagrada su sada dvije varijable. Ovaj parametrima funkcije. Naša funkcija ima dva parametra (odnosno, uzima dvije varijable).

Parametri se mogu koristiti unutar funkcije baš kao i obične varijable. U drugom retku stvaramo varijabilni rezultat, koji je jednak zbroju parametara a i b. U trećem retku vraćamo vrijednost varijable rezultata.

Sada, u daljnjem kodu, možemo napisati nešto poput:

Novo = zbroj (2, 3) ispis (novo)

Pozivamo funkciju zbroja i prosljeđujemo joj dva argumenta redom: 2 i 3. 2 postaje vrijednost varijable a, a 3 postaje vrijednost varijable b. Naša funkcija vraća vrijednost (zbroj 2 i 3) i koristimo je za stvaranje nove varijable new .

Zapamtiti. U gornjem kodu, brojevi 2 i 3 su argumenti funkcije zbroja. A u samoj funkciji zbroja, varijable a i b su parametri. Drugim riječima, varijable koje prosljeđujemo funkciji kada se ona pozove nazivaju se argumenti. Ali unutar funkcije, te proslijeđene varijable nazivaju se parametri. Zapravo, to su dva naziva za istu stvar, ali ih ne smijete brkati.

Razmotrimo još jedan primjer. Kreirajmo funkciju square(a) koja uzima jedan broj i kvadrira ga:

Def square(a): vrati a * a

Naša funkcija se sastoji od samo jednog retka. Odmah vraća rezultat množenja parametra a s a .

Mislim da ste već pogodili da također proizvodimo izlaz podataka na konzolu pomoću funkcije. Ova funkcija se zove print() i ispisuje argument koji joj je proslijeđen na konzolu: broj, niz, varijablu.

Nizovi

Ako se varijabla može zamisliti kao kutija koja sadrži nešto (ne nužno broj), tada se nizovi mogu smatrati policama za knjige. Sadrže nekoliko varijabli odjednom. Evo primjera niza od tri broja i jednog niza:

niz=

Evo primjera, kada varijabla ne sadrži broj, nekom drugom objektu. U ovom slučaju, naša varijabla sadrži niz. Svaki element niza je numeriran. Pokušajmo prikazati neki element niza:

Niz = ispis (niz)

U konzoli ćete vidjeti broj 89. Ali zašto 89, a ne 1? Stvar je u tome da u Pythonu, kao iu mnogim drugim programskim jezicima, numeriranje nizova počinje od 0. Dakle, niz nam daje drugi element niza, a ne prvi. Za pozivanje prvog, trebalo je napisati niz .

Veličina niza

Ponekad je vrlo korisno dobiti broj elemenata u nizu. Za to možete koristiti funkciju len(). Automatski će prebrojati broj elemenata i vratiti njihov broj.

Niz = ispis (len(niz))

Na konzoli će se prikazati broj 4.

Uvjeti i ciklusi

Prema zadanim postavkama, bilo koji programi jednostavno izvršavaju sve naredbe od vrha do dna u nizu. No, postoje situacije kada trebamo provjeriti neki uvjet, pa ovisno o tome je li to točno ili ne, izvršiti različite radnje.

Osim toga, često postaje potrebno ponoviti gotovo isti slijed naredbi mnogo puta.

U prvoj situaciji pomažu uvjeti, a u drugoj ciklusi.

Pojmovi

Uvjeti su potrebni za izvođenje dva različita skupa radnji ovisno o tome je li tvrdnja koja se testira istinita ili netočna.

U Pythonu se uvjeti mogu napisati korištenjem if: ... else: ... konstrukcije. Recimo da imamo neku varijablu x = 10 . Ako je x manji od 10, tada želimo x podijeliti s 2. Ako je x veći ili jednak 10, tada želimo stvoriti drugu varijablu new , koja je jednaka zbroju x i broja 100. Kod izgledalo bi ovako:

X = 10 ako (x< 10): x = x / 2 print(x) else: new = x + 100 print(new)

Nakon kreiranja varijable x, počinjemo pisati naš uvjet.

Sve počinje ključnom riječi if (prevedeno s engleskog "ako"). U zagradama označavamo izraz koji treba provjeriti. U ovom slučaju provjeravamo je li naša varijabla x stvarno manja od 10. Ako je stvarno manja od 10, tada je dijelimo s 2 i ispisujemo rezultat na konzolu.

Zatim dolazi ključna riječ else , nakon čega počinje blok radnji koje će se izvršiti ako je izraz u zagradama iza if netočan.

Ako je veći ili jednak 10, tada kreiramo novu varijablu new, koja je jednaka x + 100 i također je ispisujemo na konzolu.

Ciklusi

Petlje se koriste za ponavljanje radnji iznova i iznova. Pretpostavimo da želimo prikazati tablicu kvadrata prvih 10 prirodnih brojeva. Može se ovako.

Print("Kvadrat 1 je " + str(1**2)) print("Kvadrat 2 je " + str(2**2)) print("Kvadrat 3 je " + str(3**2)) print( "Kvadrat 4 je " + str(4**2)) print("Kvadrat 5 je " + str(5**2)) print("Kvadrat 6 je " + str(6**2)) print("Kvadrat 7 je " + str(7**2)) print("Kvadrat 8 je " + str(8**2)) print("Kvadrat 9 je " + str(9**2)) print("Kvadrat 10 je " + str(10**2))

Nemojte se iznenaditi činjenicom da dodajemo žice. "početak niza" + "kraj" u Pythonu jednostavno znači spajanje nizova: "početak stringenda". Na isti način iznad, dodajemo niz "Kvadrat x je jednak" i rezultat podizanja broja na 2. stepen pretvoren pomoću funkcije str (x ** 2).

Gornji kod izgleda vrlo suvišan. Ali što ako trebamo ispisati kvadrate prvih 100 brojeva? Muči nas se povući...

Tome služe ciklusi. Postoje 2 vrste petlji u Pythonu: while i for . Pozabavimo se njima redom.

Dok petlja ponavlja potrebne naredbe sve dok uvjet ostaje istinit.

X = 1 dok je x<= 100: print("Квадрат числа " + str(x) + " равен " + str(x**2)) x = x + 1

Prvo kreiramo varijablu i dodijelimo joj broj 1. Zatim kreiramo while petlju i provjeravamo je li naš x manji od (ili jednak) 100. Ako je manje od (ili jednako), tada izvodimo dvije radnje:

1. Izvodimo kvadrat x
2. Povećaj x za 1

Nakon druge naredbe program se vraća u stanje. Ako je uvjet ponovno istinit, tada ponovno izvodimo ove dvije radnje. I tako sve dok x ne postane jednako 101. Tada će se uvjet vratiti lažno i petlja se više neće izvršavati.

Petlja for je dizajnirana za ponavljanje nizova. Napišimo isti primjer s kvadratima prvih sto prirodnih brojeva, ali kroz petlju for.

Za x u rasponu (1101): print("Kvadrat od " + str(x) + " je " + str(x**2))

Analizirajmo prvi redak. Koristimo ključnu riječ for za stvaranje petlje. Zatim označavamo da želimo ponoviti određene radnje za sve x u rasponu od 1 do 100. Funkcija range(1,101) stvara niz od 100 brojeva, počevši s 1 i završavajući sa 100.

Evo još jednog primjera ponavljanja niza pomoću for petlje:

Za i in : ispis (i * 2)

Gornji kod daje 4 znamenke: 2, 20, 200 i 2000. Ovdje možete jasno vidjeti kako uzima svaki element niza i izvodi skup radnji. Zatim uzima sljedeći element i ponavlja isti skup radnji. I tako sve dok ne ponestane elemenata u nizu.

Klase i objekti

U stvarnom životu ne operiramo s varijablama ili funkcijama, već s objektima. Olovka, auto, čovjek, mačka, pas, avion - predmeti. Sada počnimo detaljno promatrati mačku.

Ima neke opcije. To uključuje boju kaputa, boju očiju, njezin nadimak. Ali to nije sve. Osim parametara, mačka može izvoditi razne radnje: predeti, šištati i grebati.

Upravo smo shematski opisali sve mačke općenito. Sličan opis svojstava i radnji neki objekt (na primjer, mačka) u jeziku Python i naziva se klasa. Klasa je jednostavno zbirka varijabli i funkcija koje opisuju neku vrstu objekta.

Važno je razumjeti razliku između klase i objekta. razred - shema A koji opisuje objekt. Objekt je ona materijalno utjelovljenje. Mačka klasa je opis njezinih svojstava i radnji. Mačji objekt je sama stvarna mačka. Može postojati mnogo različitih pravih mačaka – mnogo mačjih objekata. Ali postoji samo jedna klasa mačaka. Slika ispod je dobra demonstracija:

Nastava

Da bismo stvorili klasu (shema naše mačke), moramo napisati ključnu riječ class, a zatim odrediti naziv ove klase:

Klasa mačka:

Zatim moramo navesti radnje ove klase (radnje mačke). Akcije su, kao što ste mogli pretpostaviti, funkcije definirane unutar klase. Takve funkcije unutar klase nazivaju se metodama.

Metoda- funkcija definirana unutar klase.

Verbalno, već smo gore opisali mačje metode: predenje, siktanje, grebanje. Učinimo to sada u Pythonu.

# Cat class Class Cat: # Purr def purr(self): print("Purrr!") # Šištanje def hiss(self): print("Kshh!") # Scratch def scrabble(self): print("Scratch-scratch !")

To je tako jednostavno! Uzeli smo i definirali tri regularne funkcije, ali samo unutar klase.

Kako bismo se pozabavili neshvatljivim parametrom selfa, dodajmo još jednu metodu našoj mački. Ova metoda će pozvati sve tri metode koje su već stvorene odjednom.

# Cat class Class Cat: # Purr def purr(self): print("Purrr!") # Šištanje def hiss(self): print("Kshh!") # Scratch def scrabble(self): print("Scratch-scratch !") # Sve zajedno def all_in_one(self): self.purr() self.hiss() self.scrabble()

Kao što vidite, self parametar, koji je obavezan za svaku metodu, omogućuje nam pristup metodama i varijablama same klase! Bez ovog argumenta ne bismo mogli izvoditi takve radnje.

Postavimo sada svojstva naše mačke (boja dlake, boja očiju, nadimak). Kako to učiniti? U apsolutno svakoj klasi možete definirati funkciju __init__(). Ova funkcija se uvijek poziva kada kreiramo pravi objekt naše klase.

U gore istaknutoj metodi __init__() postavili smo varijable naše mačke. Kako ćemo to učiniti? Prvo, ovoj metodi prosljeđujemo 3 argumenta, koji su odgovorni za boju kaputa, boju očiju i nadimak. Zatim koristimo self parametar kako bismo odmah postavili našu mačku s 3 gore opisana atributa prilikom stvaranja objekta.

Što znači ova linija?

Self.wool_color = boja_wool_color

Na lijevoj strani kreiramo atribut za našu mačku pod nazivom wool_color , a zatim taj atribut postavljamo na vrijednost sadržanu u parametru wool_color koji smo proslijedili funkciji __init__(). Kao što možete vidjeti, gornji redak se ne razlikuje od uobičajenog stvaranja varijable. Samo prefiks self označava da ova varijabla pripada Cat klasi.

Atribut- varijabla koja pripada nekoj klasi.

Dakle, stvorili smo gotovu klasu za mačke. Evo njegovog koda:

# Cat klasa klase Cat: # Radnje koje treba poduzeti prilikom kreiranja Cat objekta def __init__(self, wool_color, eyes_color, name): self.wool_color = wool_color self.eyes_color = eyes_color self.name = name # Purr def purr( self): print("Purrr!") # Scrabble def hiss(self): print("Shh!") # Scrabble def scrabble(self): print("Scratch-scratch!") # Sve zajedno def all_in_one(self) : self. predenje() self.hiss() self.scrabble()

Objekti

Napravili smo shemu za mačke. Sada napravimo pravi objekt mačke prema ovoj shemi:

Moja_mačka = Mačka("crna", "zelena", "Zosja")

U gornjem retku stvaramo varijablu my_cat i zatim joj dodjeljujemo objekt klase Cat. Sve ovo izgleda kao poziv neke funkcije Cat(...) . Zapravo i jest. Ovim unosom pozivamo metodu __init__() klase Cat. Funkcija __init__() u našoj klasi uzima 4 argumenta: sam objekt klase self, koji ne treba specificirati, kao i još 3 različita argumenta, koji tada postaju atributi naše mačke.

Dakle, uz pomoć gornje linije, stvorili smo pravi objekt mačke. Naša mačka ima sljedeće atribute: crnu kosu, zelene oči i nadimak Zosya. Ispišimo ove atribute na konzolu:

Print(my_cat.wool_color) print(my_cat.eyes_color) print(my_cat.name)

Odnosno, možemo se pozvati na atribute objekta tako da napišemo naziv objekta, stavimo točku i odredimo naziv željenog atributa.

Atributi mačke se mogu mijenjati. Na primjer, promijenimo ime naše mačke:

My_cat.name = "Nyusha"

Sada, ako ponovno ispišete ime mačke na konzoli, umjesto Zosia vidjet ćete Nyusha.

Dopustite mi da vas podsjetim da klasa naše mačke dopušta joj da izvodi neke radnje. Ako pomilujemo našu Zosju / Njušu, ona će početi predeti:

moja_mačka.predenje()

Izvođenje ove naredbe prikazat će tekst "Murrr!" na konzoli. Kao što možete vidjeti, pristup metodama objekta jednako je jednostavan kao i pristup njegovim atributima.

Moduli

Svaka datoteka s nastavkom .py je modul. Čak i onaj u kojem radite na ovom članku. Za što su oni potrebni? Za praktičnost. Mnogo ljudi stvara datoteke s korisnim funkcijama i klasama. Ostali programeri uključuju ove module treće strane i mogu koristiti sve funkcije i klase definirane u njima, čime se pojednostavljuje njihov rad.

Na primjer, ne morate trošiti vrijeme na pisanje vlastitih funkcija za rad s matricama. Dovoljno je uključiti modul numpy i koristiti njegove funkcije i klase.

Do sada su drugi Python programeri napisali preko 110 000 različitih modula. Gore spomenuti numpy modul omogućuje brz i praktičan rad s matricama i višedimenzionalnim nizovima. Matematički modul nudi mnoge metode za rad s brojevima: sinuse, kosinuse, pretvaranje stupnjeva u radijane i tako dalje i tako dalje...

Instalacija modula

Python je instaliran zajedno sa standardnim skupom modula. Ovaj set uključuje vrlo velik broj modula koji vam omogućuju rad s matematikom, web upitima, čitanje i pisanje datoteka te obavljanje drugih potrebnih radnji.

Ako želite koristiti modul koji nije uključen u standardni set, morat ćete ga instalirati. Da biste instalirali modul, otvorite naredbeni redak (Win + R, zatim unesite "cmd" u polje koje se pojavi) i unesite naredbu u nju:

Pip instalacija [module_name]

Započet će proces instalacije modula. Kada se završi, možete sigurno koristiti instalirani modul u svom programu.

Povezivanje i korištenje modula

Modul treće strane spojen je vrlo jednostavno. Trebate napisati samo jedan kratki redak koda:

Uvezi [naziv_modula]

Na primjer, da biste uvezli modul koji vam omogućuje rad s matematičkim funkcijama, trebate napisati sljedeće:

uvoz matematike

Kako pristupiti funkciji modula? Trebate napisati naziv modula, zatim staviti točku i napisati naziv funkcije/klase. Na primjer, faktorijel od 10 nalazi se ovako:

Matematika.faktorijal(10)

Odnosno, okrenuli smo se funkciji faktorijala(a), koja je definirana unutar matematičkog modula. To je zgodno, jer ne trebamo gubiti vrijeme i ručno kreirati funkciju koja izračunava faktorijel broja. Možete spojiti modul i odmah izvršiti potrebnu radnju.

Izvornik: Stvaranje neuronske mreže u Pythonu
Autor: John Serrano
Datum objave: 26. svibnja 2016
Prijevod: A.Panin
Datum prijenosa: 06.12.2016

Neuronske mreže su iznimno složeni programi, razumljivi samo akademicima i genijima, s kojima se po definiciji ne mogu nositi obični programeri, da ne spominjem mene. mislite li tako?

Pa zapravo uopće nije tako. Nakon sjajne prezentacije Louisa Moniera i Grega Renarda na koledžu Holberton, shvatio sam da su neuronske mreže dovoljno jednostavne da ih svaki programer softvera razumije i implementira. Naravno, najsloženije mreže su projekti velikih razmjera s elegantnom i zamršenom arhitekturom, ali koncepti iza njih također su više-manje očiti. Dizajniranje bilo koje neuronske mreže od nule može biti popriličan izazov, ali srećom postoje neke sjajne knjižnice koje mogu obaviti sav posao niske razine umjesto vas.

U ovom kontekstu, neuron je prilično jednostavan entitet. Prihvaća nekoliko ulaznih vrijednosti i ako zbroj tih vrijednosti prijeđe navedenu granicu, aktivira se. U ovom slučaju, svaka ulazna vrijednost se množi svojom težinom. Proces učenja je u biti proces postavljanja pondera vrijednosti za generiranje traženih izlaznih vrijednosti. Mreže o kojima će se raspravljati u ovom članku nazivaju se mrežama širenja prema naprijed, što znači da su neuroni u njima raspoređeni po razinama, pri čemu njihovi ulazi dolaze s prethodne razine, a njihovi izlazi šalju se na sljedeću razinu.

Postoje i druge vrste neuronskih mreža, kao što su rekurentne neuronske mreže, koje su organizirane na drugačiji način, ali to je tema za drugi članak.

Neuron koji radi prema gore opisanom principu naziva se perceptron i temelji se na originalnom modelu umjetnih neurona koji se danas rijetko koristi. Problem s perceptronima je što mala promjena ulaznih vrijednosti može dovesti do velike promjene izlazne vrijednosti zbog funkcije koraka aktivacije. U tom slučaju, blagi pad ulazne vrijednosti može dovesti do činjenice da unutarnja vrijednost neće premašiti postavljenu granicu i neuron se neće aktivirati, što će dovesti do još značajnijih promjena u stanju neurona koji ga prate . Srećom, ovaj se problem lako rješava glatkijom funkcijom aktivacije koja se danas koristi u većini mreža.

Međutim, naša neuronska mreža bit će toliko jednostavna da su perceptroni sasvim prikladni za njezino stvaranje. Napravit ćemo mrežu koja izvodi logičku operaciju "I". To znači da će nam trebati dva ulazna neurona i jedan izlazni neuron, kao i nekoliko neurona u "skrivenom" sloju između. Ilustracija u nastavku prikazuje arhitekturu ove mreže, koja bi trebala biti prilično razumljiva.

Monier i Renard koristili su skriptu convnet.js za kreiranje demo mreže za svoj razgovor. Convnet.js se može koristiti za stvaranje neuronskih mreža izravno u vašem web pregledniku, omogućujući vam da ih istražite i modificirate na gotovo svakoj platformi. Naravno, ova implementacija JavaScripta također ima značajne nedostatke, od kojih je jedna mala brzina. Pa, u ovom članku koristit ćemo biblioteku FANN (Fast Artifical Neural Networks). U ovom slučaju, na razini programskog jezika Python koristit će se modul pyfann koji sadrži veze za FANN biblioteku. Trebali biste odmah instalirati softverski paket s ovim modulom.

Uvoz modula za rad s FANN bibliotekom vrši se na sljedeći način:

>>> iz pyfann import libfann

Sada možemo početi! Prva operacija koju ćemo morati izvesti je stvaranje prazne neuronske mreže.

>>> neural_net = libfann.neural_network()

Stvoreni objekt neural_net trenutno ne sadrži neurone, pa pokušajmo ih stvoriti. U tu svrhu koristit ćemo funkciju libfann.create_standard_array(). Funkcija create_standard_array() stvara neuronsku mrežu u kojoj su svi neuroni povezani s neuronima sa susjednih razina, pa se može nazvati "potpuno povezanom" mrežom. Kao parametar, funkcija create_standard_array() uzima niz s brojčanim vrijednostima koje odgovaraju broju neurona na svakoj razini. U našem slučaju, ovo je niz.

>>> neural_net.create_standard((2, 4, 1))

Nakon toga, morat ćemo postaviti vrijednost stope učenja. Ova vrijednost odgovara broju promjena težine unutar jedne iteracije. Postavit ćemo prilično visoku stopu učenja od 0,7 jer ćemo s našom mrežom rješavati prilično jednostavan problem.

>>> neural_net.set_learning_rate(0,7)

Sada je vrijeme da instalirate funkciju aktivacije, čija je svrha gore spomenuta. Koristit ćemo način aktiviranja SIGMOID_SYMMETRIC_STEPWISE , koji odgovara funkciji postupne aproksimacije hiperboličke tangente. Manje je točna i brža od uobičajene hiperboličke tangentne funkcije i izvrsna je za naš zadatak.

>>> neural_net.set_activation_function_output(libfann.SIGMOID_SYMMETRIC_STEPWISE)

Konačno, moramo pokrenuti algoritam mrežnog učenja i pohraniti mrežne podatke u datoteku. Funkcija mrežnog učenja uzima četiri argumenta: naziv podatkovne datoteke na kojoj će se trenirati, maksimalni broj pokušaja pokretanja algoritma učenja, broj operacija obuke prije iznošenja podataka o stanju mreže i stopu pogreške.

>>> neural_network.train_on_file("and.data", 10000, 1000, .00001) >>> neural_network.save("and.net")

Datoteka "and.data" mora sadržavati sljedeće podatke:

4 2 1 -1 -1 -1 -1 1 -1 1 -1 -1 1 1 1

Prvi redak sadrži tri vrijednosti: broj primjera u datoteci, broj ulaznih vrijednosti i broj izlaznih vrijednosti. Ispod su primjeri redaka, gdje su retki s dvije vrijednosti ulazne vrijednosti, a retki s jednom vrijednosti su izlazne vrijednosti.

Uspješno ste završili mrežni trening i sada ga želite testirati u produkciji, zar ne? Ali prvo ćemo morati učitati mrežne podatke iz datoteke u kojoj su ranije spremljeni.

>>> neural_net = libfann.neural_net() >>> neural_net.create_from_file("and.net")

Nakon toga, jednostavno ga možemo aktivirati na isti način:

>>> ispiši neural_net.run()

Izlaz bi trebao biti [-1.0] ili sličan, ovisno o mrežnim podacima generiranim tijekom mrežne obuke.

Čestitamo! Upravo ste naučili računalo izvoditi jednostavne logičke operacije!