Theano - Guida rapida

Hai sviluppato modelli di Machine Learning in Python? Quindi, ovviamente, conosci le complessità nello sviluppo di questi modelli. Lo sviluppo è in genere un processo lento che richiede ore e giorni di potenza di calcolo.

Lo sviluppo del modello di Machine Learning richiede molti calcoli matematici. Questi generalmente richiedono calcoli aritmetici, in particolare matrici grandi di dimensioni multiple. Oggigiorno utilizziamo reti neurali piuttosto che le tradizionali tecniche statistiche per lo sviluppo di applicazioni di Machine Learning. Le reti neurali devono essere addestrate su un'enorme quantità di dati. La formazione viene eseguita in batch di dati di dimensioni ragionevoli. Pertanto, il processo di apprendimento è iterativo. Pertanto, se i calcoli non vengono eseguiti in modo efficiente, l'addestramento della rete può richiedere diverse ore o addirittura giorni. Pertanto, l'ottimizzazione del codice eseguibile è altamente desiderata. Ed è quello che offre esattamente Theano.

Theano è una libreria Python che consente di definire espressioni matematiche utilizzate nel Machine Learning, ottimizzare queste espressioni e valutarle in modo molto efficiente utilizzando in modo decisivo le GPU in aree critiche. Può competere con le tipiche implementazioni C complete nella maggior parte dei casi.

Theano è stato scritto nel laboratorio LISA con l'intenzione di fornire un rapido sviluppo di algoritmi di apprendimento automatico efficienti. È rilasciato con una licenza BSD.

In questo tutorial imparerai a usare la libreria Theano.

Theano può essere installato su Windows, MacOS e Linux. L'installazione in tutti i casi è banale. Prima di installare Theano, è necessario installare le sue dipendenze. Di seguito è riportato l'elenco delle dipendenze:

• Python
• NumPy: obbligatorio
• SciPy: richiesto solo per Sparse Matrix e funzioni speciali
• BLAS - Fornisce elementi costitutivi standard per l'esecuzione di operazioni di base su vettori e matrici

I pacchetti opzionali che puoi scegliere di installare a seconda delle tue esigenze sono:

• naso: per eseguire la suite di test di Theano
• Sfinge - Per la documentazione di costruzione
• Graphiz e pydot - Per gestire grafici e immagini
• Driver NVIDIA CUDA: necessari per la generazione / esecuzione del codice GPU
• libgpuarray - Richiesto per la generazione di codice GPU / CPU su dispositivi CUDA e OpenCL

Discuteremo i passaggi per installare Theano in MacOS.

Installazione su MacOS

Per installare Theano e le sue dipendenze, usi pipdalla riga di comando come segue. Queste sono le dipendenze minime di cui avremo bisogno in questo tutorial.

$ pip install Theano
$ pip install numpy
$ pip install scipy
$ pip install pydot

È inoltre necessario installare lo strumento di sviluppo della riga di comando OSx utilizzando il seguente comando:

$ xcode-select --install

Vedrai la seguente schermata. Clicca sulInstall pulsante per installare lo strumento.

Al termine dell'installazione, vedrai il messaggio di successo sulla console.

Verifica dell'installazione

Dopo che l'installazione è stata completata con successo, apri un nuovo blocco note in Anaconda Jupyter. Nella cella del codice, inserisci il seguente script Python:

Esempio

import theano
from theano import tensor
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
d = f(1.5, 2.5)
print (d)

Produzione

Esegui lo script e dovresti vedere il seguente output:

4.0

Lo screenshot dell'esecuzione è mostrato di seguito per una rapida consultazione -

Se ottieni l'output di cui sopra, l'installazione di Theano è riuscita. In caso contrario, segui le istruzioni di debug sulla pagina di download di Theano per risolvere i problemi.

Cos'è Theano?

Ora che hai installato con successo Theano, proviamo prima a capire cos'è Theano? Theano è una libreria Python. Consente di definire, ottimizzare e valutare espressioni matematiche, in particolare quelle utilizzate nello sviluppo di modelli di apprendimento automatico. Theano stesso non contiene alcun modello ML predefinito; ne facilita solo lo sviluppo. È particolarmente utile quando si tratta di array multidimensionali. Si integra perfettamente con NumPy, che è un pacchetto fondamentale e ampiamente utilizzato per i calcoli scientifici in Python.

Theano facilita la definizione delle espressioni matematiche utilizzate nello sviluppo ML. Tali espressioni generalmente coinvolgono l'aritmetica della matrice, la differenziazione, il calcolo del gradiente e così via.

Theano crea prima l'intero grafico computazionale per il tuo modello. Quindi lo compila in un codice altamente efficiente applicando diverse tecniche di ottimizzazione sul grafico. Il codice compilato viene iniettato nel runtime Theano da una speciale operazione chiamatafunctiondisponibile a Theano. Lo eseguiamofunctionripetutamente per addestrare una rete neurale. Il tempo di formazione è sostanzialmente ridotto rispetto all'utilizzo della codifica Python pura o anche di un'implementazione C completa.

Ora capiremo il processo di sviluppo di Theano. Cominciamo con come definire un'espressione matematica in Theano.

Cominciamo il nostro viaggio di Theano definendo e valutando un'espressione banale in Theano. Considera la seguente espressione banale che aggiunge due scalari:

c = a + b

Dove a, b sono variabili e cè l'output dell'espressione. In Theano, definire e valutare anche questa banale espressione è complicato.

Cerchiamo di capire i passaggi per valutare l'espressione sopra.

Importazione di Theano

Per prima cosa, dobbiamo importare la libreria Theano nel nostro programma, cosa che facciamo usando la seguente dichiarazione:

from theano import *

Piuttosto che importare i singoli pacchetti, abbiamo usato * nell'istruzione precedente per includere tutti i pacchetti dalla libreria Theano.

Dichiarazione di variabili

Successivamente, dichiareremo una variabile chiamata a utilizzando la seguente dichiarazione:

a = tensor.dscalar()

Il dscalarmetodo dichiara una variabile scalare decimale. L'esecuzione dell'istruzione precedente crea una variabile chiamataanel codice del programma. Allo stesso modo, creeremo variabileb utilizzando la seguente dichiarazione:

b = tensor.dscalar()

Definizione dell'espressione

Successivamente, definiremo la nostra espressione che opera su queste due variabili a e b.

c = a + b

In Theano, l'esecuzione dell'istruzione precedente non esegue l'addizione scalare delle due variabili a e b.

Definizione della funzione Theano

Per valutare l'espressione precedente, dobbiamo definire una funzione in Theano come segue:

f = theano.function([a,b], c)

La funzione functionaccetta due argomenti, il primo argomento è un input per la funzione e il secondo è il suo output. La dichiarazione precedente afferma che il primo argomento è di tipo array composto da due elementia e b. L'output è un'unità scalare chiamatac. Questa funzione sarà referenziata con il nome della variabilef nel nostro ulteriore codice.

Richiamo della funzione Theano

La chiamata alla funzione f viene effettuata utilizzando la seguente istruzione:

d = f(3.5, 5.5)

L'input per la funzione è un array costituito da due scalari: 3.5 e 5.5. L'output dell'esecuzione è assegnato alla variabile scalared. Per stampare il contenuto did, useremo il print dichiarazione -

print (d)

L'esecuzione causerebbe il valore di d da stampare sulla console, che in questo caso è 9.0.

Elenco completo del programma

L'elenco completo del programma viene fornito qui per una rapida consultazione -

from theano import *
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
d = f(3.5, 5.5)
print (d)

Esegui il codice sopra e vedrai l'output come 9.0. La schermata è mostrata qui -

Ora, discutiamo un esempio leggermente più complesso che calcola la moltiplicazione di due matrici.

Calcoleremo un prodotto scalare di due matrici. La prima matrice è di dimensione 2 x 3 e la seconda è di dimensione 3 x 2. Le matrici che abbiamo usato come input e il loro prodotto sono espresse qui -

$$ \ begin {bmatrix} 0 & -1 & 2 \\ 4 & 11 & 2 \ end {bmatrix} \: \ begin {bmatrix} 3 & -1 \\ 1 & 2 \\ 35 & 20 \ end {bmatrix} = \ begin {bmatrix} 11 & 0 \\ 35 & 20 \ end {bmatrix} $$

Dichiarazione di variabili

Per scrivere un'espressione Theano per quanto sopra, prima dichiariamo due variabili per rappresentare le nostre matrici come segue:

a = tensor.dmatrix()
b = tensor.dmatrix()

La dmatrix è il tipo di matrici per doppie. Nota che non specifichiamo la dimensione della matrice da nessuna parte. Pertanto, queste variabili possono rappresentare matrici di qualsiasi dimensione.

Definizione dell'espressione

Per calcolare il prodotto punto, abbiamo utilizzato la funzione incorporata chiamata dot come segue -

c = tensor.dot(a,b)

L'output della moltiplicazione è assegnato a una variabile di matrice chiamata c.

Definizione della funzione Theano

Successivamente, definiamo una funzione come nell'esempio precedente per valutare l'espressione.

f = theano.function([a,b], c)

Notare che l'input alla funzione sono due variabili aeb che sono di tipo matrice. L'uscita della funzione è assegnata alla variabilec che sarebbe automaticamente di tipo matrice.

Richiamo della funzione Theano

Ora invochiamo la funzione utilizzando la seguente istruzione:

d = f([[0, -1, 2], [4, 11, 2]], [[3, -1],[1,2], [6,1]])

Le due variabili nell'istruzione precedente sono array NumPy. Puoi definire esplicitamente gli array NumPy come mostrato qui -

f(numpy.array([[0, -1, 2], [4, 11, 2]]),
numpy.array([[3, -1],[1,2], [6,1]]))

Dopo d è calcolato stampiamo il suo valore -

print (d)

Vedrai il seguente output sull'output:

[[11. 0.]
[25. 20.]]

Elenco completo del programma

The complete program listing is given here:
from theano import *
a = tensor.dmatrix()
b = tensor.dmatrix()
c = tensor.dot(a,b)
f = theano.function([a,b], c)
d = f([[0, -1, 2],[4, 11, 2]], [[3, -1],[1,2],[6,1]])
print (d)

Lo screenshot dell'esecuzione del programma è mostrato qui -

Dai due esempi precedenti, potresti aver notato che in Theano creiamo un'espressione che alla fine viene valutata usando Theano function. Theano utilizza tecniche di ottimizzazione avanzate per ottimizzare l'esecuzione di un'espressione. Per visualizzare il grafico di calcolo, Theano fornisce un fileprinting pacchetto nella sua libreria.

Grafico simbolico per l'addizione scalare

Per vedere il grafico di calcolo per il nostro programma di addizione scalare, usa la libreria di stampa come segue:

theano.printing.pydotprint(f, outfile="scalar_addition.png", var_with_name_simple=True)

Quando si esegue questa istruzione, un file chiamato scalar_addition.pngverrà creato sulla tua macchina. Il grafico di calcolo salvato viene visualizzato qui per una rapida consultazione -

Di seguito è riportato l'elenco completo del programma per generare l'immagine sopra:

from theano import *
a = tensor.dscalar()
b = tensor.dscalar()
c = a + b
f = theano.function([a,b], c)
theano.printing.pydotprint(f, outfile="scalar_addition.png", var_with_name_simple=True)

Grafico simbolico per moltiplicatore di matrici

Ora, prova a creare il grafico di calcolo per il nostro moltiplicatore di matrice. Di seguito è riportato l'elenco completo per la generazione di questo grafico:

from theano import *
a = tensor.dmatrix()
b = tensor.dmatrix()
c = tensor.dot(a,b)
f = theano.function([a,b], c)
theano.printing.pydotprint(f, outfile="matrix_dot_product.png", var_with_name_simple=True)

Il grafico generato è mostrato qui -

Grafici complessi

In espressioni più grandi, i grafici computazionali potrebbero essere molto complessi. Uno di questi grafici tratto dalla documentazione di Theano è mostrato qui:

Per comprendere il funzionamento di Theano, è importante conoscere prima il significato di questi grafici computazionali. Con questa comprensione, conosceremo l'importanza di Theano.

Perché Theano?

Osservando la complessità dei grafici computazionali, sarai ora in grado di comprendere lo scopo dietro lo sviluppo di Theano. Un tipico compilatore fornirebbe ottimizzazioni locali nel programma poiché non considera mai l'intero calcolo come una singola unità.

Theano implementa tecniche di ottimizzazione molto avanzate per ottimizzare l'intero grafo computazionale. Combina gli aspetti di Algebra con gli aspetti di un compilatore ottimizzato. Una parte del grafico può essere compilata in codice in linguaggio C. Per calcoli ripetuti, la velocità di valutazione è fondamentale e Theano soddisfa questo scopo generando un codice molto efficiente.

Ora che hai compreso le basi di Theano, iniziamo con i diversi tipi di dati a tua disposizione per creare le tue espressioni. La tabella seguente fornisce un elenco parziale dei tipi di dati definiti in Theano.

Tipo di dati	Tipo Theano
Byte	bscalar, bvector, bmatrix, brow, bcol, btensor3, btensor4, btensor5, btensor6, btensor7
Intero a 16 bit	wscalar, wvector, wmatrix, wrow, wcol, wtensor3, wtensor4, wtensor5, wtensor6, wtensor7
Intero a 32 bit	iscalar, ivector, imatrix, irow, icol, itensor3, itensor4, itensor5, itensor6, itensor7
Intero a 64 bit	lscalar, lvector, lmatrix, lrow, lcol, ltensor3, ltensor4, ltensor5, ltensor6, ltensor7
galleggiante	fscalar, fvector, fmatrix, frow, fcol, ftensor3, ftensor4, ftensor5, ftensor6, ftensor7
Doppio	dscalar, dvector, dmatrix, drow, dcol, dtensor3, dtensor4, dtensor5, dtensor6, dtensor7
complesso	cscalar, cvector, cmatrix, crow, ccol, ctensor3, ctensor4, ctensor5, ctensor6, ctensor7

L'elenco sopra non è esaustivo e si rimanda il lettore al documento di creazione del tensore per un elenco completo.

Ora ti fornirò alcuni esempi di come creare variabili di vari tipi di dati in Theano.

Scalare

Per costruire una variabile scalare dovresti usare la sintassi -

Sintassi

x = theano.tensor.scalar ('x')
x = 5.0
print (x)

Produzione

5.0

Array unidimensionale

Per creare una matrice unidimensionale, utilizzare la seguente dichiarazione:

Esempio

f = theano.tensor.vector
f = (2.0, 5.0, 3.0)
print (f)f = theano.tensor.vector
f = (2.0, 5.0, 3.0)
print (f)
print (f[0])
print (f[2])

Produzione

(2.0, 5.0, 3.0)
2.0
3.0

Se fate f[3] genererebbe un errore di indice fuori intervallo come mostrato qui -

print f([3])

Produzione

IndexError                          Traceback (most recent call last)
<ipython-input-13-2a9c2a643c3a> in <module>
   4 print (f[0])
   5 print (f[2])
----> 6 print (f[3])
IndexError: tuple index out of range

Array bidimensionale

Per dichiarare un array bidimensionale dovresti usare il seguente frammento di codice:

Esempio

m = theano.tensor.matrix
m = ([2,3], [4,5], [2,4])
print (m[0])
print (m[1][0])

Produzione

[2, 3]
4

Array a 5 dimensioni

Per dichiarare un array a 5 dimensioni, utilizzare la seguente sintassi:

Esempio

m5 = theano.tensor.tensor5
m5 = ([0,1,2,3,4], [5,6,7,8,9], [10,11,12,13,14])
print (m5[1])
print (m5[2][3])

Produzione

[5, 6, 7, 8, 9]
13

È possibile dichiarare un array tridimensionale utilizzando il tipo di dati tensor3 al posto di tensor5, una matrice quadridimensionale che utilizza il tipo di dati tensor4e così via fino a tensor7.

Costruttori plurali

A volte, potresti voler creare variabili dello stesso tipo in una singola dichiarazione. Puoi farlo utilizzando la seguente sintassi:

Sintassi

from theano.tensor import * x, y, z = dmatrices('x', 'y', 'z') 
x = ([1,2],[3,4],[5,6]) 
y = ([7,8],[9,10],[11,12]) 
z = ([13,14],[15,16],[17,18]) 
print (x[2]) 
print (y[1]) 
print (z[0])

Produzione

[5, 6] 
[9, 10] 
[13, 14]

Nel capitolo precedente, discutendo i tipi di dati, abbiamo creato e utilizzato le variabili Theano. Per ribadire, utilizzeremo la seguente sintassi per creare una variabile in Theano:

x = theano.tensor.fvector('x')

In questa affermazione, abbiamo creato una variabile xdi tipo vettore contenente float a 32 bit. Lo chiamiamo anchex. I nomi sono generalmente utili per il debug.

Per dichiarare un vettore di interi a 32 bit, dovresti usare la seguente sintassi:

i32 = theano.tensor.ivector

Qui, non specifichiamo un nome per la variabile.

Per dichiarare un vettore tridimensionale costituito da float a 64 bit, dovresti usare la seguente dichiarazione:

f64 = theano.tensor.dtensor3

I vari tipi di costruttori insieme ai loro tipi di dati sono elencati nella tabella seguente:

Costruttore	Tipo di dati	Dimensioni
fvector	float32	1
ivector	int32	1
fscalar	float32	0
fmatrix	float32	2
ftensor3	float32	3
dtensor3	float64	3

È possibile utilizzare un costruttore di vettori generico e specificare il tipo di dati in modo esplicito come segue:

x = theano.tensor.vector ('x', dtype=int32)

Nel prossimo capitolo impareremo come creare variabili condivise.

Molte volte è necessario creare variabili condivise tra funzioni diverse e anche tra più chiamate alla stessa funzione. Per citare un esempio, durante l'allenamento di una rete neurale si crea il vettore dei pesi per assegnare un peso a ciascuna caratteristica in esame. Questo vettore viene modificato ad ogni iterazione durante l'addestramento in rete. Pertanto, deve essere globalmente accessibile attraverso più chiamate alla stessa funzione. Quindi creiamo una variabile condivisa per questo scopo. In genere, Theano sposta tali variabili condivise sulla GPU, a condizione che sia disponibile. Questo accelera il calcolo.

Sintassi

Crei una variabile condivisa che usi la seguente sintassi:

import numpy
W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')

Esempio

Qui viene creato l'array NumPy composto da quattro numeri in virgola mobile. Per impostare / ottenere il fileW valore useresti il ​​seguente frammento di codice:

import numpy
W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')
print ("Original: ", W.get_value())
print ("Setting new values (0.5, 0.2, 0.4, 0.2)")
W.set_value([0.5, 0.2, 0.4, 0.2])
print ("After modifications:", W.get_value())

Produzione

Original: [0.1 0.25 0.15 0.3 ]
Setting new values (0.5, 0.2, 0.4, 0.2)
After modifications: [0.5 0.2 0.4 0.2]

Theano functionagisce come un gancio per interagire con il grafico simbolico. Un grafico simbolico viene compilato in un codice di esecuzione altamente efficiente. Ottiene questo risultato ristrutturando le equazioni matematiche per renderle più veloci. Compila alcune parti dell'espressione nel codice del linguaggio C. Sposta alcuni tensori alla GPU e così via.

Il codice compilato efficiente viene ora fornito come input a Theano function. Quando esegui il Theanofunction, assegna il risultato del calcolo alle variabili da noi specificate. Il tipo di ottimizzazione può essere specificato come FAST_COMPILE o FAST_RUN. Questo è specificato nella variabile d'ambiente THEANO_FLAGS.

A Theano function viene dichiarato utilizzando la seguente sintassi:

f = theano.function ([x], y)

Il primo parametro [x] è l'elenco delle variabili di input e il secondo parametro y è l'elenco delle variabili di output.

Avendo ora compreso le basi di Theano, iniziamo la codifica di Theano con un esempio banale.

Theano è molto utile nell'addestramento di reti neurali in cui dobbiamo calcolare ripetutamente costi e gradienti per ottenere un ottimo. Su set di dati di grandi dimensioni, questo diventa computazionalmente intenso. Theano lo fa in modo efficiente grazie alle sue ottimizzazioni interne del grafo computazionale che abbiamo visto in precedenza.

Dichiarazione problema

Ora impareremo come usare la libreria Theano per addestrare una rete. Prenderemo un semplice caso in cui iniziamo con un set di dati di quattro funzionalità. Calcoliamo la somma di queste caratteristiche dopo aver applicato un certo peso (importanza) a ciascuna caratteristica.

L'obiettivo della formazione è modificare i pesi assegnati a ciascuna caratteristica in modo che la somma raggiunga un valore target di 100.

sum = f1 * w1 + f2 * w2 + f3 * w3 + f4 * w4

Dove f1, f2, ... sono i valori delle caratteristiche e w1, w2, ... sono i pesi.

Consentitemi di quantizzare l'esempio per una migliore comprensione dell'enunciato del problema. Assumeremo un valore iniziale di 1.0 per ogni caratteristica e prenderemo w1 uguale0.1, w2 equivale 0.25, w3 equivale 0.15, e w4 equivale 0.3. Non esiste una logica definita nell'assegnazione dei valori di peso, è solo una nostra intuizione. Pertanto, la somma iniziale è la seguente:

sum = 1.0 * 0.1 + 1.0 * 0.25 + 1.0 * 0.15 + 1.0 * 0.3

Che si riassume in 0.8. Ora continueremo a modificare l'assegnazione del peso in modo che questa somma si avvicini a 100. Il valore risultante corrente di0.8 è lontano dal valore target desiderato di 100. In termini di Machine Learning, definiamo costcome la differenza tra il valore target meno il valore di uscita corrente, tipicamente al quadrato per far saltare l'errore. Riduciamo questo costo in ogni iterazione calcolando i gradienti e aggiornando il nostro vettore dei pesi.

Vediamo come tutta questa logica viene implementata in Theano.

Dichiarazione di variabili

Per prima cosa dichiariamo il nostro vettore di input x come segue:

x = tensor.fvector('x')

Dove x è un array monodimensionale di valori float.

Definiamo uno scalare target variabile come indicato di seguito -

target = tensor.fscalar('target')

Successivamente, creiamo un tensore dei pesi W con i valori iniziali come discusso sopra -

W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')

Definizione dell'espressione di Theano

Calcoliamo ora l'output utilizzando la seguente espressione:

y = (x * W).sum()

Si noti che nella dichiarazione di cui sopra x e Wsono i vettori e non semplici variabili scalari. Calcoliamo ora l'errore (costo) con la seguente espressione:

cost = tensor.sqr(target - y)

Il costo è la differenza tra il valore target e l'uscita corrente, al quadrato.

Per calcolare il gradiente che ci dice quanto siamo lontani dall'obiettivo, utilizziamo il built-in grad metodo come segue -

gradients = tensor.grad(cost, [W])

Ora aggiorniamo il weights vettore prendendo un tasso di apprendimento di 0.1 come segue -

W_updated = W - (0.1 * gradients[0])

Successivamente, dobbiamo aggiornare il nostro vettore di pesi utilizzando i valori sopra. Lo facciamo nella seguente dichiarazione:

updates = [(W, W_updated)]

Definizione / richiamo della funzione Theano

Infine, definiamo un file function in Theano per calcolare la somma.

f = function([x, target], y, updates=updates)

Per richiamare la funzione di cui sopra un certo numero di volte, creiamo un file for loop come segue -

for i in range(10):
output = f([1.0, 1.0, 1.0, 1.0], 100.0)

Come detto in precedenza, l'input della funzione è un vettore contenente i valori iniziali per le quattro caratteristiche: assegniamo il valore di 1.0a ciascuna funzionalità senza alcun motivo specifico. Puoi assegnare diversi valori di tua scelta e controllare se la funzione alla fine converge. Stamperemo i valori del vettore peso e il corrispondente output in ogni iterazione. È mostrato nel codice sottostante -

print ("iteration: ", i)
print ("Modified Weights: ", W.get_value())
print ("Output: ", output)

Elenco completo del programma

L'elenco completo del programma è riprodotto qui per una rapida consultazione -

from theano import *
import numpy

x = tensor.fvector('x')
target = tensor.fscalar('target')

W = theano.shared(numpy.asarray([0.1, 0.25, 0.15, 0.3]), 'W')
print ("Weights: ", W.get_value())

y = (x * W).sum()
cost = tensor.sqr(target - y)
gradients = tensor.grad(cost, [W])
W_updated = W - (0.1 * gradients[0])
updates = [(W, W_updated)]

f = function([x, target], y, updates=updates)
for i in range(10):
   output = f([1.0, 1.0, 1.0, 1.0], 100.0)
   print ("iteration: ", i)
   print ("Modified Weights: ", W.get_value())
   print ("Output: ", output)

Quando esegui il programma vedrai il seguente output:

Weights: [0.1 0.25 0.15 0.3 ]
iteration: 0
Modified Weights: [19.94 20.09 19.99 20.14]
Output: 0.8
iteration: 1
Modified Weights: [23.908 24.058 23.958 24.108]
Output: 80.16000000000001
iteration: 2
Modified Weights: [24.7016 24.8516 24.7516 24.9016]
Output: 96.03200000000001
iteration: 3
Modified Weights: [24.86032 25.01032 24.91032 25.06032]
Output: 99.2064
iteration: 4
Modified Weights: [24.892064 25.042064 24.942064 25.092064]
Output: 99.84128
iteration: 5
Modified Weights: [24.8984128 25.0484128 24.9484128 25.0984128]
Output: 99.968256
iteration: 6
Modified Weights: [24.89968256 25.04968256 24.94968256 25.09968256]
Output: 99.9936512
iteration: 7
Modified Weights: [24.89993651 25.04993651 24.94993651 25.09993651]
Output: 99.99873024
iteration: 8
Modified Weights: [24.8999873 25.0499873 24.9499873 25.0999873]
Output: 99.99974604799999
iteration: 9
Modified Weights: [24.89999746 25.04999746 24.94999746 25.09999746]
Output: 99.99994920960002

Osserva che dopo quattro iterazioni, l'output è 99.96 e dopo cinque iterazioni, lo è 99.99, che è vicino al nostro obiettivo desiderato di 100.0.

A seconda della precisione desiderata, è possibile concludere con sicurezza che la rete viene addestrata in 4-5 iterazioni. Al termine dell'addestramento, cerca il vettore dei pesi, che dopo 5 iterazioni assume i seguenti valori:

iteration: 5
Modified Weights: [24.8984128 25.0484128 24.9484128 25.0984128]

È ora possibile utilizzare questi valori nella rete per distribuire il modello.

La costruzione del modello di Machine Learning implica calcoli intensivi e ripetitivi che coinvolgono i tensori. Questi richiedono risorse di elaborazione intense. Poiché un normale compilatore fornirebbe le ottimizzazioni a livello locale, generalmente non produce un codice di esecuzione veloce.

Theano costruisce prima un grafo computazionale per l'intero calcolo. Poiché l'intera immagine del calcolo è disponibile come una singola immagine durante la compilazione, durante la pre-compilazione possono essere applicate diverse tecniche di ottimizzazione e questo è esattamente ciò che fa Theano. Ristruttura il grafo computazionale, lo converte in parte in C, sposta le variabili condivise sulla GPU e così via per generare un codice eseguibile molto veloce. Il codice compilato viene quindi eseguito da un Theanofunctionche funge solo da hook per iniettare il codice compilato nel runtime. Theano ha dimostrato le sue credenziali ed è ampiamente accettato sia dal mondo accademico che industriale.