Aprenentatge profund amb Python: Guia per a principiants d’aprenentatge profund

Aquest article us proporcionarà un coneixement complet i detallat de l’aprenentatge profund amb Python i de la utilitat que té en el dia a dia.

és un dels temes més calents del 2018-19 i per una bona raó. Hi ha hagut tants avenços a la indústria en què ha arribat el moment en què les màquines o els programes informàtics substitueixen els humans. Això Aprenentatge profund amb Python l'article us ajudarà a entendre què és exactament l'aprenentatge profund i com s'ha fet possible aquesta transició. En aquest article tractaré els temes següents:



Ciència de les dades i els seus components

Bé, la ciència de dades és una cosa que existeix des de fa segles. Ciència de les dades és l'extracció de coneixement de dades mitjançant l'ús de diferents tècniques i algorismes.



Cronologia d

és una tècnica que permet a les màquines imitar el comportament humà. La idea darrere de la IA és bastant senzilla però fascinant, que consisteix a fabricar màquines intel·ligents que puguin prendre decisions per si soles. Durant anys, es va pensar que els ordinadors mai no coincidirien amb la potència del cervell humà.



Bé, aleshores no teníem prou potència de càlcul i dades, però ara sí Dades massives amb l’aparició de les GPU, és possible la intel·ligència artificial.

és un subconjunt de tècnica d’IA que utilitza mètodes estadístics per permetre que les màquines millorin amb l’experiència.



Aprenentatge profund és un subconjunt de ML que fa factible el càlcul de la xarxa neuronal de múltiples capes. Utilitza xarxes neuronals per simular la presa de decisions de tipus humà.

La necessitat d’un aprenentatge profund

Un pas cap a la intel·ligència artificial és l’aprenentatge automàtic. L’aprenentatge automàtic és un subconjunt d’IA i es basa en la idea que les màquines haurien de tenir accés a les dades i s’haurien de deixar aprendre i explorar per elles mateixes. S’ocupa de l’extracció de patrons de grans conjunts de dades. La manipulació de grans conjunts de dades no va ser un problema.

  • Algorismes d’aprenentatge automàtic no pot gestionar dades d'alta dimensió - on tenim un gran nombre d’entrades i sortides: al voltant de milers de dimensions. La manipulació i el processament d’aquest tipus de dades esdevé molt complex i exhaustiu. Això es denomina així Maledicció de Dimensionalitat.

  • Un altre desafiament afrontat va ser, per especificar el funcions a extreure . Això té un paper important en la predicció del resultat, així com per aconseguir una millor precisió. Per tant, sense extracció de característiques, el desafiament per al programador augmenta ja que l'eficàcia de l'algorisme depèn en gran mesura de la perspicàcia del programador.

Ara, aquí és on Deep Learning va rescatar. L’aprenentatge profund ho és capaç de manejar les dades d’alta dimensió i també és eficient en centrant-se en les funcions adequades per si mateix.

Què és l'aprenentatge profund?

L’aprenentatge profund és un subconjunt de Machine Learning on s’utilitzen algorismes d’aprenentatge automàtic similars per entrenar per tal d’aconseguir una millor precisió en aquells casos en què el primer no estigués rendint fins a la marca. Bàsicament, L’aprenentatge profund imita la manera com funciona el nostre cervell és a dir, aprèn de l’experiència.

Com ja saps,el nostre cervell està format per milers de milions de neurones això ens permet fer coses increïbles. Fins i tot el cervell d’un nen petit és capaç de resoldre problemes complexos que són molt difícils de resoldre fins i tot amb Superordinadors. Llavors, com podem aconseguir la mateixa funcionalitat en un programa? Ara és aquí on entenem Neurona artificial (Perceptron) i Xarxa de neurones artificials.

Perceptron i xarxes neuronals artificials

Deep Learning estudia la unitat bàsica d’un cervell anomenada cèl·lula cerebral o neurona. Ara, entenem la funcionalitat de les neurones biològiques i com imitem aquesta funcionalitat en la percepció o en una neurona artificial.

  • Dendrita: Rep senyals d'altres neurones
  • Cos cel·lular: Suma totes les entrades
  • Axó: S'utilitza per transmetre senyals a les altres cèl·lules

Una neurona artificial o un Perceptron és un model lineal utilitzat per a la classificació binària. Modela una neurona que té un conjunt d’entrades, a les quals se’ls dóna un pes específic. La neurona calcula alguna funció sobre aquests ponderat entrades i dóna la sortida.

Rep n entrades (corresponents a cada funció). A continuació, suma aquestes entrades, aplica una transformació i produeix una sortida. Té dues funcions:

  • Suma
  • Transformació (activació)

El pes mostra l’eficàcia d’una aportació particular. Més pes tindrà un impacte en la xarxa neuronal . Per altra banda, Parcialitat és un paràmetre addicional al Perceptron que s’utilitza per ajustar la sortida juntament amb la suma ponderada de les entrades a la neurona que ajuda el model de manera que s’adapti millor a les dades donades.

Funcions d'activació tradueix les entrades en sortides. Utilitza un llindar per produir una sortida. Hi ha moltes funcions que s’utilitzen com a funcions d’activació, com ara:

  • Lineal o Identitat
  • Unitat o pas binari
  • Sigmoide o logístic
  • Tanh
  • ReLU
  • Softmax

Bé. si creieu que Perceptron soluciona el problema, s’equivoca. Hi va haver dos problemes principals:

exemple d'invocació de mètode remot java
  • Perceptrons d’una sola capa no pot classificar els punts de dades no separables linealment .
  • Problemes complexos, que impliquen molts paràmetres no es pot resoldre amb els perceptrons d’una sola capa.

Tingueu en compte l'exemple aquí i la complexitat amb els paràmetres implicats per prendre una decisió per part de l'equip de màrqueting.

Una neurona no pot tenir tantes entrades i és per això que s’utilitzaria més d’una neurona per resoldre aquest problema. Neural Network és realment només un composició de perceptrons, connectats de diferents maneres i operant en diferents funcions d'activació.

  • Nodes d'entrada proporcionen informació del món exterior a la xarxa i es coneixen junts com a 'capa d'entrada'.
  • Nodes ocults realitzar càlculs i transferir informació des dels nodes d’entrada als nodes de sortida. Una col·lecció de nodes ocults forma una 'capa oculta'.
  • Nodes de sortida es coneixen col·lectivament com a 'capa de sortida' i són responsables dels càlculs i de la transferència d'informació de la xarxa al món exterior.

Ara que ja teniu una idea de com es comporta un perceptron, els diferents paràmetres implicats i les diferents capes d’una xarxa neuronal, continuem aquest Deep Learning amb Python Blog i vegem algunes aplicacions interessants de Deep Learning.

Aplicacions de l'aprenentatge profund

Hi ha diverses aplicacions de l’aprenentatge profund a la indústria, a continuació en detallem algunes de les més importants que estan presents a les nostres tasques del dia a dia.

  • Reconeixement de veu

  • Traducció automàtica

  • Reconeixement facial i etiquetatge automàtic

  • Assistents personals virtuals

  • Cotxe autònom

  • Chatbots

Per què Python for Deep Learning?

  • és una d'aquestes eines que té un atribut únic, de ser un llenguatge de programació d’ús general com a ser fàcil d'usar pel que fa a la computació analítica i quantitativa.
  • És molt fàcil d'entendre
  • Python ho és Escriptura dinàmica
  • Enorme
  • Una àmplia gamma de biblioteques per a diferents propòsits, com ara Numpy, Seaborn, Matplotlib, Pandas i Scikit-learn

Ara ja tenim prou teoria, a veure com podem iniciar l’aprenentatge profund amb Python amb un petit però emocionant exemple.

Aprenentatge profund amb Python: exemple de Perceptron

Ara estic segur que heu de familiaritzar-vos amb el funcionament del ' O ” porta. La sortida és 1 si alguna de les entrades també ho és 1.

Per tant, un Perceptron es pot utilitzar com a separador o com a línia de decisió que divideix el conjunt d'entrada de la porta OR en dues classes:

Classe 1: Entrades amb sortida 0 que es troba per sota de la línia de decisió.
Classe 2: Entrades amb sortida 1 que es troba per sobre de la línia de decisió o del separador.

Fins ara, hem entès que es pot utilitzar un perceptron lineal per classificar el conjunt de dades d’entrada en dues classes. Però, com classifica realment les dades?

Matemàticament es pot pensar un perceptró com una equació de pesos, entrades i biaix.

Pas 1: importeu tota la biblioteca necessària

Aquí només importaré una biblioteca, és a dir. TensorFlow

importa tensorflow com a tf

Pas 2: definiu les variables vectorials per a l'entrada i la sortida

A continuació, hem de crear variables per emmagatzemar l'entrada, la sortida i el biaix del Perceptron.

train_in = [[0,0,1], [0,1,1], [1,0,1], [1,1,1]] train_out = [[0], [1], [1], [1]]

Pas 3: definiu la variable de pes

Aquí definirem la variable tensorial de forma 3 × 1 per als nostres pesos i li assignarem inicialment alguns valors aleatoris.

w = tf.Variable (tf.random_normal ([3, 1], seed = 15))

Pas 4: definiu espais reservats per a entrada i sortida

Hem de definir espais reservats perquè puguin acceptar entrades externes en execució.

x = tf.placeholder (tf.float32, [Cap, 3]) y = tf.placeholder (tf.float32, [Cap, 1])

Pas 5: Calculeu la sortida i la funció d'activació

Com s’ha comentat anteriorment, l’entrada rebuda per un perceptró es multiplica primer pels pesos respectius i, després, totes aquestes entrades ponderades es sumen. Aquest valor sumat s’alimenta a l’activació per obtenir el resultat final.

output = tf.nn.relu (tf.matmul (x, w))

Nota: En aquest cas, he utilitzat relu com a funció d’activació. Podeu utilitzar qualsevol de les funcions d'activació segons les vostres necessitats.

Pas 6: calculeu el cost o l'error

Hem de calcular el cost = error quadrat mitjà que no és res més que el quadrat de la diferència de sortida del perceptron i la sortida desitjada.

loss = tf.reduce_sum (tf.square (sortida - y))

Pas 7: Minimitzar l’error

L’objectiu d’un perceptró és minimitzar la pèrdua o el cost o l’error. Per tant, aquí utilitzarem l’Optimitzador de descens de gradient.

optimitzador = tf.train.GradientDescentOptimizer (0,01) tren = optimitzador.minimitzar (pèrdua)

Pas 8: inicialitzeu totes les variables

Les variables només es defineixen amb tf.Variable. Per tant, hem d’inicialitzar les variables definides.

init = tf.global_variables_initializer () sess = tf.Session () sess.run (init)

Pas 9: Entrenar Perceptron en iteracions

Hem d’entrenar el nostre perceptron, és a dir, actualitzar els valors de pesos i biaixos en la iteració successiva per minimitzar l’error o la pèrdua. Aquí, entrenaré el nostre perceptró en 100 èpoques.

per a l’interval (100): sess.run (tren, {x: train_in, y: train_out}) cost = sess.run (loss, feed_dict = {x: train_in, y: train_out}) print ('Època-- ', i,' - pèrdua - ', cost)

Pas 10: sortida

......

......

Com podeu veure aquí, la pèrdua va començar a 2.07 i va acabar a les 0.27

.

Aprenentatge profund amb Python: creació d’una xarxa neuronal profunda

Ara que hem creat amb èxit un perceptró i l’hem entrenat per a una porta OR. Continuem aquest article i vegem com podem crear la nostra pròpia xarxa neuronal des de Scratch, on crearem una capa d’entrada, capes ocultes i capa de sortida.

Utilitzarem el conjunt de dades MNIST. El conjunt de dades MNIST consta de 60.000 formació mostres i 10.000 proves mostres d'imatges digitals manuscrites. Les imatges són de mida 28 × 28 píxels i la sortida pot estar entre 0-9 .

La tasca aquí és formar un model que pugui identificar amb precisió el dígit present a la imatge

En primer lloc, utilitzarem la importació següent per portar la funció d'impressió de Python 3 a Python 2.6+. Les declaracions __future__ han d’estar a prop de la part superior del fitxer perquè canvien coses fonamentals sobre l’idioma i, per tant, el compilador ha de saber-ne des del principi

des de __future__ importa funció_impressió

A continuació es mostra el codi amb comentaris a cada pas

# Importa dades MNIST de tensorflow.examples.tutorials.mnist importa input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) importa tensorflow com a importació tf matplotlib.pyplot com plt # Paràmetres learning_rate = 0,001 training_epochs = 15 batch_size = 100 display_step = 1 # Paràmetres de xarxa n_hidden_1 = 256 # 1a capa nombre de funcions n_hidden_2 = 256 # 2a capa nombre de funcions n_input = 784 # entrada de dades MNIST (forma img: 28 * 28) n_classes = 10 # MNIST classes totals ( 0-9 dígits) # tf Entrada gràfica x = tf.placeholder ('float', [Cap, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Crea el model def multilayer_perceptron (x, peses , biaixos): # Capa oculta amb activació de RELU layer_1 = tf.add (tf.matmul (x, weights ['h1']), biases ['b1']) layer_1 = tf.nn.relu (layer_1) # Capa oculta amb activació RELU layer_2 = tf.add (tf.matmul (layer_1, weights ['h2']), biases ['b2']) layer_2 = tf.nn.relu (layer_2) # Capa de sortida amb activació lineal out_layer = tf. matmul (capa _2, pesos ['out']) + biaixos ['out'] retornen 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]))}} # Model de construcció pred = multicapa_perceptron (x, pesos, biaixos) # Defineix la pèrdua i el cost de l’optimitzador = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (cost) # Inicialització de les variables init = tf.global_variables_initializer () #create una llista buida per emmagatzemar l'historial de costos i l'historial de precisió cost_history = [] precision_history = [] # Inicieu el gràfic amb tf.Session () com sess: sess.run (init ) # Cicle formatiu per a l'època en el rang (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Bucle sobre tots els lots per a l’interval (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Execució d’optimització (backprop) i cost op (per obtenir el valor de la pèrdua) _, c = sess.run ([optimitzador, cost], feed_dict = {x: batch_x, y: batch_y}) # Computa la pèrdua mitjana avg_cost + = c / total_batch # Mostra els registres per pas d'època si època% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calculeu la precisió de precisió = tf.reduce_mean (tf.cast (correct_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 ('Època:', '% 04d'% (època + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Optimització finalitzada! ') #plot l'historial de costos plt.plot (cost_history) plt.show () #plot l'historial de precisió plt.plot (precisió _history) plt.show () # Model de prova correcta_predició = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calculeu la precisió de precisió = tf.reduce_mean (tf.cast (correcta_predicció, ' float ')) print (' Precisió: ', precision.eval ({x: mnist.test.images, y: mnist.test.labels}))

Sortida:

Ara amb això, arribem al final d’aquest article d’aprenentatge profund amb Python. Espero que tingueu coneixement dels diversos components de l’aprenentatge profund, com va començar tot i com usant Python podem crear un perceptró senzill i una xarxa neuronal profunda.

Edureka’s està comissariat per professionals de la indústria segons els requisits i les demandes de la indústria. Dominarà conceptes com ara la funció SoftMax, les xarxes neuronals del codificador automàtic, la màquina restringida de Boltzmann (RBM) i treballareu amb biblioteques com Keras i TFLearn. El curs ha estat especialment comissariat per experts del sector amb estudis de casos en temps real.

Tens alguna pregunta? Esmenteu-lo a la secció de comentaris de 'Aprenentatge profund amb Python' i us respondrem.