Deep learning con Python: guida per principianti al deep learning

è uno degli argomenti più caldi del 2018-19 e per una buona ragione. Ci sono stati così tanti progressi nel settore in cui è giunto il momento in cui le macchine oi programmi per computer stanno effettivamente sostituendo gli umani. Questo Apprendimento profondo con Python l'articolo ti aiuterà a capire cos'è esattamente il Deep Learning e come è stata resa possibile questa transizione. Tratterò i seguenti argomenti in questo articolo:

• Scienza dei dati e componenti
• La necessità del Deep Learning
• Cos'è il deep learning?
• Perceptron e reti neurali artificiali
• Applicazioni del deep learning
• Perché Python per il deep learning?
• Apprendimento approfondito con Python: esempio di Perceptron
• Apprendimento profondo con Python: creazione di una rete neurale profonda

Scienza dei dati e componenti

Bene, Data Science è qualcosa che esiste da secoli. Scienza dei dati è l'estrazione di conoscenza dai dati utilizzando diverse tecniche e algoritmi.

è una tecnica che consente alle macchine di imitare il comportamento umano. L'idea alla base dell'IA è abbastanza semplice ma affascinante, ovvero creare macchine intelligenti in grado di prendere decisioni da sole. Per anni si è pensato che i computer non avrebbero mai eguagliato la potenza del cervello umano.

Bene, allora non avevamo dati e potenza di calcolo sufficienti, ma ora con Big Data nascendo e con l'avvento delle GPU, l'intelligenza artificiale è possibile.

funzione goto c ++

è un sottoinsieme della tecnica di intelligenza artificiale che utilizza metodi statistici per consentire alle macchine di migliorare con l'esperienza.

Apprendimento approfondito è un sottoinsieme di ML che rende fattibile il calcolo della rete neurale multistrato. Utilizza reti neurali per simulare un processo decisionale simile a quello umano.

La necessità del Deep Learning

Un passo verso l'intelligenza artificiale è l'apprendimento automatico. L'apprendimento automatico è un sottoinsieme dell'intelligenza artificiale e si basa sull'idea che le macchine dovrebbero avere accesso ai dati e dovrebbero essere lasciate a imparare ed esplorare da sole. Si occupa dell'estrazione di modelli da grandi set di dati. La gestione di set di dati di grandi dimensioni non era un problema.

• Algoritmi di machine learning non può gestire dati ad alta dimensione - dove abbiamo un gran numero di input e output: intorno a migliaia di dimensioni. La gestione e l'elaborazione di questo tipo di dati diventa molto complessa e le risorse esauriscono. Questo è definito come Maledizione della dimensionalità.

• Un'altra sfida affrontata è stata, per specificare il file caratteristiche da estrarre . Questo gioca un ruolo importante nella previsione del risultato e per ottenere una migliore precisione. Pertanto, senza estrazione delle caratteristiche, la sfida per il programmatore aumenta poiché l'efficacia dell'algoritmo dipende molto da quanto è perspicace il programmatore.

Ora, è qui che il Deep Learning è venuto in soccorso. L'apprendimento profondo lo è in grado di gestire i dati ad alta dimensione ed è anche efficiente in concentrandosi sulle caratteristiche giuste da solo.

Cos'è il deep learning?

Il deep learning è un sottoinsieme del machine learning in cui vengono utilizzati algoritmi di machine learning simili per l'addestramento in modo da ottenere una migliore precisione nei casi in cui il primo non era all'altezza del marchio. Fondamentalmente, L'apprendimento profondo imita il modo in cui funziona il nostro cervello cioè impara dall'esperienza.

Come sai,il nostro cervello è composto da miliardi di neuroni che ci permette di fare cose incredibili. Anche il cervello di un bambino piccolo è in grado di risolvere problemi complessi che sono molto difficili da risolvere anche utilizzando i supercomputer. Allora, come possiamo ottenere la stessa funzionalità in un programma? Ora, è qui che capiamo Neurone artificiale (Perceptron) e Rete neurale artificiale.

Perceptron e reti neurali artificiali

Il Deep Learning studia l'unità di base di un cervello chiamata cellula cerebrale o neurone. Ora, cerchiamo di capire la funzionalità dei neuroni biologici e come imitiamo questa funzionalità nella percezione o in un neurone artificiale.

• Dendrite: Riceve segnali da altri neuroni
• Corpo cellulare: Somma tutti gli input
• Axon: Viene utilizzato per trasmettere segnali alle altre cellule

Un neurone artificiale o un Perceptron è un modello lineare utilizzato per la classificazione binaria. Modella un neurone che ha una serie di input, ognuno dei quali ha un peso specifico. Il neurone calcola alcune funzioni su questi ponderato input e fornisce l'output.

Riceve n ingressi (corrispondenti a ciascuna funzione). Quindi somma gli input, applica una trasformazione e produce un output. Ha due funzioni:

• Somma
• Trasformazione (attivazione)

Il peso mostra l'efficacia di un particolare input. Più il peso dell'input, più avrà un impatto sulla rete neurale . D'altronde, Bias è un parametro aggiuntivo nel Perceptron che viene utilizzato per regolare l'output insieme alla somma ponderata degli input per il neurone che aiuta il modello in modo che possa adattarsi meglio ai dati forniti.

Funzioni di attivazione traduce gli input in output. Utilizza una soglia per produrre un output. Ci sono molte funzioni che vengono utilizzate come funzioni di attivazione, come:

• Lineare o identità
• Unità o passo binario
• Sigmoide o logistico
• Tanh
• ReLU
• Softmax

Bene. se pensi che Perceptron risolva il problema, ti sbagli. C'erano due problemi principali:

• Perceptrons monostrato non è possibile classificare i punti dati separabili in modo non lineare .
• Problemi complessi, che coinvolgono molti parametri non può essere risolto da Single-Layer Perceptrons.

Considera l'esempio qui e la complessità con i parametri coinvolti per prendere una decisione da parte del team di marketing.

Un neurone non può ricevere così tanti input ed è per questo che verrebbe utilizzato più di un neurone per risolvere questo problema. Neural Network è davvero solo un file composizione di Perceptrons, collegati in modi diversi e operando su diverse funzioni di attivazione.

• Nodi di input forniscono informazioni dal mondo esterno alla rete e sono insieme denominati 'Livello di input'.
• Nodi nascosti eseguire calcoli e trasferire informazioni dai nodi di input ai nodi di output. Una raccolta di nodi nascosti forma un 'livello nascosto'.
• Nodi di output sono indicati collettivamente come 'Livello di output' e sono responsabili dei calcoli e del trasferimento delle informazioni dalla rete al mondo esterno.

Ora che hai un'idea di come si comporta un perceptron, dei diversi parametri coinvolti e dei diversi livelli di una rete neurale, continuiamo questo Deep Learning con il blog di Python e vediamo alcune fantastiche applicazioni di Deep Learning.

Applicazioni del deep learning

Esistono varie applicazioni del Deep Learning nel settore, eccone alcune di quelle importanti presenti nelle nostre attività quotidiane.

• Riconoscimento vocale

• Traduzione automatica

• Riconoscimento facciale e codifica automatica

• Assistenti personali virtuali

• Auto a guida autonoma

• Chatbot

Perché Python per il deep learning?

• è uno di questi strumenti che ha un attributo unico, essere un linguaggio di programmazione generico come essere facile da usare quando si tratta di calcolo analitico e quantitativo.
• È molto facile da capire
• Python lo è Digitato dinamicamente
• Enorme
• Una vasta gamma di librerie per scopi diversi come Numpy, Seaborn, Matplotlib, Panda e Scikit-learn

Ora basta con la teoria, vediamo come possiamo iniziare il Deep Learning con Python con un piccolo ma entusiasmante esempio.

Apprendimento profondo con Python: esempio di Perceptron

Ora sono sicuro che voi ragazzi dovete avere familiarità con il funzionamento del ' O' cancello. L'output è uno se uno qualsiasi degli input è anche uno.

Pertanto, un Perceptron può essere utilizzato come separatore o linea di decisione che divide l'insieme di input di OR Gate, in due classi:

Classe 1: Input con output pari a 0 che si trova al di sotto della linea di decisione.
Classe 2: Input con output come 1 che si trova sopra la linea di decisione o il separatore.

crea una classe singleton in java

Fino ad ora, abbiamo capito che un perceptron lineare può essere utilizzato per classificare il data set di input in due classi. Ma come classifica effettivamente i dati?

Matematicamente un perceptron può essere pensato come un'equazione di pesi, input e bias.

Passaggio 1: importa tutta la libreria richiesta

Qui importerò solo una libreria, ad es. TensorFlow

importa tensorflow come tf

Passaggio 2: definizione delle variabili vettoriali per input e output

Successivamente, dobbiamo creare variabili per memorizzare l'input, l'output e il bias per Perceptron.

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

Passaggio 3: definire la variabile di peso

Qui definiremo la variabile tensore di forma 3 × 1 per i nostri pesi e le assegneremo inizialmente alcuni valori casuali.

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

Passaggio 4: definire i segnaposto per input e output

Dobbiamo definire segnaposto in modo che possano accettare input esterni durante la corsa.

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

Passaggio 5: calcolo dell'output e della funzione di attivazione

Come discusso in precedenza, l'input ricevuto da un perceptron viene prima moltiplicato per i rispettivi pesi e quindi tutti questi input ponderati vengono sommati insieme. Questo valore sommato viene quindi alimentato all'attivazione per ottenere il risultato finale.

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

Nota: in questo caso, ho usato relu come funzione di attivazione. Sei libero di utilizzare una qualsiasi delle funzioni di attivazione in base alle tue necessità.

Passaggio 6: calcolare il costo o l'errore

Dobbiamo calcolare il costo = errore quadratico medio che non è altro che il quadrato della differenza tra l'output del perceptron e l'output desiderato.

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

Passaggio 7: ridurre al minimo l'errore

L'obiettivo di un perceptron è ridurre al minimo la perdita, il costo o l'errore. Quindi qui useremo l'ottimizzatore della discesa del gradiente.

optimizer = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimize (loss)

Passaggio 8: inizializza tutte le variabili

Le variabili vengono definite solo con tf.Variable. Quindi, dobbiamo inizializzare le variabili definite.

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

Passaggio 9: addestramento di Perceptron nelle iterazioni

Dobbiamo allenare il nostro perceptron, cioè aggiornare i valori di pesi e bias nell'iterazione successiva per ridurre al minimo l'errore o la perdita. Qui, allenerò il nostro percettore in 100 epoche.

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,' - perdita - ', costo)

Passaggio 10: output

……

……

Come puoi vedere qui, la perdita è iniziata a 2.07 e si è conclusa alle 0.27

.

Apprendimento profondo con Python: creazione di una rete neurale profonda

Ora che abbiamo creato con successo un perceptron e lo abbiamo addestrato per una porta OR. Continuiamo questo articolo e vediamo come creare la nostra rete neurale da zero, dove creeremo un livello di input, livelli nascosti e un livello di output.

Useremo il set di dati MNIST. Il set di dati MNIST è costituito da 60.000 formazione campioni e 10.000 test campioni di immagini di cifre scritte a mano. Le immagini sono di dimensioni 28 × 28 pixel e l'output può trovarsi tra 0-9 .

Il compito qui è addestrare un modello in grado di identificare con precisione la cifra presente sull'immagine

In primo luogo, utilizzeremo l'importazione di seguito per portare la funzione di stampa da Python 3 a Python 2.6+. Le istruzioni __future__ devono essere all'inizio del file perché cambiano le cose fondamentali sulla lingua, quindi il compilatore deve conoscerle dall'inizio

from __future__ import print_function

Di seguito è riportato il codice con i commenti ad ogni passaggio

# Importa i dati MNIST da tensorflow.examples.tutorials.mnist importa input_data mnist = input_data.read_data_sets ('/ tmp / data /', one_hot = True) importa tensorflow come tf importa matplotlib.pyplot come plt # Parametri learning_rate = 0.001 training_epochs = 15 batch_size = 100 display_step = 1 # Network Parameters n_hidden_1 = 256 # 1st layer number of features n_hidden_2 = 256 # 2nd layer number of features n_input = 784 # MNIST data input (img shape: 28 * 28) n_classes = 10 # MNIST total classes ( 0-9 cifre) # tf Input grafico x = tf.placeholder ('float', [None, n_input]) y = tf.placeholder ('float', [None, n_classes]) # Crea modello def multilayer_perceptron (x, weights , bias): # Livello nascosto con attivazione RELU layer_1 = tf.add (tf.matmul (x, weights ['h1']), biases ['b1']) layer_1 = tf.nn.relu (layer_1) # Livello nascosto con attivazione RELU layer_2 = tf.add (tf.matmul (layer_1, weights ['h2']), biases ['b2']) layer_2 = tf.nn.relu (layer_2) # Livello di output con attivazione lineare out_layer = tf. matmul (strato _2, pesi ['out']) + bias ['out'] return out_layer # Memorizza il peso dei livelli e i pesi di polarizzazione = {'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]))} bias = {'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]))} # Costruisci il modello pred = multilayer_perceptron (x, weights, biases) # Define loss and optimizer cost = tf.reduce_mean (tf.nn.softmax_cross_entropy_with_logits (logits = pred, labels = y)) optimizer = tf.train.AdamOptimizer (learning_rate = learning_rate) .minimize (cost) # Inizializzazione delle variabili init = tf.global_variables_initializer () #crea una lista vuota per memorizzare la cronologia dei costi e la cronologia dell'accuratezza cost_history = [] accuratezza_istoria = [] # Lancia il grafico con tf.Session () as sess: sess.run (init ) # Ciclo di addestramento per l'epoca nell'intervallo (training_epochs): avg_cost = 0. total_batch = int (mnist.train.num_examples / batch_size) # Ciclo su tutti i batch per i nell'intervallo (total_batch): batch_x, batch_y = mnist.train.next_batch (batch_size) # Esegui ottimizzazione op (backprop) e costo op (per ottenere il valore della perdita) _, c = sess.run ([optimizer, cost], feed_dict = {x: batch_x, y: batch_y}) # Calcola la perdita media avg_cost + = c / total_batch # Visualizza i log per passo dell'epoca se epoch% display_step == 0: correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calcola accuratezza accuratezza = tf.reduce_mean (tf.cast (correct_prediction, 'float') ) acu_temp = accuratezza.eval ({x: mnist.test.images, y: mnist.test.labels}) #append l'accuratezza all'elenco accuratezza_history.append (acu_temp) #append la cronologia dei costi cost_history.append (avg_cost) stampa ('Epoch:', '% 04d'% (epoch + 1), '- cost =', '{: .9f}'. Format (avg_cost), '- Accuracy =', acu_temp) print ('Ottimizzazione finita! ') # traccia la cronologia dei costi plt.plot (cost_history) plt.show () # traccia la cronologia dell'accuratezza plt.plot (accuratezza _history) plt.show () # Test model correct_prediction = tf.equal (tf.argmax (pred, 1), tf.argmax (y, 1)) # Calcola accuratezza accuratezza = tf.reduce_mean (tf.cast (correct_prediction, ' float ')) print (' Precisione: ', accuratezza.eval ({x: mnist.test.images, y: mnist.test.labels}))

Produzione:

cos'è il corso di data science

Con questo, arriviamo alla fine di questo articolo Deep Learning with Python. Spero che tu abbia capito i vari componenti del Deep Learning, come tutto è iniziato e come usando Python possiamo creare un semplice percettrone e una rete neurale profonda.

Edureka's è curato da professionisti del settore secondo i requisiti e le richieste del settore. Imparerai concetti come la funzione SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM) e lavorerai con librerie come Keras e TFLearn. Il corso è stato appositamente curato da esperti del settore con casi di studio in tempo reale.

Hai domande per noi? Per favore, menzionalo nella sezione commenti di 'Deep Learning with Python' e ti risponderemo.