de Daphne Cornelisse

Cum se construiește o rețea neuronală cu trei straturi de la zero

În această postare, voi parcurge pașii necesari pentru construirea unui Trei rețea neuronală strat. Voi trece printr-o problemă și vă voi explica procesul împreună cu cele mai importante concepte de-a lungul drumului.

Problema de rezolvat

Un fermier din Italia avea o problemă cu mașina sa de etichetare: amesteca etichetele a trei soiuri de vin. Acum îi mai rămân 178 de sticle și nimeni nu știe ce soi le-a făcut! Pentru a-l ajuta pe acest biet om, vom construi un clasificator care recunoaște vinul pe baza a 13 atribute ale vinului.

Faptul că datele noastre sunt etichetate (cu una dintre cele trei etichete ale soiului) face ca aceasta să fie o Învățare supravegheată problemă. În esență, ceea ce vrem să facem este să folosim datele noastre de intrare (cele 178 de sticle de vin neclasificate), să le introducem prin Retea neurala, apoi obțineți eticheta potrivită pentru fiecare cultivar de vin ca rezultat.

Vom instrui algoritmul nostru pentru a obține din ce în ce mai bine predicția (y-hat) care sticlă aparține cărei etichete.

Acum este timpul să începeți construirea rețelei neuronale!

Abordare

Construirea unei rețele neuronale este aproape ca și cum ai construi o funcție foarte complicată sau dacă ai pune împreună o rețetă foarte dificilă. La început, ingredientele sau pașii pe care va trebui să îi faceți pot părea copleșitori. Dar dacă spargi totul și o faci pas cu pas, te vei simți bine.

În scurt:

• Stratul de intrare (x) este format din 178 de neuroni.
• A1, primul strat, este format din 8 neuroni.
• A2, al doilea strat, este format din 5 neuroni.
• A3, al treilea și cel de ieșire, este format din 3 neuroni.

Pasul 1: pregătirea obișnuită

Importați toate bibliotecile necesare (NumPy, skicit-learn, panda) și setul de date și definiți x și y.

#importing all the libraries and dataset

import pandas as pdimport numpy as np

df = pd.read_csv('../input/W1data.csv')df.head()

# Package imports

# Matplotlib import matplotlibimport matplotlib.pyplot as plt

# SciKitLearn is a machine learning utilities libraryimport sklearn

# The sklearn dataset module helps generating datasets

import sklearn.datasetsimport sklearn.linear_modelfrom sklearn.preprocessing import OneHotEncoderfrom sklearn.metrics import accuracy_score

Pasul 2: inițializare

Înainte de a ne putea folosi greutățile, trebuie să le inițializăm. Deoarece nu avem încă valori de utilizat pentru greutăți, folosim valori aleatorii între 0 și 1.

În Python, random.seed funcția generează „numere aleatorii”. Cu toate acestea, numerele aleatoare nu sunt cu adevărat aleatorii. Numerele generate sunt pseudorandom, adică numerele sunt generate de o formulă complicată care o face să arate aleatoriu. Pentru a genera numere, formula ia ca intrare valoarea anterioară generată. Dacă nu există nicio valoare anterioară generată, aceasta necesită adesea timpul ca primă valoare.

De aceea semănăm generatorul – pentru a ne asigura că obținem întotdeauna aceleași numere aleatorii. Oferim o valoare fixă ​​cu care poate începe generatorul de numere, care este zero în acest caz.

np.random.seed(0)

Pasul 3: propagare înainte

Există aproximativ două părți ale antrenării unei rețele neuronale. În primul rând, vă propagați prin NN. Adică, „faceți pași” înainte și comparați aceste rezultate cu valorile reale pentru a obține diferența dintre rezultatul dvs. și ceea ce ar trebui să fie. Practic vedeți cum merge NN și găsiți erorile.

După ce am inițializat greutățile cu un număr pseudo-aleatoriu, facem un pas liniar înainte. Calculăm acest lucru luând intrarea noastră de 0 ori mai mare decât produs dot a greutăților inițializate aleatoriu plus a părtinire. Am început cu o părtinire de 0. Aceasta este reprezentată ca:

Acum luăm z1-ul nostru (pasul nostru liniar) și îl trecem prin primul nostru funcția de activare. Funcțiile de activare sunt foarte importante în rețelele neuronale. În esență, ei convertesc un semnal de intrare într-un semnal de ieșire – de aceea sunt cunoscuți și ca Funcții de transfer. Ei introduc proprietăți neliniare la funcțiile noastre prin convertirea intrării liniare într-o ieșire neliniară, făcând posibilă reprezentarea funcțiilor mai complexe.

Există diferite tipuri de funcții de activare (explicate în detaliu în acest articol). Pentru acest model, am ales să folosim tanh funcție de activare pentru cele două straturi ascunse – A1 și A2 – care ne oferă o valoare de ieșire între -1 și 1.

Deoarece acesta este un problemă de clasificare multi-clasă (avem 3 etichete de ieșire), vom folosi softmax funcție pentru stratul de ieșire – A3 – deoarece aceasta va calcula probabilitățile pentru clase scuipând o valoare între 0 și 1.

Trecând z1 prin funcția de activare, am creat primul nostru strat ascuns – A1 – care poate fi folosit ca intrare pentru calcularea următorului pas liniar, z2.

În Python, acest proces arată astfel:

# This is the forward propagation functiondef forward_prop(model,a0):        # Load parameters from model    W1, b1, W2, b2, W3, b3 = model['W1'], model['b1'], model['W2'], model['b2'], model['W3'],model['b3']        # Do the first Linear step     z1 = a0.dot(W1) + b1        # Put it through the first activation function    a1 = np.tanh(z1)        # Second linear step    z2 = a1.dot(W2) + b2        # Put through second activation function    a2 = np.tanh(z2)        #Third linear step    z3 = a2.dot(W3) + b3        #For the Third linear activation function we use the softmax function    a3 = softmax(z3)        #Store all results in these values    cache = {'a0':a0,'z1':z1,'a1':a1,'z2':z2,'a2':a2,'a3':a3,'z3':z3}    return cache

În cele din urmă, toate valorile noastre sunt stocate în cache.

Pasul 4: propagare înapoi

După ce ne propagăm înainte prin NN, ne propagăm înapoi gradientul de eroare pentru a ne actualiza parametrii de greutate. Știm eroarea noastră și dorim să o reducem cât mai mult posibil.

Facem acest lucru luând derivată a funcției de eroare, cu privire la greutățile (W) ale NN-ului nostru, folosind coborâre în gradient.

Să vizualizăm acest proces cu o analogie.

Imaginați-vă că ați ieșit la plimbare în munți în timpul după-amiezii. Dar acum este o oră mai târziu și ți-e puțin foame, așa că este timpul să pleci acasă. Singura problemă este că este întuneric și există mulți copaci, așa că nu vă puteți vedea nici casa, nici unde vă aflați. A, și ți-ai uitat telefonul acasă.

Dar apoi îți amintești că casa ta se află într-o vale, cel mai de jos punct din întreaga zonă. Așadar, dacă mergi pe munte pas cu pas până nu simți nicio pantă, în teorie ar trebui să ajungi la tine acasă.

Deci iată-te, pas cu pas coborând cu atenție. Acum gândiți-vă la munte ca la funcția de pierdere, iar voi sunteți algoritmul, încercând să vă găsiți casa (adică punctul cel mai de jos). De fiecare dată când faceți un pas în jos, vă actualizăm coordonatele de locație (algoritmul actualizează parametrii).

Funcția de pierdere este reprezentată de munte. Pentru a ajunge la o pierdere mică, algoritmul urmează panta – adică derivata – funcției de pierdere.

Când mergem pe munte, ne actualizăm coordonatele de locație. Algoritmul actualizează parametrii rețelei neuronale. Apropiindu-ne de punctul minim, ne apropiem de obiectivul nostru minimizând eroarea noastră.

În realitate, coborârea în gradient arată mai mult așa:

Începem întotdeauna cu calculul panta funcției de pierdere față de z, panta pasului liniar pe care îl facem.

Notarea este după cum urmează: dv este derivatul funcției de pierdere, în raport cu o variabilă v.

Apoi calculăm panta funcției de pierdere cu privire la greutățile și părtinirile noastre. Deoarece acesta este un NN cu 3 straturi, vom itera acest proces pentru z3,2,1 + W3,2,1 și b3,2,1. Propagarea înapoi de la ieșire la stratul de intrare.

Așa arată acest proces în Python:

# This is the backward propagation functiondef backward_prop(model,cache,y):

# Load parameters from model    W1, b1, W2, b2, W3, b3 = model['W1'], model['b1'], model['W2'], model['b2'],model['W3'],model['b3']        # Load forward propagation results    a0,a1, a2,a3 = cache['a0'],cache['a1'],cache['a2'],cache['a3']        # Get number of samples    m = y.shape[0]        # Calculate loss derivative with respect to output    dz3 = loss_derivative(y=y,y_hat=a3)

# Calculate loss derivative with respect to second layer weights    dW3 = 1/m*(a2.T).dot(dz3) #dW2 = 1/m*(a1.T).dot(dz2)         # Calculate loss derivative with respect to second layer bias    db3 = 1/m*np.sum(dz3, axis=0)        # Calculate loss derivative with respect to first layer    dz2 = np.multiply(dz3.dot(W3.T) ,tanh_derivative(a2))        # Calculate loss derivative with respect to first layer weights    dW2 = 1/m*np.dot(a1.T, dz2)        # Calculate loss derivative with respect to first layer bias    db2 = 1/m*np.sum(dz2, axis=0)        dz1 = np.multiply(dz2.dot(W2.T),tanh_derivative(a1))        dW1 = 1/m*np.dot(a0.T,dz1)        db1 = 1/m*np.sum(dz1,axis=0)        # Store gradients    grads = {'dW3':dW3, 'db3':db3, 'dW2':dW2,'db2':db2,'dW1':dW1,'db1':db1}    return grads

Pasul 5: faza de antrenament

Pentru a ajunge la greutăți și părtiniri optime care ne va da rezultatul dorit (cele trei cultivare de vin), va trebui tren rețeaua noastră neuronală.

Cred că acest lucru este foarte intuitiv. Pentru aproape orice în viață, trebuie să te antrenezi și să exersezi de multe ori înainte să te pricepi la asta. La fel, o rețea neuronală va trebui să sufere multe epocăsau iterații pentru a ne oferi o predicție exactă.

Când înveți ceva, să spunem că citești o carte, ai o anumită ritm. Acest ritm nu ar trebui să fie prea lent, deoarece citirea cărții va dura veacuri. Dar nici nu ar trebui să fie prea rapid, deoarece s-ar putea să pierdeți o lecție foarte valoroasă din carte.

În același mod, trebuie să specificați un „rata de învățare”Pentru model. Rata de învățare este multiplicatorul pentru actualizarea parametrilor. Determină cât de repede se pot schimba. Dacă rata de învățare este scăzută, instruirea va dura mai mult. Cu toate acestea, dacă rata de învățare este prea mare, s-ar putea să pierdem un minim. Rata de învățare este exprimată ca:

• : = înseamnă că aceasta este o definiție, nu o ecuație sau o afirmație dovedită.
• A se numește rata de învățare alfa
• dL (w) este derivatul pierderii totale în raport cu greutatea noastră w
• da este derivatul lui alfa

Am ales o rată de învățare de 0,07 după câteva experimente.

# This is what we return at the endmodel = initialise_parameters(nn_input_dim=13, nn_hdim= 5, nn_output_dim= 3)model = train(model,X,y,learning_rate=0.07,epochs=4500,print_loss=True)plt.plot(losses)

În cele din urmă, există graficul nostru. Puteți calcula acuratețea și / sau pierderea pentru a obține un grafic frumos al acurateței predicției. După 4.500 de epoci, algoritmul nostru are o precizie de 99,4382022472%.

Rezumat scurt

Începem prin introducerea datelor în rețeaua neuronală și efectuăm mai multe operații matriciale pe aceste date de intrare, strat cu strat. Pentru fiecare dintre cele trei straturi ale noastre, luăm produsul punct al intrării prin greutăți și adăugăm o părtinire. Apoi, trecem această ieșire printr-un funcția de activare la alegere.

Ieșirea acestei funcții de activare este apoi utilizată ca intrare pentru următorul strat pentru a urma aceeași procedură. Acest proces este iterat de trei ori, deoarece avem trei straturi. Rezultatul nostru final este y-hat, care este predicție pe care vinul aparține cărui soi. Acesta este sfârșitul procesului de propagare înainte.

Calculăm apoi diferență între predicția noastră (y-hat) și rezultatul așteptat (y) și utilizați această valoare de eroare în timpul propagării înapoi.

În timpul propagării înapoi, ne luăm eroarea – diferența dintre predicția noastră y-hat și y – și o împingem matematic înapoi prin NN în cealaltă direcție. Învățăm din greșelile noastre.

Luând derivata funcțiilor pe care le-am folosit în timpul primului proces, încercăm să descoperim ce valoare ar trebui să acordăm greutăți pentru a realiza cea mai bună predicție posibilă. În esență, vrem să știm care este relația dintre valoarea greutății noastre și eroarea pe care o obținem ca rezultat.

Și după multe epoci sau iterații, NN a învățat să ne ofere predicții mai precise, adaptându-și parametrii la setul nostru de date.

Această postare a fost inspirată de provocarea din săptămâna 1 din Bletchley Machine Learning Bootcamp care a început pe 7 februarie. În următoarele nouă săptămâni, sunt unul dintre cei 50 de studenți care vor trece prin fundamentele învățării automate. În fiecare săptămână discutăm un subiect diferit și trebuie să depunem o provocare, care necesită să înțelegeți cu adevărat materialele.

Dacă aveți întrebări sau sugestii sau, permiteți-le pe mine stii!

Sau dacă doriți să verificați întregul cod, îl puteți găsi Aici pe Kaggle.

Videoclipuri recomandate pentru a înțelege mai profund rețelele neuronale:

• 3Blue1Brownseria pe rețele neuronale
• Siraj Ravalseria despre Deep Learning