Scienza dei dati

Tutorial su Python Tensorflow

Tutorial su Python Tensorflow
In questa lezione, esamineremo TensorFlow, una libreria di machine learning open source utilizzata per progettare, costruire e addestrare modelli di deep learning. È possibile eseguire calcoli numerici con la libreria TensorFlow i cui grafici di flusso di dati in cui le operazioni matematiche sono rappresentate come nodi e i dati sono rappresentati come bordi tra quei nodi.

Nel complesso, tratteremo tre argomenti principali in questa lezione:

  1. Cosa sono i tensori e TensorFlow?
  2. Applicazione di algoritmi ML con TensorFlow
  3. Casi d'uso di TensorFlow

TensorFlow è un eccellente pacchetto Python di Google che fa buon uso del paradigma di programmazione del flusso di dati per calcoli matematici altamente ottimizzati. Alcune delle caratteristiche di TensorFlow sono:

Grazie a tutte queste funzionalità e alla gamma di algoritmi di apprendimento automatico implementati da TensorFlow, è una libreria su scala di produzione. Immergiamoci nei concetti in TensorFlow in modo che possiamo sporcarci le mani con il codice subito dopo.

Installazione di TensorFlow

Poiché utilizzeremo l'API Python per TensorFlow, è bene sapere che funziona con entrambi Python 2.7 e 3.3+ versioni. Installiamo la libreria TensorFlow prima di passare agli esempi e ai concetti reali. Ci sono due modi per installare questo pacchetto. Il primo include l'uso del gestore di pacchetti Python, pip:

pip install tensorflow

Il secondo modo riguarda Anaconda, possiamo installare il pacchetto come:

conda install -c conda-forge tensorflow

Sentiti libero di cercare build notturne e versioni GPU nelle pagine di installazione ufficiali di TensorFlow.

Userò il manager Anaconda per tutti gli esempi in questa lezione. Lancerò un notebook Jupyter per lo stesso:

Ora che siamo pronti con tutte le istruzioni di importazione per scrivere del codice, iniziamo a tuffarci nel pacchetto SciPy con alcuni esempi pratici.

Cosa sono i tensori??

I tensori sono le strutture dati di base utilizzate in Tensorflow. Sì, sono solo un modo per rappresentare i dati nel deep learning. Visualizzali qui:

Come descritto nell'immagine, i tensori possono essere definiti come array n-dimensionali che ci permette di rappresentare i dati in una dimensione complessa. Possiamo pensare a ogni dimensione come a una caratteristica diversa dei dati nel deep learning. Ciò significa che i tensori possono diventare piuttosto complessi quando si tratta di set di dati complessi con molte funzionalità.

Una volta che sappiamo cosa sono i tensori, penso che sia abbastanza facile ricavare cosa succede in TensorFlow. Questo termine significa come i tensori o le caratteristiche possono fluire nei set di dati per produrre un output prezioso mentre eseguiamo varie operazioni su di esso.

Comprensione di TensorFlow con le costanti

Proprio come abbiamo letto sopra, TensorFlow ci consente di eseguire algoritmi di apprendimento automatico su Tensor per produrre output di valore. Con TensorFlow, la progettazione e la formazione di modelli di Deep Learning è semplice straight.

TensorFlow viene fornito con la costruzione Grafici di calcolo. I grafici di calcolo sono i grafici del flusso di dati in cui le operazioni matematiche sono rappresentate come nodi e i dati sono rappresentati come bordi tra quei nodi. Scriviamo uno snippet di codice molto semplice per fornire una visualizzazione concreta:

import tensorflow come tf
x = tf.costante(5)
y = tf.costante(6)
z = x * y
stampa(z)

Quando eseguiamo questo esempio, vedremo il seguente output:

Perché la moltiplicazione è sbagliata?? Non era quello che ci aspettavamo. Questo è successo perché non è così che possiamo eseguire operazioni con TensorFlow. Per prima cosa, dobbiamo iniziare a sessione per far funzionare il grafico di calcolo,

Con le sessioni, possiamo incapsulare il controllo delle operazioni e lo stato dei tensori. Ciò significa che una sessione può anche memorizzare il risultato di un grafico di calcolo in modo che possa passare quel risultato all'operazione successiva nell'ordine di esecuzione delle pipeline. Creiamo ora una sessione per ottenere il risultato corretto:

# Inizia con l'oggetto sessione
sessione = tf.Sessione()
# Fornire il calcolo alla sessione e memorizzarlo
risultato = sessione.corri(z)
# Stampa il risultato del calcolo
stampa (risultato)
# Chiudi sessione
sessione.vicino()

Questa volta, abbiamo ottenuto la sessione e le abbiamo fornito il calcolo di cui ha bisogno per essere eseguita sui nodi. Quando eseguiamo questo esempio, vedremo il seguente output:

Sebbene abbiamo ricevuto un avviso da TensorFlow, abbiamo comunque ottenuto l'output corretto dal calcolo.

Operazioni con tensore a elemento singolo

Proprio come abbiamo moltiplicato due tensori costanti nell'ultimo esempio, abbiamo molte altre operazioni in TensorFlow che possono essere eseguite su singoli elementi:

Operazioni a elemento singolo significa che anche quando fornisci un array, le operazioni verranno eseguite su ciascuno degli elementi di quell'array. Per esempio:

import tensorflow come tf
importa numpy come np
tensore = np.matrice([2, 5, 8])
tensore = tf.convert_to_tensor(tensor, dtype=tf.galleggiante64)
con tf.Session() come sessione:
print(sessione.eseguire (tf.cos(tensore)))

Quando eseguiamo questo esempio, vedremo il seguente output:

Abbiamo capito due concetti importanti qui:

  1. Qualsiasi array NumPy può essere facilmente convertito in un tensore con l'aiuto della funzione convert_to_tensor
  2. L'operazione è stata eseguita su ciascuno degli elementi dell'array NumPy

Segnaposto e variabili

In una delle sezioni precedenti, abbiamo visto come possiamo usare le costanti Tensorflow per creare grafici computazionali. Ma TensorFlow ci consente anche di prendere input in corsa in modo che il grafico di calcolo possa essere di natura dinamica. Questo è possibile con l'aiuto di Segnaposto e Variabili.

In realtà, i segnaposto non contengono alcun dato e devono essere forniti input validi durante il runtime e come previsto, senza un input, genereranno un errore.

Un segnaposto può essere definito come un accordo in un grafico che un input verrà sicuramente fornito in fase di esecuzione. Ecco un esempio di segnaposto:

import tensorflow come tf
# Due segnaposto
x = tf. segnaposto (tf.galleggiante32)
y = tf. segnaposto (tf.galleggiante32)
# Assegnazione dell'operazione di moltiplicazione w.r.t. un & b al nodo mul
z = x * y
# Crea una sessione
sessione = tf.Sessione()
# Passa i valori per i segnaposto
risultato = sessione.run(z, x: [2, 5], y: [3, 7])
print('Moltiplicando x e y:', risultato)

Quando eseguiamo questo esempio, vedremo il seguente output:

Ora che abbiamo conoscenza dei segnaposto, volgiamo lo sguardo verso le variabili. Sappiamo che l'output di un'equazione può cambiare per lo stesso insieme di input nel tempo. Quindi, quando addestriamo la nostra variabile del modello, può cambiare il suo comportamento nel tempo. In questo scenario, una variabile ci consente di aggiungere questi parametri addestrabili al nostro grafico computazionale. Una variabile può essere definita come segue:

x = tf.Variabile( [5.2], dtype = tf.galleggiante32 )

Nell'equazione sopra, x è una variabile a cui viene fornito il suo valore iniziale e il tipo di dati. Se non forniamo il tipo di dati, verrà dedotto da TensorFlow con il suo valore iniziale. Fare riferimento ai tipi di dati TensorFlow qui.

A differenza di una costante, dobbiamo chiamare una funzione Python per inizializzare tutte le variabili di un grafico:

init = tf.global_variables_initializer()
sessione.esegui (inizia)

Assicurati di eseguire la funzione TensorFlow sopra prima di utilizzare il nostro grafico.

Regressione lineare con TensorFlow

La regressione lineare è uno degli algoritmi più comuni utilizzati per stabilire una relazione in un dato dato continuo. Questa relazione tra i punti coordinati, diciamo x e y, è chiamata a ipotesi. Quando si parla di regressione lineare, l'ipotesi è una linea retta:

y = mx + c

Qui, m è la pendenza della linea e qui è un vettore che rappresenta pesi. c è il coefficiente costante (intercetta y) e qui rappresenta il bias. Il peso e il bias sono chiamati parametri del modello.

Le regressioni lineari ci consentono di stimare i valori di peso e distorsione in modo tale da avere un minimo funzione di costo. Infine, la x è la variabile indipendente nell'equazione e y è la variabile dipendente. Ora, iniziamo a costruire il modello lineare in TensorFlow con un semplice frammento di codice che spiegheremo:

import tensorflow come tf
# Variabili per la pendenza del parametro (W) con valore iniziale pari a 1.1
W = tf.Variabile([1.1], tf.galleggiante32)
# Variabile per bias (b) con valore iniziale -1.1
b = tf.Variabile ([-1.1], tf.galleggiante32)
# Segnaposto per fornire un input o una variabile indipendente, indicata da x
x = tf.segnaposto (tf.galleggiante32)
# Equazione della linea o regressione lineare
modello_lineare = W * x + b
# Inizializzazione di tutte le variabili
sessione = tf.Sessione()
init = tf.global_variables_initializer()
sessione.esegui (inizia)
# Esegui il modello di regressione
print(sessione.run(modello_lineare x: [2, 5, 7, 9]))

Ecco, abbiamo fatto proprio quello che abbiamo spiegato prima, riassumiamo qui:

Quando eseguiamo questo esempio, vedremo il seguente output:

Il semplice frammento di codice fornisce solo un'idea di base su come possiamo costruire un modello di regressione. Ma abbiamo ancora bisogno di fare qualche altro passo per completare il modello che abbiamo costruito:

Funzione di perdita e convalida del modello

Per convalidare il modello, dobbiamo avere una misura di quanto l'uscita di corrente deviata sia dall'uscita prevista. Esistono varie funzioni di perdita che possono essere utilizzate qui per la convalida, ma esamineremo uno dei metodi più comuni, Somma dell'errore al quadrato o SSE.

L'equazione per SSE è data come:

E = 1/2 * (t - y)2

Qui:

Ora, scriviamo un frammento di codice in continuità con l'ultimo frammento per riflettere il valore della perdita:

y = tf.segnaposto (tf.galleggiante32)
errore = modello_lineare - y
errori_quadrati = tf.quadrato (errore)
perdita = tf.reduce_sum(squared_errors)
print(sessione.run(perdita, x:[2, 5, 7, 9], y:[2, 4, 6, 8]))

Quando eseguiamo questo esempio, vedremo il seguente output:

Chiaramente, il valore della perdita è molto basso per il dato modello di regressione lineare.

Conclusione

In questa lezione, abbiamo esaminato uno dei pacchetti di apprendimento profondo e machine learning più popolari, TensorFlow. Abbiamo anche realizzato un modello di regressione lineare che aveva una precisione molto elevata.

Vulkan per utenti Linux
Con ogni nuova generazione di schede grafiche, vediamo gli sviluppatori di giochi spingere i limiti della fedeltà grafica e avvicinarsi di un passo al...
OpenTTD vs Simutrans
Creare la tua simulazione di trasporto può essere divertente, rilassante ed estremamente allettante. Ecco perché devi assicurarti di provare quanti pi...
Tutorial OpenTTD
OpenTTD è uno dei giochi di simulazione aziendale più popolari in circolazione. In questo gioco, devi creare una meravigliosa attività di trasporto. T...