Approssimazione di funzioni mediante tecniche di programmazione genetica.

1. Anno Accademico 2010/2011 Approssimazione di funzioni mediante tecniche di programmazione genetica. Salvatore Alaimo 05 maggio 2011

2. Algoritmi Genetici • Un algoritmo genetico è un metodo euristico di ottimizzazione e ricerca, ispirato al principio della selezione naturale di Charles Darwin che regola l’evoluzione biologica. • Gli algoritmi genetici sono applicabili alla risoluzione di un'ampia varietà di problemi d'ottimizzazione non indicati per gli algoritmi classici, compresi quelli in cui la funzione obiettivo è discontinua, non derivabile, stocastica, o fortemente non lineare.

3. Algoritmi Genetici • Un tipico algoritmo genetico parte da un certo numero di possibili soluzioni (individui) chiamate popolazione. • Si provvede a far evolvere ogni soluzione nel corso dell'esecuzione. • L’evoluzione è ottenuta mediante: • Parziale ricombinazione delle soluzioni: ogni individuo trasmette parte del suo patrimonio genetico ai propri discendenti; • Mutazioni casuali nella popolazione di partenza: sporadicamente nascono individui con caratteristiche diverse dai genitori. • In generale, per ciascuna iterazione (generazione): • Si selezionano alcuni individui della popolazione corrente; • Con essi si generano nuovi elementi della popolazione stessa (riproduzione o crossover, mutazione) • Gli elementi generati sostituiranno un pari numero d'individui già presenti • Si forma così la popolazione per la successiva iterazione.

4. Algoritmi Genetici • La soluzione del problema è codificata attraverso una struttura (tipicamente stringa) detta Gene. • Per stabilire la «bontà» di un gene, si definisce una funzione, detta Funzione di Fitness.

5. Algoritmi Genetici • Crossover:è l’operazione che definisce la programmazione di un gene sulla base di altri due geni detti genitori. Cut-Splice Crossover Single-Point Crossover Two-Point Crossover Uniform Crossover

6. Algoritmi Genetici • Mutazione: è l’operazione che mantiene la diversità genetica da una generazione alla successiva.

7. Algoritmi Genetici • La successione di iterazioni evolverà verso una soluzione ottimale (locale o globale) del problema. • Finita la fase di evoluzione, sono tenute solo le soluzioni che meglio risolvono il problema. • Alla fine ci si aspetta di trovare una popolazione di soluzioni che risolva adeguatamente il problema posto.

8. Algoritmi Genetici • Non vi è modo di decidere a priori se l'algoritmo sarà effettivamente in grado di trovare una soluzione accettabile. • Utilizzo: problemi di ottimizzazione per i quali non si conoscono algoritmi di complessità lineare o polinomiale.

9. Programmazione Genetica • Elaborata fondamentalmente da John R. Koza • È un metodo per la generazione automatica di programmi, a partire da una descrizione ad alto livello del task da svolgere • Basato sul principio darwiniano della selezione naturale. • Si avvale di operazioni capaci di alterare l'architettura di detti programmi e di prendere decisioni sull'uso delle subroutine, dei loop, della ricorsione e della memoria. • Costituisce un'estensione degli algoritmi genetici al caso di popolazioni costituite da programmi di dimensione variabile. • La popolazione risulta composta da un numero di programmi, i quali, mediante operatori genetici, producono, in un certo numero di generazioni, il programma che risolve al meglio un problema.

10. Programmazione Genetica • + • + • * • 5 • La struttura base è un ad albero, il cui corpo è costituito da funzioni (primitive), mentre i nodi terminali rappresentano variabili o costanti numeriche. • 75 • 5 • 3 • ^ • 5 • 2 • + • + • + • * • 5 • * • 5 • 80 • * • 5 • 3 • 25 • 3 • ^ • 3 • ^ • g • 2 • x • 2 • x

11. Programmazione Genetica • Struttura generica di un algoritmo: • Costruzione di una popolazione di programmi iniziale a partire dalle primitive disponibili • Finchè non si ottiene una soluzione accettabile: • Eseguire ogni programma e valutarne la «fitness»; • Selezionare i programmi a cui applicare gli operatori genetici; • Applicare gli operatori genetici ai programmi selezionati; • Costruire una nuova popolazione che contiene: • Il miglior programma ottenuto fino ad ora (con alta probabilità) • Alcuni dei programmi aggiornati al passo precedente • Alcuni programmi costruiti casualmente per ottenere una popolazione di dimensione identica a quella iniziale. • Restituire il miglior programma ottenuto.

12. Programmazione Genetica • Le primitive dipendono dalla natura del problema da risolvere. • Per semplici problemi numerici, esse sono tipicamente le funzioni aritmetiche. ({+, -, *, /}) • Affinché il problema sia risolto correttamente, è, necessario che siano valide le seguenti proprietà per l’insieme di primitive: • Sufficiency: esprimere una soluzione del problema solo in funzione delle primitive. (Es.: {AND, OR, NOT} per i problemi di combinatoria booleana) • Closure: si suddivide in altre due proprietà: • Strong Type Consistency: tutte le primitive devono prendere in input e restituire in output valori dello stesso tipo, indipendentemente dal compito svolto. • Evaluation Safety: ogni primitiva deve essere in grado di gestire eventuali errori e produrre un risultato valido in ogni situazione. (Es.: overflow numerici gestiti come “wraparound”, divisioni per zero gestite come “infinito”)

13. Programmazione Genetica • La funzione di fitness consente di valutare la bontà del programma in base all’errore commesso nella risoluzione del problema e alla complessità temporale, spaziale e/o computazionale. • Principali operatori genetici: • Crossover o riproduzione: • Sessuata • Asessuata (Imitazione) • Mutazione

14. Programmazione Genetica • + • Crossover • * • 5 • 3 • ^ • + • x • 2 • * • Exp • 3 • ^ • x • * • x • 2 • + • exp • 9 • x • x

15. Programmazione Genetica • Imitazione • + • * • * • b • + • exp • 9 • x • x • a • x

16. Programmazione Genetica • Mutazione • * • * • + • exp • + • exp • 9 • cos • x • 9 • x • x • x

17. Programmazione Genetica • Problemi nell’approccio di Koza alla programmazione genetica: • Schema troppo generico in cui la manipolazione delle costanti risulta essere troppo oneroso. • Convergenza troppo rapida dell’algoritmo ad una soluzione locale, piuttosto che globale, del problema. • Maggiore complessità delle funzioni usate implica maggiori parametri da aggiustare, quindi, maggiore sensibilità al rumore. • Se la funzione di fitness richiede la pura aderenza ai dati, la convergenza potrebbe non essere mai raggiunta, provocando un aumento della complessità dei programmi.

18. Approssimare Funzioni • Il problema: data una serie di valori, trovare quell’espressione matematica che meglio rappresenta l’andamento dei dati. • Aspetti problematici: • Complessità della funzione risultato; • Aderenza ai dati e rumore; • Misura della bontà del risultato. • Approcci tradizionali: • Regressione • Interpolazione

19. Approssimare Funzioni

20. Approssimare Funzioni • Per valutare l’aderenza ai dati si è scelto di usare la misura dell’errore basata sullo scarto quadratico medio: • continua al variare della parametrizzazione • non continua al variare della forma della forma di f. • La ricerca della parametrizzazione è una ricerca di un minimo di una funzione continua (o continua a tratti). • La ricerca della forma è più simile ad una ricerca in ampiezza, utilizzando delle euristiche per limitare lo spazio di ricerca.

21. Rappresentazione di una Funzione • Per implementare l’albero di definizione di una funzione sono utilizzati due vettori: • Vettore «form»: descrive la forma della funzione (dalle foglie alla radice); • Vettore «constants»: contiene le costanti numeriche della funzione. • L’algoritmo di ricerca del minimo (globale e locale) ottimizza i valori del vettore «constants» per minimizzare l’errore. • L’algoritmo di ricerca dell’approssimazione altera il vettore «form» per trovare la migliore famiglia di funzioni che risolve il problema. • Ogni elemento del vettore form contiene tre valori (FormEntry): • Operatore (eType); • Primo Operando (op1): è l’indice, nel vettore form, della radice del sottoalbero sinistro radicato nell’elemento corrente; • Secondo Operando (op2): è l’indice, nel vettore form, della radice del sottoalbero destro radicato nell’elemento corrente. • Nel vettore form, il primo operando è posto prima del secondo operando; la radice di ogni sottoalbero è posta dopo ogni operando.

22. Rappresentazione di una Funzione • Operatori a due argomenti: • Addizione (0): f(a)+g(b) • Sottrazione (1): f(a)-g(b) • Moltiplicazione (2): f(a)*g(b) • Divisione (3): f(a)/g(b) • Potenza (4): f(a)k • Operatori a un argomento: • Ripetizione (20): serve a rappresentare funzioni del tipo f(g(x)) senza ripetere più volte la funzione g(x) • Esponenziale (21): ef(x) • Seno (22): sen(f(x)) • Coseno (23): cos(f(x)) • Costante (100): rappresenta una costante del vettore «constants» • Variabile (101): rappresenta una variabile da sostituire durante la valutazione della funzione

23. Rappresentazione di una Funzione • Per calcolare f(x) si utilizza un vettore di comodo «tempCalc» della stessa dimensione di «forms». • Il calcolo avviene mediante il seguente algoritmo: • Sia x il vettore dei dati • For i := 1 to size(tempCalc) • Iftipo(forms[i])is «costante» then • tempCalc[i] := constants[op1(forms[i])] • ElseIftipo(forms[i])is «variabile» then • tempCalc[i] := x[op1(forms[i])] • Else • Applica l’operazione tipo(forms[i]) ai valori tempCalc[op1(forms[i])] e, se necessario, tempCalc[op2(forms[i])] e poni il risultato in tempCalc[i] • End • End • If errore di calcolo thenreturn+∞ • Return tempCalc[size(tempCalc)]

24. Esempio: f(x)=3x+2 «constants» «forms» Calcolo f(4) «tempCalc»

25. Calcolo del minimo • È un algoritmo che data una funzione f(x,c) calcola la parametrizzazione «c» che minimizza l’errore • Composto da due algoritmi genetici: • Algoritmo del minimo locale: sfrutta una piccola popolazione di parametrizzazioni per trovare un minimo locale della funzione errore; • per velocizzare la convergenza esegue una analisi di sensibilità al fine di stabilire l’incremento e la direzione di incremento • Algoritmo del minimo globale: sfrutta una popolazione di «minimi locali» per trovare il minimo globale dell’errore; • Una popolazione di «minimi locali» è una parametrizzazione c1 della funzione f(x, c1) calcolata mediante l’algoritmo del minimo locale.

26. Minimi Locali • Data una funzione f(x, c) e una parametrizzazione iniziale, l’algoritmo dei «minimi locali» cerca di migliorare la parametrizzazione per minimizzare localmente la funzione errore. • La velocità di convergenza dipende da: • numero di parametri presenti; • posizione dei parametri; • probabilità che scelta una parametrizzazione a caso, essa sia la migliore. • Per migliorare la convergenza si utilizzano due operatori realizzati appositamente, piuttosto che le tecniche tipiche degli algoritmi genetici: • Mutazione gaussiana; • Ricerca nella direzione. • Per migliorare le prestazioni, ad ogni iterazione, è mantenuta solo la miglior parametrizzazione, e le altre sono scartate.

27. Minimi Locali • Mutazione gaussiana: • Genera una nuova parametrizzazione in un intorno di quella di partenza, la cui distanza è funzione dell’errore. (a maggior errore corrisponde maggior distanza, e viceversa) • Per fare ciò si utilizza una distribuzione di probabilità gaussiana nello spazio dei parametri centrata nel punto corrispondente alla vecchia parametrizzazione. • Per calcolare la varianza della distribuzione si esegue una analisi di sensibilità. • Si calcola una piccola variazione della parametrizzazione e si valuta il rapporto tra la distanza degli errori e la distanza delle parametrizzazioni. • Numeri casuali distribuiti come descritto precedentemente forniscono la variazione casuale della parametrizzazione.

28. Minimi Locali • Ricerca nella direzione: • Si costruiscono nuove parametrizzazioni nella direzione in cui l’errore diminuisce, fino a trovare il punto in cui l’errore inizia ad aumentare o si raggiunge il numero massimo di iterazioni. • Velocizza la convergenza quando le parametrizzazioni sono troppo lontane dal punto di minimo errore. • Difetto: La parametrizzazione inizia ad oscillare attorno alla posizione del minimo ma non lo raggiunge mai. a f(x) = ax+b Parametrizzazione:c=(a,b) b

29. Minimi Locali • Sia • f(x,c) una funzione con parametrizzazione c (casuale o trovata precedentemente) • e(f, P) una stima dell’errore di f sui punti del datasetP • n il numero di iterazioni • oldC := c, oldE := e(f(x, oldC), P) • For i := 1 to n • c’ := gaussianMutation(oldC) • e’:= e(f(x, c’), P) • IfoldE > e’then • d := c’ - oldC • bestC := exploreDirection(d, c’) • oldC := bestC, oldE := e(f(x, bestC), p) • End • End • Return oldC

30. Minimo Globale • Data una funzione f(x) trovare la parametrizzazione «c» che minimizza l’errore sui punti del dataset P. • Gli operatori genetici definiti per l’algoritmo sono: • Crossover • Mutazione • L’algoritmo del minimo globale è utilizzato nell’algoritmo di ricerca dell’approssimazione, come unico operatore che lavora sui parametri della funzione. • Si ottengono buoni risultati anche con popolazioni di piccole dimensioni (Es. 12 individui e 6 sopravvissuti).

31. Minimo Globale • Crossover: • Date due parametrizzazione (genitori), si costruisce una nuova parametrizzazione (figlio) che, nello spazio dei parametri, risulta essere compresa tra i due. • Accelera la convergenza: • Date due parametrizzazioni che stanno convergendo allo stesso minimo locale. • L’algoritmo riesce a produrre, con un singolo passo ,una parametrizzazione molto più vicina al minimo rispetto alle due precedenti. • Rende l’algoritmo meno sensibile ai minimi locali nel caso in cui il minimo globale è circondato da tanti minimi locali. • Importante l’inizializzazione perché non cerca nell’intero spazio dei parametri. • Mutazione: • Si esegue l’algoritmo dei «minimi locali» per costruire una parametrizzazione che si avvicini il più possibile ai minimi dell’errore.

32. Minimo Globale • Sia • f(x) una funzione con valutazione dell’errore e(f,P) • n il numero di individui della popolazione • k il numero di sopravvissuti per generazione • m il numero di iterazioni dell’algoritmo dei «minimi globali» • t il numero di iterazioni dell’algoritmo dei «minimi locali» • Poni nel vettore «pop» una n parametrizzazioni casuali. • For i := 1 to m • For p in pop • Aggiorna p con il risultato di localFinder( f(x,p), e(f,P), t) • End • Best := Elemento p di pop tale che e(f(x, pop), P) è minimo • Survivor := scegli a caso k elementi di pop dando priorità a quelli con errore più piccolo • Children := combina con l’operatore crossover gli elementi di Survivorscegliendoli a caso • Aggiorna «pop» con la nuova popolazione composta da: • Best • Le parametrizzazioni contenute in Children • n-(1+k/2) parametrizzazioni casuali. • End • Return Elemento p di pop tale che e(f(x, pop), P) è minimo

33. Algoritmo Principale • Mutazione: • Presa una funzione, od un sottoalbero del suo primo operatore, la combina ad una generata casualmente utilizzando un operatore di somma o prodotto. • Rende possibile la risoluzione di problemi più complessi, ma rende anche molto più instabile la convergenza. (Problema: a maggiore complessità equivale minor crescita della fitness) • Imitazione: • L’operatore costruisce una nuova funzione con le seguenti caratteristiche rispetto a quella di partenza: • Profondità dell’albero di definizione uguale o maggiore di una unità; • Numero di costanti e variabili scelte casualmente; • Numero di funzioni trascendenti al più uguale a quello della funzione di partenza. • Aumenta la probabilità di trovare la forma giusta della funzione con piccoli incrementi della complessità.

34. Algoritmo Principale • Sia • P un insieme di punti • e una valutazione dell’errore di una qualsiasi funzione f sull’insieme dei punti • n il numero di iterazioni • m il numero di funzioni per generazione • k il numero di sopravvissuti per generazione • Costruisci il vettore «pop» con m funzioni generate casualmente • For i := 1 to n • Aggiorna gli elementi di «pop» tramite l’algoritmo dei minimi globali • Best := L’elemento di «pop» per cui l’errore e risulta minimo • Survivors := SelectSurvivors(pop, k) • pop := CreateNewPopulation(Best, Survivors, n, k) • End • Return L’elemento di «pop» per cui l’errore e risulta minimo

35. Algoritmo Principale • SelectSurvivors(pop, k) • Survivors := vettore contenente i k migliori elementi di «pop» • For j := 1 to k • p1 = rand(), p2=rand() • Ifp1 < 0,7 and p2 < 0,5then • Survivors[j] = mutate(Survivors[j]) • ElseIfp1 < 0,7 and p2 >= 0,5then • Survivors[j] = imitate(Survivors[j]) • End • End • Return Survivors

36. Algoritmo Principale • CreateNewPopulation(Best, Survivors, n, k) • Random := costruisci (n-k-1) funzioni casuali • p = rand() • Ifp < 0,98then • pop := <Best> + Survivors + Random • Else • pop := Survivors + Random • End • Return pop

37. Algoritmo Principale • generateRandomFunction(n, k, t) • Sia • nla profondità dell’albero di definizione della funzione • k il numero massimo di operazioni trascendenti • t il numero di variabili indipendenti • p=rand() • Ifn == 1 and p <0.5then • Return f(x)=1.0 • ElseIfn == 1 and p >= 0.5then • Return f(x)=x(rand()*t) • End • If rand() < 0.5 then • Scegli a caso una operazione trascendente r(x) • Return f(x) = r(generateRandomFunction(n-1,k-1,t)) • Else • Scegli a caso una operazione binaria b(f1, f2) • f1 = generateRandomFunction((1+rand()*(n-1)), k, t) • f2 = generateRandomFunction(n-1, k-1, t) • Return f(x) = b(f1, f2) • End

38. Test dell’algoritmo • Per provare il funzionamento dell’algoritmo sono state selezionate 11 funzioni per le quali è stato estratto un campione di 100 elementi nell’intervallo [-10;10). • Per rendere più verosimili i test, si è scelto di aggiungere al campione un rumore casuale distribuito secondo una normale gaussiana standardizzata. • L’iterazione principale dell’algoritmo è stata eseguita al più 250 volte, con una popolazione di 30 individui e 6 sopravvissuti per generazione. • Al fine di controllare la solidità dell’algoritmo si è scelto di ripeterlo 20 volte in modo da verificare quanto la convergenza sia dovuta ad una particolare catena di eventi, o a proprietà dell’algoritmo. • Per verificare l’efficienza del metodo si è misurato il tempo di esecuzione di ogni iterazione (minimo, massimo e medio), e l’utilizzo di memoria. Non è stato scelto come parametro l’utilizzo della CPU in quanto l’algoritmo è stato ottimizzato per saturare al massimo la risorsa in modo da ridurre i tempi di calcolo.

39. Test dell’algoritmo • Le funzioni scelte sono:

40. Test dell’algoritmo • Generazioni: 7 • Funzioni testate: 274.587 • Tempo: • Medio: 9s • Minimo: 3s • Massimo: 23s • Errore medio: 0,57 • Solidità: 20 su 20 • Utilizzo memoria: 0,01Gb

41. Test dell’algoritmo • Generazioni: 31 • Funzioni testate: 875.647 • Tempo: • Medio: 23s • Minimo: 4s • Massimo: 137s • Errore medio: 0,57 • Solidità: 20 su 20 • Utilizzo memoria: 0,02Gb

42. Test dell’algoritmo • Generazioni: 2 • Funzioni testate: 137.955 • Tempo: • Medio: 3s • Minimo: 2,5s • Massimo: 11,4s • Errore medio: 0,57 • Solidità: 20 su 20 • Utilizzo memoria: 0,01Gb

43. Test dell’algoritmo • Generazioni: 39 • Funzioni testate: 1.062.675 • Tempo: • Medio: 26s • Minimo: 3s • Massimo: 82s • Errore medio: 0,59 • Solidità: 20 su 20 • Utilizzo memoria: 0,08Gb

44. Test dell’algoritmo • Generazioni: 10 • Funzioni testate: 356.871 • Tempo: • Medio: 9s • Minimo: 3s • Massimo: 22s • Errore medio: 0,55 • Solidità: 20 su 20 • Utilizzo memoria: 0,04Gb

45. Test dell’algoritmo • Generazioni: 61 • Funzioni testate: 1.605.394 • Tempo: • Medio: 45s • Minimo: 2s • Massimo: 160s • Errore medio: 0,53 • Solidità: 19 su 20 • Utilizzo memoria: 0,15Gb

46. Test dell’algoritmo • Generazioni: 142 • Funzioni testate: 3.689.075 • Tempo: • Medio: 118s • Minimo: 1s • Massimo: 141s • Errore medio: 0,55 • Solidità: 5 su 20 • Utilizzo memoria: 0,06Gb

47. Test dell’algoritmo • Generazioni: 142 • Funzioni testate: 3.689.075 • Tempo: • Medio: 118s • Minimo: 1s • Massimo: 141s • Errore medio: 0,55 • Solidità: 5 su 20 • Utilizzo memoria: 0,06Gb

48. Test dell’algoritmo • Test con funzione probabilistica:

49. Applicazione pratica:Analisi del «Afterglow» di un Gamma RayBurst (GRB)

50. Gamma RayBurst • È un fenomeno astronomico che consiste in un lampo di radiazione gamma che avviene per: • Esplosione di una Supernova • Quasar • Altre cause legate alla morte di una stella • Dura al più qualche centinaio di secondi per cui l’unico modo per studiare il fenomeno è analizzare l’afterglow. (la luminosità residua in conseguenza al fenomeno) • L’andamento dell’afterglow nel tempo permette di identificare il tipo di GRB.