este unul dintre cele mai fierbinți subiecte din 2018-19 și dintr-un motiv bun. Au existat atât de multe progrese în industrie în care a venit momentul în care mașinile sau programele de calculator înlocuiesc de fapt oamenii. Acest Învățare profundă cu Python articolul vă va ajuta să înțelegeți exact ce este învățarea profundă și cum a fost posibilă această tranziție. Voi acoperi următoarele subiecte în acest articol:
- Știința datelor și componentele sale
- Nevoia de învățare profundă
- Ce este Deep Learning?
- Perceptron și rețele neuronale artificiale
- Aplicații ale învățării profunde
- De ce Python for Deep Learning?
- Învățare profundă cu Python: Exemplu Perceptron
- Învățare profundă cu Python: crearea unei rețele neuronale profunde
Știința datelor și componentele sale
Ei bine, Știința datelor este ceva care există acolo de veacuri. Știința datelor este extragerea cunoștințelor din date prin utilizarea diferitelor tehnici și algoritmi.
este o tehnică care permite mașinilor să imite comportamentul uman. Ideea din spatele AI este destul de simplă, dar fascinantă, și anume de a face mașini inteligente care să poată lua decizii singure. De ani de zile, s-a crezut că computerele nu se vor potrivi niciodată cu puterea creierului uman.
Ei bine, pe atunci nu aveam suficiente date și putere de calcul, dar acum cu Date mare intrând în existență și odată cu apariția GPU-urilor, este posibilă inteligența artificială.
este un subset de tehnică AI care folosește metode statistice pentru a permite mașinilor să se îmbunătățească cu experiență.
Invatare profunda este un subset al ML care face calculul rețelei neuronale cu mai multe straturi fezabil. Folosește rețele neuronale pentru a simula luarea deciziilor de tip uman.
Nevoia de învățare profundă
Un pas către inteligența artificială este învățarea automată. Învățarea automată este un subset de AI și se bazează pe ideea că mașinilor ar trebui să li se ofere acces la date și ar trebui lăsate să învețe și să exploreze singure. Se ocupă cu extragerea tiparelor din seturi mari de date. Gestionarea seturilor mari de date nu a fost o problemă.
- Algoritmi de învățare automată nu poate gestiona date de înaltă dimensiune - unde avem un număr mare de intrări și ieșiri: în jurul a mii de dimensiuni. Manipularea și prelucrarea unui astfel de tip de date devine foarte complexă și exhaustivă a resurselor. Aceasta este denumită Blestemul dimensionalității.
- O altă provocare cu care s-a confruntat a fost, pentru a specifica caracteristici care trebuie extrase . Acest lucru joacă un rol important în prezicerea rezultatului, precum și în obținerea unei acuratețe mai bune. Prin urmare, fără extragerea caracteristicilor, provocarea pentru programator crește, deoarece eficiența algoritmului depinde foarte mult de cât de perspicace este programatorul.
Acum, aici a venit salvarea Deep Learning. Învățarea profundă este capabil să manipuleze datele de înaltă dimensiune și este, de asemenea, eficient în concentrându-se pe caracteristicile potrivite pe cont propriu.
Ce este Deep Learning?
Învățarea profundă este un subset de învățare automată în care algoritmi de învățare automată similari sunt folosiți pentru a se antrena astfel încât să se obțină o precizie mai bună în acele cazuri în care primul nu a performat până la marcă. Pe scurt, Învățarea profundă imită modul în care funcționează creierul nostru adică învață din experiență.
După cum știți,creierul nostru este format din miliarde de neuroni care ne permite să facem lucruri uimitoare. Chiar și creierul unui copil mic este capabil să rezolve probleme complexe, care sunt foarte greu de rezolvat chiar și folosind Super-computere. Deci, cum putem realiza aceeași funcționalitate într-un program? Acum, aici înțelegem Neuron artificial (Perceptron) și Retele neuronale artificiale.
Perceptron și rețele neuronale artificiale
Deep Learning studiază unitatea de bază a unui creier numită celulă cerebrală sau neuron. Acum, să înțelegem funcționalitatea neuronilor biologici și cum imităm această funcționalitate în percepție sau un neuron artificial.
- Dendrita: Primește semnale de la alți neuroni
- Corpul celulei: Sumează toate intrările
- Axon: Este folosit pentru a transmite semnale către celelalte celule
Un neuron artificial sau un Perceptron este un model liniar utilizat pentru clasificarea binară. Modelează un neuron care are un set de intrări, cărora li se dă o greutate specifică. Neuronul calculează o anumită funcție asupra acestora ponderat intrări și dă ieșirea.
Primește n intrări (corespunzătoare fiecărei caracteristici). Apoi, însumează acele intrări, aplică o transformare și produce o ieșire. Are două funcții:
- Suma
- Transformare (activare)
Greutatea arată eficacitatea unui anumit aport. Cu cât este mai mare greutatea intrării, cu atât mai mult va avea un impact asupra rețelei neuronale . Pe de altă parte, Părtinire este un parametru suplimentar în Perceptron, care este utilizat pentru a regla ieșirea împreună cu suma ponderată a intrărilor în neuron, care ajută modelul într-un mod în care să se potrivească cel mai bine pentru datele date.
Funcții de activare traduce intrările în ieșiri. Folosește un prag pentru a produce o ieșire. Există multe funcții care sunt utilizate ca funcții de activare, cum ar fi:
- Liniar sau Identitate
- Unitate sau Pas binar
- Sigmoid sau Logistic
- Tanh
- ReLU
- Softmax
Bine. dacă credeți că Perceptron rezolvă problema, atunci vă înșelați. Au existat două probleme majore:
system.exit (0) poate fi folosit pentru a termina programul.
- Perceptroni cu un singur strat nu poate clasifica punctele de date separabile neliniar .
- Probleme complexe, care implică o mulțime de parametri nu poate fi rezolvat de perceptroni cu un singur strat.
Luați în considerare exemplul de aici și complexitatea parametrilor implicați pentru a lua o decizie de către echipa de marketing.
Un neuron nu poate lua atât de multe intrări și de aceea ar fi folosit mai mult de un neuron pentru a rezolva această problemă. Rețeaua neuronală este într-adevăr doar o compoziția Perceptronilor, conectate în moduri diferite și operând pe diferite funcții de activare.
- Noduri de intrare furnizați informații din lumea exterioară rețelei și sunt denumite împreună „Stratul de intrare”.
- Noduri ascunse efectuați calcule și transferați informații de la nodurile de intrare la nodurile de ieșire. O colecție de noduri ascunse formează un „strat ascuns”.
- Noduri de ieșire sunt denumiți în mod colectiv „Stratul de ieșire” și sunt responsabili pentru calcule și transferul de informații din rețea în lumea exterioară.
Acum, că aveți o idee despre cum se comportă un perceptron, diferiții parametri implicați și diferitele straturi ale unei rețele neuronale, să continuăm această învățare profundă cu blogul Python și să vedem câteva aplicații interesante ale învățării profunde.
Aplicații ale învățării profunde
Există diverse aplicații ale învățării profunde în industrie, iată câteva dintre cele importante care sunt prezente în sarcinile noastre de zi cu zi.
- Recunoaștere a vorbirii
- Traducere automată
- Recunoaștere facială și etichetare automată
- Asistenți personali virtuali
- Autoturism
- Chatbots
De ce Python for Deep Learning?
- este un astfel de instrument care are un atribut unic, de a fi un limbaj de programare de uz general ca fiind ușor de folosit când vine vorba de calcul analitic și cantitativ.
- Este foarte Ușor de înțeles
- Python este Tipat dinamic
- Imens
- O gamă largă de biblioteci în scopuri diferite, cum ar fi Numpy, Seaborn, Matplotlib, Pandas și Scikit-learn
Acum, suficientă teorie, să vedem cum putem începe Deep Learning cu Python cu un exemplu mic, dar interesant.
Învățare profundă cu Python: Exemplu Perceptron
Acum sunt sigur că voi trebuie să fiți familiarizați cu funcționarea „ SAU' Poartă. Ieșirea este unu dacă oricare dintre intrări este, de asemenea unu.
Prin urmare, un Perceptron poate fi folosit ca separator sau ca o linie de decizie care împarte setul de intrare al OR Gate, în două clase:
Clasa 1: Intrări cu ieșire 0 care se află sub linia de decizie.
Clasa 2: Intrări cu ieșire ca 1 care se află deasupra liniei de decizie sau separator.
Până acum, am înțeles că un perceptron liniar poate fi folosit pentru a clasifica setul de date de intrare în două clase. Dar, cum clasifică de fapt datele?
Matematic, un perceptron poate fi gândit ca o ecuație de greutăți, intrări și părtinire.
Pasul 1: Importați toată biblioteca necesară
Aici voi importa o singură bibliotecă, adică. TensorFlow
import tensorflow ca tf
Pasul 2: definiți variabilele vectoriale pentru intrare și ieșire
Apoi, trebuie să creăm variabile pentru stocarea intrării, ieșirii și părtinirii pentru Perceptron.
train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]
Pasul 3: definiți variabila de greutate
Aici vom defini variabila tensor de formă 3 × 1 pentru greutățile noastre și îi vom atribui inițial câteva valori aleatorii.
w = tf.Variable (tf.random_normal ([3, 1], seed = 15))
Pasul 4: definiți substituenți pentru intrare și ieșire
Trebuie să definim substituenți, astfel încât aceștia să poată accepta intrări externe.
x = tf.placeholder (tf.float32, [None, 3]) y = tf.placeholder (tf.float32, [None, 1])
Pasul 5: Calculați ieșirea și funcția de activare
După cum sa discutat mai devreme, intrarea primită de un perceptron este mai întâi înmulțită cu greutățile respective și apoi, toate aceste intrări ponderate sunt însumate împreună. Această valoare însumată este apoi alimentată la activare pentru a obține rezultatul final.
output = tf.nn.relu (tf.matmul (x, w))
Notă: În acest caz, am folosit relu ca funcție de activare a mea. Sunteți liber să utilizați oricare dintre funcțiile de activare în funcție de nevoile dvs.
Pasul 6: Calculați costul sau eroarea
Trebuie să calculăm Costul = eroarea pătrată medie, care nu este altceva decât pătratul diferenței dintre ieșirea perceptronului și ieșirea dorită.
loss = tf.reduce_sum (tf.square (output - y))
Pasul 7: Minimizați eroarea
Scopul unui perceptron este de a reduce la minimum pierderea sau costul sau eroarea. Deci, aici vom folosi Gradient Descent Optimizer.
optimizer = tf.train.GradientDescentOptimizer (0.01) tren = optimizer.minimize (pierdere)
Pasul 8: inițializați toate variabilele
Variabilele sunt definite numai cu tf.Variabil. Deci, trebuie să inițializăm variabilele definite.
init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)
Pasul 9: Instruirea Perceptronului în iterații
Trebuie să ne antrenăm perceptronul, adică să actualizăm valorile greutăților și părtinirii în iterația succesivă pentru a minimiza eroarea sau pierderea. Aici, voi instrui perceptronul nostru în 100 de epoci.
for i in range (100): sess.run (train, {x: train_in, y: train_out}) cost = sess.run (loss, feed_dict = {x: train_in, y: train_out}) print ('Epoch-- ', i,' - pierdere - ', cost)Pasul 10: ieșire
……
……
După cum puteți vedea aici, pierderea a început de la 2.07 și s-a încheiat la 0,27
.
Învățare profundă cu Python: crearea unei rețele neuronale profunde
Acum că am creat cu succes un perceptron și l-am instruit pentru o poartă SAU. Să continuăm acest articol și să vedem cum ne putem crea propria rețea neuronală de la Scratch, unde vom crea un strat de intrare, straturi ascunse și strat de ieșire.
Vom folosi setul de date MNIST. Setul de date MNIST constă din 60.000 de antrenamente probe și 10.000 de teste mostre de imagini de cifre scrise de mână. Imaginile sunt de dimensiuni 28 × 28 pixeli iar ieșirea poate fi între 0-9 .
Sarcina aici este de a instrui un model care poate identifica cu precizie cifra prezentă pe imagine
În primul rând, vom folosi importul de mai jos pentru a aduce funcția de imprimare din Python 3 în Python 2.6+. Declarațiile __future__ trebuie să fie aproape de partea de sus a fișierului, deoarece schimbă lucruri fundamentale despre limbă, astfel încât compilatorul trebuie să știe despre ele de la început
din __future__ import print_function
Următorul este codul cu comentarii la fiecare pas
# Import date MNIST din tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) import tensorflow ca tf import matplotlib.pyplot as plt # Parametri learning_rate = 0.001 training_epochs = 15 batch_size = 100 display_step = 1 # Parametrii rețelei n_hidden_1 = 256 # primul strat numărul de caracteristici n_hidden_2 = 256 # al doilea strat numărul de caracteristici n_input = 784 # MNIST date de intrare (formă img: 28 * 28) n_classes = 10 # MNIST clase totale ( 0-9 cifre) # tf Intrare grafic x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Creați model def multilayer_perceptron (x, greutăți , părtiniri): # Strat ascuns cu activare RELU strat_1 = tf.add (tf.matmul (x, greutăți ['h1']), părtiniri ['b1']) strat_1 = tf.nn.relu (strat_1) # Strat ascuns cu activare RELU layer_2 = tf.add (tf.matmul (layer_1, weights ['h2']), biases ['b2']) layer_2 = tf.nn.relu (layer_2) # Output layer with activation linear out_layer = tf. matmul (strat _2, greutăți ['out']) + biases ['out'] return out_layer # Store layer weight & bias weights = {'h1': tf.Variable (tf.random_normal ([n_input, n_hidden_1])), 'h2' : tf.Variable (tf.random_normal ([n_hidden_1, n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_hidden_2, n_classes]))} biases = {'b1': tf.Variable (tf. random_normal ([n_hidden_1])), 'b2': tf.Variable (tf.random_normal ([n_hidden_2])), 'out': tf.Variable (tf.random_normal ([n_classes]))}} # Construct model pred = multilayer_perceptron (x, greutăți, prejudecăți) # Definiți pierderea și costul optimizatorului = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (cost) # Initializarea variabilelor init = tf.global_variables_initializer () #create o listă goală pentru a stoca istoricul costurilor și istoricul preciziei cost_history = [] accurate_history = [] # Lansați graficul cu tf.Session () ca sess: sess.run (init ) # Ciclul de pregătire pentru epoca din interval (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Buclă peste toate loturile pentru i în interval (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Executați optimizarea op (backprop) și cost op (pentru a obține valoarea pierderii) _, c = sess.run ([optimizator, cost], feed_dict = {x: batch_x, y: batch_y}) # Calculează pierderea medie avg_cost + = c / total_batch # Afișează jurnalele pentru fiecare pas de epocă dacă epoch% display_step == 0: corect_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calculați acuratețea preciziei = tf.reduce_mean (tf.cast (corect_prediction, 'float') ) acu_temp = precision.eval ({x: mnist.test.images, y: mnist.test.labels}) #append the precision to the list precision_history.append (acu_temp) #append the cost history cost_history.append (avg_cost) print ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Optimizare finalizată! ') #plot istoricul costurilor plt.plot (cost_history) plt.show () #plot istoricul de precizie plt.plot (acuratețe _history) plt.show () # Model de test corect_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calculați acuratețea preciziei = tf.reduce_mean (tf.cast (corect_prediction, ' float ')) print (' Precizie: ', accurate.eval ({x: mnist.test.images, y: mnist.test.labels}))Ieșire:
Acum, cu aceasta, ajungem la sfârșitul acestui articol Deep Learning with Python. Sper că ați înțeles diferitele componente ale Deep Learning, cum a început totul și cum folosind Python putem crea un perceptron simplu și o rețea neuronală profundă.
Edureka’s este organizat de profesioniști din industrie conform cerințelor și cerințelor industriei. Veți stăpâni concepte precum funcția SoftMax, rețelele neuronale cu autocoder, mașina restricționată Boltzmann (RBM) și veți lucra cu biblioteci precum Keras și TFLearn. Cursul a fost special organizat de experți din industrie cu studii de caz în timp real.
Ai o întrebare pentru noi? Vă rugăm să o menționați în secțiunea de comentarii din „Învățare profundă cu Python” și vă vom răspunde.