Reti Neurali Artificiali: tutorial torretta robotizzata

[max_robot]

In un precedente post ho spiegato cosa sono le reti neurali artificiali e come poterle utilizzare in robotica. Prima di procedere con la lettura vi suggerisco di leggere tale post.

Fatto? Bene ora siete pronti per qualcosa di piu' pratico. Vi spieghero' come installare la libreria Tensorflow e come realizzare il vostro primo Perceptron, per controllare la torretta robotizzata utilizzata come esempio nel precedente post.

Una volta finito l'addestramento della rete neurale potrete implementarla facilmente su un microcontrollore o su una scheda commerciale (Arduino per esempio). La rete neurale che utilizzeremo e' infatti di dimensioni estremamente ridotte e puo' essere eseguita con una singola riga di codice. Utilizzeremo Tensorflow solo per l'addestramento, fase delicata e dispendiosa in termini computazionali non eseguibile su un microcontrollore.

Cominciamo con l'installazione di Tensorflow...


Installazione di TensorFlow

Tensorflow e' una libreria realizzata da Google, che viene ampiamente utilizzata per realizzare reti neurali e modelli di Deep Learning. Questa libreria permette di sfruttare una GPU (se ne possedete una). Le istruzioni presentate in questa sezione sono per la versione base (CPU only).
Vi spieghero' come installare TensorFlow su Ubuntu 14.04 e Mac OS X. Se utilizzate Windows vi suggerisco di installare una macchina virtuale con sopra Ubuntu 14.04 LTS.

Se state utilizzando Ubuntu aprite un terminale e digitate:

sudo apt-get install python-pip python-dev

Se state utilizzando Mac OS X avrete bisogno invece di questi due comandi:

sudo easy_install pip
sudo easy_install --upgrade six

Con i comandi precedenti installerete tutte le dipendenze di cui avrete bisogno tra poco.
Per scaricare il file di installazione su Ubuntu 64 bit per Python 2.7 digitate sul terminale:

export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow-0.9.0-cp27-none-linux_x86_64.whl

Se utilizzate Mac OS X con Python 2.7 dovrete invece digitare:

export TF_BINARY_URL=https://storage.googleapis.com/tensorflow/mac/tensorflow-0.9.0-py2-none-any.whl

Quindi per installare TensorFlow (sia su Ubuntu che Mac) digitate:

sudo pip install --upgrade $TF_BINARY_URL

Finito! La nostra installazione dovrebbe essere pronta per un primo test.
Vediamo se tutto funziona correttamente. Aprite un terminale e digitate:

python

Questo comando fara' partire il terminale di Python e vi permettera' di scrivere codice direttamente all'interno di esso.
Per controllare che la libreria sia installata dovete ora inserire il seguente comando all'interno della shell Python:

import tensorflow as tf

Se tutto fila liscio non dovreste vedere errori. Ora proviamo a creare una costante di tipo TensorFlow e stampiamo il suo valore:

hello = tf.constant('Ciao, roboitalia!')
sess = tf.Session()
print(sess.run(hello))

Se tutto procede per il verso giusto vedrete il terminale stampare la frase 'Ciao, roboitalia!'.
Bene siete pronti per il prossimo step, il vostro primo Perceptron!

[max_robot]

Introduzione

Il tipo di Perceptron che realizzeremo in questo tutorial ha 2 input ed 1 output. Gli input sono ottenuti dalla lettura di due sesori di distanza e l'output controlla un servomotore che muove la base di una torretta robotica.

ATTENZIONE: Se un giorno pensate di realizzare una torretta come questa ricordate di non farvi male e di non fare male a nessuno!

In questo tutorial la rete utilizzata e' leggermente diversa da quella vista nel precedente, ho aggiunto l'unita' di Bias (poi vedremo a cosa serve). Una rappresentazione del nostro Perceptron e' presentata di seguito:



Immaginiamo che l'output dei sensori sia ottenuto dalla lettura della loro tensione d'uscita e che questo valore sia catturato da un pin analogico-digitale sulla nostra scheda di controllo. La lettura sara' nel range [0, 255]. Se leggiamo un valore compreso tra [0,50] significa che un ostacolo e' molto vicino al sensore ed ha superato la soglia minima (supponiamo 50 cm). Se leggiamo un valore compreso tra [51, 255] non ci sono ostacoli vicini al sensore che siano inferiori alla soglia minima. L'output della rete sara' un valore continuo compreso tra 0 ed 1. Questo valore puo' essere convertito nel valore digitale da inviare al servo. Un valore di output uguale a 0 coincide con la rotazione del servo in senso antiorario (in direzione del sensore-1), un ouput di 1 invece, corrisponde con una rotazione in senso orario (in direzione del sensore-2).

Cosa vogliamo che faccia il nostro Perceptron? Vogliamo che ritorni un output uguale a 0 quando il sensore-1 legge un valore nel range [0-50] (qualcosa ha superato la soglia minima). La stessa cosa vale per il sensore-2, se la lettura e' nel range [0-50] allora vogliamo un output di 1 (la torretta dovra' ruotare in quella direzione). Pensiamo ora a due situazioni limite, cosa fare se entrambi i sensori ritornato un valore uguale a zero? In questo caso probabilmente il bersaglio si e' mosso molto vicino fino a coprire entrambi i sensori. Il servo dunque dovra' muoversi nella posizione centrale (output = 0.5). Cosa fare invece quando entrambi i sensori non misurano ostacoli? In questo caso e' saggio posizionare la torretta nella posizione centrale (output = 0.5), in modo tale da essere il piu' rapidi possibile nel muoverla in direzione del prossimo ostacolo rilevato. Per ricapitolare:

INPUT: [0,50] (soglia minima superata), [51,255] (nessun ostacolo).
OUTPUT: 0 (sinistra), 0.5 (centro), 1 (destra).

Per convenzione ora utilizzero' il valore 0 per identificare una lettura dei sensori compresa nel range [0,50] ed 1 per indicare una lettura nel range [51,255]. Dati questi valori possiamo trovare 4 possibili combinazioni di input ed output:

1) INPUT1=0, INPUT2=0; OUPUT=0.5 //Entrambi i sensori hanno trovato il bersaglio, torretta al centro
2) INPUT1=0, INPUT2=1; OUPUT=1.0 //Il sensore-1 ha rilevato un bersaglio, torretta a sinistra
3) INPUT1=1, INPUT2=0; OUPUT=0.0 //Il sensore-2 ha rilevato un bersaglio, torretta a destra
4) INPUT1=1, INPUT2=1; OUPUT=0.5 //Entrambi i sensori non hanno rilevato bersagli, torretta al centro

Queste combinazioni costituiscono il nostro dataset. Il dataset e' l'insieme di valori di input ed output utilizzati per addestrare la rete neurale. Nel nostro esempio abbiamo solo 4 valori ma in generale i dataset comprendono migliaia di valori.

[max_robot]

Perceptron Reloaded
Se avete letto il tutorial sulle reti neurali nel mio precedente post, saprete come funziona un Perceptron. Il passaggio di forward in cui si calcola l'output della rete viene eseguito con una sola linea di codice:

OUTPUT = f(INPUT1 * W1 + INPUT2 * W2)

Dove f e' la funzione Sigmoidea:

sigmoid_output = 1 / (1 + math.exp(-x))

In questa sezione ho introdotto un nuovo concetto, quello di Bias. Il Bias e' una sorta di unita' di ingresso fantasma, il cui input e' costantemente uguale ad 1 ed il cui valore di connessione (B1 nella foto) viene aggiornato durante l'addestramento insieme a W1 e W2. A cosa serve il Bias? Il Bias e' un valore che permette di traslare la funzione sigmoidea sull'asse x. Questa traslazione ha l'effetto di riposizionare il centro della funzione ed e' di estrema importanza in alcuni problemi. Ai fini pratici il Bias e' invisibile, ed una volta addestrata la rete diventa una parte interna della rete di cui voi non dovrete preoccuparvi. Per integrare il Bias nella nostra formula di computazione dell'output basta un fattore additivo:

OUTPUT = f( (INPUT1 * W1 + INPUT2 * W2) + B1)

L'unica differenza con la formula precedente sta nel fatto che il risultato ottenuto in (INPUT1 * W1 + INPUT2 * W2) viene addizionato con il valore di B1 prima di essere dato in pasto alla funzione sigmoidea.

Visto che Tensorflow fa uso di diversi algoritmi di ottimizzazione e' il caso che spieghi brevemente di cosa si tratta. La fase di ottimizzazione non e' altro che la fase di addestramento della nostra rete. Nel gergo di Tensorflow "ottimizzare" significa trovare i valori migliori per le connessioni W1, W2 e B1 in modo tale che l'output della rete sia congruo con quello che noi desideriamo. Come ho spiegato nel precedente tutorial la nostra rete neurale viene addestrata in una fase di Backpropagation, il corrispettivo nel gergo di Tensorflow si chiama Gradient Descent Optimizer. Questo nome potra' spaventarvi ma ridotto all'osso significa effettuare i seguenti step:

1) Prendere i valori di input ed i target ideali dal nostro dataset.
2) Dare i valori di input in ingresso alla rete neurale e calcolare l'output (forward)
3) Confrontare l'output della rete con il target (output desiderato), calcolando il costo.
4) Aggiornare il valore di W1, W2 e B1 in modo tale che l'output sia piu' simile al target.
5) Ripetere tutto dal principio finche' non si converge ad un output ottimale.

Il risultato del confronto output/target al passaggio 3 e' un valore numerico chiamato "costo". In Tensorflow si cerca di abbassare il piu' possibile questo valore. Piu 'basso e' questo valore e migliore sara' l'output prodotto dalla nostra rete. Il costo e' zero quando l'output prodotto e' identico al target desiderato. Tuttavia un costo pari a zero non puo' quasi mai essere ottenuto a causa del limite di rappresentazione del nostro computer.

Bene ora siamo pronti per Tensorflow...

[max_robot]

Il mio primo Perceptron

Cominciamo a scrivere qualcosa. Il codice e' stato realizzato in Python 2.7, il porting per Python 3.x dovrebbe essere abbastanza semplice ma richiede l'installazione della corrispettiva versione di Tensorflow. Di seguito spezzettero' il codice in diverse parti e commentero' ogni singola parte. Il file completo (e commentato) puo' essere scaricato qui. Create un nuovo file di testo sul vostro desktop e chiamatelo "perceptron_tensorflow.py". Aprite il file e cominciate con l'aggiungere le prime righe di codice che serviranno ad importare le librerie di cui abbiamo bisogno:

import tensorflow as tf
import shutil

Ora possiamo creare il dataset di input/target che utilizzeremo durante il training:

dataset_input = [[0, 0],[0, 1],[1, 0],[1, 1]]
dataset_target = [[0.5],[0],[1],[0.5]]

Ora creiamo due contenitori vuoti chiamati nel gergo di Tensorflow "placeholder". Queste variabili conterranno i valori del nostro dataset una volta avviata la sessione di tensorflow.

_input = tf.placeholder(tf.float32, shape=[4,2], name = 'input')
_target = tf.placeholder(tf.float32, shape=[4,1], name = 'target')

Dichiaro le variabili relative alle connessioni W1 e W2. Posso mettere i due valori di W1 e W2 dentro una sola variabile W rappresentata da un vettore con 2 righe ed 1 colonna. Dichiaro anche la variabile di Bias B (il valore della connessione chiamata B1 nella nostra immagine):

W = tf.Variable(tf.truncated_normal([2,1], mean=0.0, stddev=0.1), name = "W")
B = tf.Variable(tf.zeros([1]), name = "B")

Il valore delle connessioni W viene inizializzato in modo casuale vicino a zero. Perche'? Questo tipo di inizializzazione permette una convergenza piu' rapida.
Creo il perceptron. Utilizzo la sigmoide come funzione di attivazione. L'input viene moltiplicato per le connessioni W, in seguito il valore del Bias B viene aggiunto al risultato ed il tutto viene passato alla funzione di attivazione.

with tf.name_scope("perceptron") as scope:
	output = tf.sigmoid(tf.matmul(_input, W) + B)

Questa parte del codice definisce il tipo di costo da ridurre durante l'addestramento. Viene calcolata la differenza tra il target e l'output della rete (al quadrato). Il risultato e' un valore numerico chiamato "costo" che costituisce il metro di giudizio per capire se la rete sta apprendendo o meno. Se il training sta funzionando il valore del costo scende.

with tf.name_scope("cost") as scope:
	cost = tf.reduce_mean(tf.nn.l2_loss(_target - output))
        tf.scalar_summary("cost", cost)

Definisco il tipo di optimizer ed il relativo learning rate. In questo caso utilizzo il classico Gradient Descent optimizer. Il valore del learning rate viene generalmente trovato per prove successive. Nel nostro caso un valore di 0.01 fa il suo dovere.

with tf.name_scope("optimizer") as scope:
	optimizer = tf.train.GradientDescentOptimizer(0.01).minimize(cost)

Inizializzo tutte le variabili di tipo tf che abbiamo dichiarato sopra. Dichiaro un oggetto di tipo "Session" che ci servira' per gestire la nostra sessione di lavoro.

init = tf.initialize_all_variables()
sess = tf.Session()

Il writer serve per pubblicare le informazioni relative alla nostra rete in Tensorboard. Per visualizzare queste informazioni dal vostro browser dovete aprire un terminale e lanciare il comando: tensorboard --logdir=/tmp/tf_log
quindi aprire il vostro browser inserendo nella barra il seguente indirizzo: http://0.0.0.0:6006
Potrebbe essere necessario attendere alcuni secondi prima di cominciare a vedere qualcosa in EVENTS, il grafo della rete e' invece immediatamente accessibile in GRAPH.

shutil.rmtree("/tmp/tf_log") #cancella la directory precedente
summary_writer = tf.train.SummaryWriter("/tmp/tf_log", sess.graph_def)
merged_summaries = tf.merge_all_summaries()

Avvia la sessione TensorFlow. Il concetto di sessione e' semplice, nel nostro codice abbiamo dichiarato diversi oggetti di tipo "tf", questi oggetti vengono allocati in memoria solo a sessione inizializzata.

sess.run(init)

Il seguente loop costituisce la fase di apprendimento. Il numero totale di epoche viene definito nella variabile tot_epoch.

tot_epoch = 10000
for epoch in range(tot_epoch):
        #Questa linea di codice racchiude tutta la logica dietro TensorFlow.
        #La sessione e' stata avviate e tutte le variabili allocate in memoria.
        #Posso interrogare il grafo specificando i valori che voglio vengano
        #calcolati, in questo caso: [optimizer, merged_summaries, output, cost, W, B]
        #Come valori di ingresso devo dare: {_input: dataset_input, _target: dataset_target}
        #Salvo i valori di uscita nelle variabili locali: _, my_summary, my_output, my_cost, my_weights, my_bias 
	_, my_summary, my_output, my_cost, my_weights, my_bias = sess.run([optimizer, merged_summaries, output, cost, W, B], 
                                                                          feed_dict={_input: dataset_input, _target: dataset_target})
        summary_writer.add_summary(my_summary, epoch) #aggiunge al sommario le variabili monitorate

        #Stampo sul terminale i valori di tutte le variabili ogni 1000 epoche.
	if epoch % 1000 == 0:
                print("")
		print("Epoch ..... " + str(epoch))
		print("Cost ..... " + str(my_cost))
                print("Target: " + str(dataset_target[0]) + str(dataset_target[1]) + str(dataset_target[2]) + str(dataset_target[3]))
		print("Output: " + str(my_output[0]) + str(my_output[1]) + str(my_output[2]) + str(my_output[3]))
		print("W: " + str(my_weights[0]) + str(my_weights[1]))
		print("B: " + str(my_bias))

        #Stampo un sommario dell'addestramento una volta giunto all'ultima epoca.
	if epoch == (tot_epoch-1):
                print("")
		print('Training complete!')
                print("Tot Epochs ..... " + str(tot_epoch))
		print("Final Cost ..... " + str(my_cost))
		print("Estimated Weights: " + str(my_weights[0]) + str(my_weights[1]))
		print("Estimated Bias: " + str(my_bias))

Bene, il nostro codice e' completo. Vi consiglio di scaricare il file completo a questo indirizzo, in quanto con i copia-incolla spesso salta qualcosa. Nella prossima sessione vi mostrero' come interpretare i risultati ottenuti una volta avviato il file...

[max_robot]

Eseguire il codice

Il codice della sessione precedente puo' essere eseguito da terminale. Per eseguirlo digitate da terminale (attenzione: affinche' i comandi vadano a segno e' importante che il vostro file si chiami "perceptron_tensorflow.py" e che si trovi sul desktop):

cd Desktop
python perceptron_tensorflow.py

Vedrete sul terminale cominciare ad apparire una serie di informazioni. Ogni 1000 epoche verranno stampate delle informazioni del tipo:

Epoch ..... 0
Cost ..... 0.241133
Target: [0.5][0][1][0.5]
Output: [ 0.5][ 0.51445305][ 0.53627348][ 0.55062038]
W: [ 0.14637725][ 0.05641799]
B: [-0.0002571]

Queste informazioni rappresentano il numero attuale di epoche trascorse. Il valore del Costo, i valori di target ideali da ottenere ed i valori ritornati come output dal Perceptron. Durante l'avanzare del training vedrete che i valori di output cominceranno ad essere sempre piu' simili ai valori di target ideali, dopo circa 9000 epoche (pochi secondi di esecuzione) i valori di output saranno quasi perfetti:

Target: [0.5][0][1][0.5]
Output: [ 0.49939373][ 0.08730381][ 0.91259986][ 0.50030416]

Come vedete output e target sono molto simili, se guardate invece ai valori nelle prime epoche vedrete che l'output e' molto differente dal valore ideale voluto. Alla fine dell'addestramento otterrete le seguenti informazioni:

Training complete!
Tot Epochs ..... 10000
Final Cost ..... 0.00676628
Estimated Weights: [ 2.41338325][-2.4108851]
Estimated Bias: [-0.00167224]

Ovviamente visto che i valori iniziali sono generati in modo casuale il vostro output sara' leggermente diverso dal mio.
Salvate questi valori perche' sono i valori che vi permetteranno di utilizzare il vostro Perceptron in seguito.

Ora ricordiamoci che Tensorflow ha uno strumento estremamente potente chiamato Tensorboard, che permette di visualizzare il Grafo della rete e le variabili registrate in precedenza. Per attivare Tensorboard e' necessario aprire un terminale e digitare il seguente comando:

tensorboard --logdir=/tmp/tf_log

Per accedere a tensorboard dovete aprire il browser al seguente indirizzo: http://0.0.0.0:6006

Ora potrete visualizzare come il valore del "costo" sia sceso durante l'addestramento. Ricordate che e' proprio quello che volevamo. Un basso costo significa che output e target sono simili. Ecco il grafico che ho ottenuto nel mio caso:



Altra scheda importante e' quella relativa al Grafo della rete:



Con Tensorboard e' possibile analizzare anche immagini ed histograms, vi rimando alla documentazione ufficiale per maggiori spiegazioni.
Nella prossima sezione vi spieghero' come utilizzare il Perceptron che abbiamo appena addestrato su un Arduino, una Raspberry o qualsiasi cosa vogliate...

[max_robot]

Importare il Perceptron

Dopo aver eseguito il codice abbiamo ottenuto i valori di W1, W2 e B1 che ci permettono di avere un output con costo estremamente basso. Nel mio caso ho ottenuto:

Estimated Weights: [ 2.41338325][-2.4108851]
Estimated Bias: [-0.00167224]

I vostri valori possono essere diversi, visto che abbiamo inizializzato la rete in modo casuale. Questi valori sono tutto quello di cui abbiamo bisogno per il nostro Perceptron. Per usare il Perceptron non avete bisogno di Tensorflow, basta reimplementare il forward nel linguaggio di programmazione che state utilizzando. Ricorderete come calcolare l'output della rete:

OUTPUT = f( (INPUT1 * W1 + INPUT2 * W2) + B1)

Ora abbiamo tutti i valori da inserire in questa equazione. Supponiamo che il sensore-2 abbia individuato un ostacolo molto vicino. La lettura sara' del tipo SENSORE1 = 1 e SENSORE2 = 0, questo ci porta ad avere:

W1 = 2.41338325
W2 = -2.4108851
B1 = -0.00167224
SENSORE1 = 1
SENSORE2 = 0

Ora basta inserire i valori nella nostra equazione:

OUTPUT = f( (1 * 2.41338325 + 0 * -2.4108851) -0.00167224)

Ricordate che avete bisogno della funzione sigmoidea per avere l'output. Su arduino il codice completo potrebbe essere una cosa di questo tipo:

//Funzione di attivazione
float sigmoid(float x){
 float result = 1 / (1 + exp(-1 * x));
 return result;
}

//Variabili
float input1 = 1.0;
float input2 = 0.0;
float w1 = 2.41338325;
float w2 = -2.4108851;
float b1 = -0.00167224;

//Output del Perceptron
float output = sigmoid((input1 * w1 + input2 * w2) + b1);

Al momento non ho un arduino qunindi non ho potuto testare il codice, ma dovrebbe funzionare.
Una implementazione in python:

import math

#Funzione di attivazione
def sigmoid(x):
  return 1 / (1 + math.exp(-x))

#Variabili
input1 = 1.0;
input2 = 0.0;
w1 = 2.41338325;
w2 = -2.4108851;
b1 = -0.00167224;

#Output del Perceptron
output = sigmoid((input1 * w1 + input2 * w2) + b1);

Ovviamente il valore di input1 ed input2 dovrete aggiornarlo ad ogni lettura. Questo dipende dalla piattaforma e dall'hardware che utilizzate per leggere i sensori.

Spero che il codice vi torni utile e che questo tutorial vi sia piaciuto. Commenti e feedback sono benvenuti...


Max