IMPLEMENTAZIONE PARALLELA SU GPU DI RETI NEURALI ARTIFICIALI EVOLUTIVE PARALLEL GPU-BASED IMPLEMENTATION OF EVOLUTIONARY ARTIFICIAL NEURAL NETWORKS

UNIVERSITÀ DEGLI STUDI DI PARMA FACOLTÀ DI INGEGNERIA CORSO DI LAUREA IN INGEGNERIA INFORMATICA IMPLEMENTAZIONE PARALLELA SU GPU DI RETI NEURALI ARTIFICIALI EVOLUTIVE PARALLEL GPU-BASED IMPLEMENTATION OF EVOLUTIONARY ARTIFICIAL NEURAL NETWORKS Relatore: Chiar.mo Prof. S. Cagnoni Candidato: Luca Donati ANNO ACCADEMICO 2009 2010

Per prima cosa vorrei ringraziare il mio relatore, Stefano Cagnoni, che ha saputo motivare il mio interesse per il corso da lui insegnato ed è stato una guida importante in questo lavoro di tesi. Un ringraziamento va alla mia famiglia, che ha contribuito in maniera fondamentale al raggiungimento di questo traguardo. Un ringraziamento speciale a Moira, che ha condiviso con me il percorso di questa tesi, mostrandone interesse notevole, nonostante l argomento trattato. Un grande ringraziamento a Marco Giuberti, importantissimo per il suo esempio nel mondo dell università e del lavoro. Grazie anche a tutti i miei amici, Fabio Cartagini, Filippo Ferri, Nicolò Moretti, Michael Riccò, Elisa Tovoli ed Elisa Trombi, che in questi anni hanno condiviso gioie e dolori della carriera universitaria. Un grazie a tutti i colleghi universitari che sono rimasti in circolazione durante la laurea specialistica, Andrea Benassi, Fabio Cavazzini e Federico Soliani. Infine, un caloroso grazie ad un prezioso collega, e direi quasi amico, Roberto Ugolotti. La sua disponibilità e competenza, anche cinematografica, si sono rivelate fondamentali in questi anni di studio ed in questa tesi. Genio.

Indice Introduzione 1 1 Soft computing 3 1.1 Le reti neurali artificiali......................... 4 1.2 La logica fuzzy............................. 5 1.3 Calcolo evoluzionistico......................... 6 1.4 Swarm Intelligence........................... 7 1.5 Vantaggi del Soft Computing...................... 9 2 Reti neurali 11 2.1 Il neurone................................ 12 2.2 Topologie................................ 14 2.2.1 Reti FeedForward a strati.................... 15 2.2.2 Reti FeedForward generiche.................. 17 2.2.3 Reti ricorsive.......................... 18 2.3 Addestramento............................. 20 2.3.1 Apprendimento supervisionato................. 20 2.3.2 Apprendimento non supervisionato.............. 22 2.3.3 Apprendimento per rinforzo.................. 24 2.3.4 Ulteriori considerazioni sull apprendimento.......... 24 3 Algoritmi evolutivi 27 3.1 Applicazione degli algoritmi evolutivi alle ANN............ 29 3.1.1 Evoluzione dei pesi....................... 29 iii

Indice iv 3.1.2 Evoluzione delle architetture.................. 30 3.1.3 Evoluzione dei parametri.................... 30 3.2 Approcci all evoluzione delle architetture............... 31 3.2.1 Lo schema di codifica diretta.................. 31 3.2.2 Lo schema di codifica indiretta................. 34 4 CUDA 36 4.1 Architettura di una GPU e considerazioni............... 38 4.2 Programmazione............................ 39 4.2.1 Kernel.............................. 40 4.2.2 Thread............................. 41 4.2.3 Warp.............................. 42 4.2.4 Blocco............................. 45 4.2.5 Shared memory......................... 48 4.2.6 Device memory......................... 48 4.3 CUBLAS................................ 49 5 Implementazione parallela su GPU di Reti Neurali Evolutive 51 5.1 La progettazione............................ 52 5.1.1 La classe FeedForwardNN................... 54 5.1.2 La classe LearningSet..................... 57 5.1.3 La classe FeedForwardNNTrainer............... 58 5.2 L implementazione su CPU....................... 58 5.2.1 Implementazione di FeedForwardNN............ 59 5.2.2 Implementazione di LearningSet............... 64 5.2.3 Implementazione di FeedForwardNNTrainer........ 65 traincpubp....................... 67 traincpubatch..................... 72 5.3 Implementazione su GPU-CUDA................... 73 traingpubatch..................... 79 5.4 La progettazione dell algoritmo genetico................ 81 5.4.1 La classe FloatChromosome.................. 82

Indice v 5.4.2 La classe GAFeedForwardNN................. 83 5.5 L implementazione dell algoritmo genetico.............. 83 5.5.1 Implementazione di FloatChromosome........... 83 5.5.2 Implementazione di GAFeedForwardNN.......... 84 5.6 GUI - Graphic User Interface...................... 88 6 Risultati Sperimentali 92 6.1 Benchmark 1 - Classificazione di segnali stradali........... 92 6.2 Benchmark 2 - Problema mushroom di FANN............ 97 6.3 Benchmark 3 - BCW.......................... 98 6.4 Esecuzione dell Algoritmo Genetico.................. 99 7 Conclusioni 103 A Backpropagation 105 Bibliografia 107

Elenco delle figure 1.1 Porzione di rete neurale......................... 4 2.1 Neurone artificiale........................... 13 2.2 Funzione sigmoidale.......................... 14 2.3 Generica rete neurale.......................... 14 2.4 Rete neurale di tipo FeedForward a strati................ 15 2.5 Esempio del funzionamento di una rete di tipo FeedForward..... 17 2.6 Generica rete neurale di tipo FeedForward............... 18 2.7 Rete FeedForward generata dalle connessioni in Tabella 2.1...... 19 2.8 Rete ricorsiva generata dalle connessioni in Tabella 2.2........ 19 2.9 Apprendimento supervisionato per reti neurali............. 21 2.10 Generica SOM, detta anche Mappa di Kohonen............ 23 3.1 Un esempio di due tipologie comuni di crossover........... 28 3.2 Esempio di rete ricorsiva da tradurre in genoma............ 32 4.1 Raffronto della capacità computazionale tra CPU e GPU....... 37 4.2 Raffronto della larghezza di banda tra CPU e GPU.......... 37 4.3 Raffronto tra il modello teorico di una CPU e quello di una GPU... 38 5.1 Esempio di una generica porzione di rete dotata di neuroni di bias.. 53 5.2 Rete corrispondente al file del Listato 5.1............... 56 5.3 Rete di esempio per la backpropagation................ 75 5.4 Esempio di passo in avanti della backpropagation standard...... 76 5.5 Esempio di passo in avanti della backpropagation batch........ 76 vi

Elenco delle figure vii 5.6 Interfaccia della GUI realizzata..................... 90 5.7 Esempio di un addestramento eseguito sul BCW problem....... 91 6.1 Benchmark su CPU di una rete con numero variabile di neuroni dello strato intermedio............................ 96 6.2 Benchmark su GPU di una rete con numero variabile di neuroni dello strato intermedio............................ 96 6.3 Benchmark comparativi CPU-GPU di una rete con numero variabile di neuroni dello strato intermedio.................... 97

Elenco delle tabelle 2.1 Matrice dei pesi di una rete FeedForward generica........... 18 2.2 Matrice dei pesi di una rete ricorsiva.................. 19 3.1 Matrice delle connessioni relativa alla rete in Figura 3.2........ 32 3.2 Matrice delle connessioni e dei pesi di una generica rete ricorrente.. 33 6.1 Benchmark su 1000 epoche della rete 2500x150x90x30........ 93 6.2 Benchmark su 1000 epoche della rete 2500x150x90x30, con report intermedi ogni 10 epoche........................ 94 6.3 Benchmark su 10000 epoche della rete 2500x150x90x30, con report intermedi ogni 10 epoche........................ 94 6.4 Benchmark su 100 epoche di reti con diverse topologie........ 95 6.5 Benchmark su 100 epoche di reti con diverse topologie e report intermedi ogni epoca............................. 95 6.6 Benchmark su 1000 epoche di reti con diverse topologie....... 95 6.7 Benchmark su 1000 epoche di reti con diverse topologie e report intermedi ogni 10 epoche.......................... 95 6.8 Benchmark su 1000 epoche di reti con diverse topologie e report intermedi ogni 10 epoche.......................... 98 6.9 Benchmark su 10000 epoche di reti con diverse topologie....... 99 6.10 Confronto con i risultati di alcune ricerche............... 99 viii

Introduzione Lo scopo di questa tesi è stato realizzare un ambiente integrato per il soft computing parallelo su GPU e, in particolare, un pacchetto software in grado di progettare ed addestrare reti neurali artificiali in parallelo sfruttando la potenza di calcolo offerta dalle schede grafiche NVIDIA. Una caratteristica delle schede grafiche, rispetto ai processori tradizionali, è la possibilità di eseguire calcoli paralleli, anziché un singolo processo sequenziale. Inoltre, la loro architettura garantisce prestazioni ben più alte rispetto ad una classica CPU, a patto di sfruttare correttamente quelle operazioni che realizzano in modo più efficiente. L implementazione parallela, e la conseguente velocità di esecuzione degli algoritmi su scheda video, possono essere essenziali nell applicazione di molte tecniche di soft computing, in particolare le reti neurali artificiali. Le reti neurali artificiali sono infatti strutture di calcolo distribuite, composte da molte unità elementari che, tramite il loro calcolo congiunto, riescono a svolgere od approssimare funzioni molto complesse. Nel corso degli anni sono state sfruttate per diverse applicazioni, dalla visione artificiale, alla diagnosi di malattie, al controllo di robot. Per imparare a svolgere queste funzioni, però, la rete neurale deve essere addestrata tramite un opportuno algoritmo, detto di apprendimento. Questa è la fase più lenta e difficile per quanto riguarda il loro utilizzo. A seconda del problema trattato possono essere necessarie ore od addirittura giorni per insegnare alla rete un determinato comportamento. Uno degli algoritmi di apprendimento più utilizzati è l algoritmo di backpropagation, e permette, a partire da alcuni esempi di un comportamento corretto, di insegnare 1

Introduzione 2 alla rete a replicare lo stesso comportamento, rendendola però anche capace di generalizzare quanto appreso, ovvero di applicarlo correttamente anche a casi ed esempi mai visti prima. Il progetto si propone di implementare alcuni di questi algoritmi di apprendimento, e di aumentarne significativamente la velocità di esecuzione sfruttando i vantaggi derivanti dalla potenza di calcolo delle schede video e dalla natura intrinsecamente parallela delle reti neurali. Le reti neurali sono infatti strutture parallele, in quanto formate da molti neuroni, ciascuno dei quali opera in gran parte autonomamente. Inoltre, questa tesi si propone anche di esplorare una possibile integrazione tra reti neurali artificiali e algoritmi evolutivi. Gli algoritmi evolutivi sono un settore del soft computing che studia fenomeni evolutivi naturali, come lo sviluppo di nuove generazioni nelle popolazioni di esseri viventi, e cerca di copiarne e sfruttarne i principi, al fine di evolvere individui che rappresentino soluzioni sempre migliori ad un determinato problema. In particolare, nel progetto si sono applicati questi algoritmi allo sviluppo di reti neurali, evolvendo popolazioni di queste reti e cercando di ottenere strutture ottime sia per efficienza che per efficacia. Questo processo si svolge attraverso la generazione di successive popolazioni di reti neurali, partendo di volta in volta dalle migliori della generazione precedente, accoppiandole e mutandole per ottenere nuovi individui, e quindi reti, migliori dei precedenti. Questo permette di facilitare ulteriormente il compito allo sviluppatore di reti neurali, che può limitarsi alla sola impostazione delle caratteristiche basilari dell algoritmo evolutivo. Lo stesso algoritmo, poi, opererà autonomamente sulle popolazioni di reti, selezionando le migliori per ottenerne di ancora più performanti, riuscendo a giungere a risultati utili e reti valide in un tempo ragionevole e senza alcun vincolo o necessità di conoscenza a priori sul problema da trattare. Il progetto si propone quindi, anche attraverso un interfaccia grafica dedicata, di realizzare un ambiente software facile da usare ed estensibile, in grado implementare vari algoritmi di soft computing ed in particolare quelli che riguardano lo sviluppo e l addestramento di reti neurali artificiali.

Capitolo 1 Soft computing Il cosiddetto soft computing è un area di studio recente all interno dell informatica, essendo nata nei primi anni 90. Prima di allora, l approccio predominante alla soluzione dei problemi ingegneristici era di tipo esatto. Il sistema su cui operare era completamente definito, e si cercava di implementare su di esso un algoritmo deterministico, in grado di risolvere con precisione il problema presentato. Quest approccio matematico e analitico può essere molto efficace, ma non sempre applicabile col crescere della complessità dei problemi da risolvere. Infatti, lavorando in campi come la medicina, la biologia, l interazione con l essere umano, risulta spesso impossibile arrivare a metodi esatti, in quanto il sistema studiato risulta essere per gran parte imprevedibile all analista che può basarsi solo su un insieme limitato di nozioni scientifiche. Per risolvere queste situazioni è entrato in gioco il soft computing, ovvero un approccio morbido alla soluzione dei problemi. I metodi di soft computing sono stati definiti per operare in situazioni di incertezza, approssimazioni, verità parziali e imprecisione. Al contrario dell approccio hard, un metodo di tipo soft cerca di trovare una soluzione accettabile senza però prevedere e gestire tutti i possibili avvenimenti con metodo esatto. Un metodo soft cerca, con varie metodologie, di trovare una soluzione approssimata e a basso costo, ma robusta, a un problema troppo difficile per la metodologia tradizionale di approccio ai problemi. Più formalmente, cerca di risolvere problemi NP-completi trovandone una soluzione approssimata, ma ottenuta in tempo polinomiale. 3

Capitolo 1. Soft computing 4 Il soft computing si è sviluppato in diverse direzioni, tra le quali possiamo citare: le reti neurali (NN) la logica fuzzy il calcolo evoluzionistico la cosiddetta swarm intelligence 1.1 Le reti neurali artificiali L idea alla base delle reti neurali artificiali è creare una struttura connettiva simile a quella di un cervello biologico. Come per quest ultimo, sono presenti una serie di neuroni connessi tra loro, in grado, tramite il loro funzionamento congiunto, di produrre capacità cognitiva. Dal punto di vista computazionale, le operazioni svolta da ogni singolo neurone sono elementari. Tuttavia l unione di una massiccia quantità di elementi intelligenti riesce a formare una rete in grado di svolgere funzioni anche molto complesse. Figura 1.1: Porzione di rete neurale La rete è implementata in modo da adattarsi gradualmente all ambiente in cui si trova, proprio come un cervello biologico, in modo da imparare ad agirvi correttamente e secondo le specifiche volute dal suo creatore. Questo avviene utilizzando algoritmi

Capitolo 1. Soft computing 5 detti di apprendimento. Durante questo processo, il progettista non avrà un completo controllo su tutta la rete. Non riconoscerà l utilità di ogni singolo neurone o gruppo di neuroni. Semplicemente, osserverà che, nel tempo, l intera rete si comporterà via via meglio sul determinato problema. A seconda della complessità del problema, difficilmente la rete riuscirà a raggiungere un funzionamento corretto in tutti i casi. Tuttavia riuscirà, nel tempo, ad ottenere risultati sempre migliori, fino ad arrivare ad una buona od ottima approssimazione del funzionamento voluto, che sarebbe stata impossibile, o molto difficile e dispendiosa da raggiungere, usando approcci tradizionali. 1.2 La logica fuzzy La logica fuzzy è un estensione della classica booleana, che ha però la particolarità di non essere composta solo da affermazioni vere e affermazioni false, ma di permettere gradi intermedi tra queste. Ad esempio definendo valori come parzialmente vero o parzialmente falso. Interpretando la logica booleana assegnando vero = 1 e f also = 0, la logica fuzzy ammette anche tutto il range di valori tra 0 ed 1 come valori accettabili. In realtà, per ogni variabile definita in logica fuzzy, viene anche definito un cosiddetto fuzzy set, ovvero un elenco discreto dei valori che la variabile può assumere. Ad esempio, la temperatura dell acqua all interno di una caldaia può essere fredda o bollente. Questi sono i valori limite (vero o falso in logica booleana). Tra di essi però possono esserne definiti altri a seconda della temperatura dell acqua, come fresca, tiepida, calda. L insieme di tutti questi valori fuzzy compone appunto il fuzzy set della nostra variabile. A questo punto, dopo avere dichiarato tutta una serie di variabili fuzzy si possono formare regole fuzzy alle quali il sistema deve sottostare. Si tratta di semplici quesiti logici del tutto analoghi a quelli della logica booleana, però definiti in modo diverso. Ad esempio tramite la semplice regola del Listato 1.1 è possibile controllare la temperatura all interno di una caldaia riscaldando l acqua quando questa si raffredda. Infatti quando l acqua si avvicina alla temperatura fresca il riscaldamento verrà im-

Capitolo 1. Soft computing 6 Listato 1.1: Esempio di regola fuzzy IF t e m p e r a t u r a acqua IS f r e s c a THEN i n t e n s i t à r i s c a l d a m e n t o IS media postato ad un intensità media. E da notare che la logica fuzzy non associa questi valori ( fredda, fresca, tiepida, calda, bollente ) a soglie rigide, oltre le quali attivare la regola. Invece valuta ciascuna regola e verifica quanto si attivi. L acqua alla temperatura fresca è in realtà simile all acqua alla temperatura fredda, così come all acqua alla temperatura tiepida. In questo modo anche se l acqua è solo tiepida, la regola 1.1 può comunque attivarsi, impostando il riscaldamento non a livello medio, ma magari leggero o ad un valore intermedio tra i due. Il valore di output della logica fuzzy (come nel caso precedente medio ) è decodificato con un procedimento chiamato defuzzificazione al fine di renderlo effettivamente utilizzabile per controllare il sistema a cui è connesso, che può essere in logica binaria o analogica. In realtà la maggioranza dei sistemi fuzzy prevede una serie di regole fuzzy che concorrono a controllare l attuatore, a seconda di quanto le rispettive regole siano attivate. Questo può portare a realizzare sistemi di decisione potenti ed efficaci. A tal proposito sono stati anche definiti operatori analoghi a quelli classici booleani di AND, OR e NOT. Solitamente l AND restituisce il minore dei valori di attivazione tra le proposizioni. L OR invece il maggiore tra di esse. Il NOT, se il fuzzy set è mappato ad esempio tra 0 ed 1, restituisce 1 meno il valore della variabile stessa. 1.3 Calcolo evoluzionistico Questo campo del Soft Computing comprende algoritmi ispirati all evoluzione naturale per cercare una soluzione ad un problema non risolvibile con tecniche tradizionali, o risolvibile ma con sforzo computazionale molto intenso. Un algoritmo evolutivo prevede la creazione di una popolazione di individui ognuno rappresentanti una soluzione al problema, che concorrono o cooperano al raggiungimento della soluzione

Capitolo 1. Soft computing 7 ottimale al problema proposto. Questo può avvenire tramite successivi miglioramenti o ampliamenti della popolazione. Più in dettaglio, viene simulata l evoluzione di una popolazione biologica, guidata da una serie di regole che possono essere di tipo Darwiniano o Lamarckiano. L algoritmo evolutivo più diffuso, è denominato Algoritmo Genetico (Genetic Algorithm - GA). Questo algoritmo genera inizialmente una popolazione di individui (soluzioni al problema) in modo da campionare in modo soddisfacente lo spazio di tutte le soluzioni ammissibili. Successivamente, valuta una funzione di fitness per ciascuno di essi. Questa funzione definisce quanto quella specifica soluzione (individuo) è buona, e si avvicina a quella ideale. Valutato ciascun individuo inizia una fase di selezione, durante la quale i migliori di essi hanno più probabilità di essere scelti. Gli individui migliori sopravvivono, mentre quelli inferiori vengono eliminati. Inoltre gli individui migliori possono accoppiarsi tra loro per formare nuovi individui che in parte mantengono le caratteristiche dei genitori, in parte ne introducono delle nuove, frutto di combinazione dei geni paterni o di mutazioni. Questo fino ad ottenere una popolazione di una certa dimensione, che forma la generazione successiva. L algoritmo, quindi, ad ogni iterazione genera una nuova popolazione, che tende ad essere migliore della precedente. Continuando in questo modo si potrà esplorare in modo selettivo lo spazio delle soluzioni al nostro problema, basandosi un metodo che è stato provato essere efficace (da milioni di anni di evoluzione naturale). L algoritmo viene arrestato quando si sarà trovata una soluzione reputata abbastanza buona per il nostro problema o quando si avrà esplorato a sufficienza lo spazio delle soluzioni ammissibili. 1.4 Swarm Intelligence Questa tecnica, che potrebbe essere vista come una variante del calcolo evoluzionistico, basa anch essa i propri fondamenti sull osservazione di fenomeni biologici e naturali, come l intelligenza condivisa tra i membri di uno sciame di animali. Osservando infatti il comportamento di colonie di formiche o stormi di uccelli alla ricerca di cibo, si sono notati dei pattern o degli schemi che questi seguivano. Pur non avendo

Capitolo 1. Soft computing 8 una conoscenza completa dell ambiente nel quale si muovono, i singoli elementi di uno sciame sono in grado di orientarsi e spostarsi assieme in modo ben più efficace che singolarmente. Questo non solo per la quantità di elementi in gioco, ma anche per la capacità di comunicare tra di essi informazioni importanti sui migliori percorsi verso la meta (cibo o altro). Le formiche, ad esempio, vagano casualmente per un ambiente alla ricerca di cibo. Quando una formica trova del cibo, lo raccoglie e comincia a trasportarlo verso la tana. Lungo il percorso rilascia del feromone che rimane sul terreno per un certo lasso di tempo, fino ad evaporare. Successivamente, se altre formiche passano sul tratto di strada ricoperto dal feromone, saranno attratte da questo, e inizieranno a seguirne il percorso fino al cibo deponendone altro. Quindi, si verifica uno scambio di informazione utile tra gli elementi della colonia. Inoltre, c è un ulteriore possibilità fornita dall evaporazione naturale del feromone. Se più formiche trovano percorsi diversi verso il cibo, torneranno alla tana lasciando la scia di feromone che attrarrà altre formiche. Tuttavia, il feromone rilasciato dalla formica che ha compiuto il percorso più lungo, tende ad evaporare maggiormente. Quindi, le successive formiche che passeranno per la zona saranno più attratte dal percorso più ricco di feromone, ovvero quello più corto. Col passare del tempo il percorso più lungo sarà via via meno utilizzato, fino ad essere abbandonato del tutto in favore di quello più corto. Le formiche in questo modo trovano una soluzione ottimale al problema del cammino più corto verso la meta. Questo comportamento naturale è stato preso d esempio per realizzare un algoritmo di ricerca dei percorsi all interno dei grafi, chiamato appunto Ant Colony Optimization (ACO). Un altro algoritmo studiato e implementato con successo è la Particle Swarm Optimization (PSO). Questo algoritmo si ispira alle regole che governano il volo degli stormi di uccelli alla ricerca di cibo. Questi esplorano una zona di territorio muovendosi in parte autonomamente alla caccia di prede, in parte controllando se i vicini abbiano trovato zone redditizie. Quindi si influenzano l un l altro pur mantenendo una certa indipendenza. Lo stormo quindi si muove nello spazio, ma anche non in modo uniforme e può contrarsi o allargarsi a seconda della zona esplorata. Questo viene implementato nell algoritmo come un insieme di particelle che esplorano lo spazio delle

Capitolo 1. Soft computing 9 possibili soluzioni muovendosi a partire da una certa posizione e velocità iniziali. Ad ogni iterazione, mutano la loro direzione e velocità seguendo in parte le proprie valutazioni, in parte quelle degli elementi vicini o dell intero sciame. Le particelle, quindi, esploreranno autonomamente tutto lo spazio delle soluzioni convergendo verso una soluzione ottima o sub-ottima. 1.5 Vantaggi del Soft Computing Il soft computing, come già accennato, è particolarmente efficace in condizioni di incertezza, verità parziali o situazioni troppo complesse per essere gestite con un metodo esatto. In aggiunta a questi pregi, si possono notare altre caratteristiche che rendono il soft computing così attraente. In primo luogo è riscontrabile una miglior resistenza al rumore rispetto a metodi più tradizionali. Quando un metodo esatto viene applicato a sistemi influenzati da rumore esterno non prevedibile, l algoritmo può fallire senza trovare alcuna soluzione, o trovarne una pessima. Per quanto riguarda il soft computing, invece, questo troverà comunque una soluzione, magari alterata da questo rumore, ma comunque accettabile e tra le migliori per un sistema in quelle condizioni. Pensiamo ad esempio ad una funzione, per la quale esista un metodo esatto per trovare il minimo assoluto. In presenza di rumore, magari non stazionario e non derivabile, sommato alla funzione, l algoritmo esatto potrebbe persino non essere applicabile, o fallire. Invece, un algoritmo evolutivo, troverebbe agevolmente dei buoni minimi locali, e si avvicinerebbe molto a quello globale. Il soft computing può lavorare bene su spazi di ricerca molto difficili per le tecniche tradizionali. Un algoritmo evolutivo, ad esempio, come descritto da Yao [23], può trovare buone soluzioni su superfici non limitate, discrete, discontinue e non derivabili, complesse e rumorose, ingannevoli e multimodali. Un altra preziosa caratteristica dei metodi soft computing è la capacità di generalizzare. Questi sistemi infatti sono in grado, a partire da una base limitata di nozioni o di esempi, di arrivare ad una visione più ampia del problema e delle soluzioni (appunto di generalizzare ), fino a comportarsi correttamente in un grande numero di casi, anche non previsti dal progettista. Per esempio, una rete neurale potrebbe essere adde-

Capitolo 1. Soft computing 10 strata a riconoscere la presenza o meno di un automobile all interno di un immagine. Questo potrebbe essere utile in un sistema di guida assistita. Ebbene, durante l addestramento alla rete verranno sottoposti alcuni esempi selezionati di vetture, e questa autonomamente imparerà a riconoscere vetture di ogni tipo, anche mai viste prima. Questo avviene non imparando a memoria ma intuendo la regola generale che sta sotto la visione di un auto. Infine, una delle proprietà che rende il soft computing affidabile è la fault-tolerance, tolleranza ai guasti, che lo caratterizza. In un modello tradizionale, se viene meno una parte del sistema, o un parametro è erroneamente elaborato dall algoritmo, questo può causare il fallimento di tutto il metodo. Invece le strutture soft computing sono molto più elastiche, in parte per la già citata tolleranza al rumore, in parte per le topologie utilizzate. Pensiamo ad esempio ad una rete neurale con migliaia di neuroni implementati in hardware. Un danno ad una manciata di neuroni, o un calcolo errato svolto da questi, influenzerà il sistema in modo ridotto, non pregiudicando eccessivamente la qualità della soluzione. In un algoritmo di PSO l intrappolamento di una particella in un minimo locale, o l assegnazione ad essa di valori fuori scala, pregiudicheranno il solo comportamento di quella particella, e non dell intero sistema, che continuerà a comportarsi nel modo corretto.

Capitolo 2 Reti neurali Le Reti neurali artificiali costituiscono un modello topologico adatto a rappresentare i collegamenti tra elementi semplici in grado di compiere operazioni banali che formano una struttura non lineare in grado di esibire qualche forma di intelligenza, ovvero di apprendere e realizzare/approssimare una funzione desiderata. Alla base del modello è la simulazione di una rete di neuroni biologici. Il cervello umano, ad esempio, è composto da una grande quantità di neuroni (decine di miliardi) connessi tra loro tramite un enorme quantità di interconnessioni, chiamate sinapsi (migliaia per ogni neurone). Ricevendo gli impulsi provenienti dai nervi presenti in tutto il corpo, questi neuroni vengono sollecitati, e seguendo alcune regole, si possono attivare, propagando ai neuroni a cui sono collegati un ulteriore impulso, che anch essi valuteranno, per poi attivarsi a loro volta. Tutte queste possibilità di attivazione formano la complessità del cervello umano. Alcuni di questi neuroni, poi, trasmettono i loro impulsi al sistema nervoso e ai muscoli, realizzando da funzioni fisiologiche semplici come la respirazione, fino a quelle più complesse come l articolazione della parola. L interconnessione di tutti questi neuroni consente di produrre la coscienza, la conoscenza e gli istinti vitali dell uomo. Le reti neurali artificiali (NN o ANN) cercano di riprodurre queste strutture formalizzando i due elementi costitutivi dei modelli biologici: i neuroni e le connessioni tra di essi. Il neurone viene visto come un nodo in grado di ricevere input e produrre output, che forma una rete connettendosi con gli altri nodi. Le topologie teorizzate per 11

Capitolo 2. Reti neurali 12 simulare un cervello sono molte, e verranno discusse in seguito. La cosa che interessa per ora notare è che le reti neurali che andremo a trattare sono di dimensioni assai ridotte rispetto a quelle biologiche, in particolare quelle presenti nel cervello umano, il cui effettivo funzionamento rimane per molti aspetti uno dei più grandi misteri ancora da esplorare completamente. In questa sede possiamo però definire cosa rende così interessanti queste strutture, che in realtà sembrerebbero soltanto calcolatori paralleli. La particolarità più importante delle reti neurali artificiali è, al pari di una rete biologica, la capacità di apprendere un determinato comportamento, tramite esempi espliciti o addirittura autonomamente dagli stimoli sensoriali. Sono stati infatti proposti, e validati nel tempo, numerosi algoritmi, detti algoritmi di apprendimento, in grado di insegnare ad una rete neurale qualche tipo di comportamento da seguire. Di conseguenza si potrà utilizzare la rete neurale così addestrata per svolgere compiti quali riconoscere oggetti o controllare macchinari, diagnosticare malattie e molto altro ancora. 2.1 Il neurone Il principale elemento alla base di ogni rete neurale è il neurone, solitamente presente in gran numero nella rete e collegati con gli altri in vario modo. È quindi importante definirne subito il funzionamento per comprendere quello della rete complessiva. Il funzionamento di un generico neurone artificiale è così riassumibile (Figura 2.1): riceve in ingresso una serie di input da altri neuroni o dall esterno ne calcola una somma pesata, in cui è data più o meno importanza a ciascuna connessione (quindi a ciascun input) sul valore risultante applica una funzione non lineare (che eventualmente presenta un valore di soglia soglia fissa) il valore di questa funzione è l output del neurone stesso.

Capitolo 2. Reti neurali 13 input x 1 pesi w i1 somma funzione di attivazione x 2 w i2 output y i x 3 w i3. i x n w i n soglia Figura 2.1: Neurone artificiale Questo si può descrivere nella forma: ( n ) y i = f i w i j x j θ i j=1 (2.1) dove y i è l output del neurone i, f i è la funzione non lineare applicata alla somma pesata degli ingressi x j. La variabile w i j rappresenta il peso della connessione tra il nodo i ed il nodo j della rete. θ i è invece una soglia di attivazione per il neurone stesso (o bias). Con questa struttura di base è possibile costruire reti di complessità e topologia arbitrarie. Quello che resta da fare è definire delle connessioni tra i neuroni ed assegnare a ciascuna di esse un peso. Proprio questi pesi, come vedremo in seguito, codificheranno gran parte della capacità cognitiva della rete. Per quanto riguarda la funzione non lineare utilizzata si può scegliere tra un elevato numero di soluzioni alternative. Il modello originario del Percettrone prevedeva una funzione a gradino. Recentemente una delle funzioni più utilizzate è la sigmoide, eventualmente traslata (tangente iperbolica), la quale realizza l espressione: f (x) = 1 1 + e x (2.2)

Capitolo 2. Reti neurali 14 ed è visualizzabile come un gradino continuo e smussato (e derivabile) (Fig.2.2). Come vedremo questo risulterà molto utile nella fase di addestramento. Figura 2.2: Funzione sigmoidale 2.2 Topologie Definiti questi elementi del modello si può iniziare a parlare delle differenti architetture che sono state teorizzate e implementate per formare la rete a partire dai suoi nodi e dalle sue connessioni. Innanzitutto un elemento comune a gran parte delle reti neurali artificiali è disporre un certo numero n di ingressi e da un certo numero m di uscite, come si vede nella Figura 2.3. Gli ingressi riceveranno valori (stimoli) dall esterno e le uscite produrranno valori utilizzabili all esterno. Quindi, per convenzione, si defi- i 1 i 2 o 1 o 2.. NN o m i n Figura 2.3: Generica rete neurale

Capitolo 2. Reti neurali 15 niranno un numero n di neuroni detti neuroni di ingresso e un numero m di neuroni di uscita. Tutti gli altri neuroni che si andranno eventualmente ad inserire saranno detti neuroni nascosti perché non saranno direttamente connessi all ambiente esterno. Questi saranno ovviamente in quantità N n m, se N è il numero totale dei neuroni della rete artificiale. A partire da queste principali definizioni le reti possono essere classificate sulla base delle topologie che realizzano. 2.2.1 Reti FeedForward a strati Una delle topologie più comuni è quella della rete FeedForward a strati (layers). Sostanzialmente i neuroni vengono suddivisi in layers, assegnando ciascun neurone ad uno e un solo layer. I layers dovranno essere almeno due, cioè quello di ingresso e quello di uscita. Ogni layer addizionale viene detto hidden layer, ovvero strato nascosto, perché non accessibile dall esterno. La particolarità di questa topologia è che l uscita di ciascun neurone può essere connessa solamente a neuroni del layer immediatamente successivo nella lista degli strati (FeedForward). Ovvero i neuroni di input potranno essere connessi solamente ai neuroni del primo strato nascosto, quelli del primo strato nascosto solo a quelli del secondo, e così via sino allo strato di uscita. Questo è rappresentato in Figura 2.4. Nella figura si può notare che ogni neurone di uno strato i 1 Input Layer Hidden Layers Output Layer i 2 o 1...... o 2 o m i n Figura 2.4: Rete neurale di tipo FeedForward a strati

Capitolo 2. Reti neurali 16 è collegato a tutti i neuroni dello strato successivo. Questa è la struttura più comune e uniforme, detta rete completamente connessa. In realtà ogni neurone può avere un numero arbitrario di connessioni verso singoli neuroni dello strato successivo, anche soltanto una o nessuna. Questa tipologia di rete ha diversi pregi, e qualche difetto. Il pregio principale è la semplicità di definizione e di realizzazione. Infatti per definire una rete di questo tipo basta dichiarare le quantità di neuroni presenti in ciascuno strato ed, eventualmente (in caso di reti non completamente connesse), le connessioni tra di essi. Per quanto riguarda la realizzazione si può subito notare che l architettura è facilmente computabile in parallelo. Infatti per calcolare i valori dei neuroni di uno strato si possono eseguire in parallelo le somme dei soli neuroni dello strato precedente e il calcolo delle funzioni di attivazione. Questo però non va a discapito della capacità prestazionale di questo tipo di topologia. Infatti come già riportato da Lippmann [11] e dimostrato da Lorentz [12], una rete neurale di tipo FeedForward con 2 hidden layers e k(2k +1) neuroni è in grado di calcolare qualunque funzione continua di k variabili, a patto di essere in grado di determinare i pesi corretti e le corrette funzioni di attivazione tramite un algoritmo di apprendimento. Tra i difetti di questa topologia, per definizione, vi è quello di non potere creare strutture con retroazione tra i neuroni, mentre, logicamente, può avere senso che vi siano uno o più rami di feedback tra i nodi. Questo in realtà potrebbe essere un limite solo a seconda dell algoritmo usato per l addestramento, cosa che verrà discussa successivamente. Una cosa che si può notare, e che varrà anche per le altre topologie, è che i neuroni dello strato di ingresso svolgono la sommatoria di un solo valore: appunto il valore di ingresso. Per questo quasi sempre lo strato d ingresso è soltanto virtuale. Lo strato d ingresso quindi modifica solo il numero di ingressi della rete, ma i corrispondenti neuroni non calcolano alcuna funzione, passando il loro valore direttamente al layer successivo. Un esempio molto semplice del funzionamento di una rete FeedForward con due ingressi ed un uscita è quello in Figura 2.5.

Capitolo 2. Reti neurali 17 input output 2 0.3 0.75 5 0.1 Figura 2.5: Esempio del funzionamento di una rete di tipo FeedForward con due input ed un output. All ingresso della rete si presentano i due input: 2 e 5. Questi vengono moltiplicati per il peso della propria connessione, quindi 2 0.3 = 0.6 e 5 0.1 = 0.5. I due valori vengono sommati (0.6 + 0.5 = 1.1) e sulla somma si calcola la funzione sigmoidale f (1.1) = 1/(1 + e 1.1 ) = 0.75. Quindi l output della rete sarà 0.75. 2.2.2 Reti FeedForward generiche La topologia FeedForward può anche essere implementata senza considerare la presenza di strati. Anche in questa architettura sono presenti n neuroni d ingresso e m neuroni d uscita. Tuttavia i neuroni non sono raggruppati per layer ma semplicemente numerati in ordine crescente, come una lista o un vettore. L unica limitazione tra le connessioni è che un neurone si possa collegare solo ad uno o più neuroni con indice maggiore del proprio, e mai minore. Quindi supponendo che vi siano N neuroni, l i esimo neurone potrà collegarsi al j esimo solo se i < j. Anche in questa topologia è possibile realizzare la piena connessione. Ogni neurone i sarà collegato a tutti i neuroni ad esso successivo: i + 1, i + 2, i + 3,... N (Figura 2.6). Unica regola aggiuntiva è che gli input non siano collegati tra loro, in quanto, come detto prima, sono nodi puramente virtuali. È evidente che questo tipo di topologia aumenterà in maniera quadratica il numero delle connessioni, che potranno diventare dell ordine di N 2. Questo è insieme il punto di forza e di debolezza della topologia. Da un lato permette di inserire connessioni che potrebbero avere significato a seconda del problema trattato e dell algoritmo di apprendimento. Dall altro però rende molto più complessa la descrizione della rete e lenti l esecuzione e l addestramento. Una particolarità interessante di questo tipo di topologia è che le connessioni ed eventualmente i loro pesi possono essere rappresentati

Capitolo 2. Reti neurali 18 n inputs......... 1 n n+1 N-m-1 N-m N m outputs Figura 2.6: Generica rete neurale di tipo FeedForward mediante una matrice triangolare superiore usando come indici i neuroni di partenza e quelli di arrivo, come in Tabella 2.1 1 2 3 4 5 1 - - 0.6-0.5 2 - - 0.1-0.6-0.3 3 - - - -0.4 0.9 4 - - - - -0.3 5 - - - - - Tabella 2.1: Matrice dei pesi di una rete FeedForward generica Considerando i come indice di riga e j come indice di colonna si può risalire a quanto vale il peso della connessione corrispondente w i j e conoscere quindi la completa topologia della rete. In caso un valore manchi dalla tabella (come nei casi w 12 e w 14 ), o che sia nullo, il collegamento tra i due neuroni non esiste. La Figura 2.7 mostra la topologia derivante da questa rappresentazione. 2.2.3 Reti ricorsive L ultima limitazione che si può togliere alle topologie di reti neurali già trattate è quella di non ammettere feedback. Le reti neurali ricorsive possono invece avere qualunque

Capitolo 2. Reti neurali 19 input 1 2 0.6 0.5 0.1-0.3-0.6-0.4 3 4 0.9-0.3 5 output Figura 2.7: Rete FeedForward generata dalle connessioni in Tabella 2.1. tipo di connessione tra i neuroni (tranne collegamenti fra neuroni d ingresso, come detto). Anche in questo caso si può avere un numero di connessioni dell ordine di N 2, ma al contrario delle reti FeedForward il calcolo dell output risulta assai più complesso, in quanto ora non tutti i calcoli possono essere svolti in maniera sequenziale, ma bisogna tenere anche conto dei feedback della rete. Anche per questa topologia di rete si può definire una matrice che ne rappresenti le connessioni come quelle delle reti FeedForward generiche. Tuttavia in questo caso la matrice non sarà più triangolare superiore, ma rettangolare completa. 1 2 3 1-0.3-0.7 2 - - 0.1 3 0.01 - - Tabella 2.2: Matrice dei pesi di una rete ricorsiva La Figura 2.8 mostra la topologia derivante da questa rappresentazione. input output 0.3 1 2-0.7 0.1 0.01 3 Figura 2.8: Rete ricorsiva generata dalle connessioni in Tabella 2.2.

Capitolo 2. Reti neurali 20 2.3 Addestramento Trattiamo ora la caratteristica principale delle reti neurali: la capacità di apprendimento mediante un algoritmo di addestramento (o training). L addestramento consiste nel modificare i pesi in modo che la rete svolga un particolare compito, a seconda dell ambiente o del sistema in cui si trova. Questo può variare dal sapere dividere una serie di oggetti che le vengono presentati in categorie, al controllare un veicolo, al prendere decisioni finanziarie. In ogni caso si cerca di fare assumere alla nostra rete una serie di ben precisi output in corrispondenza di specifici input, realizzando quindi una funzione di cui gli esempi costituiscono un campionamento (eventualmente rumoroso). Per fare questo ci si avvale di algoritmi detti di apprendimento, che tradizionalmente possono essere separati in tre categorie principali: Apprendimento supervisionato Apprendimento non supervisionato Apprendimento per rinforzo 2.3.1 Apprendimento supervisionato L apprendimento supervisionato consiste nell insegnare alla rete un determinato comportamento grazie al controllo di un supervisore. La rete è addestrata mostrandole un associazione fra un possibile input e l output che la rete dovrà produrre in quel caso. Questo processo sarà ripetuto finché la rete non otterrà un comportamento soddisfacente sia sui dati con cui è stata addestrata, sia su in insieme di casi mai visti usati come riferimento (capacità di generalizzare). Molti degli algoritmi di apprendimento supervisionato possono essere descritti come in Figura 2.9. L algoritmo gestisce un cosiddetto Training Set. Questo è formato da una serie di esempi che la rete neurale userà per imparare a svolgere il proprio lavoro. Questi esempi sono una lista di coppie input-output che rappresentano ciascuno un generico

Capitolo 2. Reti neurali 21 INIZIO LA RETE LEGGE UN SET DI INGRESSI CALCOLA LE USCITE CORRISPONDENTI VERIFICA QUANTO SIANO DIFFERENTI DA QUELLE DESIDERATE AGGIORNA I PESI DELLE CONNESSIONI PER RIDURRE QUESTA DIFFERENZA NO LA DIFFERENZA È PICCOLA? FINE SI Figura 2.9: Apprendimento supervisionato per reti neurali

Capitolo 2. Reti neurali 22 pattern di ingresso (con n valori) e la corrispondente uscita (con m valori) (esempio Listato 2.1). Listato 2.1: Esempio di un semplice Training Set per addestrare una rete composta da 2 ingressi ed 1 uscita a riprodurre la classica funzione XOR IN : 0 0 OUT: 0 IN : 0 1 OUT: 1 IN : 1 0 OUT: 1 IN : 1 1 OUT: 0 L algoritmo sottopone alla rete questi esempi, uno ad uno. Ad ogni esempio la rete calcola i suoi output. L algoritmo valuta questi output, e verifica quanto siano simili a quelli desiderati. A seconda di questa distanza dalle uscite ottimali aggiorna i pesi delle connessioni (che come già detto rappresentano la conoscenza vera e propria della rete), in modo da ridurre queste differenze. Ci sono numerosi algoritmi che operano in vari modi; uno tra i più utilizzati la backpropagation (Appendice A), che è una discesa del gradiente. Questa procedura viene iterata più volte (dette Epoche) per ogni esempio del Training Set. Dopo un certo numero di epoche, o quando si è raggiunta una differenza sufficientemente piccola fa output della rete e output desiderati, si può terminare l algoritmo. 2.3.2 Apprendimento non supervisionato Al contrario dell apprendimento supervisionato, quello non supervisionato non prevede la presenza di un agente esterno che guidi l addestramento della rete. Questo corrisponde a mostrare alla rete un Training Set composto da esempi che riportano i soli ingressi, e nessuna indicazione su quali uscite produrre. La rete adatterà la propria configurazione in base agli esempi che gli sono stati sottoposti ed alla regola di apprendimento utilizzata. Ciò consente solitamente di catalogare o suddividere i casi del Training Set in categorie o classi. Quindi la funzione di una rete in questo caso diventa quella di clusterizzare l informazione sulla base di schemi che si ripetono e difficili da individuare per un operatore umano.

Capitolo 2. Reti neurali 23 Tra le reti più utilizzate che si basano su questo tipo di apprendimento le reti SOM - Self Organizing Maps teorizzate da Kohonen [8] sono le più comuni. La topologia tipica è rappresentata in Figura 2.10 i 1. i n Figura 2.10: Generica SOM, detta anche Mappa di Kohonen Ogni singolo ingresso della rete è collegato ad ogni neurone d uscita. Al presentarsi di un determinato pattern in ingresso, l algoritmo di addestramento non supervisionato andrà a rafforzare i collegamenti (e quindi i pesi delle connessioni) verso uno di questi neuroni di uscita. In particolare rafforzerà il neurone di output che più assomiglierà al segnale in ingresso, ovvero quello la cui somma pesata delle connessioni sarà di valore maggiore. In questo modo, successivi pattern simili in ingresso andranno ancora a essere rappresentati da quell output. Inoltre viene introdotto anche il concetto di vicinanza tra i neuroni. All aggiornamento dei pesi di uno dei neuroni di uscita anche quelli dei neuroni fisicamente vicini verranno modificati in modo da aumentarne l uscita in presenza di tale esempio. Col passare degli esempi, pattern simili produrranno l uscita più alta in neuroni vicini della rete, che quindi avrà diviso (o clusterizzato) in modo corretto i nostri dati o si preparerà a funzionare come classificatore. Il risultato sarà una rete divisa efficacemente nei prototipi dei dati che si volevano classificare, costituiti dai pesi dei neuroni della rete, la cui funzione di attivazione produce un uscita tanto più alta quanto più simile è l ingresso ai pesi delle connessioni fra ingresso e neurone.

Capitolo 2. Reti neurali 24 2.3.3 Apprendimento per rinforzo Un generico algoritmo di apprendimento per rinforzo agisce sul sistema senza un supervisore che dica alla nostra rete cosa debba fare in ogni caso. Tuttavia, prevede comunque una qualche forma di ritorno per la qualità del lavoro che la rete sta eseguendo. Infatti, al contrario dell algoritmo supervisionato, nel quale venivano specificati precisamente gli output da ottenere, qui viene soltanto data una valutazione di correttezza di quanto la rete sta facendo. Questa valutazione viene generalmente chiamata reward (ricompensa). A seconda che la ricompensa sia alta o bassa la rete sarà incoraggiata dall algoritmo a tenere o meno lo stesso comportamento quando si ripresentano casi simili. Quindi, a lungo andare, la rete dovrà basarsi solo su questa reward per potere migliorare il proprio comportamento all interno del sistema. Da un lato questo approccio può essere più semplice da implementare perché non prevede la creazione di un Training Set completo e rappresentativo. Dall altro però questa tecnica rallenterà pesantemente l addestramento, che dovrà essere effettuato su molte più iterazioni e risentirà della cripticità delle informazioni di ritorno. 2.3.4 Ulteriori considerazioni sull apprendimento Quando si parla di algoritmi di apprendimento, ed in particolare di apprendimento supervisionato, diventa fondamentale la specifica del Training Set. Sono state elaborate alcune linee guida da seguire per ottenere Training Set efficienti. Fondamentale è la completezza della rappresentazione del problema, ovvero la necessità di tutta una serie di esempi che arrivino a descrivere bene l ambiente nel quale la rete dovrà operare. Tralasciare alcuni comportamenti magari poco frequenti potrebbe invalidare l intero addestramento, qualora questi siano comunque fondamentali. Quindi è consigliabile avere un Training Set diversificato e rappresentativo. Un altro aspetto importante è il bilanciamento. E fondamentale garantire che gli elementi di un Training Set siano bilanciati in quantità tra loro. Fornire dieci esempi di un comportamento e uno di un altro porterà la rete ad apprendere bene il primo, ma a comprendere male o addirittura a tralasciare il secondo. Ovviamente poi conta la dimensione del Training Set: un in-

Capitolo 2. Reti neurali 25 sieme troppo ampio o ridondante di esempi rallenterebbe inutilmente l addestramento della rete, che è spesso la fase più onerosa del suo utilizzo. Il Training Set è fondamentale per quanto riguarda l addestramento di una rete neurale. Con le successive presentazioni degli esempi, però, si è riscontrato che a volte la rete può specializzarsi troppo, arrivando a rendere alla perfezione il Training Set, ma fornendo risultati pessimi in altri casi anche poco differenti dagli esempi stessi. In questo caso si parla di overtraining (o sovra-addestramento). In reti particolarmente grandi, infatti, o dopo una lunga sequenza di addestramento, può accadere che la rete apprenda talmente bene il Training Set da impararlo a memoria, fino a perdere la capacità di generalizzare, ovvero di giudicare correttamente casi simili, ma non esattamente identici. Per ovviare a questo problema si utilizza il cosiddetto Test Set. Il Test Set per conformazione è totalmente identico al Training Set: una serie di corrispondenze ingressiuscite che descrivono il comportamento ideale della nostra rete. Tuttavia, il Test Set deve comprendere elementi diversi da quelli del Training Set. È possibile, volendo, partire da un insieme più grande di casi, e selezionarne una parte per il Training Set ed una per il Test Set. Il Training Set ed il Test Set infatti, pur contenendo esempi diversi, devono condividere la distribuzione statistica degli esempi stessi. Il Test Set non viene usato dalla rete durante l addestramento, ma solo successivamente. Infatti, una volta ottenuti risultati soddisfacenti addestrando la rete, si andrà ad accertare quanto questa sia stata in grado di generalizzare. Questo si verificherà valutando la rete proprio sul Test Set. Per questo è importante che gli elementi che lo compongono non siano stati usati durante l addestramento. Valutando i risultati ottenuti sul Test Set, e verificando che anch essi siano buoni, si avrà la sicurezza che la rete abbia appreso a sufficienza, generalizzando e senza ricadere nell overtraining. Il Test Set potrebbe anche essere utilizzato durante (ma non dentro) l addestramento, qualora si vedesse che i risultati della rete continuino a migliorare sul Training Set ma, tramite valutazioni intermedie, si noti che inizino a peggiorare sul Test Set. In questo caso la rete starebbe iniziando a sovra-addestrare e quindi sarebbe opportuno interrompere l addestramento. A questo punto, però, andrebbero definiti tre set diversi: Training Set

Capitolo 2. Reti neurali 26 Validation Set, usato per arrestare l addestramento Test Set, per valutarne la generalizzazione

Capitolo 3 Algoritmi evolutivi Gli Algoritmi evolutivi (Evolutionary Algorithms - EA) sono una serie di strategie ispirate all evoluzione naturale applicabili come algoritmi di ottimizzazione. Si basano sull evoluzione di una popolazione di individui che competono e collaborano per trovare la miglior soluzione possibile ad un problema. L esplorazione dello spazio delle possibili soluzioni avviene attraverso operatori ispirati alla riproduzione genetica, detti di ricerca, che provvederanno ad analizzare e valutare questo spazio facendo evolvere la popolazione in modo efficace, alla ricerca di minimi locali e globali. Uno degli algoritmi di questo tipo tra i più diffusi è detto Algoritmo Genetico (GA). Come suoi operatori di ricerca implementa la combinazione e la mutazione, applicati agli individui che comporranno le successive generazioni della popolazione. In particolare ogni individuo che rappresenta un punto nello spazio di ricerca (soluzione di un problema) è codificato secondo una rappresentazione delle sue caratteristiche detta genotipo. Il genotipo verrà poi decodificato in una soluzione applicabile al problema da risolvere, detta fenotipo. Una volta decodificata, ogni soluzione sarà valutata da un apposita funzione di fitness che ne stabilirà la bontà. Le soluzioni migliori saranno scelte secondo un algoritmo detto appunto di selezione (roulette wheel, tournament selection,... ). I genomi che avranno fornito le soluzioni migliori verranno scelti come base per usare gli altri due operatori, ovvero la combinazione e la mutazione. Due genomi potranno essere combinati tramite un operazione detta di crossover, ovvero verrà generato un nuovo 27

Capitolo 3. Algoritmi evolutivi 28 individuo (o meglio, il suo genoma), a partire dalle caratteristiche dei suoi genitori. La codifica dell individuo così generato deriverà in parte dalla codifica di un genitore, in parte da quella dell altro. Tra le scelte più utilizzate per la combinazione ci sono il one-point crossover e il two-point crossover (Figura 3.1), l uniform crossover e altri. one point crossover 1011010101010001 1010100000110111 two point crossover 1011010101010001 1010100000110111 = = 1011010000110111 & 1010100101010001 1010100000110001 & 1011010101010111 Figura 3.1: Un esempio di due tipologie comuni di crossover. Il one-point crossover sceglie un punto nella stringa dal quale effettuare il crossover. Il two-point sceglie due punti ed effettua il crossover su tutti i bit compresi nell intervallo. Successivamente si potrà applicare anche l operatore di mutazione al nuovo nato. Questo partirà dal genoma generato dai genitori e gli applicherà qualche tipo di mutazione, simile a quella che avviene negli organismi biologici. Quindi il genoma generato potrà introdurre soluzioni innovative, che poi verranno valutate dalla funzione di fitness, per verificare se abbia senso trasmetterle alle nuove generazioni, o scartarle. Anche qui si possono elencare alcuni operatori utilizzati molto di frequente, come il point mutation o l inversion. In realtà tutti questi operatori devono essere definiti a seconda della rappresentazione del problema, e quindi dei genotipi che andranno a popolare le generazioni di individui. Una delle operazioni più importanti nella specifica di un buon algoritmo evolutivo sarà infatti proprio implementare degli operatori di ricerca in grado di esplorare efficacemente lo spazio delle soluzioni. Una volta applicati tutti gli operatori di ricerca agli individui selezionati di una generazione, ne verrà creata una successiva appunto con alcuni tra i migliori selezionati e con tutti i nuovi, generati dalle riproduzioni e dalle mutazioni. Selezionando opportunamente gli operatori e i parametri dell algoritmo (come popolazione iniziale,

Capitolo 3. Algoritmi evolutivi 29 probabilità di crossover e mutazione, ecc... ), si potrà simulare un evoluzione che via via raffinerà la propria ricerca, arrivando a trovare molti ottimi locali per il problema proposto, fino a convergere ad una soluzione sub-ottima. 3.1 Applicazione degli algoritmi evolutivi alle ANN Una delle applicazioni più interessanti studiate negli anni recenti nell ambito del soft computing riguarda l interazione tra gli algoritmi evolutivi e le reti neurali. L idea di applicare l evoluzione alle reti neurali artificiali non è affatto strana, visto che entrambi i modelli si basano sull osservazione e l imitazione di fenomeni naturali abbastanza correlati, come l evoluzione e lo sviluppo dell intelligenza all interno del cervello. Sono stati studiati molti approcci diversificati al problema, tra i quali: l uso degli algoritmi evolutivi come algoritmo per l addestramento della rete l uso degli algoritmi evolutivi per trovare una topologia di rete che meglio si adatti a risolvere determinati problemi l uso di algoritmi evolutivi per ricercare nuovi parametri e regole per l apprendimento 3.1.1 Evoluzione dei pesi Una prima applicazione di un algoritmo evolutivo ad una rete neurale può essere quella in cui si usa l evoluzione per addestrare la rete stessa. Quindi l idea che sta alla base di questa implementazione è quella di rimpiazzare (od affiancare) l algoritmo tradizionale di addestramento (come la backpropagation) con uno di tipo evolutivo. Questo, al pari di uno tradizionale, andrà nel corso dell addestramento, a modificare i pesi delle connessioni dei neuroni della rete, fino a trovare una combinazione efficace per risolvere un determinato problema. Al contrario di un approccio classico, però, non procederà per aggiornamenti graduali, e seguendo metodi esatti come la discesa del gradiente. Infatti evolverà di

Capitolo 3. Algoritmi evolutivi 30 volta in volta popolazioni di individui rappresentanti ognuno l intera rete, con tutte le sue connessioni. Quindi genererà inizialmente una popolazione di reti, ognuna coi propri pesi, e ne valuterà la bontà (fitness). Sceglierà le reti migliori e le farà combinare (crossover) e mutare. A seconda di come questi operatori saranno definiti la nuova rete figlia erediterà porzioni dei pesi dei genitori (e quindi conoscenza se queste operavano correttamente), e proverà tramite la mutazione a generare nuova conoscenza. Questo approccio ha dato buoni risultati in molti casi rispetto a tecniche tradizionali come la backpropagation [19] [21], anche, e soprattutto, per la miglior capacità degli algoritmi evolutivi di evitare di cadere in in minimi locali, al contrario delle tecniche basate sul gradiente. 3.1.2 Evoluzione delle architetture Nella precedente sottosezione sull evoluzione dei pesi si è dato per scontato che le reti avessero una struttura ben definita e che l algoritmo evolutivo variasse i pesi delle connessioni. In realtà gli algoritmi evolutivi possono essere utilizzati anche per evolvere l architettura della rete. Per esempio, lavorando su una rete con architettura FeedForward a strati, potrebbe essere utile scoprire quali topologie sono le più efficaci per un determinato problema, ovvero la dimensione di ciascuno strato. Oppure, in un architettura di tipo meno rigido, come quelle ricorrenti, è interessante scoprire quali topologie possono avere più senso, evolvendo le connessioni fino a trovare strutture in grado di svolgere bene qualche funzione. Infine sono possibili anche approcci più complessi, non ultimo quello di evolvere contemporaneamente pesi e architetture della rete, cosa che permette di ridurre molti problemi inerenti al rumore dei pesi e alla mappatura genotipo-fenotipo in questo tipo di reti evolutive[9]. 3.1.3 Evoluzione dei parametri L evoluzione dei parametri e delle regole può essere vista come imparare ad addestrare una rete neurale. Ovvero scoprire, tramite l evoluzione, algoritmi efficienti per

Capitolo 3. Algoritmi evolutivi 31 addestrare le reti neurali. All inizio dell evoluzione verrà espressa qualche generica funzione di apprendimento, con una grande quantità di parametri fondamentali che la governano. Questi parametri saranno evoluti dall algoritmo. Di volta in volta si testeranno le regole evolutive sviluppate per verificarne l efficacia sull addestramento di una generica rete. Questo metodo si propone, mediante l evoluzione, di scoprire nuove tecniche di addestramento, o di trovare parametri efficienti per tecniche già conosciute. Tramite questi approcci si sono riusciti a ri-scoprire in modo automatico algoritmi già utilizzati e trovarne anche varianti finora inesplorate [4]. 3.2 Approcci all evoluzione delle architetture Quando si parla di evoluzione delle architetture di una rete neurale, la prima importante valutazione da fare è quali e quanti aspetti evolvere, e quali vantaggi possa apportare un approccio rispetto ad un altro. Come abbiamo già detto, una prima distinzione può essere quella tra evolvere l architettura della rete ed addestrare poi la rete normalmente (backpropagation), o evolvere sia l architettura che i pesi contemporaneamente. Questo in realtà ci porta a discutere dei due principali metodi di codifica delle architetture di una rete neurale: la codifica diretta la codifica indiretta 3.2.1 Lo schema di codifica diretta La codifica diretta, come il nome stesso implica, si propone di rappresentare direttamente l intera architettura della rete, senza mediazioni. Quindi il genoma sarà composto da ciascun elemento costitutivo della rete neurale, senza lasciare nulla da interpretare agli algoritmi addizionali, come quello di addestramento. Come già visto nelle sottosezioni 2.2.2 e 2.2.3, una rete neurale con le sue connessioni può essere vista come una matrice di NxN elementi, che possono essere i

Capitolo 3. Algoritmi evolutivi 32 pesi delle connessioni, o semplicemente 1 e 0 che rappresentano se esista o meno un collegamento tra i due nodi. Da questa rappresentazione è semplicissimo ricavare un genoma, ad esempio trasformando la matrice in un vettore. Questo vettore, a sua volta, è rappresentabile come una stringa di bit (nel caso si conservino anche i pesi sarà un array di numeri reali). In questo modo abbiamo già definito completamente una mappatura da ogni architettura verso il suo genoma. Vediamo un esempio di una generica rete neurale: Fig. 3.2. 1 2 3 4 Figura 3.2: Esempio di rete ricorsiva da tradurre in genoma Questa può essere mappata nella Tabella 3.1 1 2 3 4 1 0 1 0 1 2 0 0 1 1 3 1 0 0 0 4 0 0 0 0 Tabella 3.1: Matrice delle connessioni relativa alla rete in Figura 3.2 Nella colonna sinistra sono indicati i neuroni di partenza e nella riga sopra quelli di arrivo, per ciascuna connessione. Ovviamente l 1 sta ad indicare la presenza di una connessione, lo 0 un assenza. È immediato tradurre questa matrice in una stringa di bit e quindi in un genoma: {0 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0} Partendo da questa tipologia di codifica è facile implementare i classici operatori di crossover e mutazione che sono già stati visti. Tradizionalmente, infatti, la codifica a stringa di bit è una delle più utilizzate e quindi già ricca di molte analisi sull efficacia dei suoi operatori. Partendo da questo genoma, quindi, la conversione in fenotipo

Capitolo 3. Algoritmi evolutivi 33 riuscirà a creare la corretta rete. Specificando però solo la presenza o meno di connessioni, resteranno comunque da definirne i relativi pesi. Questi pesi verranno impostati dall algoritmo di addestramento tradizionale, per completare la decodifica in fenotipo. A questo punto verrà eseguito l addestramento vero e proprio che, giunto al termine, ci fornirà risultati sull efficacia (fitness) della struttura. Alternativamente a questo approccio, ma comunque con metodo diretto, si possono già specificare nella matrice della rete i relativi pesi di ogni connessione, come già visto in precedenza (e riportato nuovamente in Tabella 3.2). 1 2 3 4 1 0 0.1 0 0.3 2-0.9 0 0-0.2 3-0.7 0.4 0 0.5 4 0.1 0 0.2 0 Tabella 3.2: Matrice delle connessioni e dei pesi di una generica rete ricorrente Tuttavia questa volta la mappatura in fenotipo sarà diversa e il risultato sarà un array di numeri reali, rappresentabili ad esempio con il formato float: {0 0. 1 0 0. 3 0.9 0 0 0.2 0.7 0. 4 0 0. 5 0. 1 0 0. 2 0} Quindi, a parte l ovvio problema delle quantità di dati da memorizzare, sorge la necessità di definire corretti operatori di crossover e mutazione. Una prima idea potrebbe essere quella di convertire semplicemente i numeri reali che compongono il vettore in una stringa di bit. Questo è possibile ad esempio convertendo i parametri dal tipo float al corrispettivo formato binario con i quali vengono memorizzati sui calcolatori. Questo approccio è praticabile, e ci permette di usufruire dei classici operatori di crossover e mutazione su stringhe, senza alcuno sforzo addizionale. Tuttavia è facile intuire che un crossover che aveva senso su una stringa di bit rappresentanti ciascuno una connessione o meno, può avere molto meno senso in questo ambito. Infatti la ricombinazione tra due float sotto forma di bit potrebbe partire da due valori relativamente vicini nella rappresentazione reale e trasformarli in un valore di uscita completamente diverso e poco correlato con i genitori.

Capitolo 3. Algoritmi evolutivi 34 Un alternativa a questo è ridefinire gli operatori di crossover e mutazione, adattandoli alla logica dei numeri reali, magari nella loro rappresentazione floating point. Questo è stato implementato in alcuni studi con successo [15]. E importante notare che in entrambi questi approcci con i pesi delle connessioni già descritti nella matrice non è necessario prevedere una fase di addestramento. Infatti, l intera rete compresi i pesi delle connessioni vengono evoluti dall algoritmo. Nell approccio precedente (un bit per ogni connessione), dopo la decodifica, per valutare la fitness era necessaria una fase di training che assegnasse alla rete tutti i pesi che le permettessero di operare. Con questa tecnica, invece, i pesi vengono già gestiti dall evoluzione, e quindi la valutazione della fitness si riduce a testare il funzionamento della rete su un Training Set. 3.2.2 Lo schema di codifica indiretta Spesso può essere più conveniente, e più logico, utilizzare una metodologia di codifica meno complessa e pesante, questo sia per quanto riguarda le strutture dati che è necessario memorizzare ed elaborare nel processo di evoluzione, sia per quanto riguarda l effettiva capacità espressiva del metodo, che spesso non richiede di scendere a tale livello di dettaglio. Anche dal punto di vista biologico, un cromosoma non specifica tutta la completa struttura nervosa che andrà a creare [7]. Per rispondere a queste esigenze, si può creare una metodologia di codifica detta indiretta. Al contrario di quella diretta, questa specifica solo una serie di parametri, che andranno poi interpretati per generare il fenotipo, a partire dal genotipo. Un esempio potrebbe essere la descrizione di una rete di tipo FeedForward a strati. Come già detto nella sottosezione 2.2.1, infatti, per specificare una rete di tipo FeedForward a strati, basterebbero pochi parametri. Per definire in maniera totale una rete completamente connessa di questo tipo basterebbero infatti il numero di strati nascosti e le dimensioni di ciascuno di questi. Sarebbe possibile però evolvere anche altri parametri, quali le funzioni di attivazione di ciascun layer, oppure, nel caso di reti non completamente connesse, anche le percentuali di connessione tra uno strato e l altro. In ogni caso il genoma così codificato si ridurrà a pochi valori contro le migliaia di quelli di una

Capitolo 3. Algoritmi evolutivi 35 codifica diretta. Questo rende l algoritmo evolutivo assai veloce e permette di concentrarsi maggiormente sulla valutazione della fitness, che avverrà nuovamente tramite l addestramento classico, come descritto nella codifica diretta delle sole connessioni. Un semplice genoma come: {2 140 30} andrebbe a definire una rete con n ingressi e m uscite (a seconda delle dimensioni del Training Set), 2 strati nascosti, uno da 140 neuroni, ed uno da 30 neuroni. In un caso come questo la rete sarebbe completamente connessa e ciascuna funzione di attivazione sarebbe quella predefinita (ad esempio quella sigmoidale). Contemporaneamente a questi parametri, vista la leggerezza della rappresentazione, e possibile anche evolvere parametri del successivo addestramento, per esempio il learning rate, il momentum e gli altri parametri della backpropagation, affinché anch essi vengano ottimizzati dall evoluzione. E evidente che un approccio di questo tipo facilita enormemente una buona implementazione dell algoritmo evolutivo, e permetterà di gestire velocemente popolazioni molto più grandi, magari al prezzo di una minore espressività. Inoltre sarà anche più agevole introdurre operatori di crossover e mutazione, cosa assai complicata nelle rappresentazioni dirette dove un mediocre operatore di ricerca può pregiudicare seriamente l intero algoritmo. Infine, un interessante alternativa a questo tipo di codifica indiretta per parametri è quella di codificare nel genoma i parametri di alcune regole costruttive per la rete, anziché dei valori. Queste, nella successiva decodifica a fenotipo (più onerosa), andranno a formare la topologia vera e propria della rete, seguendo qualche regola topografica di espansione precedentemente definita.

Capitolo 4 CUDA CUDA è un architettura per il calcolo parallelo basata su processore grafico (GPU) sviluppata da NVIDIA. Permette agli utenti equipaggiati con schede video NVIDIA di sfruttarle per l esecuzione di programmi general purpose, al pari di quello che si potrebbe fare con un processore (CPU). Infatti, è messo a disposizione degli sviluppatori di software un linguaggio chiamato C for CUDA, molto simile al C tradizionale, che permette di sfruttare agevolmente tutte le capacità computazionali delle schede video. A differenza delle classiche CPU, però, l approccio di programmazione è totalmente orientato alla parallelizzazione del programma. Infatti, se una CPU punta ad eseguire un singolo thread il più velocemente possibile, la GPU ne esegue invece una grande quantità in parallelo, ciascuno dei quali è in genere più lento di quello della CPU. Il risultato è che se si riesce a parallelizzare l algoritmo che si vuole eseguire in modo efficiente, la GPU garantirà capacità computazionali molto superiori a quelle di CPU della stessa generazione, come si vede nelle figure 4.1 e 4.2. A seconda quindi dell algoritmo che si deve implementare, e dell esperienza dello sviluppatore che andrà a parallelizzarlo, si potranno ottenere benefici dal punto di vista prestazionale in media di uno o più ordini di grandezza. In particolare l esecuzione su GPU sarà molto efficace per algoritmi che presentino calcoli aritmeticamente intensi e che operino su grandi quantità di dati, visto che questo è proprio lo scopo per cui sono progettate le schede video che gestiscono la grafica delle applicazioni. Da un punto di vista ingegneristico, infatti, le schede video sono state progettate 36

Capitolo 4. CUDA 37 Figura 4.1: Raffronto della capacità computazionale tra CPU e GPU nel corso degli anni. Dalla NVIDIA CUDA Programming Guide c Figura 4.2: Raffronto della larghezza di banda tra CPU e GPU nel corso degli anni. Dalla NVIDIA CUDA Programming Guide c

Capitolo 4. CUDA 38 per avere strutture di controllo di flusso molto più semplici di quelle delle CPU, e di non utilizzare cache, come si vede in Figura 4.3. Questo perché i calcoli che devono effettuare sono quasi sempre gli stessi: operazioni matematiche in virgola mobile su vettori e matrici di dati. Figura 4.3: Raffronto tra il modello teorico di una CPU e quello di una GPU. Dalla NVIDIA CUDA Programming Guide c 4.1 Architettura di una GPU e considerazioni Una generica GPU NVIDIA è dotata di una serie di multiprocessori (30 per i modelli high-end Tesla, 16 per i modelli Fermi), ognuno dei quali comprende a sua volta un numero di core (8 per le Tesla, due gruppi da 16 per le fermi). Questi core in realtà possono essere visti come le ALU di una generica CPU, ovvero sono le unità preposte al calcolo numerico. La particolarità di questi core è che possono svolgere in parallelo più thread. In particolare si parla di SIMT - Single Instruction Multiple Thread. Questo significa che tutti questi thread in parallelo andranno a compiere il medesimo set di istruzioni. Starà poi al programmatore implementare questo set di istruzioni in modo da lavorare su porzioni differenti di dati. In realtà questo meccanismo è implementato per svolgere in parallelo 32 thread alla volta, una quantità che NVIDIA chiama warp. Questo avviene in 4 cicli di clock per quanto riguarda le GPU Tesla (8 core per 4 cicli = 32 thread). Le GPU Fermi