Esercitazione su TensorFlow - Apprendimento approfondito con TensorFlow

Ho progettato questo tutorial di TensorFlow per professionisti e appassionati interessati ad applicare l'algoritmo di apprendimento profondo utilizzando TensorFlow per risolvere vari problemi. TensorFlow è una libreria di deep learning open source basata sul concetto di grafici del flusso di dati per la creazione di modelli. Ti consente di creare reti neurali su larga scala con molti livelli.Imparare l'uso di questa libreria è anche una parte fondamentale del .Di seguito sono riportati gli argomenti che verranno discussi in questo blog tutorial di TensorFlow:

• Cos'è TensorFlow
• Nozioni di base sul codice TensorFlow
• TensorFlow UseCase

Cosa sono i tensori?

In questo tutorial di TensorFlow, prima di parlare di TensorFlow, dobbiamo prima capire cosa sono i tensori . I tensori non sono altro che un de facto per rappresentare i dati nel deep learning.

Come mostrato nell'immagine sopra, i tensori sono solo array multidimensionali, che ti permettono di rappresentare dati con dimensioni maggiori. In generale, Deep Learning si occupa di set di dati ad alta dimensione in cui le dimensioni si riferiscono a diverse funzionalità presenti nel set di dati. Infatti, il nome “TensorFlow” è stato derivato dalle operazioni che le reti neurali eseguono sui tensori. È letteralmente un flusso di tensori. Dato che hai capito cosa sono i tensori, andiamo avanti in questo tutorial di TensorFlow e capiamo: cos'è TensorFlow?

Cos'è TensorFlow?

TensorFlow è una libreria basata su Python che fornisce diversi tipi di funzionalità per l'implementazione di modelli di deep learning. Come discusso in precedenza, il termine TensorFlow è composto da due termini: Tensore e flusso:

In TensorFlow, il termine tensore si riferisce alla rappresentazione dei dati come array multidimensionale mentre il termine flusso si riferisce alla serie di operazioni che si eseguono sui tensori come mostrato nell'immagine sopra.

Ora abbiamo coperto abbastanza informazioni su TensorFlow.

Successivamente, in questo tutorial di TensorFlow parleremo delle nozioni di base sul codice di TensorFlow.

Esercitazione su TensorFlow: nozioni di base sul codice

Fondamentalmente, il processo complessivo di scrittura di un programma TensorFlow prevede due passaggi:

1. Costruire un grafico computazionale
2. Esecuzione di un grafico computazionale

Lascia che ti spieghi i due passaggi precedenti uno per uno:

1. Costruire un grafico computazionale

Così, cos'è un grafo computazionale? Bene, un grafico computazionale è una serie di operazioni TensorFlow disposte come nodi nel grafico. Ogni nodo accetta 0 o più tensori come input e produce un tensore come output. Lascia che ti faccia un esempio di un semplice grafo computazionale che consiste di tre nodi: per , b & c come mostrato di seguito:

l'inverso di un numero in java

Spiegazione del grafico computazionale sopra:

• Nodi costantivengono utilizzati per memorizzare valori costanti poiché non richiede input, ma produce i valori memorizzati come output. Nell'esempio precedente, aeb sono nodi costanti con valori 5 e 6 rispettivamente.

• Il nodo c rappresenta l'operazione di moltiplicare la costante nodo a con b. Pertanto, l'esecuzione del nodo c comporterà la moltiplicazione del nodo const a & b.

Fondamentalmente, si può pensare a un grafico computazionale come un modo alternativo di concettualizzare calcoli matematici che si svolgono in un programma TensorFlow. Le operazioni assegnate ai diversi nodi di un Computational Graph possono essere eseguite in parallelo, fornendo così una migliore performance in termini di calcoli.

Qui descriviamo solo il calcolo, non calcola nulla, non contiene alcun valore, definisce solo le operazioni specificate nel codice.

2. Esecuzione di un grafico computazionale

Prendiamo l'esempio precedente di grafo computazionale e capiamo come eseguirlo. Di seguito è riportato il codice dell'esempio precedente:

Esempio 1:

importa tensorflow come tf # Costruisci un grafico a = tf.constant (5.0) b = tf.constant (6.0) c = a * b

Ora, per ottenere l'output del nodo c, dobbiamo eseguire il grafo computazionale all'interno di a sessione . Session posiziona le operazioni del grafico su Dispositivi, come CPU o GPU, e fornisce metodi per eseguirle.

Una sessione incapsula il controllo e lo stato del runtime TensorFlow, ovvero memorizza le informazioni sull'ordine in cui verranno eseguite tutte le operazioni e passa il risultato dell'operazione già calcolata all'operazione successiva nella pipeline. Lascia che ti mostri come eseguire il grafico computazionale sopra all'interno di una sessione (la spiegazione di ogni riga di codice è stata aggiunta come commento):

# Crea l'oggetto sessione sess = tf.Session () # Esegui il grafico all'interno di una sessione e memorizza l'output su una variabile output_c = sess.run (c) # Stampa l'output del nodo c print (output_c) #Chiudi la sessione su libera alcune risorse sess.close ()

 Produzione: 30

Quindi, si trattava di una sessione e dell'esecuzione di un grafico computazionale al suo interno. Parliamo ora delle variabili e dei segnaposto che utilizzeremo ampiamente durante la creazione del modello di deep learning utilizzando TensorFlow.

Costanti, segnaposto e variabili

In TensorFlow, costanti, segnaposto e variabili vengono utilizzati per rappresentare diversi parametri di un modello di apprendimento profondo. Poiché ho già discusso delle costanti in precedenza, inizierò con i segnaposto.

Segnaposto:

Una costante TensorFlow ti consente di memorizzare un valore ma, cosa succede se, vuoi che i tuoi nodi ricevano input durante la corsa? Per questo tipo di funzionalità, vengono utilizzati segnaposto che consentono al grafico di prendere input esterni come parametri. Fondamentalmente, un segnaposto è una promessa di fornire un valore in un secondo momento o durante il runtime. Lascia che ti faccia un esempio per rendere le cose più semplici:

import tensorflow come tf # Creazione di segnaposto a = tf. segnaposto (tf.float32) b = tf. segnaposto (tf.float32) # Assegnazione dell'operazione di moltiplicazione w.r.t. a & ampamp b al nodo mul mul = a * b # Crea oggetto sessione sess = tf.Session () # Eseguendo mul passando i valori [1, 3] [2, 4] rispettivamente per a e b output = sess.run ( mul, {a: [1,3], b: [2, 4]}) print ('Moltiplicazione ab:', output)

 Produzione: [2. 12.]

Punti da ricordare segnaposto:

• I segnaposto non vengono inizializzati e non contengono dati.
• È necessario fornire input o feed al segnaposto che vengono considerati durante il runtime.
• L'esecuzione di un segnaposto senza input genera un errore.

Ora, andiamo avanti e comprendiamo: cosa sono le variabili?

Variabili

Nell'apprendimento approfondito, i segnaposto vengono utilizzati per prendere input arbitrari nel modello o nel grafico. Oltre a prendere input, è anche necessario modificare il grafico in modo che possa produrre nuovi output w.r.t. stessi input. Per questo utilizzerai le variabili. In poche parole, una variabile consente di aggiungere tali parametri o nodi al grafico che sono allenabili, ovvero il valore può essere modificato nel periodo di tempo. Le variabili vengono definite fornendo il loro valore iniziale e tipo come mostrato di seguito:

var = tf.Variable ([0.4], dtype = tf.float32)

Nota:

• Nel caso in cui non sia stato fornito il tipo di dati in modo esplicito, TensorFlow dedurrà il tipo di costante / variabile dal valore inizializzato.
• TensorFlow ha molti dei propri tipi di dati come tf.float32 , tf.int32 eccetera. Puoi fare riferimento a tutti loro sopra Qui .

Le costanti vengono inizializzate quando si chiama tf. costante e il loro valore non potrà mai cambiare. Al contrario, le variabili non vengono inizializzate quando chiamate tf.Variable . Per inizializzare tutte le variabili in un programma TensorFlow, devi dovere chiamare esplicitamente un'operazione speciale come mostrato di seguito:

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

Ricorda sempre che una variabile deve essere inizializzata prima che un grafico venga utilizzato per la prima volta.

Nota: Le variabili TensorFlow sono buffer in memoria che contengono tensori, ma a differenza dei normali tensori che vengono istanziati solo quando viene eseguito un grafico e vengono immediatamente eliminati in seguito, le variabili sopravvivono attraverso più esecuzioni di un grafico.

Ora che abbiamo coperto abbastanza nozioni di base di TensorFlow, andiamo avanti e comprendiamo come implementare un modello di regressione lineare utilizzando TensorFlow.

Modello di regressione lineare utilizzando TensorFlow

Il modello di regressione lineare viene utilizzato per prevedere il valore sconosciuto di una variabile (variabile dipendente) dal valore noto di altre variabili (variabile indipendente) utilizzando l'equazione di regressione lineare come mostrato di seguito:

Pertanto, per creare un modello lineare, è necessario:

1. Variabile dipendente o di output (Y)
2. Variabile pendenza (w)
3. Y - Intercetta o Bias (b)
4. Indipendente o variabile di ingresso (X)

Quindi, iniziamo a creare un modello lineare utilizzando TensorFlow:

Copia il codice facendo clic sul pulsante indicato di seguito:

# Creazione di una variabile per la pendenza del parametro (W) con valore iniziale come 0.4 W = tf.Variable ([. 4], tf.float32) # Creazione di una variabile per il bias del parametro (b) con valore iniziale come -0.4 b = tf.Variable ( [-0.4], tf.float32) # Creazione di segnaposto per fornire input o variabili indipendenti, denotato da xx = tf.placeholder (tf.float32) # Equazione della regressione lineare linear_model = W * x + b # Inizializzazione di tutte le variabili sess = tf.Session () init = tf.global_variables_initializer () sess.run (init) # Esecuzione del modello di regressione per calcolare l'output rispetto a per stampare i valori x forniti (sess.run (linear_model {x: [1, 2, 3, 4]}))

Produzione:

[0. 0.40000001 0.80000007 1.20000005]

Il codice sopra indicato rappresenta solo l'idea di base alla base dell'implementazione del modello di regressione, ovvero come si segue l'equazione della linea di regressione in modo da ottenere l'output rispetto a quanto segue. un insieme di valori di input. Ma ci sono altre due cose da aggiungere a questo modello per renderlo un modello di regressione completo:

• In primo luogo, dobbiamo fornire un meccanismo mediante il quale il nostro modello possa addestrarsi automaticamente in base a un dato insieme di input e rispettivi output.
• La seconda cosa di cui abbiamo bisogno è convalidare il nostro modello addestrato confrontando il suo output con l'output desiderato o target in base a un dato insieme di valori x.

Ora vediamo come posso incorporare le funzionalità sopra indicate nel mio codice per il modello di regressione.

Funzione di perdita - Convalida del modello

Una funzione di perdita misura la distanza tra l'uscita corrente del modello e quella dell'uscita desiderata o target. Userò una funzione di perdita più comunemente usata per il mio modello di regressione lineare chiamata Somma dell'errore quadratico o SSE. SSE calcolato rispetto a output del modello (rappresentato da linear_model) e output desiderato o target (y) come:

differenza tra jquery e javascript

y = tf.placeholder (tf.float32) error = linear_model - y squared_errors = tf.square (error) loss = tf.reduce_sum (squared_errors) print (sess.run (loss, {x: [1,2,3,4 ], y: [2, 4, 6, 8]})

 Produzione: 90.24

Come puoi vedere, stiamo ottenendo un valore di perdita elevato. Pertanto, dobbiamo regolare i nostri pesi (W) e bias (b) in modo da ridurre l'errore che stiamo ricevendo.

tf.train API - Training the Model

TensorFlow fornisce ottimizzatori che cambiano lentamente ogni variabile per ridurre al minimo la funzione di perdita o l'errore. L'ottimizzatore più semplice è discesa in pendenza . Modifica ogni variabile in base all'entità della derivata di perdita rispetto a quella variabile.

#Creating an instance of gradient descent optimizer optimizer = tf.train.GradientDescentOptimizer (0.01) train = optimizer.minimize (loss) for i in range (1000): sess.run (train, {x: [1, 2, 3, 4], y: [2, 4, 6, 8]}) print (sess.run ([W, b]))

 Produzione: [array ([1.99999964], dtype = float32), array ([9.86305167e-07], dtype = float32)]

Quindi, ecco come creare un modello lineare utilizzando TensorFlow e addestrarlo per ottenere l'output desiderato.

Ora che conosci il Deep Learning, dai un'occhiata al da Edureka, una società di formazione online affidabile con una rete di oltre 250.000 studenti soddisfatti sparsi in tutto il mondo. Il corso di formazione sulla certificazione Edureka Deep Learning con TensorFlow aiuta gli studenti a diventare esperti nella formazione e nell'ottimizzazione delle reti neurali di base e convoluzionali utilizzando progetti e compiti in tempo reale insieme a concetti come la funzione SoftMax, le reti neurali con codificatore automatico, la macchina RBM ristretta di Boltzmann.

Hai domande per noi? Per favore menzionalo nella sezione commenti e ti risponderemo.