TensorFlow™ su Databricks
Variabili
TensorFlow offre una modalità per rappresentare un calcolo senza eseguirlo effettivamente finché non viene esplicitamente richiesto. In questo senso, si tratta di una forma di valutazione pigra (lazy computing) che consente di migliorare sensibilmente alcuni aspetti dell'esecuzione del codice:- Calcolo più rapido di variabili complesse.
- Calcolo distribuito su più sistemi, incluse le GPU.
- Ridondanza ridotta in alcuni calcoli.
Diamo un'occhiata a questi concetti con esempi concreti. Cominciamo con uno script Python molto elementare:
x = 35
y = x + 5
print(y)
Questo script dice semplicemente “crea una variabile x con valore 35, imposta il valore di una nuova variabile y pari a x più 5, cioè 40, e stampa il risultato”. Eseguendo questo programma viene stampato il valore 40. Se non si ha familiarità con Python si può creare un nuovo file di testo chiamato basic_script.py
e copiare il codice all'interno del file. Dopodiché si deve salvare il file sul computer ed eseguirlo con:
python basic_script.py
È importante osservare che il percorso (cioè basic_script.py
) deve fare riferimento al file, pertanto se si trova nella cartella Code
, bisogna utilizzare:
python Code/basic_script.py
Inoltre, bisogna assicurarsi di aver attivato l'ambiente virtuale Anaconda. Su Linux, questo renderà il prompt simile a:
(tensorenv)username@computername:~$
Se funziona, convertiamolo in un equivalente TensorFlow.
import tensorflow as tf
x = tf.constant(35, name='x')
y = tf.Variable(x + 5, name='y')
print(y)
Una volta eseguito, si otterrà un risultato strano, del tipo <tensorflow.python.ops.variables.Variable object at 0x7f074bfd9ef0>
. Chiaramente questo non è il valore 40.
Il motivo è che questo programma fa qualcosa di molto diverso rispetto al precedente. Il codice opera nel modo seguente:
- Importa il modulo tensorflow e lo chiama
tf
. - Crea un valore costante chiamato x e gli assegna il valore numerico 35.
- Crea una variabile chiamata y e la definisce come equivalente di x + 5.
- Stampa il risultato dell'operazione per y.
La sottile differenza è che alla variabile y non viene assegnato "il valore corrente di x + 5" come nel programma precedente. Si tratta invece di un'equazione che significa "quando viene calcolata questa variabile, prendi il valore di x (com'è in quel momento) e aggiungi 5". Il calcolo del valore di y non viene mai realmente eseguito nel programma riportato sopra.
Correggiamo l'errore:
import tensorflow as tf
x = tf.constant(35, name='x')
y = tf.Variable(x + 5, name='y')
model = tf.global_variables_initializer()
with tf.Session() as session:
session.run(model)
print(session.run(y))
Abbiamo eliminato l'istruzione print(y)
e, al suo posto, abbiamo inserito un codice che crea una sessione e calcola effettivamente il valore di y
. È un po' lungo, ma funziona così:
- Importa il modulo tensorflow e lo chiama
tf
. - Crea un valore costante chiamato x e gli assegna il valore numerico 35.
- Crea una variabile chiamata y e la definisce come equivalente di x + 5.
- Inizializza le variabili con
tf.global_variables_initializer()
(entreremo nel dettaglio più avanti). - Crea una sessione per calcolare i valori.
- Esegue il modello creato al punto 4.
- Esegue solo la variabile y e stampa il valore corrente.
Il punto 4 è quello in cui avviene il trucco. In questo passaggio viene creato un grafo delle dipendenze fra le variabili. In questo caso la variabile y dipende dalla variabile x e quel valore viene trasformato sommandolo a 5. È importante ricordare che questo valore non viene calcolato fino al punto 7, perché fino a quel momento vengono calcolate solo equazioni e relazioni.
1) Le costanti possono essere anche matrici. Prova a indovinare che cosa farà questo codice, poi eseguilo per verificare:
import tensorflow as tf
x = tf.constant([35, 40, 45], name='x')
y = tf.Variable(x + 5, name='y')
model = tf.global_variables_initializer()
with tf.Session() as session:
session.run(model)
print(session.run(y))
2) Genera una matrice NumPy di 10.000 numeri casuali (chiamata x
) e crea una Variabile che memorizza l'equazione
La matrice NumPy può essere generata con il codice seguente:
import numpy as np
data = np.random.randint(1000, size=10000)
Questa variabile di dati
può quindi essere usata in sostituzione della lista riportata alla domanda 1. Come regola generale, per le liste/matrici di numeri più grandi si dovrebbe utilizzare NumPy, perché è molto più efficiente a livello di memoria e più veloce nel calcolo. Offre inoltre diverse funzioni (ad esempio il calcolo della media) che normalmente non sono disponibili per le liste.
3) Le variabili possono anche essere aggiornate in cicli, che verranno utilizzati in seguito per il machine learning. Guarda il codice seguente e prova a indovinare che cosa farà (e poi eseguilo per verificare):
import tensorflow as tf
x = tf.Variable(0, name='x')
model = tf.global_variables_initializer()
with tf.Session() as session:
session.run(model)
for i in range(5):
x = x + 1
print(session.run(x))
4) Utilizzando il codice dei punti (2) e (3), crea un programma che calcola la media mobile della seguente riga di codice: np.random.randint(1000)
. In altri termini, continua a ripetere il ciclo e, per ogni ciclo, chiama np.random.randint(1000)
una volta avviato il ciclo e memorizza la media corrente in una Variabile che continua ad aggiornare ogni ciclo.
5) Usa TensorBoard per visualizzare il grafo per alcuni di questi esempi. Per eseguire TensorBoard, usa il comando: tensorboard --logdir=path/to/log-directory
import tensorflow as tf
x = tf.constant(35, name='x')
print(x)
y = tf.Variable(x + 5, name='y')
with tf.Session() as session:
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter("/tmp/basic", session.graph)
model = tf.global_variables_initializer()
session.run(model)
print(session.run(y))
Per maggiori informazioni su Tensorboard, guarda la nostra lezione sulla visualizzazione.