UNIVERSITA’ DEGLI STUDI DI CAGLIARI

FACOLTA’ DI SCIENZE

Corso di Laurea in Informatica

TensorFlow - libreria software open source per l'apprendimento automatico

Docente di riferimento Candidato Prof. Reforgiato Recupero Diego Angelo Gaetano Pes Nicola (matr. 48305)

ANNO ACCADEMICO 2015-2016

Indice1 INTRODUZIONE.........................................................................................................1

1.1 INTELLIGENZAARTIFICIALE.................................................................................................11.2 APPRENDIMENTOAUTOMATICO.........................................................................................3

1.2.1 Apprendimentoapprofondito.................................................................................52 TENSORFLOW................................................................................................................7

2.1 INTRODUZIONE...............................................................................................................7

3 MODELLO DI PROGRAMMAZIONE E CONCETTI BASE.....................................93.1 OPERAZIONI E KERNELS............................................................................................93.2 SESSIONI..................................................................................................................103.3 VARIABILI..................................................................................................................11

4 IMPLEMENTAZIONE...............................................................................................134.1 DISPOSITIVI...............................................................................................................134.2 TENSORI...................................................................................................................13

5 ESECUZIONE DI UN SINGOLO DISPOSITIVO....................................................15

6 ESECUZIONE DI PIÙ DISPOSITIVI........................................................................176.1 COLLOCAMENTO DEL NODO.....................................................................................176.2 COMUNICAZIONE CROSS-DEVICE............................................................................18

7 ESECUZIONE DISTRIBUITA..................................................................................217.1 TOLLERANZA AGLI ERRORI.......................................................................................21

8 ESTENSIONI.............................................................................................................238.1 CALCOLO DEL GRADIENTE.......................................................................................238.2 ESECUZIONE PARZIALE............................................................................................248.3 VINCOLI DI DISPOSITIVO...........................................................................................258.4 FLUSSO DI CONTROLLO............................................................................................268.5 OPERAZIONI DI INPUT...............................................................................................278.6 CODE........................................................................................................................278.7 CONTENITORI...........................................................................................................28

9 OTTIMIZZAZIONE....................................................................................................299.1 ELIMINAZIONE DELLA SOTTO ESPRESSIONE COMUNE............................................299.2 CONTROLLO DELLA COMUNICAZIONE DEI DATI E UTILIZZO DELLA MEMORIA.........299.3 KERNEL ASINCRONI..................................................................................................299.4 LIBRERIE OTTIMIZZATE PER LE IMPLEMENTAZIONI DEL KERNEL.............................309.5 COMPRESSIONE CON PERDITA................................................................................30

10 STATO ED ESPERIENZA...................................................................................33

11 IDIOMI DI PROGRAMMAZIONE COMUNI.........................................................3711.1 TRAINING DI DATI PARALLELO..................................................................................3711.2 MODELLO DI TRAINING PARALLELO.........................................................................3811.3 PASSI SIMULTANEI PER IL MODELLO DI CALCOLO PIPELINING................................39

12 TOOLS..................................................................................................................4112.1 TENSORBOARD: VISUALIZZAZIONE DELLE STRUTTURE DEL GRAFICO E STATISTICHE RIASSUNTIVE..........................................................................................................................41

12.1.1 Visualizzazione del grafico di calcolo.........................................................4112.1.2 Visualizzazione dei dati di sintesi................................................................42

13 TRACCIATO DI ESECUZIONE...........................................................................45

14 ESEMPI.................................................................................................................4914.1 HELLO,TENSORFLOW!...................................................................................................4914.2 SEMPLICIOPERAZIONI....................................................................................................50

14.2.1 Moltiplicazionetraduevariabili.......................................................................50

15 CONCLUSIONI.....................................................................................................55

RIFERIMENTI BIBLIOGRAFICI......................................................................................57

1

1 Introduzione 1.1 IntelligenzaartificialeL'intelligenza artificiale è una disciplina scientifica che studia la possibilità di realizzare macchine e programmi informatici in grado di risolvere i problemi con ragionamenti simili a quelli umani. È anche indicata con il termine inglese Artificial Intelligence (A.I.). L'obiettivo dell'intelligenza artificiale è realizzare un sistema in grado di simulare il comportamento e il ragionamento umano. “Le fondamenta dell'intelligenza artificiale (I.A.) sono poste dal matematico inglese Alan Turing che nel 1936 ipotizza la possibilità di costruire una macchina ideale in grado di svolgere qualsiasi tipologia di calcolo (macchina di Turing) e nel 1950 pubblica l'articolo "Computing Machinery and Intelligence" in cui definisce un apposito test (test di Turing) per riconoscere una macchina intelligente. L'espressione Articial Intelligence (A.I.) viene utilizzata per la prima volta nel 1956 dall'informatico John McCarthy durante un convegno.” [2] La disciplina è suddivisa in due distinte aree:

o I.A. forte. L'intelligenza artificiale forte ipotizza la possibilità di realizzare un computer in grado di svolgere tutte le operazioni dell'uomo e di raggiungere un livello di intelligenza pari o superiore a quella umana. In base a questo approccio la macchina è un'entità intelligente autonoma e indipendente dall'uomo.

o I.A. debole. L'intelligenza artificiale debole ipotizza la possibilità di costruire una macchina in grado di svolgere operazioni complesse simulando il comportamento umano. In base a questo approccio la macchina si limita a simulare l'intelligenza umana senza mai eguagliarla.

La disciplina comprende campi di studio particolarmente complessi, come la comprensione del linguaggio naturale, l'analisi visiva, la robotica, i sistemi esperti ecc. Negli anni '70 e '80 la disciplina I.A. conosce un periodo di rapida evoluzione, in particolar modo nel settore dei sistemi esperti e delle reti neurali. In questi anni sono sviluppati agenti razionali più flessibili e potenti.

o Agenti razionali. Un agente razionale è un programma informatico (algoritmo) in grado di prendere le decisioni più razionali in condizioni di incertezza sulla base delle conoscenze e dei dati a disposizione. L'agente razionale interagisce

2

con l'ambiente che lo circonda tramite sensori e attuatori. Sulla base di un processo inferenziale può accumulare esperienza e modificare la base di conoscenza. L'agente razionale è detto logico (o basato sulla conoscenza) quando è in grado di apprendere nuove formule tramite il ragionamento logico.

o Sistemi esperti. Un sistema esperto è un software in grado di organizzare la conoscenza su un particolare ambito del sapere. Sulla base di una serie di premesse, il software esegue delle procedure di inferenza per derivare delle conclusioni logiche, al fine di risolvere problemi anche complessi. “Un sistema esperto è composto da una base di conoscenza e da un motore inferenziale. Le conoscenze iniziali sono alimentate dagli esperti in materia e dagli ingegneri della conoscenza. Il sistema esperto è progettato per essere utilizzato dagli utenti e per fornire loro delle soluzioni ai problemi che possono presentarsi in un particolare ambito.” [8]

o Reti neurali. Le reti neurali artificiali sono modelli matematici ispirati alle reti neurali biologiche. La rete è composta da nodi, ognuno dei quali ha specifiche proprietà, dati e svolge particolari funzioni. I nodi della rete sono interconnessi tra loro per controllare le funzioni superiori del sistema.

A differenza dei comuni sistemi informatici quelli intelligenti hanno la capacità di rispondere ai problemi con maggiore flessibilità, trovando il significato corretto anche nei casi in un cui messaggio sembra essere contraddittorio o ambiguo. Questi sistemi operano una comparazione con casi simili (ma non uguali) alla situazione osservata ed elaborano un ventaglio di soluzioni (non una sola) tra cui scegliere. In tal modo l'intelligenza artificiale simula il processo di scelta umano ed accumula esperienza (IA debole).

3

Soltanto una parte dei problemi che si incontrano quotidianamente possono essere risolti mediante una procedura automatizzata o un algoritmo. L'automazione non è in grado di affrontare problemi troppi complessi senza mettere in campo un metodo di analisi diverso. Ad esempio, la comprensione automatica del linguaggio naturale richiede un sistema di analisi più complesso rispetto a quello utilizzato per un qualsiasi database di computer. In questi campi entra in gioco l'intelligenza artificiale (IA debole). A differenza dell'uomo il sistema di intelligenza artificiale ha un enorme vantaggio: non muore. In teoria, può quindi accumulare un’esperienza e una conoscenza superiore a quella di qualsiasi essere umano. Finora l'intelligenza artificiale ha contribuito a creare sistemi esperti in grado di analizzare singoli aspetti della realtà. Non è escluso che in futuro tali progressi portino alla nascita di una vera e propria vita artificiale senziente e cosciente (IA forte).

1.2 Apprendimentoautomatico

« un programma apprende da una certa esperienza E se: nel rispetto di una classe di compiti T, con una misura di prestazione P, la prestazione P misurata nello svolgere il compito T è migliorata

dall'esperienza E.» - Tom M. Mitchell “L'apprendimento automatico è la capacità di un sistema di ampliare le proprie conoscenze senza l'intervento dell'uomo. Il concetto di apprendimento automatico è utilizzato nell'ingegneria del software, nel data mining e, in particolar modo, nell'intelligenza artificiale.” [5] I sistemi di apprendimento automatico si basano su diversi metodi di ragionamento, tra i quali si ricordano:

• Ragionamento induttivo. Il ragionamento induttivo è un processo logico che consente di giungere a una conoscenza generale a partire dallo studio dei casi particolari. Ad esempio, gli uccelli hanno le ali e volano, le api hanno le ali e volano (asserzioni singolari), quindi tutti gli animali con le ali volano (asserzione generale). Questo tipo di ragionamento può causare errori di valutazione, dovuto all'eccessiva generalizzazione. Ad esempio, la gallina ha le ali ma non vola.

4

• Ragionamento deduttivo. Il ragionamento deduttivo è un processo logico che consente di giungere a una conoscenza come conseguenza logica delle premesse. Ad esempio, tutti gli animali mangiano, gli uomini sono animali (premesse), quindi tutti gli uomini mangiano. Questo tipo di ragionamento (inferenza deduttiva) preserva la verità contenuta nelle premesse.

A partire da una base di conoscenza, ricca di informazioni, un sistema di apprendimento automatico ricerca ed estrae le eventuali regolarità tra i dati mediante le tecniche di data mining. Per avviare un percorso di apprendimento automatico è necessario utilizzare sia il metodo induttivo e sia il metodo deduttivo, anche se ciò potrebbe portare a compiere errori. La sola presenza del metodo deduttivo potrebbe comportare l'interruzione del processo di apprendimento entro i limiti imposti dalle premesse. Un sistema di apprendimento automatico deve essere in grado di fare esperienza e di riconoscere gli errori compiuti in passato al fine di evitare di ricommetterli in futuro. Negli anni '50-'60 per realizzare le prime forme di ragionamento automatico sono stati adottati due approcci:

• Approccio deterministico. Nell'approccio deterministico l'uomo inserisce nella macchina una tabella con tutte le associazioni di causa ed effetto. In una colonna è indicata una particolare situazione e in un'altra l'azione che la macchina dovrà eseguire. Tale approccio richiede una grande quantità di dati. Si pensi, ad esempio, al numero di combinazioni possibili in una partita a scacchi. Inoltre, non si può parlare di vero e proprio ragionamento automatico poiché la macchina si limita a seguire meccanicamente ciò che il programmatore ha impostato. Per quanto sia completa, la tabella non potrà mai prevedere tutte le situazioni che si possono presentare in un ambiente reale.

• Approccio probabilistico. Nell'approccio probabilistico l'uomo si limita a spiegare le regole del gioco alla macchina e una minima conoscenza di base. È la macchina ad accumulare esperienza. Inizialmente la macchina procede con azioni casuali analizzando il risultato (effetto) finale. Quando il risultato è positivo memorizza la scelta come valida e la ripete in situazioni analoghe. Quando il risultato è negativo la memorizza tra le scelte da evitare. Dopo numerosi cicli di esecuzione la macchina dovrebbe aver costruito una propria conoscenza empirica del problema. Ad esempio, in una partita a scacchi il computer perde quasi tutte le prime partite poiché deve ancora maturare

5

esperienza. Alla n-esima partita è, invece, più difficile battere il computer poiché quest'ultimo ha già in memoria diverse situazioni e non risponde più casualmente alle mosse del giocatore umano. Tale approccio è preferibile rispetto all'approccio deterministico ma non elimina del tutto alcune criticità. L'associazione causa-effetto di ogni situazione in una tabella richiede comunque una grande quantità di memoria per ospitare i dati. Quanto maggiore è la quantità di dati da analizzare, tanto minore è la velocità di risposta della macchina.

• Approccio previsionale. Più che un approccio si tratta di una estensione degli approcci precedenti (deterministico o probabilistico). Nell'approccio previsionale la macchina analizza per ogni sua possibile scelta tutte le possibili contro-mosse del giocatore avversario. In tal modo la macchina riesce a prevedere l'evoluzione futura del gioco analizzando tutte le sequenze di azioni possibili. L'approccio previsionale è relativamente semplice in un gioco astratto come gli scacchi dove tutte le mosse appartengono a un insieme chiuso e le regole sono ben delineate. E', invece, molto complesso da realizzare in un ambiente reale (es. guida automatica su strada) dove gli imprevisti sono la regola del gioco.

Le innovazioni informatiche degli ultimi trent'anni hanno consentito di lavorare con macchine sempre più veloci e con memorie sempre più capienti. Ciò nonostante, la complessità spaziale (memoria) e la complessità temporale (velocità di ragionamento) degli algoritmi di intelligenza artificiale è ancora oggi uno dei principali problemi dell'apprendimento e del ragionamento automatico. 1.2.1 Apprendimentoapprofondito

“L'apprendimento approfondito (in inglese deep learning) è quel campo di ricerca dell'apprendimento automatico e dell'intelligenza artificiale che si basa su diversi livelli di rappresentazione, corrispondenti a gerarchie di caratteristiche di fattori o concetti, dove i concetti di alto livello sono definiti sulla base di quelli di basso. Tra le architetture di apprendimento approfondito si annoverano le reti neurali profonde, la convoluzione di reti neurali profonde, le Deep belief network, e reti neurali ricorrenti, che sono state applicati nella computer vision, nel riconoscimento

6

automatico del discorso, nell'elaborazione del linguaggio naturale, nel riconoscimento audio e nella bioinformatica. "Deep learning" è un'espressione oggi famosa che ridà lustro al concetto di rete neurale.” [7]

7

2 TensorFlow

TensorFlow è una libreria software open source per l’apprendimento automatico in diversi tipi di compiti percettivi e di comprensione del linguaggio. È una seconda generazione di API che è attualmente usata sia in ambito di ricerca che di produzione da 50 team in dozzine di prodotti commerciali Google, come il riconoscimento vocale, Gmail, Google Foto, e Ricerca. Questi team hanno usato in precedenza DistBelief, la prima generazione di API. TensorFlow fu sviluppato dal team Google Brain e rilasciato sotto la licenza open source Apache 2.0 il 9 novembre 2015. Fornisce API in linguaggio Python, e delle API meno documentate in linguaggio C++. Fu sviluppato inizialmente dal team di Google Brain all’interno dell’organizzazione di ricerca Google’s Machine Intelligence con lo scopo di condurre l’apprendimento automatico e la ricerca sulle reti neurali approfondite, ma il sistema è abbastanza generale per essere applicato pure in un enorme varietà di altri domini. L’architettura flessibile permette di impiegare le operazioni in una o più CPU o GPU in un desktop, server, o dispositivo mobile con una singola API. 2.1 Introduzione Il progetto Google Brain parte nel 2011 per esplorare l’uso delle reti neurali profonde in larga scala, sia per la ricerca che per l’uso nei prodotti Google. Come primo lavoro del progetto, Google Brain costruisce DistBelief; DistBelief è la prima generazione di API. Tramite questo sistema si è fatta molta ricerca inclusi lavori nell’apprendimento non supervisionato, nella rappresentazione del linguaggio, nei modelli per la classificazione di immagini e il riconoscimento di oggetti, la classificazione di video, il riconoscimento vocale e altre aree. Inoltre in collaborazione con Google Brain team,

8

più di 50 team della Google e altre compagnie Alphabet sono ricorse alle reti neurali profonde usando DistBelief in un’ampia varietà di prodotti, incluso Google Search, il sistema di riconoscimento vocale, Google Photos, Google Maps e SteetView, Google Translate, YouTube e molti altri. Sull’esperienza di DistBelief il team costruisce TensorFlow, sistema di seconda generazione per l’implementazione e creazione di una larga scala di modelli di apprendimento automatico. TensorFlow descrive le operazioni tramite un modello a flusso di dati e mappa questi in una varietà di piattaforme hardware differenti, variando dalla gestione dell’inferenza nelle piattaforme dei dispositivi mobili come ad esempio Android e iOS sino a sistemi di training e inferenza di modeste dimensioni usando singole macchine contenenti una o più GPU sino a sistemi di training che girano in centinaia di macchine specializzate con migliaia di GPU. Avere un unico sistema che può estendersi a una così ampia gamma di piattaforme semplifica significativamente l’uso del sistema di apprendimento automatico. I calcoli in TensorFlow si esprimono mediante grafici a flusso di dati stateful. Per scalare la formazione di reti neurali in implementazioni più grandi, TensorFlow permette di esprimere facilmente vari tipi di parallelismi attraverso la replica e l’esecuzione parallela di un modello base del grafico a flusso di dati, con molti dispositivi di calcolo differenti che collaborano tutti per aggiornare un insieme di parametri condivisi o altro. Alcuni usi di TensorFlow consentono flessibilità in termini di consistenza di aggiornamenti dei parametri. Comparato a DistBelief, il modello di programmazione in TensorFlow è più flessibile, la sua performance è significativamente migliore, e supporta la formazione e l’utilizzo di un’ampia gamma di modelli su una più ampia varietà di piattaforme hardware eterogenee.

9

3 Modello di programmazione e concetti base “Un’operazione in TensorFlow è descritta da un grafico composto da un insieme di nodi. Il grafico rappresenta un’operazione di flusso di dati, con estensioni per permettere ad alcuni tipi di nodi di mantenere e aggiornare uno stato persistente e per la ramificazione e le strutture di controllo del loop all’interno del grafico in maniera simile a Naiad (un sistema di flusso di dati tempestivo).” [1] Tipicamente gli utilizzatori costruiscono un grafico computazionale usando uno dei linguaggi di frontend supportati (C++ o Python). In un grafico TensorFlow, ogni nodo ha zero o più inputs e zero o più outputs, e rappresenta l’istanziazione di un’operazione. I valori che scorrono lungo i bordi nel grafico (da outputs a inputs) sono tensori, array multidimensionali dove il tipo dell’elemento sottostante è specificato o dedotto alla costruzione del grafico. “Possono esserci dei bordi speciali nel grafico detti control dependencies: in questi non avviene flusso di dati, ma indicano che il nodo sorgente per il controllo della dipendenza deve terminare l’esecuzione prima che il nodo destinazione per la dipendenza di controllo inizi l’esecuzione. “ [5] 3.1 Operazioni e Kernels Un’operazione ha un nome e rappresenta un’operazione astratta (es. “add”). Un’operazione può avere attributi, e tutti gli attributi devono provvedere o dedurre al momento della costruzione del grafico in ordine dall’istanziare un nodo a performare l’operazione. Un uso comune degli attributi è di fare operazioni polimorfe su tensori di tipi diversi (es. sommare due tensori di tipo float vs sommare due tensori di tipo int32). Un kernel è una particolare implementazione di un’operazione che può essere avviata in un particolare tipo di dispositivo (es. CPU o GPU). Un binario TensorFlow definisce l’insieme delle operazioni e dei kernels disponibili tramite un meccanismo di registrazione, e quest’insieme può essere esteso collegandolo in un’operazione aggiuntiva e/o alle definizioni/registrazioni del kernel.

10

3.2 Sessioni I programmi client interagiscono con il sistema TensorFlow creando una sessione. Per creare un grafico computazionale, l’interfaccia della sessione supporta un metodo Extend per aumentare il corrente grafico gestito dalla sessione con nodi e bordi aggiuntivi (il grafico iniziale, quando una sessione viene creata, è vuoto). L’altra operazione primaria supportata dall’interfaccia della sessione è Run, che prende un insieme di nomi di output che richiedono di essere calcolati, così come un insieme relativo a operazioni dei tensori da immettere nel grafico al posto di output certi dei nodi. Usando gli argomenti con Run, l’implementazione di TensorFlow può calcolare la chiusura transitiva di tutti i nodi che devono essere eseguiti in ordine per calcolare gli output richiesti, e può poi provvedere a eseguire i nodi appropriati in un ordine che rispetta le loro dipendenze.

11

3.3 Variabili In molte operazioni un grafico è eseguito molte volte. La maggior parte dei tensori non sopravvive dopo una singola esecuzione del grafico. Tuttavia, una variabile è un tipo speciale di operazione che ritorna un puntatore a un persistente tensore mutevole che sopravvive oltre le esecuzioni di un grafico. “I puntatori a questi persistenti tensori mutevoli può essere passata a una manciata di operazioni speciali, come Assign e AssignAdd (equivalente a +=) che cambia i tensori di riferimento.” [3] Per applicazioni di Machine Learning in TensorFlow, i parametri del modello sono tipicamente memorizzati in tensori tenuti in variabili, a sono aggiornati come una parte dell’operazione Run del grafico di training per il modello.

12

13

4 Implementazione I principali componenti in un sistema TensorFlow sono i client, che usano l’interfaccia della Sessione per comunicare con il Master, e uno o più Worker processes, responsabili di arbitrare l’accesso a uno o più dispositivi computazionali (come i core della CPU o le card della GPU) e per eseguire i nodi del grafico su quei dispositivi come incaricato dal master. Abbiamo sia l’implementazione locale che quella distribuita per l’interfaccia di TensorFlow. L’implementazione locale è usata quando il client, il master e il worker vengono eseguiti in una singola macchina nel contesto di un singolo processo del sistema operativo (possibilmente con più dispositivi, se per esempio, la macchina ha più GPU card installate). L’implementazione distribuita condivide la maggior parte del codice con l’implementazione locale, ma lo estende col supporto per un ambiente dove il client, il master e i workers possono essere tutti in differenti processi o differenti macchine. In un sistema distribuito, questi differenti tasks sono contenitori in compiti gestiti da un sistema di cluster scheduling.

4.1 Dispositivi I dispositivi sono il cuore computazionale di TensorFlow. Ogni worker è responsabile per uno o più dispositivi; ogni dispositivo ha un tipo e un nome. I nomi dei dispositivi sono composti da parti che identificano il tipo di dispositivo, l’indice del dispositivo nel worker, e, nel nostro ambiente distribuito, una identificazione del job e tasks del worker (o il localhost per il caso dove i dispositivi sono locali al processo). Esempi dei nomi dei dispositivi sono “/job:localhost/device:cpu:0” o “/job:worker/task:17/device:gpu:3”. Abbiamo l’implementazione dell’interfaccia del nostro dispositivo per le CPU e GPU, e la nuova implementazione del dispositivo per altri tipi di dispositivo possono essere fornite via meccanismo di registrazione. Ogni oggetto del dispositivo è responsabile della gestione dell’allocazione e deallocazione della memoria del dispositivo, e per l’organizzazione e esecuzione di qualsiasi kernel richiesto da livelli più alti nell’implementazione di TensorFlow.

4.2 Tensori Un tensore è un array multidimensionale tipato. Ci sono molte varietà di tipi di tensori,

14

inclusi gli interi con segno e senza segno che vanno da 8 bits a 64 bits, i tipi IEEE float e double, un tipo di numero complesso, e un tipo string (un array di byte arbitrari). “Il backing store della dimensione appropriata è gestito da un allocatore che è specifico per il dispositivo dove il tensore risiede. I buffers del backing store del tensore sono relazioni contate e sono deallocati quando non rimane nessuna relazione.” [3]

15

5 Esecuzione di un singolo dispositivo Consideriamo lo scenario di una semplice esecuzione: un singolo processo worker con un singolo dispositivo. I nodi del grafico sono eseguiti in un ordine che rispetta le dipendenze tra i nodi. In particolare, teniamo traccia di un conto per nodo del numero di dipendenze di quel nodo che non è ancora stato eseguito. Una volta che il conto arriva a zero, il nodo è idoneo per l’esecuzione ed è aggiunto in una coda. La coda è elaborata in ordine non specificato, delegando l’esecuzione del kernel per un nodo all’oggetto del dispositivo. Quando un nodo termina l’esecuzione, il conto di tutti i nodi che dipendono dal nodo completato viene decrementato.

16

17

6 Esecuzione di più dispositivi Quando un sistema ha più dispositivi, ci sono due complicazioni principali: decidere quale dispositivo farà il calcolo di ogni nodo nel grafico, e poi gestire la comunicazione richiesta dei dati attraverso il termine implicito del dispositivo da queste decisioni di collocamento.

6.1 Collocamento del nodo Dato un grafico computazionale, una delle principali responsabilità dell’implementazione di TensorFlow è di mappare le operazioni in un insieme di dispositivi disponibili. Un input dell’algoritmo di posizionamento è un modello di costo, che contiene stime della grandezza (in bytes) degli input e output dei tensori per ogni nodo del grafico, insieme con le stime del tempo di calcolo richiesto per ogni nodo quando presentato con i suoi tensori di input. Questo modello di costo è statisticamente stimato sulla base di euristiche associate con differenti tipi di operazione, o è misurato sulla base di un insieme di decisioni di collocamento per le esecuzioni precedenti del grafico. L’algoritmo di posizionamento prima esegue un’esecuzione simulata del grafico. La simulazione finisce scegliendo un dispositivo per ogni nodo del grafico usando le euristiche. Il nodo di posizionamento del dispositivo generato dalla simulazione viene utilizzato nel posizionamento anche nella reale esecuzione. L’algoritmo di posizionamento inizia con le fonti del grafico computazionale, e simula l’attività su ogni dispositivo nel sistema come progredisce. Per ogni nodo che viene raggiunto durante questo attraversamento, l’insieme di dispositivi realizzabili viene considerato (un dispositivo potrebbe non essere fattibile se il dispositivo non fornisce un kernel che implementa quella particolare operazione). Per i nodi con più dispositivi possibili, l’algoritmo di posizionamento usa un’euristica che esamina gli effetti sul tempo di completamento ponendo il nodo su ogni dispositivo possibile. Quest’euristica tiene conto del tempo di esecuzione stimato o misurato dell’operazione in quel tipo di dispositivo dal modello di costo, e include anche i costi di ogni comunicazione che sarebbero stati introdotti in ordine degli input trasmessi a questo nodo da altri dispositivi al dispositivo in esame. Il dispositivo dove l’operazione del nodo dovrebbe terminare è selezionato come dispositivo di quell’operazione, e il processo di posizionamento quindi continua poi a prendere decisioni di posizionamento per altri nodi del grafico, inclusi i nodi per i passi

18

successivi che sono ora pronti per la loro esecuzione simulata.

6.2 Comunicazione cross-device Una volta che è stata eseguito il posizionamento del nodo, il grafico viene diviso in un insieme di sottografi, uno per dispositivo. Qualsiasi bordo tra dispositivi da x a y è rimosso e rimpiazzato da un bordo da x a un nuovo nodo “Send” nel sottografo di x e un bordo da un nodo corrispondente “Receive” a y nel sottografo di y. In fase di esecuzione, le implementazioni dei nodi Send e Receive coordina il trasferimento dei dati tra dispositivi. Questo ci permette di isolare tutte le comunicazioni tra le implementazioni di Send e Receive, che semplifica il resto della fase di esecuzione. Quando inseriamo i nodi Send e Receive, indirizziamo tutti gli utenti di un particolare tensore su un particolare dispositivo per usare un singolo nodo Receive. Ciò che assicura che i dati per il tensore richiesto sono trasmessi solo una volta da un dispositivo sorgente -> coppia dispositivo destinazione, e che la memoria per il tensore nel dispositivo destinazione è allocata una sola volta, piuttosto che più volte. Per la gestione della comunicazione in questo modo, lasciamo lo scheduling dei nodi individuali del grafico a dispositivi differenti per decentralizzarli nei workers: i nodi Send e Receive distribuiscono la sincronizzazione necessaria tra i differenti workers e dispositivi, e il master ha solo bisogno di emettere una singola richiesta Run per l’esecuzione del grafico per ogni worker che ha tutti i nodi per il grafico, piuttosto che essere coinvolto nello scheduling di ogni nodo o ogni comunicazione cross-device. Questo rende il sistema molto più scalabile.

19

20

21

7 Esecuzione distribuita L’esecuzione distribuita su un grafico è molto simile all’esecuzione tra più dispositivi. Dopo il posizionamento del grafico, viene creato un sottografo per dispositivo. Le coppie di nodi Send/Receive che comunicano attraverso processi worker utilizzano meccanismi di comunicazione a distanza come TCP o RDMA per spostare dati oltre i confini della macchina.

7.1 Tolleranza agli errori I fallimenti in un’esecuzione distribuita possono essere rilevati in una varietà di impieghi. I principali ai quali ci affidiamo sono un errore nella comunicazione tra la coppia Send e Receive, e nel controllo periodico del corretto funzionamento dal processo master a ogni processo worker. Quando viene rilevato un guasto, l’intera esecuzione del grafico viene interrotta e riavviata da zero. Va ricordato tuttavia che i nodi della variabile si riferiscono ai tensori che persistono attraverso le esecuzioni del grafico. Manteniamo un checkpoint e un recupero per questo stato al riavvio. In particolare, ogni nodo Variable è collegato ad un nodo Save. Questi nodi Save sono eseguiti periodicamente, una volta ogni N iterazioni, o una volta ogni N secondi. Quando sono in esecuzione, i contenuti delle variabili vengono scritti nella memoria persistente, ad esempio, un file system distribuito. Allo stesso modo ogni Variable è collegata a un nodo Restore che è abilitato solo nella prima iterazione dopo un riavvio.

22

23

8 Estensioni

8.1 Calcolo del gradiente Molti algoritmi di ottimizzazione, tra cui i comuni algoritmi di training del machine learning come la discesa del gradiente probabilistico, calcolano il gradiente di una funzione di costo rispetto a un insieme di input. Poiché questo è un bisogno così comune, TensorFlow è dotato di un supporto per il calcolo automatico del gradiente. “Se un tensore C dipende da un grafico TensorFlow, forse attraverso un sottografo complesso di operazioni, su alcuni insiemi di tensori {Xk}, allora c’è una funzione incorporata che ritornerà i tensori {dC/dXk}.” [3] I tensori del gradiente sono calcolati, come gli altri tensori, estendendo il grafico TensorFlow, usando la seguente procedura. Quando TensorFlow deve calcolare il gradiente di un tensore C rispetto a qualche tensore I in cui C dipende, esso trova prima il percorso nel calcolo del grafico da I a C; Poi torna indietro da C a I, e per ogni operazione sul percorso all’indietro aggiunge un nodo al grafico TensorFlow, componendo i gradienti parziali lungo il percorso a ritroso con la regola della catena. Il nuovo nodo aggiunto calcola la funzione gradiente per l’operazione corrispondente nel percorso in avanti. Una funzione gradiente può essere registrata da qualsiasi operazione. Questa funzione prende come input non solo i gradienti parziali calcolati già lungo il percorso a ritroso, ma anche, eventualmente, gli input e output del calcolo in avanti. La figura 5 mostra i gradienti per un costo calcolato dall’esempio della figura 2. Le frecce grigie mostrano input potenziali a funzioni del gradiente che non vengono utilizzati per le particolari operazioni mostrate. L’aggiunta necesseria in figura 1 per calcolare questi gradienti è:

In generale un’operazione può avere più output, e C può dipendere solo da alcuni di essi. “Se, per esempio, l’operazione O ha due output y1 e y2, e C dipende solo da y2, allora il primo input della funzione gradiente di O è l’insieme da O a dC/dy1 = 0.” [3] Il calcolo automatico del gradiente complica l’ottimizzazione, in particolare l’uso della memoria. Quando eseguiamo l’operazione del sottografo in avanti, vale a dire, quelli costruiti esplicitamente dall’utente, un’euristica sensibile rompe i legami al momento di decidere quale nodo eseguire successivamente osservando l’ordine in cui è stato costruito il grafico. Ciò significa che le uscite temporanee sono consumate subito dopo

24

la costruzione, per cui la loro memoria può essere riutilizzata rapidamente. Quando l’euristica è inefficace, l’utente può cambiare l’ordine di costruzione del grafico, o aggiungere dipendenze di controllo. Quando i nodi del gradiente sono automaticamente aggiunti al grafico, l’utente ha meno controllo, e le euristiche possono abbattersi. In particolare, poiché i gradienti invertono l’ordine di calcolo in avanti, i tensori utilizzati nelle prime fasi dell’esecuzione del grafico sono spesso nuovamente necessari verso la fine del calcolo del gradiente. Tali tensori possono tenere su un sacco di memoria scarsa della GPU e limitare inutilmente la dimensione delle operazioni.

8.2 Esecuzione parziale Spesso un client vuole eseguire solo un sottografo dell’intero grafico di esecuzione. A sostegno di ciò, una volta che il cliente ha creato il grafico in una sessione, il metodo Run permette di eseguire un sottografo arbitrario dell’intero grafico, e di iniettare dati arbitrari su un qualsiasi bordo del grafico. Ogni nodo nel grafico ha un nome, e ciascun output di un nodo è identificato dal nome del nodo sorgente e la porta di output del nodo, numerata da 0 (es. “bar:0” si riferisci al primo output del nodo “bar”, mentre “bar:1” si riferisce al secondo output). I due argomenti della chiamata Run aiutano a definire l’esatto sottografo del grafico di calcolo che verrà eseguito. Per prima cosa, la chiamata Run accetta gli input, una mappatura opzionale dei nomi name:port ai valori dei tensori “alimentati”. Poi, la chiamata Run accetta output_names, una lista di specificazioni di output name[:port] indicando quali nodi dovrebbero essere eseguiti, e, se la porzione di porta è presente in un nome, quel particolare valore del tensore di output per il nodo dovrebbe ritornare al client se la chiamata Run conclude con successo. Il grafico si trasforma in base ai valori di input e output. “Ogni node:port specificato in input è sostituito con un “feed node”, che prenderà il previsto tensore di input da accessi appositamente inizializzati in un oggetto Rendezvous utilizzato per la chiamata Run.” [3] Analogamente, ciascun nome di output di una porta è collegata ad un nodo speciale fetch che organizza per salvare il tensore di uscita e restituirlo al client quando la chiamata Run è completa. Infine, una volta che il grafico è stato riscritto con l’inserimento di questi nodi speciali di feed e fetch, l’insieme dei nodi di esecuzione può essere determinata a partire da ciascuno dei nodi denominati da qualunque output e lavorando a ritroso nel grafico

25

usando le dipendenze del grafico per determinare l’intero insieme di nodi che devono essere eseguiti nel grafico riscritto in ordine per calcolare gli output. “La figura 6 mostra un grafico originale a sinistra e a fianco il grafico trasformato quando viene invocata Run con iputs=={b} e outputs=={f:0}.” [3] Dal momento che abbiamo solo bisogno di calcolare l’output del nodo f, non eseguiremo i nodi d ed e, poiché non hanno alcun contributo all’output di f.

8.3 Vincoli di dispositivo Gli utilizzatori di TensorFlow possono controllare il piazzamento dei nodi nei dispositivi tramite vincoli parziali per un nodo su quali dispositivi può essere eseguito. Per esempio “piazzare il nodo solamente in un dispositivo di tipo GPU”, oppure “questo nodo può essere piazzato su qualsiasi dispositivo in /job:worker/task:17”, o “collocare questo nodo con il nodo chiamato variable13”. Entro i confini di questi vincoli, l’algoritmo di posizionamento è responsabile per la scelta dell’assegnazione di nodi ai dispositivi ai quali fornisce una rapida esecuzione di calcolo e soddisfa anche vari vincoli imposti dai dispositivi stessi, ad esempio limitando la quantità totale di memoria necessaria su un dispositivo per eseguire il suo sottoinsieme di nodi del grafico. Tenere tali vincoli richiede modifiche all’algoritmo di posizionamento. Prima abbiamo calcolato la serie possibile di dispositivi per ogni nodo, e quindi usiamo la union-find sul grafico sulla collocazione di vincoli per calcolare i componenti del grafico che devono essere messi insieme. Per ciascuno di questi

26

componenti, calcoliamo l’intersezione di un insieme di dispositivi fattibili. L’insieme di dispositivi possibili calcolati per nodo si adatta facilmente al simulatore dell’algoritmo di posizionamento.

8.4 Flusso di controllo Anche se i grafici a flusso di dati senza alcun esplicito controllo del flusso sono abbastanza significativi, abbiamo osservato un numero di casi in cui il supporto di istruzioni condizionali e cicli può portare a rappresentazioni più concise ed efficienti di algoritmi di apprendimento automatico. In TensorFlow viene introdotto un piccolo insieme di controllo primitivo di operatori di flusso e viene generalizzato TensorFlow per gestire grafici a flusso di dati ciclici. “Gli operatori Switch e Merge ci permettono di saltare l’esecuzione di un intero sottografo in base ai valori di un tensore booleano. Gli operatori Enter, Leave e NextIteration permettono di esprimere l’iterazione. I costrutti della programmazione ad alto livello come if e while possono essere facilmente compilati nei grafici a flusso di dati con questi operatori di controllo del flusso. Il runtime TensorFlow implementa un concetto di tags e frames concettualmente simile alla macchina MIT TaggedToken.” [3] Ciascuna iterazione di un loop è unicamente identificata da un tag, e il suo stato di esecuzione è rappresentato da un frame. Un input può entrare in un’iterazione ogni volta che è disponibile; pertanto, più iterazioni possono essere eseguite in concomitanza. TensorFlow utilizza un meccanismo di coordinazione distribuita per eseguire grafici con flusso di controllo. In generale, un loop può contenere nodi che sono assegnati a molti dispositivi differenti. Pertanto, gestire lo stato di un loop diventa un problema. La soluzione di TensorFlow si basa sulla riscrittura del grafico. Durante il partizionamento del grafico, vengono aggiunti automaticamente nodi di controllo per ogni partizione. Questi nodi implementano una piccola macchina a stati che orchestra l’inizio e la fine di ogni iterazione, e decide la fine del loop. Per ogni iterazione, il dispositivo che possiede il predicato di terminazione del loop invia un piccolo messaggio di controllo per ogni dispositivo partecipante. Quando un modello comprende le operazioni di controllo del flusso, dobbiamo tenere conto di queste per il calcolo del gradiente corrispondente. Per esempio, il calcolo del gradiente per un modello con un if condizionale avrà bisogno di sapere quale ramo dell’istruzione condizionale è stato preso, quindi applica la logica del gradiente a questo ramo. Allo stesso modo, il calcolo del gradiente per un modello con un ciclo while avrà bisogno

27

di sapere quante iterazioni impiegare, e farà anche affidamento sui valori intermedi calcolati in quelle iterazioni. La tecnica di base è riscrivere il grafico in modo da memorizzare i valori necessari per il calcolo del gradiente.

8.5 Operazioni di input Anche se i dati in input possono essere forniti a un calcolo tramite i nodi di feed, un altro meccanismo comune utilizzato per i modelli di apprendimento automatico su larga scala è quello di avere particolari nodi di calcolo dell’input, che in genere sono configurati con una serie di filenames e che producono un tensore contenente uno o più esempi dai dati memorizzati in quell’insieme di files ogni volta che vengono eseguiti. Ciò consente ai dati di essere letti direttamente dal sistema di storage sottostante nella memoria della macchina che eseguirà la successiva elaborazione dei dati. Nelle configurazioni dove il client è separato dal processo worker, se i dati erano elaborati, tipicamente richiede un salto di rete in più (dal sistema di storage per il client e poi dal client al worker vs. direttamente dal sistema di storage al worker quando si utilizzata un nodo di input).

8.6 Code Le code sono una caratteristica utile in TensorFlow. Esse consentono di eseguire in modo asincrono diverse parti del grafico, possibilmente a differenti ritmi, e di portare fuori dati attraverso operazioni di Enqueue e Dequeue. Operazioni di Enqueue possono bloccare fino a quando lo spazio diventa disponibile nella coda, e le operazioni di Dequeue possono bloccare fino a quando un numero minimo di elementi è disponibile nella coda. Un uso delle code è quello di consentire i dati di input da precaricare a files su disco mentre una serie precedente di dati sono ancora in fase di elaborazione dalla porzione di calcolo di un modello di apprendimento automatico. Possono essere utilizzate anche per altri tipi di raggruppamento, compresi l’accumulare più gradienti in ordine per calcolare alcune più complesse combinazioni di gradienti su una quantità più grande, o per raggruppare differenti frasi di input per modelli di linguaggio ricorrenti in contenitori di frasi che sono approssimativamente della stessa lunghezza, che possono essere processati in modo più efficiente. Oltre alle normali code FIFO, è stata implementata anche una coda di rimescolamento, che

28

mescola in modo casuale gli elementi all’interno di un buffer di grandi dimensioni in memoria. La funzione di rimescolamento casuale è utile per gli algoritmi di apprendimento automatico.

8.7 Contenitori Un contenitore è il meccanismo in TensorFlow per la gestione dello stato mutevole che dura di più. L’archivio di backup per una variabile vive in un contenitore. Il contenitore di default è quello che persiste fino a quando il processo termina. Un contenitore può essere azzerato cancellando tutto il suo contenuto. Utilizzando i contenitori è possibile condividere lo stato attraverso grafici di calcolo completamente disgiunti associati a differenti sessioni.

29

9 Ottimizzazione

9.1 Eliminazione della sotto espressione comune Poiché la costruzione dei grafici di calcolo è spesso fatta da molti differenti strati di astrazione nel codice client, il grafico di calcolo può facilmente finire con copie ridondanti dello stesso calcolo. Per gestire questa situazione, è stata implementata una sotto espressione comune che va sopra il grafico di calcolo e canonizza più copie di operazioni con input identici e tipi di operazioni a solamente un nodo dei nodi, e rindirizza i bordi del grafico in modo appropriato per riflettere questa canonizzazione.

9.2 Controllo della comunicazione dei dati e utilizzo della memoria Lo scheduling accurato delle operazioni in TensorFlow può risultare in una migliore performance del sistema, in particolare per quanto riguarda i trasferimenti di dati e l’utilizzo della memoria. In particolare, lo scheduling può ridurre il tempo durante il quale i risultati intermedi devono essere tenuti in memoria tra operazioni e quindi il consumo del picco di memoria. Questa riduzione è particolarmente importante per dispositivi GPU dove la memoria è scarsa. Inoltre, orchestrando la comunicazione di dati tra dispositivi in grado di ridurre la contesa per le risorse di rete. Mentre ci sono molte opportunità per l’ottimizzazione dello scheduling, ci concentriamo su ciò che è particolarmente necessario ed efficace. Riguarda lo scheduling dei nodi Receive per leggere valori remoti. Se non si sono prese precauzioni, questi nodi possono iniziare molto prima del necessario, possibilmente tutti in una volta quando parte l’esecuzione. Eseguendo il calcolo ASAP/ALAP (as-soon-as-possible/as-late-as-possibile), del tipo comune nella ricerca delle operazioni, analizziamo i percorsi critici dei grafici, al fine di stimare quando partono i nodi Receive. Vengono inseriti dei bordi di controllo con l’obiettivo di ritardare l’inizio di questi nodi fino a poco prima che i loro risultati sono necessari.

9.3 Kernel asincroni Oltre ai normali kernel sincroni che completano la loro esecuzione alla fine del metodo Compute, sono supportati anche kernel non bloccanti. Come i kernel non bloccanti

30

utilizzano un’interfaccia leggermente diversa per cui il metodo Compute è passato in seguito e invocato quando l’esecuzione del kernel è completo. Si tratta di una ottimizzazione per gli ambienti in cui avere molti thread attivi è relativamente costoso in termini di utilizzo della memoria o di altre risorse e ci permettere di evitare di legare un thread di esecuzione per periodi illimitati di tempo in attesa di I/O o altri eventi che si verifichino. Esempi di kernels includono il kernel Receive, e i kernels Enqueue e Dequeue (che potrebbe essere necessario bloccare se lo spazio della coda non è disponibile o se non sono disponibili dati da leggere, rispettivamente). 9.4 Librerie ottimizzate per le implementazioni del kernel “Si fa uso di preesistenti librerie numeriche ottimizzate per implementare i kernel per alcune operazioni. Per esempio, ci sono una serie di librerie ottimizzate per eseguire matrici moltiplicate in differenti dispositivi, inclusi BLAS e cuBLAS, o librerie GPU per i kernel convoluzionali per reti neurali profonde come CUDA-convnet e cuDNN. Molte implementazioni del kernel sono relativamente sottili involucri intorno a tali librerie ottimizzate. Si fa uso della libreria dell’algebra lineare open-source Elgen per molte implementazioni del kernel nel sistema. Come una parte dello sviluppo di TensorFlow, il team di sviluppo ha esteso la libreria Elgen con il supporto per le operazioni sui tensori di dimensione arbitraria.” [3]

9.5 Compressione con perdita Alcuni algoritmi di apprendimento automatico, compresi quelli tipicamente utilizzati per la formazione di reti neurali, sono tolleranti al rumore e la precisione aritmetica ridotta. In modo analogo al sistema DistBelief, che utilizza spesso la compressione con perdita di rappresentazioni interne con maggiore precisione per l’invio di dati tra dispositivi (a volte all’interno della stessa macchina, ma soprattutto attraverso i confini della macchina). Per esempio, spesso vengono inserite conversioni speciali dei nodi che convertono le rappresentazioni in virgola mobile a 32 bit in rappresentazioni in virgola mobile a 16 bit (non il proposto standard IEEE 16 bit floating point standard, ma piuttosto un formato 32 bit IEEE 794 float, ma con 16 bits con meno precisione nella mantissa), e poi riconvertire una rappresentazione a 32 bit sull’altro lato del canale di comunicazione (semplicemente compilando in zeri per la porzione perduta della mantissa, dato che è meno costoso computazionalmente che fare l’arrotondamento

31

probabilistico matematicamente corretto quando si da questa conversione 32 -> 16 -> 32 bit).

32

33

10 Stato ed esperienza L’interfaccia di TensorFlow e un’implementazione di riferimento sono open source sotto la licenza Apache 2.0, e il sistema è disponibile per il download a www.tensorflow.org. Il sistema include documentazione dettagliata, un numero di tutorials, e un numero di esempi che dimostra come utilizzare il sistema per una varietà di diversi tasks di apprendimento automatico. Il sistema include front-ends per la specifica dei calcoli TensorFlow in Python e C++. Ci sono un bel paio di modelli di apprendimento automatico in DistBelief che sono stati migrati in TensorFlow. Quindi, in questa sezione, tratteremo lezioni imparate generalizzabili per la migrazione di modelli di apprendimento automatico da un sistema all’altro. In particolare vedremo Inception (rete neurale convenzionale per il riconoscimento di immagini). Questo sistema di riconoscimento di immagini classifica immagini da 224x224 pixel in un'unica su 1000 etichette (es. “camion della nettezza urbana” etc…). Tale modello comprende 13,6 milioni di parametri apprendibili e 36,000 operazioni espresse come grafico TensorFlow. L’esecuzione di inferenza su una singola immagine richiede 2 miliardi di operazioni di “multiply-add” (moltiplicazione dei primi due inputs, a e b, e somma del risultato col terzo, c). Dopo la costruzione di tutte le operazioni matematiche in TensorFlow, l’assemblaggio e il debug di tutte le 36,000 operazioni nella struttura corretta del grafico risulta problematico. Convalidare la correttezza è un’impresa difficile perché il sistema è intrinsicamente stocastico e destinato a comportarsi in un certo modo in attesa – potenzialmente dopo due ore di calcoli. Date queste circostanze ci sono delle strategie fondamentali per il porting del modello Inception in TensorFlow: 1 – Costruire strumenti al fine di conoscere il numero esatto di parametri in un determinato modello. Tali strumenti hanno dimostrato sottili difetti in una complessa architettura di rete specifica. In particolare si è riusciti a individuare le operazioni e le variabili istanziate in modo non corretto. 2 – Partire dal basso e scalare. La prima rete neurale convoluzionale portata dal precedente sistema era una piccola rete impiegata sul set di dati CIFAR-10.

34

3 – Assicurarsi sempre che l’obiettivo (funzione loss) corrisponde tra sistemi di apprendimento automatico quando l’apprendimento è spento. Impostando la velocità di apprendimento a zero ha aiutato a identificare un comportamento imprevisto nel modo in cui erano inizializzate a random le variabili in un modello. Tale errore sarebbe stato difficile identificarlo in una rete di training dinamica. 4 – Fare un match dell’implementazione di una singola macchina prima di debuggare un’implementazione distribuita. Questa strategia ha aiutato a delineare e debuggare le discrepanze. Nelle performance di training tra sistemi di apprendimento automatico. In particolare, sono stati identificati i bugs. 5 – Guardia contro errori numerici. Le librerie numeriche sono incoerenti nel modo in cui gestiscono i valori in virgola mobile. Le reti neurali convoluzionali sono particolarmente suscettibili all’instabilità numerica e tenderà a divergere abbastanza regolarmente durante le fasi di sperimentazione e di debug. A guardia contro questo comportamento, controllando i valori in virgola mobile, permette di rilevare gli errori in tempo reale rispetto a identificare il comportamento divergente post-hoc. 6 – Analizzare pezzi di una rete e capire la grandezza dell’errore numerico. L’esecuzione di sottosezioni della rete neurale in parallelo su due sistemi di apprendimento automatico fornisce un metodo preciso per garantire che un algoritmo numerico è identico per due sistemi. Dato che tali algoritmi eseguono con precisione in virgola mobile, è importante predirre e capire la grandezza dell’errore numerico previsto al fine di giudicare se un dato componente è correttamente implementato. Convalidare complesse operazioni matematiche in presenza di un sistema stocastico è molto impegnativo. Le strategie delineate in precedenza hanno dimostrato di rivelarsi preziose nel guadagnare fiducia nel sistema e infine nell’istanziare il modello Inception in TensorFlow. Il risultato finale di questi sforzi ha determinato un

35

miglioramento della velocità di 6 volte in tempi di training vs l’implementazione esistente DistBelief del modello e tali guadagni di velocità si sono dimostrati indispensabili nella formazione di una nuova classe di modelli di riconoscimento di immagini su larga scala.

36

37

11 Idiomi di programmazione comuni Il modello di grafico a flusso di base di dati di TensorFlow può essere utilizzato in una varietà di modi per applicazioni di apprendimento automatico. Un dominio che interessa è accelerare la formazione di modelli computazionalmente intensivi di reti neurali su grandi datasets. In questa sezione si descrivono tecniche realizzate dal team TensorFlow e altri al fine di realizzare ciò, e illustra come utilizzare TensorFlow per realizzare questi diversi approcci. Gli approcci in questa sottosezione assumono che il modello è stato addestrato con discesa del gradiente stocastico (SGD) con mini-lotti relativamente di modeste dimensioni da 100 a 1000 esempi.

11.1 Training di dati parallelo “Una semplice tecnica per accellerare SGD è di parallelizzare il calcolo del gradiente per un mini-lotto attraverso elementi del mini-lotto. Per esempio, se stiamo utilizzando una dimensione di mini-lotto di 1000 elementi, possiamo usare 10 repliche del modello per ogni calcolo del gradiente per 100 elementi, e poi combina i gradienti e applica aggiornamenti ai parametri in modo sincrono, al fine di comportarsi esattamente come se stessimo eseguendo l’algoritmo sequenziale SGD con una grandezza del lotto di 1000 elementi. In questo caso, il grafico TensorFlow ha semplicemente molte repliche della porzione del grafico che fa la quantità del modello di calcolo, e un singolo thread client guida l’intero ciclo di training di questo grande grafico. Ciò è illustrato nella porzione superiore della figura 7.” [3]

38

Questo approccio può essere fatto anche asincrono, dove il grafico TensorFlow ha molte repliche della porzione del grafico che fa la quantità del modello di calcolo, e ciascuna di queste repliche applica anche gli aggiornamenti dei parametri ai parametri del modello in modo asincrono. In questa configurazione, c’è un thread client per ciascuna delle repliche del grafico. Questo è illustrato nella parte inferiore della figura 7.

11.2 Modello di training parallelo Il modello di training parallelo, dove diverse porzioni del modello di calcolo sono fatti su diversi dispositivi computazionali contemporaneamente per lo stesso lotto di esempi; è facile da esprimere in TensorFlow. La figura 8 mostra un esempio di un ricorrente, modello profondo LSTM usato per apprendimento sequenza per sequenza, parallelizzata in tre dispositivi differenti.

39

11.3 Passi simultanei per il modello di calcolo Pipelining Un altro modo comune per ottenere un migliore utilizzo per il training delle reti neurali profonde è quello di pipeline il calcolo del modello entro gli stessi dispositivi, eseguendo un piccolo numero di passi simultanei all’interno dello stesso insieme di dispositivi. Questo è mostrato in figura 9.

È in qualche modo simile al parallelismo asincrono dei dati, eccetto che il parallelismo avviene all’interno dello stesso dispositivo/dispositivi, piuttosto che replicare il grafico di calcolo su diversi dispositivi. Questo permette di “riempire i vuoti” in cui il calcolo

40

di un singolo lotto di esempi potrebbe non essere in grado di utilizzare pienamente il parallelismo totale su tutti i dispositivi in ogni momento durante un singolo passo.

41

12 Tools

12.1 TensorBoard: Visualizzazione delle strutture del grafico e statistiche riassuntive

Al fine di aiutare gli utenti a comprendere la struttura dei loro grafici di calcolo e anche per capire il comportamento generale di modelli di apprendimento automatico, è stato costruito TensorBoard, uno strumento di visualizzazione per TensorFlow. 12.1.1 Visualizzazione del grafico di calcolo Molti dei grafici di calcolo di reti neurali profonde possono essere molto complessi. Ad esempio, il grafico di calcolo per il training di un modello simile al modello Inception di Google, una profonda rete neurale convoluzionale che ha avuto “the best classification performance” nel contest ImageNet 2014, ha più di 36.000 nodi nel suo grafico di calcolo TensorFlow e alcuni modelli profondi ricorrenti LSTM per il modellismo del linguaggio ha più di 15.000 nodi. A causa delle dimensioni e della topologia di questi grafici le ingenue tecniche di visualizzazione producono diagrammi disordinati. Per aiutare gli utenti a vedere la sottostante organizzazione dei grafici, gli algoritmi in TensorBoard collassano i nodi in blocchi di alto livello, mettendo in evidenza gruppi con strutture identiche. Il sistema separa anche i nodi di alto grado, che spesso svolgono funzioni di compatibilità in una zona separata dello schermo. In questo modo si riduce l’ingombro visivo e si focalizza l’attenzione sulle sezioni principali del grafico di calcolo. L’intera visualizzazione è interattiva: gli utenti possono fare una panoramica, zoomare e espandere i nodi raggruppati scavando a fondo per i dettagli. Un esempio di visualizzazione per il grafico di un’immagine del modello convulazionale profondo è mostrato in figura 10.

42

12.1.2 Visualizzazione dei dati di sintesi Quando si formano modelli di apprendimento automatico, gli utenti spesso vogliono essere in grado di esaminare lo stato dei vari aspetti del modello, e come questo i vari cambiamenti di stato nel corso del tempo. A tal fine, TensorFlow supporta una raccolta di diverse operazioni di sintesi che possono essere inserite nel grafico, compresi riassunti scalari (ad esempio, per esaminare le proprietà generali del modello, come il valore della funzione loss mediati attraverso una raccolta di esempi, o il tempo necessario per eseguire il grafico di calcolo), riassunti basati su istogrammi (ad esempio, la distribuzione dei valori di peso in un livello di rete neurale), o riassunti basati su immagini (ad esempio, una visualizzazione dei pesi dei filtri appresi in una rete neurale convoluzionale). Tipicamente i grafici di calcolo sono impostati in modo che i nodi di sintesi vengano inclusi per monitorare vari valori interessanti, e ogni tanto durante l’esecuzione del grafico di training, l’insieme dei nodi di sintesi vengono eseguiti, in aggiunta alla normale serie di nodi che vengono eseguiti, e il programma driver del client scrive i dati di sintesi in un file log associato con il training del modello. Il programma TensorBoard è quindi configurato per vedere questo file log per i nuovi record di sintesi, e in grado di visualizzare le informazioni di riepilogo e come cambia nel tempo (con la possibilità di selezionare la misura del “tempo” per

43

essere relativo al “wall time” dall’inizio dell’esecuzione del programma TensorFlow, tempo assoluto, o “steps”, una misura numerica del numero di esecuzioni del grafico che si sono verificate dopo l’inizio dell’esecuzione del programma TensorFlow). Una schermata di visualizzazione dei valori di sintesi in TensorBoard è mostrata in figura 11.

44

45

13 Tracciato di esecuzione C’è uno strumento interno chiamato EEG (non incluso nella versione open source iniziale del mese di novembre, 2015) usato per raccogliere e visualizzare le informazioni a grana molto fine su l’ordinamento e le caratteristiche di esecuzione dei grafici TensorFlow. Questo strumento funziona sia nelle singole macchine che nelle implementazioni distribuite ed è molto utile per comprendere i colli di bottiglia nei modelli di calcolo e di comunicazione di un programma TensorFlow. “Le tracce vengono raccolte simultaneamente su ogni macchina nel sistema da una varietà di fonti, tra cui il kernel Linux ftrace, gli strumenti di tracciamento e CUPTI. Con questi registri possiamo ricostruire l’esecuzione di un passo di formazione distribuito con dettagli a livello di microsecondo di ogni thread-switch, il lancio del kernel CUDA e il funzionamento DMA.” [3] Le tracce sono combinate in un server di visualizzazione che è destinato per estrarre rapidamente eventi in una determinato TimeRange e di sintetizzare a adeguato livello di dettaglio la risoluzione di interfaccia utente. Eventuali ritardi significativi a causa di comunicazione, sincronizzazione o gli stalli di DMA correlato sono identificate e evidenziate con frecce nella visualizzazione. Inizialmente l’interfaccia utente fornisce una panoramica dell’intera traccia con solo le più significanti prestazioni evidenziate. Come l’utente zooma progressivamente, sono resi sempre più dettagli. La figura 12 mostra una visualizzazione EEG di un modello che viene formato in una piattaforma CPU multi-core.

46

La parte superiore della schermata mostra le operazioni in TensorFlow spedite in parallelo, secondo i vincoli di flusso di dati. La sezione inferiore del tracciato mostra come la maggior parte delle operazioni sono decomposte in più elementi di lavoro eseguiti contemporaneamente in un pool di thread. La figura 13 mostra un’altra visualizzazione EEG dove il calcolo avviene principalmente sulla CPU. I thread dell’host possono essere visti come operazioni TensorFlow della GPU di accodamento man mano che diventano eseguibili (la luce blu dei thread pool, cioè insieme di risorse che possono essere riutilizzate), e thread di pulizia in background possono essere visti in altri colori in fase di migrazione attraverso core del processore. Ancora una volta, le frecce indicano dove i thread sono in stallo su GPU per i trasferimenti della CPU, o dove gli ops sperimentano un significativo ritardo di code.

Infine, la figura 14 mostra una vista più dettagliata che ci permette di esaminare come gli operatori TensorFlow della GPU vengono assegnati a più flussi della GPU. Ogni volta che il grafico dataflow consente l’esecuzione parallela o il trasferimento di dati si cerca di esporre i vincoli di ordinazione al dispositivo GPU utilizzando flussi e primitive di dipendenza del flusso.

47

48

49

14 Esempi È un sistema di programmazione dove i calcoli vengono rappresentati da grafici. I nodi del grafico sono chiamati ops (abbreviazione di “operations”). Un op prende zero o più Tensors (tensori), effettua i calcoli, e produce zero o più Tensors. Un tensore è un tipo di array multi-dimensionale. Un grafico in TensorFlow è una descrizione di calcoli. Per il calcolo, il grafico dev’essere lanciato in una Session (sessione). Una Session piazza gli ops del grafico in dispositivi e provvede metodi per eseguirli. I programmi TensorFlow sono sempre strutturati in una fase di costruzione, che assembla un grafico, e una fase di esecuzione che usa una sessione per eseguire gli ops nel grafico. TensorFlow può essere usato in programmi in C, C++ e Python. Per lanciare un grafico occorre creare un oggetto Session. Senza argomenti il costruttore della sessione lancia il grafico di default. Il linguaggio utilizzato negli esempi sottostanti è Python con annesse librerie.

14.1 Hello,Tensorflow! Qui di seguito, il classico “Hello World” in TensorFlow:

50

Inizialmente si importa l’API, si crea la costante (op), cioè il nodo che viene aggiunto al grafico di default. Successivamente si fa partire la sessione e infine si avvia il grafico.

14.2 Semplicioperazioni14.2.1 Moltiplicazionetraduevariabili

Qui, invece vi è una moltiplicazione tra due variabili di tipo float. Si creano le variabili meta sintattiche di tipo float e la variabile risultante dalla moltiplicazione delle due tramite l’operazione mul. Infine si crea una sessione per valutare l’espressione simbolica e quindi poter dare come output il risultato della moltiplicazione con differenti valori tramite il costrutto sess.run, che fa partire la sessione, e quindi svolge l’espressione con i parametri per a e b assegnati tramite il costrutto feed_dict.

14.3 RegressioneLineare

51

“La regressione lineare è una tecnica statistica che misura la relazione tra le variabili. Nel caso di due variabili (regressione semplice) e il caso di più di due variabili (regressione multipla), la regressione lineare modella la relazione tra una variabile dipendente, variabili indipendenti xi e un termine casuale b. In questo caso la

52

regressione lineare è semplice, cioè y = W * x + b.” [4] Prima di tutto, importiamo il package Numpy che useremo per generare punti. Abbiamo punti generati dal rapporto y = 0.1 * x + 0.3 , anche se con qualche variazione, con una distribuzione normale, in modo che i punti non corrispondano completamente a una linea. Il punto successivo è quello di formare l’algoritmo per ottenere i valori di uscita y, definiti sulla base dei dati x_data. In questo caso, sappiamo già da prima che è una regressione lineare, possiamo rappresentare il modello con solo due parametri: W e b. L’obiettivo è di generare un codice TensorFlow che permette di individuare i migliori parametri W e b, che dai dati di input x_data, aggiunti ai dati di output y_data, nel nostro caso sarà una linea retta definita da y_data = W * x_data + b. Il lettore sa che W dovrebbe essere vicino a 0.1 e b per 0.3, ma TensorFlow non lo sa e deve realizzarlo da sé. Un metodo standard per risolvere tali problemi è quello di far scorrere ogni valore della serie di dati e modificare i parametri W e b al fine di ottenere una risposta più precisa ogni volta. “Per scoprire se stiamo migliorando in queste iterazioni, definiamo una funzione di costo che misura quanto “buona” una certa linea è. Questa funzione riceve la coppia W e come parametri b e restituisce un valore di errore in base a quanto bene la linea si adatta ai dati. Con l’errore quadratico medio otteniamo la media degli “errori” in base alla distanza tra il valore reale e quello stimato in ogni iterazione dell’algoritmo. Con le variabili definite, possiamo esprimere la funzione di costo in base alla distanza tra ciascun punto e il punto calcolato con la funzione y = W * x + b. Dopo di che, si può calcolare il quadrato e la media della somma.” [2] Quindi usiamo un’espressione che calcola la media delle distanze quadrate tra il punto y_data che conosciamo e il punto y calcolato dall’input x_data. Se riduciamo al minimo la funzione di errore troveremo il modello migliore per i nostri dati. L’algoritmo di discesa lungo il gradiente è un algoritmo che data una funzione definita da una serie di parametri, si inizia con una prima serie di valori di parametri e iterativamente muove verso un insieme di valori che minimizzano la funzione. È convenzionale quadrare la distanza per garantire che sia positivo e per rendere la funzione di errore derivabile per calcolare il gradiente. L’algoritmo inizia con i valori iniziali di un insieme di parametri (nel nostro caso W e b), e quindi l’algoritmo regola iterativamente il valore di tali variabili in modo che, alla fine del processo, i valori delle variabili minimizzano la funzione di costo. Poi, iniziamo il processo iterativo che ci permetterà di trovare i valori di W e b sino a che il modello raggiunge un modello di precisione desiderato sui dati. Possiamo vedere la linea definita dai parametri W = 0.0854 e b = 0.299 con otto iterazioni:

53

54

55

15 Conclusioni Abbiamo descritto TensorFlow, un modello di programmazione sensibile basato sul flusso di dati, sia su singola macchina che in implementazioni distribuite di questo modello di programmazione. Il sistema è utilizzato nell’attività di ricerca e distribuzione di più di cento progetti di apprendimento automatico per una vasta gamma di prodotti e servizi Google. C’è una versione Open Source di TensorFlow e si spera che il numero di utilizzatori cresca e contribuisca sempre di più allo sviluppo.

56

57

Ringraziamenti Ringraziomiamadre,miopadre,Fabio,Valeria,Pierpaolo,ManueleeRosina.

58

59

Riferimenti bibliografici [1] JordiTorres,“FirstcontactwithTensorFlow–Part1:Basics”,10/02/2016,

http://www.jorditorres.org/wp-content/uploads/2016/02/FirstContactWithTensorFlow.part1_.pdf,16/10/2016

[2] JordiTorres,“FirstcontactwithTensorFlow”,10/02/2016,

http://www.jorditorres.org/first-contact-with-tensorflow/,29/10/2016[3]Mart´ınAbadi,AshishAgarwal,PaulBarham,EugeneBrevdo,ZhifengChen,CraigCitro,

GregS.Corrado,AndyDavis,JeffreyDean,MatthieuDevin,SanjayGhemawat,IanGoodfellow,AndrewHarp,GeoffreyIrving,MichaelIsard,YangqingJia,RafalJozefowicz,LukaszKaiser,ManjunathKudlur,JoshLevenberg,DanMane,RajatMonga,SherryMoore,DerekMurray,´ChrisOlah,MikeSchuster,JonathonShlens,BenoitSteiner,IlyaSutskever,KunalTalwar,PaulTucker,VincentVanhoucke,VijayVasudevan,FernandaViegas,OriolVinyals,´PeteWarden,MartinWattenberg,MartinWicke,YuanYu,andXiaoqiangZheng,“TensorFlow:Large-ScaleMachineLearningonHeterogeneousDistributedSystems”,09/11/2015,http://download.tensorflow.org/paper/whitepaper2015.pdf,20/10/2016

[4] S.n,“IntroductiontoTensorFlow”,2015,http://flarecast.eu/wp-

content/uploads/2015/04/TensoFlow.pdf,17/10/2016[5] TensorFlowTM,“BasicUsage”,09/11/2015,

https://www.tensorflow.org/versions/r0.11/get_started/basic_usage.html,15/10/2016[6]Wikipedia,“Apprendimentoautomatico”,06/09/2016,

https://it.wikipedia.org/wiki/Apprendimento_automatico,25/10/2016[7]Wikipedia,“Apprendimentoapprofondito”,06/10/2016,

https://it.wikipedia.org/wiki/Apprendimento_approfondito,26/10/2016[8]Wikipedia,“IntelligenzaArtificiale”,04/11/2016,

https://it.wikipedia.org/wiki/Intelligenza_artificiale,04/11/2016