Exemplu de cod de rețea neuronală Python. Explorarea rețelelor neuronale în patru pași

Programare

• Traducere

Despre ce este articolul

Personal, învăț cel mai bine cu un mic cod de lucru cu care mă pot juca. În acest tutorial, vom învăța algoritmul de backpropagation folosind o rețea neuronală mică implementată în Python ca exemplu.

Dă codul!

X = np.array ([,,,]) y = np.array ([]). T syn0 = 2 * np.random.random ((3,4)) - 1 syn1 = 2 * np.random.random ((4,1)) - 1 pentru j în 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 + = XTdot (l1_delta)

Prea concis? Să-l împărțim în părți mai simple.

Partea 1: Rețea neuronală de jucărie mică

O rețea neuronală antrenată prin retropropagare încearcă să folosească intrarea pentru a prezice ieșirea.

Să presupunem că dorim să prezicem cum va arăta coloana de ieșire pe baza datelor de intrare. Această problemă ar putea fi rezolvată prin calcularea corespondenței statistice dintre ele. Și am vedea că coloana din stânga este 100% corelată cu rezultatul.

Backpropagation, în cel mai simplu caz, calculează statistici similare pentru a crea un model. Sa incercam.

Rețea neuronală în două straturi

import numpy as np # Sigmoid def nonlin (x, deriv = False): if (deriv == True): return f (x) * (1-f (x)) return 1 / (1 + np.exp (-x) )) # set de date de intrare X = np.array ([,,,]) # date de ieșire y = np.array ([]). T # face numerele aleatoare mai specifice np.random.seed (1) # inițializează greutăți aleatoare imagine cu medie 0 syn0 = 2 * np.random.random ((3,1)) - 1 pentru iter în xrange (10000): # forward propagation l0 = X l1 = nonlin (np.dot (l0, syn0)) # cat de gresit am gresit? l1_error = y - l1 # înmulțiți acest lucru cu panta sigmoidă # pe baza valorilor din l1 l1_delta = l1_error * nonlin (l1, True) # !!! # actualizare greutăți syn0 + = np.dot (l0.T, l1_delta) # !!! print "Ieșire după antrenament:" print l1

Ieșire după antrenament: [[0,00966449] [0,00786506] [0,99358898] [0,99211957]]

Variabilele și descrierile lor.

"*" - înmulțire în funcție de elemente - doi vectori de aceeași dimensiune înmulțesc valorile corespunzătoare, iar rezultatul este un vector de aceeași dimensiune
"-" - scăderea vectorilor în funcție de elemente
x.dot (y) - dacă x și y sunt vectori, atunci rezultatul va fi produsul scalar. Dacă acestea sunt matrici, atunci obțineți înmulțirea matricei. Dacă matricea este doar una dintre ele - aceasta este multiplicarea vectorului și a matricei.

• comparați l1 după prima iterație și după ultima
• uitați-vă la funcția nonlin.
• vezi cum se schimba l1_error
• analiza linia 36 - principalele ingrediente secrete sunt colectate aici (marcate !!!)
• parse line 39 - întreaga rețea se pregătește chiar pentru această operațiune (marcată !!!)

Să analizăm codul linie cu linie

import numpy ca np

Importă numpy, o bibliotecă de algebră liniară. Singura noastră dependență.

Def nonlin (x, deriv = False):

Neliniaritatea noastră. Această funcție specifică creează un „sigmoid”. Asignează orice număr unei valori de la 0 la 1 și convertește numerele în probabilități și, de asemenea, are câteva alte proprietăți utile pentru antrenarea rețelelor neuronale.

Dacă (deriv == Adevărat):

Această funcție este, de asemenea, capabilă să scoată derivata sigmoidului (deriv = True). Aceasta este una dintre proprietățile sale benefice. Dacă rezultatul funcției este variabila out, atunci derivata va fi out * (1-out). În mod eficient.

X = np.array ([, ...

Inițializarea matricei de date de intrare ca o matrice numpy. Fiecare linie este un exemplu de antrenament. Coloanele sunt noduri de intrare. Avem 3 noduri de intrare în rețea și 4 exemple de antrenament.

Y = np.array ([]). T

Inițializează ieșirea. „.T” este funcția de transfer. După transfer, matricea y are 4 rânduri cu o coloană. Ca și în cazul intrărilor, fiecare rând este un exemplu de antrenament, iar fiecare coloană (în cazul nostru, una) este un nod de ieșire. Se pare că rețeaua are 3 intrări și 1 ieșire.

Np.sămânță.aleatorie (1)

Datorită acestui fapt, distribuția aleatoare va fi aceeași de fiecare dată. Acest lucru ne va face mai ușor să urmărim performanța rețelei după ce modificăm codul.

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

Matricea ponderilor rețelei. syn0 înseamnă „synapse zero”. Deoarece avem doar două straturi, o intrare și o ieșire, avem nevoie de o matrice de greutate care le conectează. Dimensiunea sa este (3, 1), deoarece avem 3 intrări și 1 ieșire. Cu alte cuvinte, l0 are dimensiunea 3, iar l1 este 1. Deoarece conectăm toate nodurile din l0 cu toate nodurile din l1, avem nevoie de o matrice de dimensiune (3,1).

Rețineți că este inițializat aleatoriu și media este zero. În spatele asta se află o teorie destul de complicată. Deocamdată, să luăm asta doar ca pe o recomandare. De asemenea, rețineți că rețeaua noastră neuronală este chiar această matrice. Avem „straturi” l0 și l1, dar ele reprezintă valori temporale bazate pe setul de date. Nu le depozităm. Toate antrenamentele sunt stocate în syn0.

Pentru iter în xrange (10000):

Aici începe codul de antrenament al rețelei principale. Bucla de cod se repetă de mai multe ori și optimizează rețeaua pentru setul de date.

Primul strat, l0, este doar date. X conține 4 exemple de antrenament. Le vom procesa pe toate deodată - aceasta se numește antrenament de grup. În total, avem 4 linii diferite l0, dar ele pot fi considerate ca un exemplu de antrenament - în această etapă nu contează (puteți încărca 1000 sau 10000 fără nicio modificare a codului).

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

Acesta este un pas de divinație. Lăsăm rețeaua să încerce să prezică rezultatul pe baza intrării. Apoi vom vedea cum o face, astfel încât să o putem modifica în direcția îmbunătățirii.

Linia conține doi pași. Primul face înmulțirea matriceală a lui l0 și syn0. Al doilea trece ieșirea prin sigmoid. Dimensiunile lor sunt următoarele:

(4 x 3) punct (3 x 1) = (4 x 1)

Înmulțirile matricelor necesită ca dimensiunile să coincidă în mijlocul ecuației. Matricea rezultată are același număr de rânduri ca primul și numărul de coloane ca al doilea.

Am încărcat 4 exemple de antrenament și am obținut 4 presupuneri (matrice 4x1). Fiecare ieșire corespunde ipotezei rețelei pentru acea intrare.

L1_error = y - l1

Deoarece l1 conține ipoteze, putem compara diferența lor cu realitatea scăzând l1 din răspunsul corect y. l1_error - un vector de numere pozitive și negative, care caracterizează „rătăcirea” rețelei.

Și aici este ingredientul secret. Această linie trebuie analizată bucată cu bucată.

Prima parte: derivat

Nonlin (l1, adevărat)

L1 reprezintă aceste trei puncte, iar codul produce panta dreptelor prezentate mai jos. Rețineți că pentru valori mari precum x = 2,0 (punct verde) și valori foarte mici precum x = -1,0 (violet), liniile au o ușoară părtinire. Cel mai mare unghi în punctul x = 0 (albastru). Acest lucru face o mare diferență. De asemenea, rețineți că toate derivatele sunt între 0 și 1.

Expresie completă: derivată ponderată în funcție de eroare

L1_delta = l1_error * nonlin (l1, True)

Din punct de vedere matematic, există modalități mai precise, dar în cazul nostru este potrivită și aceasta. l1_error este o matrice (4,1). nonlin (l1, True) returnează matricea (4,1). Aici le înmulțim element cu element, iar la ieșire obținem și matricea (4,1), l1_delta.

Înmulțind derivatele cu erori, reducem erorile de predicții făcute cu mare încredere. Dacă panta liniei a fost mică, atunci rețeaua conține fie o valoare foarte mare, fie foarte mică. Dacă estimarea în rețea este aproape de zero (x = 0, y = 0,5), atunci nu este deosebit de sigură. Actualizăm aceste predicții incerte și lăsăm predicțiile cu încredere ridicată în pace, înmulțindu-le cu valori apropiate de zero.

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

Suntem gata să actualizăm rețeaua. Să aruncăm o privire la un exemplu de antrenament. În el vom actualiza greutățile. Actualizați greutatea cea mai din stânga (9,5)

Weight_update = input_value * l1_delta

Pentru greutatea cea mai din stânga, aceasta ar fi 1,0 * l1_delta. Probabil, aceasta va crește doar ușor 9,5. De ce? Deoarece predicția era deja suficient de sigură, predicțiile erau practic corecte. O mică eroare și o pantă ușoară a liniei înseamnă foarte puțină actualizare.

Dar, deoarece facem antrenament de grup, repetăm ​​pasul de mai sus pentru toate cele patru exemple de antrenament. Deci seamănă foarte mult cu imaginea de mai sus. Deci, ce face linia noastră? Acesta calculează actualizările greutății pentru fiecare greutate, pentru fiecare exemplu de antrenament, le însumează și actualizează toate greutățile - toate într-o singură linie.

După ce observăm actualizarea rețelei, să revenim la datele noastre de antrenament. Când atât intrarea cât și ieșirea sunt 1, creștem greutatea dintre ele. Când intrarea este 1 și ieșirea este 0, scădem greutatea.

Intrare Ieșire 0 0 1 0 1 1 1 1 0 1 1 0 1 1 0

Astfel, în cele patru exemple de antrenament de mai jos, ponderea primei intrări în raport cu ieșirea va crește sau rămâne constantă, în timp ce celelalte două greutăți vor crește și scădea în funcție de exemple. Acest efect contribuie la formarea rețelei pe baza corelațiilor datelor de intrare și de ieșire.

Partea 2: sarcină mai grea

Intrare Ieșire 0 0 1 0 0 1 1 1 1 0 1 1 1 1 1 1 0

Să încercăm să prezicem rezultatul pe baza a trei coloane de date de intrare. Niciuna dintre coloanele de intrare nu corelează 100% cu rezultatul. A treia coloană nu este deloc conectată cu nimic, deoarece conține unități pe tot parcursul. Cu toate acestea, chiar și aici puteți vedea schema - dacă una dintre primele două coloane (dar nu ambele simultan) conține 1, atunci rezultatul va fi, de asemenea, egal cu 1.

Aceasta este o schemă neliniară, deoarece nu există o mapare directă de coloană unu-la-unu. Potrivirea se bazează pe o combinație de intrare, coloanele 1 și 2.

În mod interesant, recunoașterea modelelor este o sarcină foarte similară. Dacă aveți 100 de imagini de aceeași dimensiune, care înfățișează biciclete și țevi, prezența anumitor pixeli în anumite locuri nu se corelează direct cu prezența unei biciclete sau a unei țevi în imagine. Statistic, culoarea lor poate părea a fi aleatorie. Dar unele dintre combinațiile de pixeli nu sunt întâmplătoare - cele care formează imaginea unei biciclete (sau tub).

Strategie

Pentru a combina pixelii în ceva care poate avea o corespondență unu-la-unu cu rezultatul, trebuie să adăugați un alt strat. Primul strat combină intrarea, al doilea atribuie o potrivire la ieșire folosind ieșirea primului strat ca intrare. Atenție la masă.

Intrare (l0) Greutăți latente (l1) Ieșire (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 0,9 1 1 0,2 0,9

Prin atribuirea aleatorie a greutăților, obținem valorile ascunse pentru stratul # 1. Interesant este că a doua coloană de ponderi ascunse are deja o ușoară corelație cu rezultatul. Nu perfect, dar este. Și aceasta este, de asemenea, o parte importantă a procesului de formare în rețea. Antrenamentul nu va face decât să întărească această corelație. Acesta va actualiza syn1 pentru a se potrivi cu ieșirea și syn0 pentru a primi mai bine intrarea.

Rețea neuronală în trei straturi

import numpy ca 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) # inițializați aleatoriu greutăți, în medie - 0 syn0 = 2 * np.random.random ((3,4)) - 1 syn1 = 2 * np.random.random ((4,1)) - 1 pentru j în xrange (60000): # mergi înainte prin straturile 0, 1 și 2 l0 = X l1 = nonlin (np.dot (l0, syn0)) l2 = nonlin (np.dot (l1, syn1)) # cât de grav ne-am înșelat cu privire la valoarea cerută? l2_error = y - l2 if (j% 10000) == 0: tipăriți „Eroare:” + str (np.mean (np.abs (l2_error))) # în ce direcție ar trebui să vă mutați? # dacă am fost încrezători în predicție, atunci nu trebuie să o schimbăm prea mult l2_delta = l2_error * nonlin (l2, deriv = True) # cât de puternic afectează valorile lui l1 erorile din l2? l1_error = l2_delta.dot (syn1.T) # în ce direcție trebuie să vă deplasați pentru a ajunge la l1? # dacă am fi siguri de predicție, atunci nu trebuie să o schimbăm mult l1_delta = l1_error * nonlin (l1, deriv = True) syn1 + = l1.T.dot (l2_delta) syn0 + = l0.T.dot (l1_delta)

Eroare: 0.496410031903 Eroare: 0.00858452565325 Eroare: 0.00578945986251 Eroare: 0.00462917677677 Eroare: 0.00395876528027 Eroare: 518.6022: 560.6022

Variabilele și descrierile lor

X - matricea setului de date de intrare; coarde - exemple de exersare
y - matricea setului de date de ieșire; coarde - exemple de exersare
l0 - primul strat al rețelei, definit de datele de intrare
l1 - al doilea strat al rețelei, sau stratul ascuns
l2 este stratul final, aceasta este ipoteza noastră. Pe măsură ce te antrenezi, ar trebui să te apropii de răspunsul corect.
syn0 este primul strat de greutăți, Synapse 0, care combină l0 cu l1.
syn1 este al doilea strat de greutăți, Synapse 1, care combină l1 cu l2.
l2_error - ratare cuantificată a rețelei
l2_delta - eroare de rețea, în funcție de încrederea predicției. Aproape la fel ca eroarea, cu excepția predicțiilor sigure
l1_error - cântărind l2_delta cu greutăți din syn1, calculăm eroarea în stratul mijlociu / ascuns
l1_delta - erori de rețea de la l1, scalate de încrederea predicțiilor. Aproape la fel ca l1_error, cu excepția predicțiilor sigure

Codul ar trebui să fie suficient de simplu - este doar o implementare anterioară a rețelei, stivuită în două straturi, unul peste altul. Ieșirea primului strat l1 este intrarea celui de-al doilea strat. Există ceva nou doar în rândul următor.

L1_error = l2_delta.dot (syn1.T)

Utilizează erorile ponderate în funcție de încredere ale predicțiilor de la l2 pentru a calcula eroarea pentru l1. Obținem, s-ar putea spune, o eroare ponderată în funcție de contribuție - calculăm cât de mult contribuie valorile de la nodurile l1 la erorile din l2. Acest pas se numește retropropagare a erorilor. Apoi actualizăm syn0 folosind același algoritm ca și pentru rețeaua neuronală cu două straturi.

În prezent, ne confruntăm cu un adevărat boom în rețelele neuronale. Sunt utilizate pentru recunoașterea, localizarea și procesarea imaginilor. Rețelele neuronale sunt deja capabile să facă multe lucruri care nu sunt accesibile oamenilor. Trebuie să ne băgăm și noi în această chestiune! Luați în considerare o rețea de neutroni care va recunoaște numerele din imaginea de intrare. Este foarte simplu: doar un strat și o funcție de activare. Acest lucru nu ne va permite să recunoaștem absolut toate imaginile de testare, dar ne vom descurca cu marea majoritate. Ca date, vom folosi colecția de date MNIST cunoscută în lumea recunoașterii numerelor.

Există o bibliotecă python-mnist pentru a lucra cu ea în Python. A instala:

Pip instalează python-mnist

Acum putem încărca date

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

Arhivele cu datele trebuie să fie încărcate independent, iar programul trebuie să specifice calea către directorul cu acestea. Acum variabilele tr_images și test_images conțin imagini pentru antrenamentul și, respectiv, testarea rețelei. Iar variabilele tr_labels și test_labels sunt etichete cu clasificarea corectă (adică numere din imagini). Toate imaginile sunt 28x28. Să setăm o variabilă cu o dimensiune.

Forma_Img = (28, 28)

Să convertim toate datele în matrice numpy și să le normalizăm (le vom aduce la dimensiunea de la -1 la 1). Acest lucru va crește acuratețea calculelor.

Import numpy ca np pentru i în interval (0, len (test_images)): test_images [i] = np.array (test_images [i]) / 255 pentru i în interval (0, len (tr_images)): tr_images [i] = np.array (tr_images [i]) / 255

Rețineți că, deși este obișnuit să reprezentați imaginile ca o matrice bidimensională, vom folosi o matrice unidimensională, este mai ușor pentru calcule. Acum trebuie să înțelegeți „ce este o rețea neuronală”! Și aceasta este doar o ecuație cu mulți coeficienți. Avem la intrare o matrice de 28 * 28 = 784 de elemente și încă 784 de greutăți pentru a determina fiecare cifră. În timpul funcționării rețelei neuronale, trebuie să înmulțiți valorile intrărilor cu greutăți. Adăugați datele primite și adăugați un offset. Trimiteți rezultatul funcției de activare. În cazul nostru, va fi Relu. Această funcție este zero pentru toate argumentele negative și un argument pentru toate argumentele pozitive.

Există multe mai multe funcții de activare! Dar aceasta este cea mai simplă rețea neuronală! Să definim această funcție folosind numpy

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

Acum, pentru a calcula imaginea din imagine, trebuie să calculați rezultatul pentru 10 seturi de coeficienți.

Def nn_calculate (img): resp = listă (interval (0, 10)) pentru i în interval (0,10): r = w [:, i] * img r = relu (np.sum (r) + b [ i]) resp [i] = r return np.argmax (resp)

Pentru fiecare set, vom obține o ieșire. Rezultatul cu cel mai mare scor este cel mai probabil numărul nostru.

În acest caz, 7. Gata! Dar nu... La urma urmei, trebuie să luați aceiași coeficienți undeva. Trebuie să ne antrenăm rețeaua neuronală. Pentru aceasta, se folosește metoda de retropropagare. Esența sa este de a calcula ieșirile rețelei, de a le compara cu cele corecte și apoi de a scădea din coeficienți numerele necesare pentru ca rezultatul să fie corect. Trebuie reținut că pentru a calcula aceste valori este nevoie de derivata funcției de activare. În cazul nostru, este egal cu zero pentru toate numerele negative și cu 1 pentru toate numerele pozitive. Să determinăm coeficienții într-un mod aleatoriu.

W = (2 * np.random.rand (10, 784) - 1) / 10 b = (2 * np.random.rand (10) - 1) / 10 pentru n în interval (len (tr_images)): img = tr_images [n] cls = tr_labels [n] #forward propagation resp = np.zeros (10, dtype = np.float32) for i in range (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 #back propagation true_resp = np. zerouri (10, dtype = np.float32) true_resp = 1.0 error = resp - true_resp delta = eroare * ((resp> = 0) * np.ones (10)) pentru i în interval (0,10): w [i ] - = np.dot (img, delta [i]) b [i] - = delta [i]

În procesul de antrenament, coeficienții vor deveni ușor similari cu numerele:

Să verificăm acuratețea lucrării:

Def nn_calculate (img): resp = listă (interval (0, 10)) pentru i în interval (0,10): r = w [i] * img r = np.maximum (np.sum (r) + b [ i], 0) #relu resp [i] = r return np.argmax (resp) total = len (test_images) valid = 0 invalid = for i in range (0, total): img = test_images [i] predicted = nn_calculate (img) true = test_labels [i] if prezis == true: valid = valid + 1 else: invalid.append ((„imagine”: img, „predicted”: prezis, „true”: true)) print („acuratețe”) () ". format (valid / total))

Am primit 88%. Nu atât de tare, dar foarte interesant!

Keras Este o bibliotecă populară de deep learning, care a contribuit foarte mult la comercializarea deep learning. Biblioteca Keras este ușor de utilizat și vă permite să creați rețele neuronale cu doar câteva linii de cod Python.

În acest articol, veți învăța cum să utilizați Keras pentru a crea o rețea neuronală care prezice evaluările utilizatorilor pentru un produs pe baza recenziilor lor, clasificându-l în două categorii: pozitive sau negative. Această sarcină se numește analiza sentimentelor (analiza sentimentelor)și o vom rezolva cu site-ul de recenzii de filme IMDb. Modelul pe care îl vom construi poate fi aplicat și pentru a rezolva alte probleme după mici modificări.

Vă rugăm să rețineți că nu vom intra în detalii despre Keras și despre învățarea profundă. Această postare este menită să ofere o schemă în Keras și să prezinte implementarea acesteia.

• Ce este Keras?
• Ce este analiza sentimentelor?
• Setul de date IMDB
• Explorarea datelor
• Pregătirea datelor
• Creați și antrenați un model

Ce este Keras?

Keras este o bibliotecă Python open source care facilitează construirea rețelelor neuronale. Biblioteca este compatibilă cu Microsoft Cognitive Toolkit, Theano și MXNet. Tensorflow și Theano sunt cadrele numerice cele mai frecvent utilizate în Python pentru dezvoltarea algoritmilor de învățare profundă, dar sunt destul de dificil de utilizat.

Evaluarea popularității cadrelor de învățare automată în 7 categorii

În schimb, Keras oferă o modalitate ușoară și convenabilă de a crea modele de învățare profundă. Creatorul său, François Chollet, l-a dezvoltat pentru a accelera și simplifica pe cât posibil procesul de creare a rețelelor neuronale. S-a concentrat pe extensibilitate, modularitate, minimalism și suport pentru Python. Keras poate fi folosit cu GPU și CPU; acceptă atât Python 2, cât și Python 3. Keras de la Google a contribuit foarte mult la comercializarea învățării profunde și pentru că conține algoritmi avansați de învățare profundă care anterior nu erau doar indisponibili, ci și inutilizabili.

Ce este analiza sentimentelor (analiza sentimentelor)?

Folosind analiza sentimentelor, puteți determina atitudinea unei persoane (de exemplu, starea de spirit) față de un text, interacțiune sau eveniment. Prin urmare, analiza sentimentelor aparține domeniului prelucrării limbajului natural, în care sensul textului trebuie descifrat pentru a extrage sentimentul și starea de spirit din acesta.

Exemplu de scară de analiză a sentimentelor

Spectrul de sentimente este de obicei subdivizat în pozitiv, negativ și neutru categorii. Folosind analiza sentimentelor, poți, de exemplu, prezice opinia clienților și atitudinea acestora față de un produs pe baza recenziilor pe care le-au scris. Prin urmare, analiza sentimentelor este aplicată pe scară largă la recenzii, sondaje, scris și multe altele.

Setul de date IMDb

Recenzii pe site-ul IMDb

Setul de date IMDb constă din 50.000 de recenzii de filme de la utilizatori marcați pozitiv (1) și negativ (0).

• Recenziile sunt preprocesate și fiecare este codificată cu o secvență de indici de cuvinte ca numere întregi.
• Cuvintele din recenzii sunt indexate în funcție de frecvența lor generală de apariție în setul de date. De exemplu, întregul „2” codifică al doilea cuvânt cel mai frecvent utilizat.
• Cele 50.000 de recenzii sunt împărțite în două seturi: 25.000 pentru antrenament și 25.000 pentru testare.

Setul de date a fost creat de cercetătorii de la Universitatea Stanford și prezentat într-un articol din 2011, în care acuratețea predicției a fost de 88,89%. Setul de date a fost folosit și în competiția comunității Keggle „Sacul de cuvinte întâlnește pungi de floricele”în 2011.

Importarea dependențelor și preluarea datelor

Să începem prin a importa dependențele necesare pentru preprocesarea datelor și construirea modelului.

% matplotlib import inline matplotlib import matplotlib.pyplot ca plt import numpy ca np din keras.utils import to_categorical din keras import modele din straturile de import keras

Să încărcăm setul de date IMDb, care este deja încorporat în Keras. Deoarece nu dorim să avem date de antrenament și testare 50/50, vom combina imediat aceste date după încărcare pentru împărțirea ulterioară. 80/20:

Din keras.datasets import imdb (training_data, training_targets), (testing_data, testing_targets) = imdb.load_data (num_words = 10000) data = np.concatenate ((training_data, testing_data), axa = 0) targets = np.concatenate_ , testing_targets), axa = 0)

Explorarea datelor

Să examinăm setul nostru de date:

Print ("Categorii:", np.unique (ținte)) print ("Număr de cuvinte unice:", len (np.unique (np.hstack (date)))) Categorii: Număr de cuvinte unice: 9998 lungime = imprimare ("Average Review length:", np.mean (lungime)) print ("Standard Deviation:", rotund (np.std (lungime))) Media Review length: 234.75892 Standard Deviation: 173.0

Puteți observa că toate datele se încadrează în două categorii: 0 sau 1, care reprezintă starea de spirit a recenziei. Întregul set de date conține 9998 de cuvinte unice, cu o dimensiune medie a recenziei de 234 de cuvinte cu o abatere standard de 173.

Să luăm în considerare o modalitate simplă de a învăța:

Imprimare („Etichetă:”, ținte) Etichetă: 1 tipărire (date)

Aici vedeți prima vizualizare din setul de date, care este marcată ca pozitivă (1). Următorul cod convertește indicii înapoi în cuvinte, astfel încât să îi putem citi. Înlocuiește fiecare cuvânt necunoscut cu „#”. Acest lucru se face folosind funcția get_word_index ().

Index = imdb.get_word_index () reverse_index = dict ([(value, key) for (key, value) in index.items ()]) decoded = "" .join () print (decoded) # acest film a fost doar o turnare genial locație peisaj poveste regie toată lumea s-a potrivit cu rolul pe care l-au jucat și vă puteți imagina că sunteți acolo. conexiune reală cu acest film, remarcile pline de spirit de-a lungul filmului au fost grozave, a fost pur și simplu genial, atât de mult încât am cumpărat filmul de îndată ce a fost lansat pentru # și l-aș recomanda tuturor să-l vizioneze, iar pescuitul cu muscă a fost uimitor. În final, a fost atât de trist și știi ce se spune dacă plângi la un film trebuie să fi fost bine și asta cu siguranță a fost și pentru cei doi băieți care au jucat rolul lui Norman și Paul, au fost doar copii geniali sunt adesea rămas în afara listei # cred pentru că vedetele care le joacă pe toate gro Sunt un profil atât de mare pentru întregul film, dar acești copii sunt uimitori și ar trebui lăudați pentru ceea ce au făcut, nu crezi că toată povestea a fost atât de frumoasă pentru că era adevărată și a fost viața cuiva după tot ce a fost împărtășită cu noi toți

Pregătirea datelor

Este timpul să pregătim datele. Trebuie să vectorizați fiecare vizualizare și să o umpleți cu zerouri, astfel încât vectorul să conțină exact 10.000 de numere. Aceasta înseamnă că completăm fiecare recenzie care este mai scurtă de 10.000 de cuvinte cu zerouri. Acest lucru se face deoarece cea mai mare vizualizare are aproape aceeași dimensiune și fiecare parte de intrare în rețeaua noastră neuronală trebuie să aibă aceeași dimensiune. De asemenea, trebuie să convertiți variabilele în tip pluti.

Def vectorize (secvențe, dimensiune = 10000): rezultate = np.zeros ((len (secvențe), dimensiune)) pentru i, secvență în enumerate (secvențe): rezultate = 1 returnează rezultate date = vectorize (date) ținte = np. matrice (ținte) .astype ("float32")

Să împărțim setul de date în seturi de antrenament și de testare. Trusa de antrenament va consta din 40.000 de recenzii, iar trusa de testare va contine 10.000.

Test_x = date [: 10000] test_y = ținte [: 10000] train_x = date train_y = ținte

Creați și antrenați un model

Acum puteți crea o rețea neuronală simplă. Să începem prin a defini tipul de model pe care dorim să-l creăm. Există două tipuri de modele disponibile în Keras: API secvențial și funcțional.

Apoi trebuie să adăugați straturi de intrare, ascunse și de ieșire. Pentru a preveni supraadaptarea, vom folosi excepția dintre ele ( "Renunța"). Rețineți că ar trebui să utilizați întotdeauna o rată de excludere între 20% și 50%. Fiecare strat folosește funcția "Dens" pentru a conecta complet straturile între ele. În straturi ascunse vom folosi "Relu" prin urmare, aproape întotdeauna duce la rezultate satisfăcătoare. Simțiți-vă liber să experimentați cu alte funcții de activare. Pe stratul de ieșire, folosim o funcție sigmoid care renormalizează valorile între 0 și 1. Rețineți că setăm dimensiunea setului de date de intrare la 10.000, deoarece vizualizările noastre sunt de până la 10.000 de numere întregi. Stratul de intrare acceptă elemente cu o dimensiune de 10.000 și le emite cu o dimensiune de 50.

În cele din urmă, cereți Keras să scoată o scurtă descriere a modelului pe care tocmai l-am creat.

# Intrare - 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 (straturi.Dense (50, activare = "relu") model.add (straturi.Dropout (0.2, noise_shape = None, seed = None)) model.add (straturi.Dense (50, activare = "relu) ")) # Output- Layer model.add (straturi.Dense (1, activare =" sigmoid ")) model.summary () model.summary () _________________________________________________________________ Layer (tip) Output Shape Param # ======= ==================================================== ======== dens_1 (Dens) (Niciunul, 50) 500050 _________________________________________________________________ abandon_1 (Renunțare) (Niciunul, 50) 0 _________________________________________________________________ dens_2 (Dens) (Niciunul, 50) 2550 _________________________________________________________________ abandon_2 (Fără _________________________________________________ abandon_2) 0 _________________________________________________________________ dens_3 (dens ) (Niciuna, 50) 2550 _________________________________________________________________ dens_4 (Dens) (Niciuna, 1) 51 ================================ ============================== Parametri totale: 505,201 Parametri antrenabili: 505,201 Parametri neantrenabil: 0 _________________________________________________________________

Acum trebuie să compilam modelul nostru, adică, în esență, să-l setăm pentru antrenament. Noi vom folosi optimizator "adam"... Un optimizator este un algoritm care modifică greutățile și părtinirile în timpul antrenamentului. La fel de funcții de pierdere folosim entropia încrucișată binară (din moment ce lucrăm cu clasificare binară), ca metrică de evaluare - acuratețe.

Model.compile (optimizator = „adam”, pierdere = „binary_crossentropy”, metrics = [„precizie”])

Acum ne putem antrena modelul. Vom face asta cu o dimensiune a lotului de 500 și doar două epoci de când mi-am dat seama modelul începe să se reantreneze dacă îl antrenezi mai mult. Mărimea lotului determină numărul de elemente care vor fi distribuite în rețea, iar epoca este o trecere a tuturor elementelor setului de date. Obișnuit o dimensiune mai mare a lotului duce la o învățare mai rapidă, dar nu întotdeauna o convergență rapidă. Loturile mai mici se antrenează mai lent, dar pot converge mai repede. Alegerea acestei sau acelea opțiuni depinde cu siguranță de tipul de problemă care este rezolvată și este mai bine să încercați fiecare dintre ele. Dacă sunteți nou la această întrebare, vă sfătuiesc să utilizați prima dată dimensiunea lotului 32 care este un fel de standard.

Rezultate = model.fit (train_x, train_y, epochs = 2, batch_size = 500, validation_data = (test_x, test_y)) Antrenează pe 40000 mostre, validare pe 10000 mostre Epoca 1/2 40000/40000 [====== =======================] - 5s 129us / pas - pierdere: 0,4051 - acc: 0,8212 - val_loss: 0,2635 - val_acc: 0,8945 Epoca 2/2 40000 / 40000 [==============================] - 4s 90us / pas - pierdere: 0,2122 - acc: 0,9190 - val_loss: 0,2598 - val_acc: 0,8950

Să evaluăm activitatea modelului:

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

Amenda! Modelul nostru simplu a doborât deja recordul de precizie într-un articol din 2011. mentionat la inceputul postarii. Simțiți-vă liber să experimentați cu setările de plasă și numărul de straturi.

Codul complet al modelului este prezentat mai jos:

Import numpy ca np din keras.utils import to_categorical din keras import modele din keras import layers din keras.datasets import imdb (training_data, training_targets), (testing_data, testing_targets) = imdb.load_data (num_words = 10000) data = (np.concatenate) (training_data, testing_data), axa = 0) targets = np.concatenate ((training_targets, testing_targets), axa = 0) def vectorize (secvențe, dimensiune = 10000): rezultate = np.zeros ((len (secvențe), dimensiune) ) pentru i, secvență în enumerate (secvențe): rezultate = 1 returnează rezultate date = vectorize (date) targets = np.array (targets) .astype ("float32") test_x = data [: 10000] test_y = targets [: 10000 ] train_x = date train_y = targets model = models.Sequential () # Input - Layer model.add (straturi.Dense (50, activare = "relu", input_shape = (10000,))) # Hidden - Layers model.add ( layers.Dropout (0.3, noise_shape = None, seed = None)) model.add (layers.Dense (50, activation = "relu")) model.add (layers.Dropout (0.2, noise_shape = None, seed = None) ) model. add (layers.Dense (50, activation = "relu")) # Output- Layer model.add (layers.Dense (1, activation = "sigmoid")) model.summary () # compilarea modelului model.compile (optimizator) = "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- Acuratețe: ", np.mean (results.history [" val_acc "]))

Rezultate

Ați învățat ce este analiza sentimentelor și de ce Keras este una dintre cele mai populare biblioteci de deep learning.

Am creat o rețea neuronală simplă cu șase straturi care poate calcula starea de spirit a recenzenților de filme cu o precizie de 89%. Acum puteți folosi acest model pentru a analiza sentimentele binare din alte surse, dar pentru aceasta trebuie să faceți dimensiunea lor egală cu 10.000 sau să modificați parametrii stratului de intrare.

Acest model (cu modificări minore) poate fi aplicat și altor probleme de învățare automată.

Rețelele neuronale sunt create și predate în principal în Python. Prin urmare, este foarte important să aveți o înțelegere de bază despre cum să scrieți programe în el. În acest articol, voi descrie pe scurt și clar conceptele de bază ale acestui limbaj: variabile, funcții, clase și module.

Materialul este destinat persoanelor care nu sunt familiarizate cu limbajele de programare.

Mai întâi trebuie să instalați Python. Apoi, trebuie să puneți într-un mediu confortabil pentru a scrie programe Python. Portalul este dedicat acestor doi pași.

Odată ce totul este instalat și configurat, sunteți gata să începeți.

Variabile

Variabil- un concept cheie în orice limbaj de programare (și nu numai în ele). Cel mai simplu mod de a te gândi la o variabilă este o cutie cu o etichetă. Această casetă conține ceva (număr, matrice, obiect, ...) care este de valoare pentru noi.

De exemplu, dorim să creăm o variabilă x, care ar trebui să stocheze valoarea 10. În Python, codul pentru crearea acestei variabile ar arăta astfel:

În stânga noi declara o variabilă numită x. Este ca și cum ai pune o etichetă cu numele pe cutie. Urmează semnul egal și numărul 10. Semnul egal joacă un rol neobișnuit aici. Nu înseamnă că „x este 10”. Egalitatea în acest caz pune numărul 10 în casetă. Mai corect, noi atribui variabila x numărul 10.

Acum, în codul de mai jos, putem accesa această variabilă și, de asemenea, putem efectua diverse acțiuni cu ea.

Puteți afișa pur și simplu valoarea acestei variabile pe ecran:

X = 10 tipărire (x)

Print (x) este un apel de funcție. Le vom lua în considerare în continuare. Ceea ce este important acum este că această funcție trimite către consolă ceea ce este între paranteze. Avem x între paranteze. Mai devreme am atribuit x la 10. Este 10 care este imprimat pe consolă dacă rulați programul de mai sus.

Cu variabilele care stochează numere, puteți efectua diverse acțiuni simple: adăugați, scădeți, înmulțiți, împărțiți și ridicați la o putere.

X = 2 y = 3 # Adunarea z = x + y print (z) # 5 # Diferența z = x - y print (z) # -1 # Produs z = x * y print (z) # 6 # Diviziunea z = x / y print (z) # 0,66666 ... # Exponentiation z = x ** y print (z) # 8

În codul de mai sus, creăm mai întâi două variabile care conțin 2 și 3. Apoi creăm o variabilă z care stochează rezultatul operației cu x și y și tipărește rezultatele pe consolă. Acest exemplu arată clar că o variabilă își poate schimba valoarea în timpul execuției programului. Deci, variabila noastră z își schimbă valoarea de până la 5 ori.

Funcții

Uneori devine necesar să efectuați aceleași acțiuni de mai multe ori. De exemplu, în proiectul nostru, deseori trebuie să afișați 5 rânduri de text.

„Acesta este un text foarte important!”
„Acest text nu poate fi citit”
„Eroarea din linia de sus a fost făcută intenționat”
"Bună și la revedere"
"Sfârșit"

Codul nostru va arăta astfel:

X = 10 y = x + 8 - 2 print ("Acesta este un text foarte important!") Print ("Acest text nu poate fi citit") print ("Eroarea din linia de sus a fost făcută intenționat") print (" Bună, pa") print ("Sfârșit") z = x + y print ("Acesta este un text foarte important!") Print ("Acest text nu poate fi citit") print ("Eroarea din linia de sus a fost făcută pe scop") print ("Bună ziua, pa") print ("Sfârșit") test = z print ("Acesta este un text foarte important!") Print ("Acest text nu poate fi citit") print ("Eroarea din partea de sus linia a fost făcută intenționat") print ("Bună ziua, pa") print ("Sfârșit")

Totul pare foarte redundant și incomod. În plus, a fost o greșeală în linia a doua. Poate fi corectat, dar va trebui corectat în trei locuri deodată. Și dacă în proiectul nostru aceste cinci linii sunt numite de 1000 de ori? Și toate în locuri și fișiere diferite?

Funcțiile pot fi create în limbaje de programare, în special pentru cazurile în care trebuie să executați frecvent aceleași comenzi.

Funcţie- un bloc separat de cod care poate fi numit după nume.

Funcția este specificată folosind cuvântul cheie def. Acesta este urmat de numele funcției, apoi de paranteze și două puncte. Apoi, indentat, trebuie să enumerați acțiunile care vor fi efectuate atunci când funcția este apelată.

Def print_5_lines (): print ("Acesta este un text foarte important!") Print ("Acest text nu poate fi citit") print ("Eroarea din linia de sus a fost făcută intenționat") print ("Salut și pa") tipăriți („Sfârșit”)

Acum am definit funcția print_5_lines (). Acum, dacă în proiectul nostru trebuie din nou să inserăm cinci linii, atunci numim pur și simplu funcția noastră. Acesta va efectua automat toate acțiunile.

# Definiți funcția def print_5_lines (): print ("Acesta este un text foarte important!") Print ("Acest text nu poate fi citit") print ("Eroarea din linia de sus a fost făcută intenționat") print ("Salut , bye") print (" End ") # Codul nostru de proiect x = 10 y = x + 8 - 2 print_5_lines () z = x + y print_5_lines () test = z print_5_lines ()

Convenabil, nu-i așa? Am îmbunătățit serios lizibilitatea codului. În plus, funcțiile sunt bune și prin aceea că, dacă doriți să schimbați unele dintre acțiuni, atunci este suficient să corectați funcția în sine. Această modificare va funcționa oriunde este apelată funcția dvs. Adică, putem corecta eroarea din a doua linie a textului afișat ("nilja"> "nu este permis") în corpul funcției. Versiunea corectă va fi apelată automat în toate locurile proiectului nostru.

Funcții cu parametri

Este convenabil să repetați doar câțiva pași. Dar asta nu este tot. Uneori vrem să transmitem un fel de variabilă funcției noastre. Astfel, funcția poate primi date și le poate folosi în timpul executării comenzilor.

Variabilele pe care le transmitem funcției sunt numite argumente.

Să scriem o funcție simplă care adună două numere date și returnează rezultatul.

Def sum (a, b): rezultat = a + b returnează rezultat

Prima linie arată aproape la fel ca funcțiile normale. Dar acum există două variabile între paranteze. aceasta Opțiuni funcții. Funcția noastră are doi parametri (adică necesită două variabile).

Parametrii pot fi utilizați în interiorul unei funcții ca variabilele obișnuite. Pe a doua linie, creăm variabila rezultat, care este egală cu suma parametrilor a și b. Pe a treia linie, returnăm valoarea variabilei rezultat.

Acum, în codul suplimentar, putem scrie ceva de genul:

Nou = suma (2, 3) print (nou)

Numim funcția sum și îi transmitem două argumente pe rând: 2 și 3. 2 devine valoarea lui a, iar 3 devine valoarea lui b. Funcția noastră returnează o valoare (suma 2 și 3) și o folosim pentru a crea o nouă variabilă, nouă.

Tine minte. În codul de mai sus, numerele 2 și 3 sunt argumentele funcției de sumă. Și în suma funcției în sine, variabilele a și b sunt parametri. Cu alte cuvinte, variabilele pe care le transmitem funcției atunci când este apelată se numesc argumente. Dar în interiorul funcției, aceste variabile transmise sunt numite parametri. De fapt, acestea sunt două nume pentru același lucru, dar nu trebuie confundate.

Să luăm un alt exemplu. Să creăm o funcție pătrat (a) care ia un singur număr și îl pătratează:

Def pătrat (a): returnează a * a

Funcția noastră constă dintr-o singură linie. Returnează imediat rezultatul înmulțirii parametrului a cu a.

Cred că ați ghicit deja că trimitem și date către consolă folosind o funcție. Această funcție se numește print () și tipărește argumentul transmis către consolă: număr, șir, variabilă.

Matrice

Dacă o variabilă poate fi gândită ca o cutie care stochează ceva (nu neapărat un număr), atunci matricele pot fi gândite ca rafturi de cărți. Acestea conțin mai multe variabile simultan. Iată un exemplu de matrice de trei numere și un șir:

Matrice =

Iată un exemplu, când o variabilă nu conține un număr, la un alt obiect. În acest caz, variabila noastră conține o matrice. Fiecare element al matricei este numerotat. Să încercăm să afișăm un element al matricei:

Array = imprimare (matrice)

Veți vedea în consolă numărul 89. Dar de ce 89 și nu 1? Chestia este că în Python, ca și în multe alte limbaje de programare, numerotarea matricei începe de la 0. Prin urmare, matricea ne oferă al doilea elementul matricei, nu primul. Pentru a apela primul, a trebuit să scrieți matrice.

Dimensiunea matricei

Uneori este foarte util să obțineți numărul de elemente dintr-o matrice. Puteți utiliza funcția len () pentru aceasta. Acesta va număra numărul de elemente în sine și va returna numărul acestora.

Array = imprimare (len (matrice))

Consola va afișa numărul 4.

Condiții și cicluri

În mod implicit, orice program pur și simplu execută toate comenzile într-un rând de sus în jos. Dar există situații în care trebuie să verificăm o anumită condiție și, în funcție de faptul că este adevărată sau nu, să realizăm diferite acțiuni.

În plus, este adesea necesar să repeți aproape aceeași secvență de comenzi de multe ori.

În prima situație, condițiile ajută, iar în a doua, ciclurile.

Condiții

Sunt necesare condiții pentru a efectua două seturi diferite de acțiuni, în funcție de faptul dacă afirmația testată este adevărată sau falsă.

În Python, condițiile pot fi scrise folosind constructul if: ... else: .... Să presupunem că avem o variabilă x = 10. Dacă x este mai mic de 10, atunci vrem să împărțim x la 2. Dacă x este mai mare sau egal cu 10, atunci vrem să creăm o altă variabilă nouă, care este egală cu suma lui x și numărul 100. Aceasta este cum va arata codul:

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

După crearea variabilei x, începem să ne înregistrăm starea.

Totul începe cu cuvântul cheie if (tradus din engleză „dacă”). În paranteză, indicăm expresia de testat. În acest caz, verificăm dacă variabila noastră x este într-adevăr mai mică de 10. Dacă este într-adevăr mai mică de 10, atunci o împărțim la 2 și imprimăm rezultatul în consolă.

Apoi urmează cuvântul cheie else, urmat de un bloc de acțiuni care vor fi executate dacă expresia dintre paranteze după if este falsă.

Dacă este mai mare sau egal cu 10, atunci creăm o nouă variabilă, nouă, care este egală cu x + 100 și o tipărim și pe consolă.

Cicluri

Buclele sunt necesare pentru mai multe repetări de acțiuni. Să presupunem că vrem să afișăm un tabel cu pătrate ale primelor 10 numere naturale. Se poate face așa.

Print ("Patratul 1 este egal" + str (1 ** 2)) print ("Patratul 2 este egal" + str (2 ** 2)) print ("Patratul 3 este egal" + str (3 ** 2)) print ( „Pătratul 4 este egal cu” + str (4 ** 2)) print („Pătratul 5 este egal cu” + str (5 ** 2)) print („Pătratul 6 este egal cu” + str (6 ** 2) )) print ("Patratul 7 este "+ str (7 ** 2)) print (" Patratul lui 8 este "+ str (8 ** 2)) print (" Patratul 9 este "+ str (9 ** 2) )) print ("Patratul de 10 este "+ str (10 ** 2))

Nu fi surprins de faptul că adăugăm șiruri. „Începutul liniei” + „sfârșitul” în Python înseamnă pur și simplu concatenarea șirurilor de caractere: „începutul sfârșitului liniei”. La fel, adăugăm șirul „Pătratul lui x este egal cu” și rezultatul ridicării numărului la puterea a 2-a, convertit folosind funcția str (x ** 2).

Codul de mai sus pare foarte redundant. Ce se întâmplă dacă vrem să imprimăm pătratele primelor 100 de numere? Vom fi torturați pentru a scoate...

Pentru astfel de cazuri există cicluri. Există 2 tipuri de bucle în Python: while și for. Să ne ocupăm de ei pe rând.

Bucla while repetă comenzile necesare atâta timp cât condiția rămâne adevărată.

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

Mai întâi, creăm o variabilă și îi atribuim numărul 1. Apoi creăm o buclă while și verificăm dacă x-ul nostru este mai mic decât (sau egal cu) 100. Dacă este mai mică (sau egală), atunci efectuăm două acțiuni:

1. Scoateți pătratul x
2. Măriți x cu 1

După a doua comandă, programul revine la starea. Dacă condiția este din nou adevărată, atunci executăm din nou aceste două acțiuni. Și așa mai departe până când x devine egal cu 101. Atunci condiția va reveni fals și bucla nu va mai fi executată.

Bucla for este menită să itereze peste matrice. Să scriem același exemplu cu pătratele primei sute de numere naturale, dar prin bucla for.

Pentru x în intervalul (1.101): tipăriți ("Pătrat al numărului" + str (x) + "este" + str (x ** 2))

Să analizăm prima linie. Folosim cuvântul cheie for pentru a crea o buclă. În continuare, indicăm că dorim să repetăm ​​anumite acțiuni pentru toți x din intervalul de la 1 la 100. Funcția interval (1.101) creează o matrice de 100 de numere, începând de la 1 și terminând la 100.

Iată un alt exemplu de iterare peste o matrice folosind o buclă for:

Pentru i în: imprimare (i * 2)

Codul de mai sus afișează 4 numere: 2, 20, 200 și 2000. Aici puteți vedea clar cum ia fiecare element al matricei și efectuează un set de acțiuni. Apoi ia următorul articol și repetă același set de acțiuni. Și așa mai departe până când elementele din matrice se epuizează.

Clase și obiecte

În viața reală, nu operăm pe variabile sau funcții, ci pe obiecte. Pix, mașină, om, pisică, câine, avion - obiecte. Acum să începem să examinăm pisica în detaliu.

Are niște parametri. Acestea includ culoarea hainei, culoarea ochilor și porecla ei. Dar asta nu este tot. Pe lângă parametri, pisica poate efectua diverse acțiuni: toarcet, șuierat și zgârietură.

Tocmai am descris schematic toate pisicile în general. Similar descrierea proprietăților și acțiunilor un obiect (de exemplu, o pisică) în Python și se numește clasă. O clasă este pur și simplu o colecție de variabile și funcții care descriu un obiect.

Este important să înțelegeți diferența dintre o clasă și un obiect. Clasa - sistem care descrie obiectul. Obiectul este ea realizare materială... O clasă de pisici este o descriere a proprietăților și acțiunilor sale. Obiectul pisicii este pisica reală în sine. Pot exista multe pisici reale diferite - multe obiecte pentru pisici. Dar există o singură clasă de pisici. Imaginea de mai jos servește ca o bună demonstrație:

Clase

Pentru a crea o clasă (schema pisicii noastre), trebuie să scrieți cuvântul cheie class și apoi să specificați numele acestei clase:

Clasa pisica:

În continuare, trebuie să enumerăm acțiunile acestei clase (acțiuni ale pisicii). Acțiunile, după cum ați ghicit, sunt funcții definite în cadrul unei clase. Este obișnuit să apelați astfel de funcții în cadrul unei clase de metode.

Metodă- o funcție definită în interiorul unei clase.

Verbal, am descris deja metodele pisicii mai sus: toarce, șuierat, zgârie. Acum să o facem în Python.

# Clasa de pisici Cat: # Purr def purr (self): print ("Murrr!") # Hiss def hiss (self): print ("Shhh!") # Scrabble def scrabble (self): print ("Scrabble!" )

Este atat de simplu! Am luat și definit trei funcții obișnuite, dar numai în interiorul clasei.

Pentru a face față cu sine parametrul de neînțeles, să mai adăugăm o metodă pisicii noastre. Această metodă va apela simultan toate cele trei metode deja create.

# Clasa de pisici Cat: # Purr def purr (self): print ("Murrr!") # Hiss def hiss (self): print ("Shhh!") # Scrabble def scrabble (self): print ("Scrabble!" ) # Put all together def all_in_one (self): self.purr () self.hiss () self.scrabble ()

După cum puteți vedea, parametrul self, necesar oricărei metode, ne permite să accesăm metodele și variabilele clasei în sine! Fără acest argument, nu am putea efectua astfel de acțiuni.

Să setăm acum proprietățile pisicii noastre (culoarea blanii, culoarea ochilor, porecla). Cum să o facă? În absolut orice clasă, puteți defini funcția __init __ (). Această funcție este întotdeauna apelată atunci când creăm un obiect real al clasei noastre.

În metoda __init __ () evidențiată mai sus, setăm variabilele pisicii noastre. Cum o facem? În primul rând, trecem 3 argumente acestei metode, care sunt responsabile pentru culoarea hainei, culoarea ochilor și porecla. Apoi, folosim parametrul self pentru a seta imediat cele 3 atribute descrise mai sus pisicii noastre atunci când creăm un obiect.

Ce înseamnă această linie?

Self.wool_color = culoare_lană

În partea stângă, creăm un atribut pentru pisica noastră numit wool_color, iar apoi atribuim acestui atribut valoarea conținută în parametrul wool_color, pe care l-am trecut la funcția __init __ (). După cum puteți vedea, linia de mai sus nu este diferită de crearea obișnuită a unei variabile. Doar prefixul de sine indică faptul că această variabilă aparține clasei Cat.

Atribut- o variabilă care aparține unei clase.

Deci, am creat o clasă de pisici gata făcută. Iată codul său:

# Cat class class Cat: # Acțiuni care trebuie efectuate la crearea unui obiect „Cat” def __init __ (self, wool_color, eyes_culo, name): self.wool_color = wool_color self.eyes_color = eyes_culo self.name = name # Purr def purr ( self): print ("Murrr!") # Hiss def hiss (self): print ("Shhhh!") # Scrabble def scrabble (self): print ("Scrabble!") # Together def all_in_one (self) : self .torc () auto.suierat () auto.scrabble ()

Obiecte

Am creat o diagramă a pisicii. Acum să creăm un obiect de pisică reală folosind această schemă:

My_cat = Pisică ("neagră", "verde", "Zosia")

În rândul de mai sus, creăm variabila my_cat și apoi îi atribuim un obiect din clasa Cat. Totul pare un apel la o funcție Cat (...). De fapt, este. Cu această intrare, numim metoda __init __ () a clasei Cat. Funcția __init __ () din clasa noastră are 4 argumente: obiectul self class, care nu trebuie specificat, precum și încă 3 argumente diferite, care devin apoi atributele pisicii noastre.

Deci, cu linia de mai sus am creat un adevărat obiect de pisică. Pisica noastră are următoarele atribute: blană neagră, ochi verzi și porecla Zosia. Să imprimăm aceste atribute pe consolă:

Imprimare (my_cat.wool_color) imprimare (my_cat.eyes_color) imprimare (my_cat.name)

Adică ne putem referi la atributele unui obiect notând numele obiectului, punând un punct și specificând numele atributului dorit.

Atributele pisicii pot fi modificate. De exemplu, să schimbăm numele pisicii noastre:

My_cat.name = „Nyusha”

Acum, dacă afișați din nou numele pisicii în consolă, veți vedea Nyusha în loc de Zosia.

Permiteți-mi să vă reamintesc că clasa pisicii noastre îi permite să efectueze câteva acțiuni. Dacă ne mângâiem pe Zosia / Nyusha, ea va începe să toarcă:

My_cat.purr ()

Executarea acestei comenzi va scoate textul „Murrr!” În consolă. După cum puteți vedea, accesarea metodelor unui obiect este la fel de ușor ca accesarea atributelor acestuia.

Module

Orice fișier cu extensia .py este un modul. Chiar și cel în care redactați acest articol. Pentru ce sunt necesare? Pentru confort. Mulți oameni creează fișiere cu funcții și clase utile. Alți programatori conectează aceste module terțe și pot folosi toate funcțiile și clasele definite în ele, simplificându-le astfel munca.

De exemplu, nu trebuie să pierdeți timpul scriind propriile funcții de matrice. Este suficient să conectați modulul numpy și să folosiți funcțiile și clasele acestuia.

Până în prezent, alți programatori Python au scris peste 110.000 de module diferite. Modulul numpy menționat mai sus vă permite să lucrați rapid și convenabil cu matrici și matrice multidimensionale. Modulul de matematică oferă multe metode de lucru cu numere: sinusuri, cosinusuri, conversia grade în radiani și tot mai multe...

Instalarea modulului

Python este instalat împreună cu un set standard de module. Acest set include un număr foarte mare de module care vă permit să lucrați cu matematică, interogări web, să citiți și să scrieți fișiere și să efectuați alte acțiuni necesare.

Dacă doriți să utilizați un modul care nu este inclus în setul standard, atunci va trebui să îl instalați. Pentru a instala modulul, deschideți linia de comandă (Win + R, apoi introduceți „cmd” în câmpul afișat) și introduceți comanda în ea:

Pip install [nume_modul]

Procesul de instalare a modulului va începe. Când se termină, puteți utiliza în siguranță modulul instalat în programul dvs.

Conectarea și utilizarea modulului

Modulul terță parte este foarte ușor de conectat. Trebuie doar să scrieți o scurtă linie de cod:

Importă [nume_modul]

De exemplu, pentru a importa un modul care vă permite să lucrați cu funcții matematice, trebuie să scrieți următoarele:

Importă matematică

Cum se face referire la o funcție de modul? Trebuie să scrieți numele modulului, apoi să puneți punct și să scrieți numele funcției / clasei. De exemplu, factorialul 10 se găsește astfel:

Math.factorial (10)

Adică, am apelat la funcția factorială (a), care este definită în interiorul modulului de matematică. Acest lucru este convenabil, deoarece nu trebuie să pierdem timpul și să creăm manual o funcție care calculează factorialul unui număr. Puteți conecta modulul și puteți efectua imediat acțiunea necesară.

Original: Crearea unei rețele neuronale în Python
Autor: John Serrano
Data publicării: 26 mai 2016
Traducere: A. Panin
Data transferului: 6 decembrie 2016

Rețelele neuronale sunt programe extrem de complexe pe care doar academicienii și genii le pot înțelege, care prin definiție nu pot fi folosite de dezvoltatorii obișnuiți, darămite de mine. Crezi asta?

Ei bine, de fapt nu este deloc așa. După o discuție excelentă a lui Louis Monier și Greg Renard la Holburton College, mi-am dat seama că rețelele neuronale sunt suficient de simple pentru a fi înțelese și implementate de orice programator. Desigur, cele mai complexe rețele sunt proiecte de anvergură, cu arhitectură elegantă și complicată, dar conceptele care stau la baza lor sunt, de asemenea, mai mult sau mai puțin evidente. Proiectarea oricărei rețele neuronale de la zero poate fi o sarcină descurajantă, dar, din fericire, există câteva biblioteci excelente care pot face toată munca de nivel scăzut pentru tine.

În acest context, un neuron este o entitate destul de simplă. Este nevoie de mai multe valori de intrare, iar dacă suma acestor valori depășește limita specificată, se activează. Aceasta înmulțește fiecare valoare de intrare cu greutatea sa. Procesul de învățare este în esență procesul de stabilire a ponderilor valorilor pentru a genera valorile de ieșire necesare. Rețelele care vor fi luate în considerare în acest articol se numesc rețele „feedforward”, ceea ce înseamnă că neuronii din ele sunt aranjați în niveluri, iar datele lor de intrare provin de la nivelul anterior, iar datele de ieșire sunt trimise la nivelul următor.

Există și alte tipuri de rețele neuronale, cum ar fi rețelele neuronale recurente, care sunt organizate într-un mod excelent, dar acesta este un subiect pentru un alt articol.

Un neuron care funcționează conform principiului descris mai sus se numește perceptron și se bazează pe un model original de neuroni artificiali, care este rar folosit astăzi. Problema cu perceptronii este că o mică modificare a valorilor de intrare poate duce la o schimbare mare a valorii de ieșire datorită funcției de activare a pasului. În acest caz, o scădere ușoară a valorii de intrare poate duce la faptul că valoarea internă nu va depăși limita setată și neuronul nu va fi activat, ceea ce va duce la modificări și mai semnificative ale stării neuronilor care îl urmăresc. . Din fericire, această problemă se rezolvă cu ușurință cu funcția de activare mai fluidă care este folosită pe majoritatea rețelelor moderne.

Cu toate acestea, rețeaua noastră neuronală va fi atât de simplă încât perceptronii sunt destul de potriviti pentru a o crea. Vom crea o rețea care efectuează o operație logică și. Aceasta înseamnă că avem nevoie de doi neuroni de intrare și un neuron de ieșire, precum și de mai mulți neuroni la un nivel intermediar „ascuns”. Ilustrația de mai jos arată arhitectura acestei rețele, care ar trebui să fie destul de evidentă.

Monier și Renard au folosit convnet.js pentru a crea rețele demo pentru discuțiile lor. Convnet.js poate fi folosit pentru a construi rețele neuronale direct în browserul dvs. web, permițându-vă să le explorați și să le modificați pe aproape orice platformă. Desigur, această implementare JavaScript are și dezavantaje semnificative, dintre care unul este viteza redusă. Ei bine, în scopul acestui articol, vom folosi biblioteca FANN (Fast Artificial Neural Networks). In acest caz, la nivelul limbajului de programare Python se va folosi modulul pyfann, care contine legaturile pentru biblioteca FANN. Ar trebui să instalați pachetul software cu acest modul acum.

Importul modulului pentru lucrul cu biblioteca FANN se realizează după cum urmează:

>>> de la pyfann import libfann

Acum putem începe! Prima operație pe care va trebui să o facem este crearea unei rețele neuronale goale.

>>> neuronal_net = libfann.neural_network ()

Obiectul neural_net creat nu conține în prezent neuroni, așa că să încercăm să-i creăm. Vom folosi funcția libfann.create_standard_array () în acest scop. Funcția create_standard_array () creează o rețea neuronală în care toți neuronii sunt conectați la neuronii din straturile învecinate, deci poate fi numită o rețea „complet conectată”. Ca parametru, funcția create_standard_array () acceptă o matrice cu valori numerice corespunzătoare numărului de neuroni la fiecare nivel. În cazul nostru, aceasta este o matrice.

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

După aceea, va trebui să setăm valoarea pentru rata de învățare. Această valoare corespunde numărului de modificări ale ponderilor într-o iterație. Vom seta o rată de învățare suficient de mare, egală cu 0,7, deoarece vom rezolva o problemă destul de simplă folosind rețeaua noastră.

>>> neural_net.set_learning_rate (0,7)

Acum este timpul să instalați funcția de activare, al cărei scop a fost discutat mai sus. Vom folosi modul de activare SIGMOID_SYMMETRIC_STEPWISE, care corespunde funcției de pas a tangentei hiperbolice. Este mai puțin precis și mai rapid decât funcția de tangentă hiperbolică convențională și este perfect pentru sarcina noastră.

>>> neural_net.set_activation_function_output (libfann.SIGMOID_SYMMETRIC_STEPWISE)

În cele din urmă, trebuie să rulăm algoritmul de învățare a rețelei și să salvăm datele rețelei într-un fișier. Funcția de antrenament în rețea are patru argumente: numele fișierului cu datele pe baza cărora va fi efectuat antrenamentul, numărul maxim de încercări de pornire a algoritmului de antrenament, numărul de operațiuni de antrenament înainte de afișarea datelor de stare a rețelei , și rata de eroare.

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

Fișierul „and.data” ar trebui să conțină următoarele date:

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

Prima linie conține trei valori: numărul de exemple din fișier, numărul de intrări și numărul de ieșiri. Mai jos sunt liniile de exemple, cu liniile cu două valori care arată valorile de intrare și liniile cu o singură valoare arată ieșirile.

Ai terminat cu succes antrenarea rețelei și acum vrei să o pui la încercare, nu? Dar mai întâi trebuie să încărcăm datele de rețea din fișierul în care au fost salvate mai devreme.

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

După aceea, îl putem activa pur și simplu în același mod:

>>> print neural_net.run ()

Ca rezultat, valoarea [-1.0] sau o valoare similară ar trebui să fie scoasă, în funcție de datele de rețea generate în timpul antrenamentului.

Felicitări! Tocmai ți-ai învățat computerul cum să efectueze cele mai simple operații logice!