Sei sulla pagina 1di 58

UNIVERSIT DEL SALENTO

Facolt di Scienze Matematiche Fisiche e Naturali


Corso di Laurea in Fisica
_______________________________________________________________


TESI DI LAUREA TRIENNALE

LEVOLUZIONE SIMULATA:
BASI E APPLICAZIONI
DEGLI ALGORITMI GENETICI


Relatore:
Chiar.mo Dott. Giorgio De Nunzio

Correlatore:
Chiar.ma Dott.ssa Marina Donativi


Laureanda:
Francesca Itta
_____________________________________________________
ANNO ACCADEMICO 2012 - 2013
1







Alla mia famiglia che ha creduto in me
anche quando io non ho creduto in me stessa.












2
SOMMARIO
Introduzione ............................................................................... 3

Capitolo 1 ......................................................................................
1.1 Introduzione agli algoritmi genetici (GA) ................................ 5
1.2 Quando occorre utilizzare un GA? .......................................... 6
1.3 Terminologia ............................................................................ 8
1.4 Funzionamento di un GA ..................................................... 10
1.5 Elementi di base degli algoritmi genetici .............................. 11
1.5.1 Codifica .............................................................................. 12
1.5.2 Funzione di fitness ............................................................. 13
1.5.3 Operatori ........................................................................... 14
1.6 Perch i GA funzionano ? ..................................................... 19
1.7 Teorema degli Schemi .......................................................... 20
1.7.1 Dimostrazione .................................................................... 21
1.8 Applicazioni di GA ................................................................ 26
1.8.1 Utilizzo della programmazione genetica in elettronica .... 27


Capitolo 2 .......................................................................................
2.1 Casi di studio ......................................................................... 31
2.2 Ricerca del massimo di una funzione ad una variabile ........ 31
2.3 Analisi di immagini digitali ................................................... 38


Conclusioni ............................................................................... 45
Appendice A .............................................................................. 47
Appendice B .............................................................................. 51
Bibliografia .............................................................................. 53





3
Introduzione
Questa Tesi di Laurea propone una panoramica su una tecnica di
ottimizzazione che offre una valida metodologia di risoluzione per svariati
problemi. Tale metodo adotta particolari algoritmi, detti genetici (GA
1
) in
quanto emulano metodi di ottimizzazione biologici e in particolare genetici.
In pratica con questo metodo si imita quel meccanismo di ottimizzazione
messo in atto dalla natura la cui validit ormai consolidata da millenni :
levoluzione. Essa un processo creativo molto fecondo: dalla complicata
biochimica delle singole cellule all'elaborata struttura del cervello umano, ha
prodotto meraviglie di incredibile complessit. Questi risultati sono ottenuti
iterando per molte generazioni pochi processi molto semplici: mutazione,
ricombinazione e selezione naturale.
In questo campo di studio vengono mescolati argomenti appartenenti a
discipline diverse (biologia, fisica e informatica) con un approccio
computazionale. necessario quindi introdurre dei concetti generali relativi a
queste materie, come le nozioni di selezione naturale e codice genetico, che
sono alla base delle iterazioni degli GA e sono indispensabili per lo sviluppo
logico del procedimento. La maggior parte dei termini utilizzati sono adottati
dalle scienze naturali. Le applicazioni possibili sono innumerevoli ed in questo
lavoro di Tesi ci si soffermer in particolare sullapplicazione di GA per la
risoluzione di problemi fisici e matematici. Uno degli scopi meno espliciti ma
che ritengo di grande importanza in questo lavoro quello di illustrare al lettore
linterazione che esiste tra rami solo apparentemente diversi e indipendenti della
scienza, mostrando quanto sia invece presente una stretta cooperazione tra i
diversi scibili.

1
Dora in avanti nel testo ci riferiremo agli algoritmi genetici con la sigla GA dallinglese genetic
algorithm.
4

La Tesi strutturata in due capitoli:
Capitolo 1: espone le basi degli algoritmi genetici, descrivendo come essi siano
mutuati dal processo di selezione naturale caratteristico dell'evoluzione delle
specie viventi; enuncia e riporta una dimostrazione del teorema degli schemi;
riporta una applicazione degli algoritmi per la progettazione di circuiti
elettronici .
Capitolo 2: la parte applicativa della Tesi, e descrive due casi di studio ai quali
mi sono dedicata al fine di comprendere meglio il funzionamento degli GA e
come essi dipendano dalla numerosit della popolazione, dal numero di
iterazioni, e dagli altri parametri in gioco; si tratta di un semplice problema di
individuazione del punto di massimo di una funzione algebrica, e di
un'applicazione all'analisi di immagini.
Chiudono la Tesi le Conclusioni e una Bibliografia essenziale.
Il lavoro da me effettuato per la realizzazione della Tesi consistito
nell'individuazione e la sintesi dei testi da consultare, la scelta e la comprensione
degli esempi applicativi da Letteratura, e la partecipazione al consolidamento e
completamento del software adoperato per i casi di studio dettagliatamente
descritti nel Capitolo 2.




5





e da un inizio cos semplice, innumerevoli forme bellissime e meravigliose si sono evolute,
e tuttora si evolvono .
Charles Darwin

5
Capitolo 1
1.1 Introduzione agli algoritmi genetici (GA)
Gli algoritmi genetici (GA) sono strategie di ottimizzazione nella ricerca di
soluzioni ispirati al principio della selezione naturale e dellevoluzione
teorizzata nel 1859 da Charles Darwin nellopera On the Origin of
species[1]. Lidea centrale della teoria evoluzionistica che in certe
popolazioni, gli individui che sono pi adatti a vivere in determinate
circostanze hanno una maggiore probabilit di sopravvivenza e di conseguenza
una migliore probabilit di trasmettere specifici tratti alla loro discendenza.
Lidea cardine della teoria evoluzionistica Darwiniana pu essere riassunta
nella seguente frase:
"Non la specie pi forte a sopravvivere, e nemmeno quella pi intelligente ma la specie che
risponde meglio al cambiamento"
2

Col trascorrere delle generazioni, le caratteristiche vantaggiose diverranno
dominanti nella popolazione. Questa la selezione naturale. L'aggettivo
"genetico" per gli algoritmi deriva dal fatto che il modello evolutivo darwiniano
trova spiegazioni nella branca della biologia detta genetica e nel fatto che gli
algoritmi genetici attuano dei meccanismi concettualmente simili a quelli dei
processi biochimici scoperti da questa scienza. Si pu dire che gli algoritmi
genetici sono algoritmi che permettono di valutare delle soluzioni di partenza e
che, ricombinandole ed introducendo elementi di disordine, sono in grado di
crearne di nuove nel tentativo di convergere ad una soluzione ottimale.Oltre a
risolvere quei problemi di ottimizzazione per i quali un approccio procedurale

2
Citazione tratta da On the Origin of Species[1]
6
impossibile o troppo complesso, i GA possono produrre risultati competitivi
anche per compiti normalmente affrontati nel modo classico. La vera prima
creazione di un algoritmo genetico storicamente attribuita a John Henry
Holland che, nel 1975, nel libro Adaptation in Natural and Artificial
Systems[2] pubblic una serie di teorie e di tecniche di fondamentale
importanza per lo sviluppo della materia.


Computer programs that evolve in ways that resemble natural selection can solve complex
problems even their creators do not fully understand
J.Holland

1.2 Quando occorre utilizzare un GA ?

Generalmente, rispetto alle altre tecniche di ricerca, gli algoritmi genetici
trovano soluzioni migliori per il problema posto e riescono a farlo in tempi pi
brevi. I problemi che normalmente si affrontano e si risolvono con i computer
e con il software sono problemi la cui complessit computazionale
polinomiale, ossia il tempo di esecuzione dipende in maniera polinomiale
dalla dimensione dei dati. Tutti quei problemi per i quali il tempo impiegato
anche dal miglior algoritmo cresce troppo velocemente rispetto al numero delle
variabili in gioco, o al loro quadrato, al loro cubo, ecc., risultano impossibili da
risolvere in un tempo ragionevole; tali problemi sono chiamati di tipo N-P, e il
tempo necessario per la soluzione, non polinomiale rispetto alla dimensione
dei dati, usualmente esponenziale.

7


Come esempio, ammettiamo che ci venga assegnato un lavoro che prevede la
stesura dellorario scolastico di una grande scuola composta da molte classi, e
decine di professori. Ci viene raccomandato, inoltre ,che lorario debba tenere
conto del sovraccarico delle lezioni sugli alunni: in altre parole, bene evitare
di sistemare ore di lezioni troppo impegnative o troppo simili una di seguito
allaltra. Naturalmente il tutto deve funzionare in modo tale che i professori
non abbiano ore di lezione nello stesso momento e pause non adeguate tra una
lezione e laltra.
Formalizzando il lavoro, ci ritroviamo con i seguenti dati: le ore fornite da
ciascun professore, il numero di classi e i vincoli suddetti.
Anche solo a livello concettuale difficile trovare un sistema risolutivo:
avremmo la tentazione di scrivere uno schema a blocchi formato da un solo
blocco che chiameremo risolutore, che fornisca in output la tabella degli orari.
In realt, contemplando una ricerca iterativa del problema, creeremmo
probabilmente dei cicli prima sui professori, poi sulle classi, poi verificheremmo
i vincoli, il tutto intriso di asserzioni che verifichino che non vengano
commesse assurdit come la sovrapposizione di ore di lezione nello stesso
momento. Se a livello concettuale tutto questo pu avere un senso, a livello
applicativo, comporterebbe un enorme impiego di tempo ed energia data la
complessit delle interazioni fra variabili.
Quella che abbiamo definito una ricerca dellorario in modo iterativo,
controllando i casi uno ad uno. Ogni caso corrisponde ad una combinazione
differente delle variabili in input.
Per risolvere questo tipo di problemi di ottimizzazione combinatoria pi
conveniente utilizzare algoritmi non lineari: di norma si usano metodi di
approssimazione della migliore soluzione che si basano sul concetto di
8
probabilit. Sembra paradossale, ma in questi casi la miglior soluzione sembra
sia estrarre casualmente una combinazione degli input dallinsieme di tutte le
combinazioni possibili e provarla, se non soddisfacente scartarla e proseguire,
cos fino alla scoperta di una soluzione accettabile.
La seleziona naturale questo, ed cos che i GA lavorano, operando
sullinsieme di tutte le combinazioni o soluzioni e scegliendo un insieme di
elementi con successo pi probabile rispetto le altre.




1.3 Terminologia

Prima dell'effettiva spiegazione del funzionamento degli algoritmi
genetici, necessario premettere che questi ereditano e riadattano dalla
biologia alcuni termini che vengono di seguito preventivamente
presentati per una successiva maggiore chiarezza espositiva:
. Cromosoma : una delle soluzioni a un problema considerato.
Generalmente codificata con un vettore di bit o di caratteri detto
materiale genetico o DNA dellindividuo (soluzione) considerato.
3




3
Gli individui sono detti cromosomi, fatto che potrebbe risultare fuorviante, dato che
ogni cellula di un organismo appartenente ad una data specie possiede un certo
numero anche elevato di cromosomi. Nella maggior parte delle applicazioni sono
comunque sufficienti individui costituiti da un solo cromosoma ovvero aploidi, ma
non mancano i casi in cui individui poliploidi siano stati utilizzati con successo.

9
. Popolazione : insieme di tutte le soluzioni relative al problema considerato.


. Gene : parte di un cromosoma.
Generalmente consiste in una o pi parti
del vettore di bit o caratteri che codificano
il cromosoma.


. Fitness : grado di valutazione associato
a una soluzione.La valutazione avviene in
base ad una funzione appositamente
progettata detta funzione di fitness.


. Crossover : generazione di una nuova
soluzione mescolando delle soluzioni
esistenti.


. Mutazione: alterazione casuale di una
soluzione.







Figura 1. Rappresentazione di un
cromosoma e del suo materiale genetico .
10

1.4 Funzionamento di un GA

Un tipico algoritmo genetico, nel corso della sua esecuzione, provvede a fare
evolvere delle soluzioni secondo il seguente schema di base:
1. Generazione casuale della prima popolazione di soluzioni (cromosomi) e
applicazione della funzione di fitness alle soluzioni appartenenti
all'attuale popolazione.
2. Selezione delle soluzioni considerate migliori in base al risultato della
funzione di fitness e della logica di selezione scelta.
3. Procedimento di crossover e mutazione per generare delle soluzioni
ibride a partire dalle soluzioni scelte al punto 2.
4. Creazione di una nuova popolazione a partire dalle soluzioni
identificate al punto 3.
5. Riesecuzione della procedura a partire dal punto 2 utilizzando la nuova
popolazione creata al punto 4.



1)Cenerazlone
random della
popolazlone
2)Selezlone degll
lndlvldul per la
rlproduzlone
3)Crossover e
muLazlone
4)lormazlone
della
generazlone
3)Condlzlone dl
ommo?
Sl)ne
no)Lorno al
punLo 2
Figura 2. Schema di funzionamento di un algoritmo genetico.
11

L'iterazione dei passi presentati permette l'evoluzione verso una soluzione
ottimale del problema come garantito dal Teorema Fondamentale di Holland
(detto anche Teorema degli schemi) il quale afferma che dopo una fase iniziale
nella quale il GA esplora in modo quasi random lo spazio di ricerca o di
campionamento, esso si concentra sulla regione pi promettente, i.e. la
regione caratterizzata da individui con fitness maggiori.

1.5 Elementi di base degli algoritmi genetici
Per quanto stato esposto nei paragrafi precedenti possiamo dire che gli
algoritmi genetici operano su una popolazione di cromosomi artificiali che
vengono fatti riprodurre selettivamente. Durante il processo riproduttivo le
repliche dei cromosomi degli individui migliori vengono accoppiate
casualmente e parte del materiale genetico viene scambiato, mentre alcune
piccole mutazioni casuali alterano localmente la struttura del codice genetico.
Le nuove strutture genetiche vanno dunque a rimpiazzare quelle dei loro
genitori dando luogo ad una nuova generazione di individui. Il processo
continua fino a quando nasce un individuo che rappresenta una soluzione
accettabile per il problema in esame. Gli algoritmi genetici si basano quindi su
tre operatori principali: la riproduzione selettiva degli individui migliori, la
ricombinazione genetica (crossover) e le mutazioni casuali. Prima di analizzare
in maggior dettaglio il funzionamento di questi operatori osserviamo che ci
sono due importanti strumenti necessari allo sviluppo di un algoritmo genetico:
la codifica e la funzione di fitness.

12
1.5.1 Codifica
Per codifica genetica si intende il tipo di rappresentazione che viene utilizzata
per identificare le soluzioni del problema. Esistono diversi tipi di codifica ma la
pi diffusa la Codifica vettoriale binaria: consiste in un vettore di n
campi binari, dove i valori 1 o 0 identificano delle caratteristiche elementari
della soluzione. I vantaggi di questa tecnica risiedono nel fatto di essere
semplice da implementare e da gestire durante l'intera evoluzione. Gli
svantaggi consistono nelle difficolt intrinseche della conversione delle soluzioni
in questa codifica.
Loriginario modello di GA proposto da Holland opera su una popolazione P
di n stringhe di bit (cromosomi o genotipi) di lunghezza l fissata come mostrato
in Figura 3. :





In alternativa alla codifica binaria possono essere usate altri tipi di codifica
come le due riportate di seguito.
Figura 3. Rappresentazione in codifica binaria degli individui
di una popolazione.
13

Codifica vettoriale reale: come la codifica vettoriale binaria ma vengono
utilizzati dei numeri reali. Il vantaggio quello di introdurre una maggiore
espressivit e versatilit nella codifica, a scapito di un'aumentata complessit.

Codifica vettoriale diretta: consiste in una codifica vettoriale dove ogni
campo contiene direttamente i valori relativi al problema. Il vantaggio quello
di una facile codifica, lo svantaggio risiede nella difficile gestione dell'algoritmo
e nella difficile progettazione della funzione di fitness e dei processi di crossover
e mutazione.

1.5.2 Funzione di fitness
Essa valuta la bont degli individui gi della popolazione P nel risolvere il
problema di ricerca dato:
f : P ! (- ", +") f(gi) = fi
L'insieme delle stringhe binarie di lunghezza l ha 2
l
elementi; tale insieme
rappresenta lo spazio di ricerca (search space) del GA, cio lo spazio che il
GA deve esplorare per risolvere il problema di ricerca. I valori della funzione
di fitness sui punti dello spazio di ricerca detto paesaggio d'idoneit
(fitness landscape).



14
Esempio
Supponiamo che la codifica binaria delle soluzioni del nostro problema possa
avvenire tramite stringhe di 2 bit.
Lo spazio di ricerca del GA, S , costituito da 2
l
= 2
2
= 4 elementi:
S = { (0,0), (0,1), (1,0), (1,1) }
I valori di fitness sui punti di S definiscono il paesaggio didoneit del GA.

1.5.3 Operatori
Una volta che la funzione di fitness ha determinato il valore di bont di ogni
individuo della popolazione, una nuova popolazione di individui (o genotipi)
viene creata applicando alcuni operatori che si ispirano alla selezione naturale
e alla genetica.
Gli operatori proposti da Holland sono:
1)Selezione (ispirato alla selezione naturale)
La selezione naturale Darwiniana sostiene che gli individui pi adatti
abbiano maggiori probabilit di sopravvivere nellambiente in cui vivono e,
dunque, maggiore probabilit di riprodursi. Nel contesto del GA di Holland,
gli individui pi adatti sono quelli con fitness pi alta, poich risolvono meglio
di altri il problema di ricerca dato; per questo essi devono essere privilegiati
nella fase di selezione degli individui che potranno riprodursi dando luogo a
nuovi individui.
15
A causa di complessi fenomeni di interazione non dato per scontato n che
da due soluzioni promettenti ne nasca una terza pi promettente n che da due
soluzioni con valori di fitness basso ne venga generata una terza con valore di
fitness pi basso. Per ovviare a questi problemi, durante la scelta delle soluzioni
candidate all'evoluzione, oltre che sul parametro ottenuto dalla funzione di
fitness ci si basa anche su particolari tecniche di "selezione" di cui si analizzano
di seguito i principali tratti.
Selezione a roulette: la probabilit che una soluzione venga scelta per farla
evolvere direttamente proporzionale al valore restituito dalla funzione di
fitness.
Sia fi il valore di fitness del genotipo gi, la probabilit che gi sia selezionato per
la riproduzione :
ps,i = fi / #fj
dove la somma calcolata sull'intera popolazione attuale di individui.
Tali probabilit sono utilizzate per costruire una sorta di roulette come di
seguito :
1. La circonferenza di un immaginario cerchio viene divisa in M segmenti con
apertura angolare:
Ai=!!!! ! !" con ! Ai = 2"
e ciascun individuo gi, associato al corrispondente segmento Ai.


16
2. si estraggono tanti numeri casuali, con distribuzione uniforme tra 0 e
2",quanti sono gli individui che si vogliono selezionare.
3. il cromosoma (i) viene scelto se il numero casuale cade nel relativo settore Ai.
Ogni volta che un individuo della popolazione selezionato ne viene creata
una copia; tale copia inserita nel cos detto mating pool (piscina
daccoppiamento).Quando il mating pool riempito con esattamente n
(numero di individui della popolazione) copie di individui della popolazione,
nuovi n discendenti sono creati applicando gli operatori genetici.


Esempio
I quattro individui A1, A2, A3 e A4, con probabilit di selezione 0.12, 0.18, 0.3 e
0.4, occupano uno spicchio di roulette di ampiezza pari alla propria
probabilit di selezione(vedi Figura 4.). Se viene generato un numero tra 0 e
0.12 verr selezionato lelemento A1,se viene estratto un numero compreso tra
0.12 e 0.3=0.12+0.18 (estremo dellintervallo ottenuto sommando al primo
estremo 0.12 la probabilit di estrazione dellelemento A2 ) verr selezionato
lelemento A2 e cos via. Nell'esempio l'operatore di selezione genera il numero
casuale c = 0.78 e l'individuo A4 viene selezionato.
Figura 4. Rappresentazione della roulette usata per il processo di selezione.
17
2)Crossover (ispirato alla genetica)
Si scelgono a caso due individui nel mating pool (genitori) e un punto di taglio
(punto di crossover) su di essi. Le porzioni di genotipo alla destra del punto di
crossover vengono scambiate generando due discendenti (vedi Figura
5.).L'operatore di crossover applicato, in accordo a una prefissata probabilit
pc, n/2 volte in modo da ottenere n discendenti; nel caso in cui il crossover non
sia applicato, i discendenti coincidono con i genitori.


La modalit di crossover appena descritta detta a un punto poich lo scambio
del materiale genetico avviene in seguito alla scelta di un punto di taglio.
Esistono ulteriori modalit di crossover come quello a due punti che consiste
nel considerare due soluzioni adatte all'evoluzione e nel tagliare i loro vettori di
codifica in due punti predefiniti o casuali al fine di ottenere una testa, una parte
centrale ed una coda dalla prima e dalla seconda soluzione. La prima nuova
soluzione sar data dalla testa e della coda della prima soluzione e dalla parte
centrale della seconda soluzione. La seconda nuova soluzione sar data dalla
parte centrale della prima soluzione e dalla testa e dalla coda della seconda
soluzione. Esiste anche il Crossover uniforme che consiste nello scambiare
casualmente dei bit tra le soluzioni candidate all'evoluzione.
Figura 5. Rappresentazione del processo di crossover
18

3)Mutazione (ispirato alla genetica)
Una volta che due discendenti sono stati generati per mezzo del crossover, in
funzione di una usualmente piccola probabilit pm, il valore di alcuni bit dei
nuovi individui sono cambiati da 0 in 1 o viceversa (vedi Figura 6.). Come il
crossover, rappresenta una metafora della riproduzione sessuale, l'operatore di
mutazione modella il fenomeno genetico della rara variazione di elementi del
genotipo negli esseri viventi durante la riproduzione. Il punto di vista
tradizionale che lincrocio sia il pi importante dei due operatori genetici
perch responsabile di una rapida esplorazione dello spazio di ricerca. Tuttavia
la presenza della mutazione ugualmente essenziale per quanto
apparentemente piccola sia la sua incidenza sulla ricerca.


Il meccanismo di selezione, ricombinazione e calcolo della fitness viene iterato.
Levoluzione termina quando viene raggiunto lottimo, se questo noto.
Altrimenti levoluzione termina quando viene raggiunto il numero massimo Ng
di generazioni oppure quando un indicatore di convergenza (uniformit della
popolazione, mancanza di progressi nellevoluzione) raggiunge un determinato
valore . Se lalgoritmo genetico correttamente implementato, la popolazione
evolver nel susseguirsi delle generazioni in modo che la fitness del miglior
individuo e la media in ogni generazione cresca verso lottimo globale.
Figura 6. Rappresentazione del processo di mutazione.
19
1.6 Perch i GA funzionano?
Il processo evolutivo della popolazione di cromosomi corrisponde ad una
ricerca nello spazio delle soluzioni potenziali. Tale ricerca richiede l'equilibrio
di due finalit apparentemente in contrasto: lo sfruttamento delle soluzioni
migliori e l'esplorazione dello spazio delle soluzioni. E' principalmente questa
capacit di bilanciamento a distinguere gli algoritmi genetici da altre
metodologie che invece sfruttano costantemente le soluzioni migliori trovate,
rinunciando all'esplorazione dello spazio delle soluzioni, o la ricerca casuale,
che, al contrario, esplora tale spazio senza dare alcun peso alle regioni
dimostratesi pi promettenti. Gli algoritmi genetici effettuano una ricerca
multi-direzionale mantenendo una popolazione di soluzioni potenziali e
incoraggiando lo scambio di informazione .

Figura 7. L'evoluzione pu essere vista come una ricerca nello spazio di tutti gli organismi
possibili, rappresentato qui nel piano. L'operazione di incrocio (in rosso) agisce in modo
creativo, combinando di quando in quando caratteristiche disparate e saltando verso nuove
regioni dello spazio degli organismi dove risiede la maggior parte degli individui pi adatti.
La mutazione (in verde), al contrario, tende quasi sempre a cercare il miglior organismo tra i
primi vicini.

20
1.7 Teorema degli schemi
John H. Holland, insieme ai suoi studenti della University of Michigan, ha
perseguito lo scopo di studiare le dinamiche generali che governano
l'adattamento in natura e trasporle in analoghi informatici ovvero i GA,
piuttosto che cercare di progettare algoritmi per un problema specifico. Era
per necessario fornire una valida base teorica che garantisse la convergenza
del GA verso lottimo. Questo viene fatto attraverso il Teorema degli
schemi. La formulazione tradizionale della teoria sugli GA (1975) ipotizza che
le soluzioni migliori tendano ad essere costituite da blocchi buoni, cio da
piccole sequenze di bit (non necessariamente vicine) che aumentano il valore
della funzione di fitness del cromosoma. Nel teorema fondamentale degli algoritmi
genetici (o teorema degli schemi)[2] Holland dimostra che gli individui cos costituiti
tendono a crescere esponenzialmente nella popolazione attraverso il
meccanismo dell'incrocio, assicurando cos la convergenza dell'algoritmo
genetico verso una soluzione ottimale. L'algoritmo funziona individuando,
favorendo e ricombinando tali blocchi. Viene qui esposto il teorema cos come
presentato da Holland, relativo cio alla codifica binaria.
E necessario introdurre i seguenti concetti:
Schema: E' un cromosoma,di lunghezza predefinita, in cui siano specificati i
valori assunti da alcune particolari posizioni di bit nella stringa e siano invece
lasciati indefiniti i valori associati alle altre posizioni. Due esempi di schemi sono
i seguenti :
Ha = 1 * * * * 0 Hb = * * * * * 1 0
cio rispettivamente l'insieme di tutte le stringhe di sei bit che cominciano con
1 e finiscono con zero (100000, 100010, 100100,....) e l'insieme di tutte le
21
stringhe di lunghezza sette e che finiscono con 10.
Istanze di uno schema : Le differenti stringhe corrispondenti allo stesso
schema. Ad esempio 100000 una istanza dello schema Ha.
Ordine dello schema o(H) :il numero di bit definiti ovvero due sia per
Ha che per Hb .
Lunghezza di definizione d(H) : la distanza tra i due bit definiti pi
esterni (5 e 1 rispettivamente per Ha e Hb) .
In un algoritmo genetico, la competizione fra cromosomi pu essere
equivalentemente intesa, dal punto di vista teorico, come una competizione
fra schemi. A questo proposito si noti che:
Il GA agendo su una stringa di lunghezza l come se agisse su una istanza
per pi schemi, !
!
in particolare essendo queste le permutazioni di l bit.
1.7.1 Dimostrazione
Supponendo di avere nella popolazione m istanze di un particolare schema
H, all'istante t cio al ciclo generazionale t-esimo, si pu indicare m con la
seguente notazione che ne descrive la dipendenza dallo schema e dalla
generazione considerate: m=m(H,t).Durante la riproduzione, nell'Algoritmo
Genetico,gli individui ricevono copie in proporzione alla loro idoneit o
valore di fitness !"!E' questo il criterio di selezione proporzionale in cui un
individuo verr selezionato con una probabilit pari a:

!"
!"
!
!
(1.1)

22
Detta f(H) l'idoneit media dello schema H, all'istante generazionale t, la
probabilit media delle m istanze di H di essere selezionate sar:

!!!!
!"
!
!
(1.2)
Ad un istante t+1 si pu quindi esprimere:
! !! ! ! ! ! ! !! ! ! ! !
!!!!
!"
!
!
(1.3)
La (1.3) afferma semplicemente che il numero di istanze dello schema che ci
si pu aspettare nella successiva generazione, aumenta linearmente sia con
n, ove n la dimensione della popolazione, sia con f(H), idoneit media
delle stringhe appartenenti allo schema.
L'idoneit media su tutta la popolazione sia indicata con :
! ! !"!!
!
!
!
!"
!
!
!
!!
(1.4)
Sostituendo questa espressione nella (1.3) si ottiene la seguente (1.5):
! !! ! ! ! ! ! !! ! !
!!!!
!
(1.5)
Quindi uno schema accresce o decresce il numero di sue istanze secondo il
rapporto fra idoneit media di schema e idoneit media di popolazione; gli
schemi con valore di idoneit' alto riceveranno molte repliche nelle prossime
generazioni. Quelli con valori bassi al contrario riceveranno un numero di
repliche che andr progressivamente decrementandosi.

23
Supponiamo che uno schema H abbia f(H) maggiore di ! di una quantit
c! con c fattore costante, cio :
! !! ! ! ! ! ! !! ! !
!!!!
!
! ! ! ! ! !!!! !! (1.7)
Ma ! !! ! ! !! ! !! ! !!!! !! e questo vale per ogni t, quindi
! !! ! ! !! ! !! ! ! !! ! ! ! ! !
!
! !!!! !! da cui la regola
generale:
! !! ! ! ! ! !! ! !!
!
! !!!! !! (1.8)
L'effetto della riproduzione, come espresso dalla (1.8) quindi quello di
allocare un numero di discendenti che cresce o decresce in progressione
geometrica per gli schemi aventi grado di idoneit rispettivamente superiore
o inferiore alla media di un fattore costante c. A questo punto bisogna
considerare lincrocio .L'incrocio distruttivo per lo schema quando una
parte delle posizioni fissate dello schema si vengono a trovare a destra del
punto di incrocio e una parte a sinistra. Quindi se la lunghezza definita
corta l'incrocio sar distruttivo con minore probabilit nei confronti dello
schema. Se l la lunghezza del cromosoma e il punto di incrocio scelto in
una posizione a caso fra 1 e l-1 la probabilit che esso divida le posizioni
definite :
!
!
! !!!!!!! ! !! (1.9)
dove con d(H) si intende la lunghezza definita dello schema H. Uno schema,
dunque, sopravvive all'incrocio se il punto di incrocio cade al di fuori della
lunghezza definita.Detta ps tale probabilit di sopravvivenza dello schema,
si ha che
24
!
!
! ! ! !
!
! ! !
! !
!!!
(1.10)
e se dopo la riproduzione, poi, l'incrocio non avviene sempre ma solo con
probabilit pc allora si pu calcolare un limite inferiore alla probabilit di
sopravvivenza di uno schema H, cio :
!
!
! ! ! !
!
! !
!!!
(1.11)
Nell'ipotesi di statistica indipendenza fra le operazioni di incrocio e
riproduzione, si possono moltiplicare il numero atteso nella generazione t+1
di istanze dello schema dopo la selezione proporzionale (1.5),per la
probabilit di sopravvivenza all'incrocio (1.10),ottenendo il numero di
istanze di schema atteso nella generazione t+1 dopo riproduzione e
incrocio.
Per concludere esaminiamo anche l'effetto della mutazione. La probabilit
di mutazione di un singolo bit sia pm ; se lo schema H deve sopravvivere
alla mutazione, tutti i singoli bit che esso contiene nelle posizioni fissate
devono sopravvivere. Quindi un singolo bit ha una probabilit di
sopravvivere alla mutazione pari a 1 - pm ; poich ogni singola mutazione
statisticamente indipendente dalle altre e uno schema ha ordine o(H) ossia
un altrettanto numero di bit, la probabilit di sopravvivenza di uno schema
alla mutazione
!
!
! !! ! !
!
!
!!!!
(1.12)


25
In conclusione si provato che (enunciato del Teorema degli schemi ) :
Schemi brevi, di basso ordine, sopra la media ricevono un incremento esponenziale nelle
successive generazioni di un algoritmo genetico.
Il numero di istanze di uno schema H alla generazione t+1, dopo un
incrocio che avviene con probabilit pc e una mutazione che avviene con
probabilit pm , dato infatti dalla seguente espressione:
! !! ! ! ! ! ! !! ! !
! !
!
! ! ! !
!
! !
!!!
! !! ! !
!
!
!!!!
(1.13)
da cui si vede che le stringhe migliori sono ottenute dal confronto fra schemi
a pi alta idoneit, a pi corta lunghezza definita e minore probabilit di
mutazione.










26

1.8 Applicazioni di GA
Le innumerevoli applicazioni degli algoritmi genetici spaziano dalla
progettazione di antenne (figura 8.) [3] allo sviluppo di modelli come quello
della corona solare[4], ad applicazioni in diagnostica medica per
immagini[5].E interessante osservare, come mostrano i seguenti grafici (Figura
9 e 10), come risulti stabilmente crescente nel tempo lutilizzo di tali tecniche.Si
analizzer di seguito, a titolo di esempio, l'applicazione dei GA alla risoluzione
di un problema di elettronica.










Figura 10. Raggruppamento dei
temi di ricerca di astrofisica che
fanno uso di GA [6]

Figura 9. Numero ricerche in
astrofisica che hanno fatto uso di
GA [6]

Figura 8. Queste che sembrano graffette modellate da
bambini sono le antenne progettate dalla NASA con GA per
la missione ST5 2006 [3]

27


1.8.1 Utilizzo della programmazione genetica in elettronica
Nella maggior parte dei casi i problemi di elettronica hanno una natura
combinatoriale, cio per risolverli si deve sondare un enorme spazio di
possibilit al fine di trovare quella che meglio soddisfa determinate richieste. Un
circuito elettronico viene sempre schematizzato in termini di pochi elementi
fondamentali collegati tra loro: resistori, induttanze, capacit, diodi,etc.
Consideriamo a titolo di esempio [7] un problema concreto quale la
realizzazione di un filtro passa basso con frequenza di taglio fT di 1kHz. Gli
elementi primordiali sono banalmente dei circuiti in cui dei cavi conduttori
connettono un input ad un output. Dunque ciascun circuito comincia come un
embrione elementare che consiste in un singolo cavo che va dall'input
all'output.Il circuito embrionale cresce per applicazione progressiva di funzioni
di costruzione dei circuiti. Alcune di queste funzioni inseriscono particolari
componenti, altre modificano lo schema di connessioni tra questi. A nostra
disposizione ci sono resistori, induttanze e capacit che connettono via via pi
cavi tra loro.
Il primo passo quello di tradurre l'organizzazione circuitale in un genotipo
matematico, cio una stringa che identifica il tipo di componente (R per
resistenza, C per condensatore...), ed i punti di connessione nella rete.
L'algoritmo genetico consente alle componenti R,L, e C di creare collegamenti
tra i cavi, connessioni a terra, cortocircuiti. L'idoneit del circuito sar valutata
in base alla capacit dello stesso di bloccare le frequenze superiori a fT.

28
Nella figura seguente (vedi Figura 11.) si mostra un esempio di mescolamento
tra due circuiti, seguito dal mescolamento relativo modellizzato con il cross-
over tra le due stringhe. La riga in alto mostra i due individui prima del
crossover, e la seconda riga dall'alto mostra l'avvenuto scambio di materiale
genetico. Sia G la lunghezza fissata del genoma, quindi il numero massimo di
collegamenti possibili, e sia P il numero di nodi (fissato) del circuito. Ogni nodo
pu essere collegato con ciascuno degli altri P-1 nodi, con un certo numero di
componenti complessivamente minore di G (possibilit di collegamento in
parallelo).Ogni gene composto (se supponiamo che i valori dei componenti
siano fissi) da tre caratteri, due numerici (nodo di partenza e nodo di arrivo) e
uno alfabetico centrale che indica il tipo di collegamento (CC cortocircuito, R
resistenza, L induttanza, C capacit, eventualmente in maniera esplicita CA
circuito aperto).



Figura 11. Rappresentazione in termini circuitali(in alto) ed in termini di geni (in basso) del
processo di cross-over tra due circuiti(in questa rappresentazione il CA non stato
esplicitamente indicato).
29

Ogni collegamento risulta indipendente dagli altri, quindi possiamo avere
collegamenti in parallelo ma escludiamo la possibilit di avere collegamenti in
serie, poich questi comporterebbero la creazione di nuovi nodi, quindi
implicitamente la variazione della lunghezza del genoma che noi abbiam
fissato.
Cerchiamo dunque una stima del numero di possibili combinazioni: ogni nodo
di partenza pu essere scelto in P modi, ogni nodo di arrivo in P-1 modi e il
collegamento in n = 5 ulteriori modi differenti. Tutto questo va considerato per
tutti i G elementi del genoma (G = 5 in questo). Quindi il numero N di
possibili combinazioni di G geni che l'algoritmo pu simulare :

! ! !! ! ! ! ! ! !!
!


Nel nostro caso se G=5 avremmo N=!"#
!
possibilit.
Se trattiamo il circuito aperto come una delle cinque possibilit di
collegamento, tra due nodi esiste sempre almeno un collegamento. Il numero
minimo di collegamenti possibili non ridondanti : P*(P-1) /2 .
Il cromosoma deve dunque essere lungo abbastanza da consentire questo
numero, cio un circuito composto solo da collegamenti semplici e nodi
isolati. Dopo un certo tempo si sar ottenuto un gran numero di variazioni, e,
in base alla capacit del circuito di attenuare le frequenze indesiderate, noi
possiamo potremo ritenere di aver raggiunto una soluzione soddisfacente.
Il processo fornisce la topologia del circuito. Del circuito soluzione noi non
30
conosciamo i dettagli, in quanto ottenuto in base a combinazioni casuali di altri
circuiti, ma sappiamo che il suo funzionamento soddisfacente rispetto alla
condizione fT=1kHz (andando a calcolare un fattore di merito). L'algoritmo
compone automaticamente i circuiti senza utilizzare alcun know-how del
sistema.

Figura 12. Evoluzione di un filtro passa-basso a partire dallincrocio di vari
individui.Tratto da [7].


31


Capitolo 2
2.1 Casi di studio
In questo capitolo verranno presentati due esempi di applicazioni di algoritmi
genetici con lutilizzo di Matlab (The Mathworks). I codici derivano da sorgenti
liberamente disponibili in Rete, e sono riportati nelle appendici. Essi sono stati
opportunamente corretti, completati e arricchiti per quanto concerne
l'interfaccia con l'utente, dal mio Relatore con la mia attiva partecipazione.
Come variante rispetto quanto descritto nel capitolo precedente, il software
adoperato parte dalla popolazione iniziale di numerosit N, effettua N volte il
crossover (ottenendo una nuova popolazione avente un numero doppio di
individui), la mutazione, realizza la selezione degli N individui pi adatti,
verifica il raggiungimento di una condizione di stop, e reitera.
Il primo esempio che verr analizzato un problema matematico riguardante
la ricerca del massimo di una funzione di una variabile, mentre il secondo
mostra unapplicazione di GA per lelaborazione di immagini digitali.
2.2 Ricerca del massimo di una funzione ad una variabile
Ci proponiamo di osservare il funzionamento di un algoritmo genetico in una
situazione molto semplice: il problema consiste nel trovare il valore della
variabile x che massimizza la funzione f(x)=!"# ! !! ! !"!
!
dove x pu
variare tra 0 e 31 (si vedr in seguito il perch della scelta dei limiti).
32

Figura 13. Grafico della funzione da massimizzare

Il codice riportato interamente in Appendice A.
Fissiamo in partenza il numero di generazioni che vogliamo creare, e dunque
di iterazioni: essendo questo un esempio dimostrativo del funzionamento del
meccanismo alla base di un GA, ci limiteremo a sole cinque generazioni cos
da poter analizzare loutput del programma ad ogni ciclo.Il secondo passo
consiste nella scelta della rappresentazione genetica: utilizziamo un codice
binario a stringhe di lunghezza 5 che ci permettono di codificare numeri interi
da 0 (00000) a 31 (11111)
4
. Come si intuisce, la scelta dei limiti per la
variabile indipendente, prima effettuata, (x tra 0 e 31) non stata quindi
casuale, ma rispecchia la struttura del codice GA; scegliendo (arbitrariamente)
5 bit per la definizione dei geni, otteniamo 32 possibili valori, che coprono il
range di numeri interi tra 0 e 31. Naturalmente, ove si fosse cercata una
soluzione non intera, o fosse stata necessaria una maggior accuratezza, o si

4
Il processo di trasformazione da numero binario a numero decimale dato da
x = ! ! !
! !!!
!!!
dove p indica la posizione del numero intero binario a partire
dall ultima cifra, N il numero di cifre e i il valore binario dellintero
corrispondente. Ad esempio 10100 =1*!
!
+ 0*!
!
+ 1*!
!
+ 0*!
!
+ 0*!
!
=20
33
fosse voluto un range pi ampio, si sarebbe considerato un numero maggiore
di bit.
Creiamo dunque una piccola popolazione iniziale composta solamente da due
stringhe generate casualmente. Ciascuna stringa viene decodificata da binario
in decimale e il suo valore di fitness calcolato applicando la funzione f al
numero decimale ottenuto.

Figura 14. Output del programma Matlab. Da sinistra verso destra, le varie colonne
rappresentano per i diversi individui : un indice progressivo, la codifica in binario, la
decodifica in decimale ed il valore di fitness.

Per ciascun individuo della popolazione attuale che indichiamo con gli
indici 1 e 2 , scelto in maniera casuale il compagno di accoppiamento e
la posizione del punto di taglio cos da poter effettuare il processo di
crossover.




In questiterazione, casualmente, il crossover ha incrociato ciascun individuo
con se stesso.

Dopo il crossover la popolazione si presenta come segue :

34


Per ciascun individuo si applicher con una probabilit (arbitraria!) pm = 50 %
loperatore di mutazione ad un bit della stringa che viene scelto casualmente.



La popolazione a questo punto si presenta come segue:



Lindividuo con il massimo valore di fitness viene registrato in una variabile, e
di esso si terr conto nel proseguo poich saranno utilizzati in combinazione,
come regole di selezione per formare la generazione successiva, sia il criterio di
selezione a roulette che il criterio elitistico, il quale garantisce il trasferimento
alla generazione successiva del miglior individuo a disposizione
5
.

5
Metodo elitistico [8]
Questo metodo che consiste nel conservare per ogni generazione il migliore individuo
e di sostituirlo al peggiore .E infatti provato che per un algoritmo genetico classico,
questo metodo rende pi efficace la ricerca del massimo globale, poich reintroduce
35


La nuova popolazione di cromosomi ottenuta stata decodificata e valutata.
Alla fine del processo di valutazione ciascuna stringa riceve una probabilit di
riproduzione proporzionale alla propria fitness; ci permette la realizzazione
dei settori circolari della roulette, ciascuno associato ad un individuo.
Il generatore di numeri casuali ci permette di estrarre dal pool dei 4 individui i
due potenziali, che andranno a formare la prima generazione. Di questi,
lesemplare con il valore di fitness pi basso viene sostituito con il migliore
individuo di cui si tenuta memoria precedentemente (metodo elitistico).


Figura 15. I cerchietti in blu rappresentano i numeri casuali generati che permettono di
selezionare gli individui che potranno formare la generazione di interesse in base al settore
della roulette in cui cadono. Per ciascun settore riportato il valore decimale dellindividuo
che esso rappresenta.

delle istanze di schemi promettenti che possono aiutare la localizzazione del massimo
quando il meccanismo di selezione proporzionale non alloca il valore atteso di
discendenza ai migliori. Si corre comunque il rischio di favorire una ricerca locale a
scapito di una prospettiva globale.

36

Di seguito vengono riportati gli output dei vari cicli di iterazione.

########################## l1L8AZlCnL n. 2 ###################
------- opolazlone aLLuale ---------------------------------
1 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000
2 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000
C8CSSCvL8 Lra lndlvlduo dl lndlce 1 e lndlvlduo dl lndlce 2, al blL 3 (da slnlsLra)
C8CSSCvL8 Lra lndlvlduo dl lndlce 2 e lndlvlduo dl lndlce 1, al blL 3 (da slnlsLra)
------- opolazlone dopo crossover ----------------------
---
1 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000
2 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000
3 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000
4 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000

Mu1AZlCnL nell'lndlvlduo dl lndlce 2, al blL 2 (da
slnlsLra)
Mu1AZlCnL nell'lndlvlduo dl lndlce 3, al blL 2 (da
slnlsLra)
------- opolazlone dopo muLazlone---------------
1 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000
2 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000
3 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000
4 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000

lndlvlduo con masslma flLness:
1 > 0 1 1 1 0 - 14.0000 --- flLness 239.0000

########################## l1L8AZlCnL n. 3 ###################
------- opolazlone aLLuale ---------------------------------
1 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000
2 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000
C8CSSCvL8 Lra lndlvlduo dl lndlce 1 e lndlvlduo dl lndlce 2, al blL 4 (da slnlsLra)
C8CSSCvL8 Lra lndlvlduo dl lndlce 2 e lndlvlduo dl lndlce 1, al blL 3 (da slnlsLra)
------- opolazlone dopo crossover ----------------------
1 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000
2 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000
3 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000
4 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000
Mu1AZlCnL nell'lndlvlduo dl lndlce 1, al blL 3 (da
slnlsLra)
Mu1AZlCnL nell'lndlvlduo dl lndlce 2, al blL 4 (da
slnlsLra)
------- opolazlone dopo muLazlone---------------
1 > 0 1 1 1 1 - 13.0000 --- flLness 260.000000
2 > 0 0 1 0 0 - 4.0000 --- flLness 139.000000
3 > 0 0 1 1 0 - 6.0000 --- flLness 179.000000
37
4 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000

lndlvlduo con masslma flLness:
1 > 0 1 1 1 1 - 13.0000 --- flLness 260.000000


########################## l1L8AZlCnL n. 4 ###################
------- opolazlone aLLuale ---------------------------------
1 > 0 1 1 1 1 - 13.0000 --- flLness 260.000000
2 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000
C8CSSCvL8 Lra lndlvlduo dl lndlce 1 e lndlvlduo dl lndlce 2, al blL 2 (da slnlsLra)
C8CSSCvL8 Lra lndlvlduo dl lndlce 2 e lndlvlduo dl lndlce 1, al blL 2 (da slnlsLra)
------- opolazlone dopo crossover -------------------------
1 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000
2 > 0 1 1 1 1 - 13.0000 --- flLness 260.000000
3 > 0 1 1 1 1 - 13.0000 --- flLness 260.000000
4 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000
Mu1AZlCnL nell'lndlvlduo dl lndlce 1, al blL 1 (da slnlsLra)
Mu1AZlCnL nell'lndlvlduo dl lndlce 4, al blL 3 (da slnlsLra)
------- opolazlone dopo muLazlone---------------
1 > 1 1 1 1 0 - 30.0000 --- flLness 33.000000
2 > 0 1 1 1 1 - 13.0000 --- flLness 260.000000
3 > 0 1 1 1 1 - 13.0000 --- flLness 260.000000
4 > 0 1 0 1 0 - 10.0000 --- flLness 233.000000
lndlvlduo con masslma flLness:
1 > 0 1 1 1 1 - 13.0000 --- flLness 260.000000


########################## l1L8AZlCnL n. 3 ###################
------- opolazlone aLLuale ---------------------------------
1 > 0 1 1 1 1 - 13.0000 --- flLness 260.000000
2 > 0 1 0 1 0 - 10.0000 --- flLness 233.000000
C8CSSCvL8 Lra lndlvlduo dl lndlce 1 e lndlvlduo dl lndlce 2, al blL 4 (da slnlsLra)
C8CSSCvL8 Lra lndlvlduo dl lndlce 2 e lndlvlduo dl lndlce 2, al blL 2 (da slnlsLra)
------- opolazlone dopo crossover -------------------------
1 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000
2 > 0 1 0 1 1 - 11.0000 --- flLness 244.000000
3 > 0 1 0 1 0 - 10.0000 --- flLness 233.000000
4 > 0 1 0 1 0 - 10.0000 --- flLness 233.000000
Mu1AZlCnL nell'lndlvlduo dl lndlce 2, al blL 2 (da slnlsLra)
------- opolazlone dopo muLazlone---------------
1 > 0 1 1 1 0 - 14.0000 --- flLness 239.000000
2 > 0 0 0 1 1 - 3.0000 --- flLness 116.000000
3 > 0 1 0 1 0 - 10.0000 --- flLness 233.000000
4 > 0 1 0 1 0 - 10.0000 --- flLness 233.000000
lndlvlduo con masslma flLness :
1 > 0 1 1 1 1 - 13.0000 --- flLness 260.000000
!"#$%&"'( * +,-....... /0123455 67.-......8

38

Figura 16. Andamento della fitness media della popolazione(in blu) e del valore massimo di
fitness(in rosso) in funzione del numero di iterazioni


Il grafico in figura 16 illustra landamento della fitness massima e della fitness
media della popolazione, in funzione della generazione. Tale grafico permette
di notare come, dopo un certo numero di iterazioni, si raggiunga la stabilit del
valore massimo. La soluzione trovata effettivamente quella corrispondente al
punto di massimo della funzione di fitness. Si pu notare come anche il valore
medio della fitness tenda ad aumentare verso il massimo, ma tale tendenza non
sempre stabile, potendo verificarsi oscillazioni anche molto ampie. Questa
convergenza del massimo alla soluzione ottimale dopo un certo numero di cicli
verifica la validit del teorema degli schemi.

2.3 Analisi di immagini digitali
Questo paragrafo illustra un ulteriore esempio di applicazione degli algoritmi
genetici, che sfrutta il codice riportato nellappendice B. Si tratta di un test
effettuato su un'immagine, denominata 'blobs.gif',
6
reperibile a corredo di

6
In analisi d'immagine si tende a indicare con il termine inglese "blob" qualunque
oggetto di interesse di forma approssimativamente circolare, quali nel nostro caso le
particelle d'oro di cui si parla nel seguito.
39
ImageJ, un software di trattamento e analisi di immagini liberamente disponibile
in rete (http://rsbweb.nih.gov/ij/).


L'immagine microscopica, mostrata in figura 17 , raffigura delle particelle di oro
su un substrato. Considereremo le particelle d'oro (grigio scuro) come gli
"oggetti" di interesse, e il substrato, grigio chiaro, sar lo sfondo. Si pu notare
come, mentre la maggior parte degli "oggetti" mostrati sia di forma rozzamente
ellittica, alcuni siano pi complessi, perch costituiti dall'accostamento di due
blob. Ci poniamo il problema di separare questi ultimi oggetti nei blob
costituenti, con il fine, ad esempio, di contare le particelle con maggior
accuratezza. Se estendiamo l'idea ad altri tipi di immagini, per esempio
immagini microscopiche rappresentanti cellule o microorganismi, lo scopo
potrebbe essere la separazione di due individui allo scopo di poterne indagare
l'interno senza essere fuorviati dagli accoppiamenti casuali tra blob.



Figura 17. L'immagine di partenza per l'applicazione del GA allo scopo di separare i "blob"
accoppiati.

Separare oggetti visualmente connessi un problema che si pone spesso, in
analisi d'immagini. Per richiamare un altro campo di applicabilit, possiamo
considerare il caso dei noduli polmonari con contatto vascolare. A differenza dei
40
noduli detti "isolati", relativamente facili da individuare con un sistema
automatico perch lontani da strutture che potrebbero in parte mascherarne la
natura (in particolare i vasi che irrorano i polmoni), i noduli vascolari crescono a
contatto con un vaso (figura 18) e con esso tendono a confondersi.


Figura 18. Particolare di un'immagine di tomografia computerizzata (TAC), che mostra un
nodulo polmonare (struttura tondeggiante al centro dell'immagine) con contatto vascolare (il
vaso parzialmente visibile, nel quadrante destro in basso). Tratta da [9]

L'applicazione del codice GA al problema della separazione dei blob "doppi"
nell'immagine di figura 17 , comporta naturalmente alcune scelte, in particolare:

a. quale modello di blob si pu adoperare nella segmentazione, ossia
nell'individuazione dei singoli blob costituenti quelli "doppi"?
b. di che tipo di preelaborazione necessita l'immagine, al fine di essere
inserita nell'algoritmo GA?
c. quali sono i parametri da introdurre nel modello, che poi diverranno i
parametri genetici del GA?
d. qual la funzione obiettivo da massimizzare o minimizzare?
41
Naturalmente le risposte alle varie domande sono tutte tra loro connesse.
Cominciamo dal punto (a). Siccome i blob hanno forma grossolanamente
ellittica, si pu proporre un modello semplificato che individui ciascuno dei blob
tramite un'ellisse generica (ossia di assi principali, centro, e inclinazione
arbitrari). Il software Matlab necessario per il tracciamento di un'ellisse, dati i
suddetti cinque parametri stato reperito all indirizzo riportato in nota
7
.
La scelta del modello semplificato in forma di ellissi porta facilmente al punto (b),
perch una preelaborazione possibile l'individuazione dei bordi degli oggetti, in
modo tale che ciascuno sia rappresentato solo dai propri pixel di bordo. Con la
definizione del modello, resta anche definito il punto (c), perch saranno usati i
menzionati cinque parametri (variabili entro limiti ragionevoli e dipendenti dalle
dimensioni dell'immagine e dei blob) come geni, da far evolvere con le regole dei
GA. Per definire il punto (d) conviene mostrare l'immagine originale dopo la
preelaborazione, con sovrapposta un'ellisse generica (figura 19):


Figura 19. L'immagine originale dopo preprocessing (individuazione dei bordi),
con un'ellisse generica sovrapposta.

Conviene ricordare che un'immagine essenzialmente una matrice le cui celle (i
pixel, picture element) hanno un valore che varia da 0 per il colore nero, ad un
valore massimo per il bianco (usualmente il valore 1, se i pixel sono rappresentati

7
http://carmelab.huji.ac.il/software/General/general.html
42
con numeri reali, o 255 se con numeri interi a 8 bit). Nel caso delll'immagine
nella figura 19 (preelaborata), la matrice contiene solo due valori: 0 per i pixel
neri, e 1 per i pixel bianchi ( una immagine binaria). Siccome lo scopo
dell'esempio sovrapporre l'ellisse (in verde nella figura 19) ai singoli elementi
costitutivi l'immagine (bordi dei blob), risulta intuitivo proporre come funzione
da massimizzare semplicemente la somma dei valori dei pixel sui quali l'ellisse si
pone, somma che tende a raggiungere un massimo quando la sovrapposizione
perfetta.
Cos facendo, i quattro punti da (a) a (d) sono tutti esplicitati, e si pu passare alla
codifica del programma.
Per semplicit, anzich scrivere un codice che individui tutti i blob, isoleremo
dapprima uno di quelli "doppi", e poi lavoreremo su quello. Chiaramente,
cercare i blob sull'intera immagine comporta semplicemente di trovare via via i
singoli blob, eliminandoli ogni volta dall'immagine prima di ripetere
l'applicazione dell'algoritmo per individuare il blob seguente.La figura n.19
mostra, quindi, un unico oggetto "doppio", previo preprocessamento.



Figura 20. L'immagine originale dopo preprocessing (individuazione dei bordi),e la scelta di
un unico oggetto composito.

In base a quanto detto, stata allestita un'interfaccia software (Appendice B)con
il codice GA gi descritto in Appendice A. Tale interfaccia carica limmagine,la
43
preelabora, definisce i parametri tipici della simulazione (popsize=20;
dimension=5; stringlength=5; x_bound=[5 30; 5 30; 90 150; 90 150; 0 pi];
pm=0.5;), la funzione di fitting, e lancia il codice GA. L'immagine seguente
mostra un momento della simulazione, con la popolazione attuale di ellissi
sovrapposte all'oggetto da segmentare.


Figura 21. Una fase della simulazione, con parte della popolazione attuale di ellissi via via
sovrapposte all'oggetto da segmentare.

Le prossime immagini si riferiscono invece a due risultati, ottenuti in run diversi,
sovrapposti all'immagine originale. Come si vede, il sistema ha efficacemente
individuato sia una che l'altra parte dell'oggetto composito, a seconda della
popolazione iniziale e delle scelte via via fatte dal programma riguardanti quali
individui accoppiare, come, dove effettuare le mutazioni, e cos via: tutte queste
scelte sono casuali (o meglio, pseudocasuali) e quindi determinano un risultato o
l'altro. Dopo ciascun risultato, anche mostrato l'andamento della funzione di
fitness durante la simulazione.






44








Figura 22. Sovrapposizione allimagine di partenza dellellisse ottenuta come
risultato dellesecuzione del GA nel run a (a sinistra) e b (a destra) .













Figura 23. Andamento della fitness media della popolazione(in blu) e del valore
massimo di fitness(in rosso) in funzione del numero di iterazioni per il run a(a
sinistra) e b(a destra).






0 50 100 150 200 250 300 350 400 450 500
0
10
20
30
40
50
60
Iterazione
F
i
t
n
e
s
s


max fitness
mean fitness
0 50 100 150 200 250 300 350 400 450 500
0
10
20
30
40
50
60
Iterazione
F
i
t
n
e
s
s


max fitness
mean fitness
45
Conclusioni
Argomento di questa Tesi di Laurea sono gli algoritmi evolutivi, in particolare
gli algoritmi genetici (GA): si tratta di metodi matematici applicabili
allottimizzazione di funzioni di un numero arbitrario di variabili. I GA
appartengono ad una linea di pensiero, affermatasi negli ultimi decenni, che
consiste nell'emulare il migliore schema organizzativo a nostra disposizione: la
Natura. L'approccio computazionale sempre pi ispirato ai modelli biologici,
dai quali c' molto da imparare essendo essi il risultato migliore ottenuto dopo
millenni di tentativi. Inoltre le attuali capacit informatiche ci permettono di
muoverci abilmente, creando dei mondi virtuali in cui far crescere ed evolvere
soluzioni a problemi altrimenti molto complessi da risolvere.
Dopo una descrizione teorica dei GA, si verificata la gran diffusione che essi
hanno attualmente, in tanti campi della scienza, constatando la costante
crescita del numero di articoli di Ricerca in questambito. Sono state descritte
brevemente alcune applicazioni di grande interesse, tra cui la progettazione di
circuiti elettronici. Infine, volendo verificare sul campo lefficacia dei GA, si
studiato, completato, e applicato un software GA alla ricerca del massimo di
una funzione ad una variabile, e ad un problema classico della segmentazione
di immagini, ossia la separazione di oggetti.
Lesperienza cos maturata ha confermato lefficacia degli algoritmi GA.Da un
punto di vista teorico e applicativo, la Tesi ha analizzato solo l'incrocio tra due
organismi aploidi e la mutazione. Molta ricerca si spinge nella direzione di
incorporare nella sintesi dei GA anche meccanismi biologici pi complicati
quali la dominanza, la trasposizione, la differenziazione sessuale e la
regolazione genetica. Mediante quest'ultima i geni degli organismi biologici si
regolano reciprocamente in maniera indiretta. In questa maniera ad ogni
46
situazione specifica solo determinati geni sono attivi, rendendo un sistema cos
complesso estremamente specifico e adattivo.
I GA dunque promettono di divenire strumenti sempre pi potenti e utili nella
ottimizzazione della ricerca di una soluzione di problemi fisici.























47
APPENDICE A
Codice MATLAB "Punto di massimo di una funzione

Il codice inserito e descritto in quest'appendice incluso in [10].L'articolo reperibile in Rete
all'indirizzo
http://www.ccsenet.org/journal/index.php/mas/article/download/9230/6779 (accesso al sito
effettuato in settembre 2013).
Il software stato lievemente corretto in alcune parti dove figuravano errori di stampa, ed
stato integrato con sezioni di codice adoperate per la visualizzazione della funzione di fitness,
per la stampa a video della popolazione di individui, per la raffigurazione della procedura di
selezione tramite roulette. Sono stati poi inseriti ampi commenti per la comprensione
approfondita dell'algoritmo adoperato. Il programma, nell'inserimento nella Tesi, ha sofferto
della limitazione sul numero di colonne di testo disponibili, dovuto alle scelte sui margini della
pagina; pertanto, alcune delle righe di codice risultano suddivise su pi righe di testo. Di ci si
dovr tenere conto nel caso in cui si volesse effettuare un test del codice riportandolo in un file
Matlab per l'esecuzione.

function [value,x] = test03
%% Massimizzazione della funzione obiettivo (coincidente con
% la funzione di fitness) entro i bound
%
% Lanciare con
% [val x] = test03
% oppure semplicemente
% test03;
%

iteraz = 5; % numero iterazioni

% Le prossime variabili sono:
% popsize: numero di individui della popolazione
% dimension: numero di parametri che costituiscono un
% individuo
% stringlength: numero di bit di ciascun parametro
% x_bound: valori limite per il o i parametri
% pm: probabilita' di mutazione

popsize=2; dimension=1; stringlength=5; x_bound=[0,31]; pm=0.5;

% grafico la funzione di fitness (contenuta nella function funname)
fplot(@(x) funname(x), x_bound)
xlabel('x')
ylabel('fitness')
drawnow

% genero la popolazione iniziale, casuale
pop=encoding(popsize,stringlength,dimension);

% dalla popolazione iniziale in rappresentazione binaria,
% calcolo i valori della funzione obiettivo
48
pop=decoding(pop,stringlength,dimension,x_bound);
% trovo l'individuo con il massimo valore della funzione
% obiettivo (andra' in 'choice')
% choice_number e' il valore della funzione obiettivo,
% choice_k e' l'indice corrispondente in pop
[choice_number,choice_k]=max(pop(:,stringlength*dimension+1));
choice=pop(choice_k,:);
maxfit = [choice_number];
meanfit = [mean(pop(:,stringlength*dimension+1))];

%% Iterazioni per la convergenza
for it=1:iteraz % numero iterazioni
fprintf('\n########## ITERAZIONE N. %d ###################\n', it)
% stampa l'attuale popolazione
fprintf('\n------- Popolazione attuale --------\n')
printPop(pop,stringlength,dimension,x_bound)
% effettua crossover e mutazione; il crossover duplica la popolazione
pop=cross_over(pop,popsize,stringlength,dimension);
pop=decoding(pop,stringlength,dimension,x_bound);
fprintf('\n------- Popolazione dopo crossover ------\n')
printPop(pop,stringlength,dimension,x_bound)
pop=mutation(pop,stringlength,dimension,pm);
pop=decoding(pop,stringlength,dimension,x_bound);
% stampa l'attuale popolazione duplicata
fprintf('\n------- Popolazione dopo mutazione------\n')
printPop(pop,stringlength,dimension,x_bound)
% trovo l'individuo con il massimo valore della funzione obiettivo
[number,k]=max(pop(:,stringlength*dimension+1));
% se il valore e' maggiore di quello individuato al ciclo precedente,
% lo conservo con il corrispondente individuo in choice_number
% e choice rispettivamente
if choice_number<number
choice_number=number;
choice=pop(k,:);
end
fprintf('\nIndividuo con massima fitness:\n')
printPop(choice,stringlength,dimension,x_bound);
% con il crossover la popolazione e' raddoppiata; seleziono popsize
% individui
pop=selection(pop,popsize,stringlength,dimension,x_bound,it);
% trovo il meno adatto della nuova popolazione e lo sostituisco con il
% piu' adatto, individuato prima
[number,m]=min(pop(:,stringlength*dimension+1));
pop(m,:)=choice;
% accodo massima e media fitness
maxfit = [maxfit choice_number];
meanfit = [meanfit mean(pop(:,stringlength*dimension+1))];
end
[value,x]=result(pop,stringlength,dimension,x_bound);
[value,x]=result(pop,stringlength,dimension,x_bound);
fprintf('\nSOLUZIONE: %f '), fprintf('%f ', x), fprintf('(fitness %f)\n', value)
%% Grafica massimo e media della fitness durante la convergenza
figure('color','w'), plot(0:iteraz, maxfit, 'r-o', 0:iteraz, meanfit, 'b-o'),
legend('max fitness', 'mean fitness', 'Location','SouthEast')
xlabel('Iterazione')
ylabel('Fitness')
set(gca,'xtick', [0:iteraz])
set(gca,'xticklabel', num2str([0:iteraz]'))
snapnow
end

% encoding genera "popsize" individui composti da "dimension" geni, ciascuno di
% "stringlength" bit
function pop=encoding(popsize,stringlength,dimension)
pop=round(rand(popsize,dimension*stringlength+1));
pop(:, stringlength*dimension+1) = NaN; % l'ultima colonna conterra' i valori della
funzione di fitting
end
49

% decoding calcola il valore della funzione di fitting
% Parte dalle rappresentazioni binarie, le trasforma in un numero tra 0 e
% 1, scala tale numero tra x_bound(*,1) e x_bound(*,2), per poi calcolarvi
% il valore della funzione di fitting, inserito nell'ultima colonna di pop
function pop=decoding(pop,stringlength,dimension,x_bound)
popsize=size(pop,1);
temp=2.^(stringlength-1:-1:0)/(2^stringlength-1);
for i=1:dimension
bound(i)=x_bound(i,2)-x_bound(i,1);
end
for i=1:popsize
for j=1:dimension
m(:,j)=pop(i,stringlength*(j-1)+1:stringlength*j);
end
x=temp*m;
x=x.*bound+x_bound(:,1)';
pop(i,stringlength*dimension+1)=funname(x);
end
end

function new_pop=cross_over(pop,popsize,stringlength,dimension)
match=round(rand(1,popsize)*(popsize-1))+1;
for i=1:popsize
fprintf(' CROSSOVER tra individuo di indice %d e individuo di indice %d, \n',
i, match(i))
[child1,child2]=cross_running(pop(i,:),pop(match(i),:),stringlength,dimension);
new_pop(2*i-1:2*i,:)=[child1;child2];
end
end

function [child1,child2]=cross_running(parent1,parent2,stringlength,dimension)
cpoint=round((stringlength-1)*rand(1,dimension))+1;
for j=1:dimension
fprintf('(componente %d): bit %d (da sinistra)\n', j, cpoint(j))
child1((j-1)*stringlength+1:j*stringlength)=...
[parent1((j-1)*stringlength+1:(j-1)*stringlength+cpoint(j)) parent2((j-
1)*stringlength+cpoint(j)+1:j*stringlength)];
child2((j-1)*stringlength+1:j*stringlength)=...
[parent2((j-1)*stringlength+1:(j-1)*stringlength+cpoint(j)) parent1((j-
1)*stringlength+cpoint(j)+1:j*stringlength)];
end
end

function new_pop=mutation(new_pop,stringlength,dimension,pm)
new_popsize=size(new_pop,1);
for i=1:new_popsize
if rand<pm
mpoint=round(rand(1,dimension)*(stringlength-1))+1;
fprintf(' MUTAZIONE nell''individuo di indice %3d, al bit %d (da
sinistra)\n', i, mpoint)
for j=1:dimension
new_pop(i,(j-1)*stringlength+mpoint(j))=1-new_pop(i,(j-
1)*stringlength+mpoint(j));
end
end
end
end


% data una pop composta dal doppio degli individui previsti, questa
% function ne sceglie popsize con approccio a roulette.
function selected=selection(pop,popsize,stringlength,dimension, x_bound, it)
popsize_new=size(pop,1);
r=rand(1,popsize);
fitness=pop(:,stringlength*dimension+1); % fitness
fitness=fitness/sum(fitness); % fitness normalizzata a 1
% traccio la roulette
50
x=binary2number(pop,stringlength,dimension,x_bound);
drawRoulette(x, fitness, r, it)
snapnow
% accumulo la fitness
fitness=cumsum(fitness); % fitness normalizzata cumulativa
for i=1:popsize % devo scegliere popsize soluzioni: per ciascuna...
for j=1:popsize_new % ciclo sulle popsize_new disponibili e...
if r(i)<=fitness(j) % se la fitness cumulativa della soluzione attuale (j-ma)
supera il random che compete alla soluzione i-ma (quindi sono nel suo settore)
selected(i,:)=pop(j,:); % mette tale soluzione nell'elenco delle
selezionate
break; % ed esce, andando quindi a scegliere la prossima i-ma soluzione
end
end
end
end

% decodifica il binario della soluzione nel corrispondente numero compreso tra i bound
% dati, e restituisce sia il valore della fitting function che la soluzione
function [value,x]=result(pop,stringlength,dimension,x_bound)
[value,k]=max(pop(:,stringlength*dimension+1));
temp=2.^(stringlength-1:-1:0)/(2^stringlength-1);
for i=1:dimension
bound(i)=x_bound(i,2)-x_bound(i,1);
end
for j=1:dimension
m(:,j)=pop(k,stringlength*(j-1)+1:stringlength*j);
end
x=temp*m;
x=x.*bound+x_bound(:,1)';
end

function y=funname(x)
y=260-(x-15)^2; % limiti: 0<x<31
end

function drawRoulette(x, probabs, r, it)
% preparo le labels per la torta
chromsAC = cell(size(x, 1), 1);
for j = 1 : size(x, 1);
chromsAC{j} = num2str(x(j));
end
figure('color','w'); pie(probabs, zeros(size(probabs)), chromsAC);
hold on, polar(r*2*pi+pi/2, 1.05*ones(size(r)), 'o'), hold off
title(['Iterazione ' num2str(it)]);
end

function x=binary2number(pop,stringlength,dimension,x_bound)
popsize=size(pop,1);
temp=2.^(stringlength-1:-1:0)/(2^stringlength-1);
for i=1:dimension
bound(i)=x_bound(i,2)-x_bound(i,1);
end
x = zeros(popsize, dimension);
for i=1:popsize
for j=1:dimension
m(:,j)=pop(i,stringlength*(j-1)+1:stringlength*j);
end
x(i,:)=temp*m;
x(i,:)=x(i,:).*bound+x_bound(:,1)';
end
end

function printPop(pop,stringlength,dimension,x_bound)
x=binary2number(pop,stringlength,dimension,x_bound);
for k = 1 : size(pop, 1)
fprintf('%3d > ', k)
for j = 1 : dimension
51
for i = 1 : stringlength
fprintf('%d ', pop(k, (j-1)*stringlength+i))
end
fprintf(' - ')
end
for j = 1 : dimension
fprintf(' %10.4f ', x(k, j))
end
fprintf(' --- fitness %12.6f\n', pop(k, stringlength*dimension+1))
end % k
fprintf('\n')
end






APPENDICE B
Codice MATLAB Segmentazione immagini
L'appendice riporta la sezione iniziale del codice di segmentazione dell'immagine
'blobs.gif', che illustra il caricamento dell'immagine, l'applicazione dell'operatore di
edge (individuazione dei margini degli oggetti), la selezione di uno degli oggetti
compositi (le due particelle di oro accoppiate). E' inoltre mostrato il calcolo della
funzione di fitness. Il resto del codice coincide con quello presente in appendice A,
tranne che per il mancato uso della rappresentazione grafica della funzione di fitness
(che qui non algebrica) e per la soppressione della visualizzazione della roulette:
quest'ultima, data la numerosit della popolazione, sarebbe stata scarsamente
interessante. La libreria di funzioni da cui tratto il calcolo dei punti dell'ellisse,
adoperato nella funzione di fitness, reperibile su
http://carmelab.huji.ac.il/software/General/general.html (accesso effettuato in settembre
2013)

function [value,x] = test04
%
% Lanciare con
% [val x] = test04
% oppure semplicemente
% test04;
%
global L3g
global ecolor

addpath GeneralTools

%% Caricamento immagine

ecolor = 'b';

I = imread('blobs.gif');
52
figure, imshow(I)
BW1 = edge(I,'canny');
figure, imshow(BW1)
% individuo l'oggetto doppio
L = bwlabel(BW1);
stats = regionprops(L,'basic');
areas = [stats.Area];
hist(areas);
idx = find(areas > 110);
L2 = zeros(size(L));
for j = idx
L2(L == j) = j;
end
figure, imshow(L2, [])

L3 = L2 == 29;
G = fspecial('gaussian',[3 3],1);
L3g = imfilter(double(L3), G, 'same');
figure, imshow(L3g)

% 5 parametri:
% x(1) e x(2) sono gli assi (limiti: da 100 a 150)
% x(3) e x(4) sono le coordinate (x,y) del centro
% (limiti da 90 a 150, e da 90 a 150)
% x(5) e' l'angolo di rotazione (da 0 a pi)

% Le prossime variabili sono:
% popsize: numero di individui della popolazione
% dimension: numero di variabili che costituiscono un individuo
% stringlength: numero di bit di ciascuna variabile
% x_bound: valori limite per la o le variabili
% pm: probabilita' di mutazione

popsize=20; dimension=5; stringlength=5;
x_bound=[5 30; 5 30; 90 150; 90 150; 0 pi]; pm=0.5;

%% Massimizzazione della funzione obiettivo (coincidente con la funzione di fitness)
entro i bound

iteraz = 500; % numero iterazioni

%%%%%% DA QUI IN POI IL CODICE COINCIDE CON QUELLO DELL'APPENDICE A
%%%%%% SI RIPORTA SOLO LA FORMA DELLA funname, LA FUNZIONE DI FITNESS

end

function y=funname(x)
global L3g
global ecolor
ax = [x(1) x(2)];
center = [x(3) x(4)];
rot = x(5);
no_points = 50;
ell = ellipse(ax, center, rot, no_points);
hold on
plot(ell(1,:), ell(2,:), ecolor)
y = sum(improfile(L3g, ell(1,:), ell(2,:)));
end



53

BIBLIOGRAFIA
[1] Charles Darwin, On the origin of species by means of natural selection or the
preservation of favoured races in the struggle for life , John Murray, London, 1859.
[2] John Holland, Adaptation in Natural and Artificial Systems: An Introductory
Analysis with Applications to Biology, Control and Artificial Intelligence, MIT Press
Cambridge, MA, USA 1992.
[3] Gregory S Hornby , Automated Antenna Design with Evolutionary
Algoritms,2006,sito visitato in Settembre 2013.
Disponibile allindirizzo:
http://alglobus.net/NASAwork/papers/Space2006Antenna.pdf
[4] Gibson, S.E., Charbonneau, P . Empirical modeling of solar corona using genetic
algorithms, Space Physics, Volume 103, Pags 14511-14521
[5] U. Maulik, Medical Image Segmentation Using Genetic Algorithms, IEEE
Transactions on Information Technology in Biomedicine", vol 13, no. 2, March 2009
[6] Jos A. Garca Gutirrez, Carlos Cotta, and Antonio J. Fernndez-Leiva,
"Evolutionary Computation in Astronomy and Astrophysics: A Review", Proceedings
of CoRR ,The Computing Research Repository 2012.
[7] J.H.Koza, M.A.Kane e M.J.Streeter; Levoluzione delle invenzioni, Le Scienze,
Marzo 2003.
[8] Valerio Lacagnina, Algoritmi genetici,Universit di Palermo,Ottobre 2003.

[9] Y. Song et al., Location Classification Of Lung Nodules With Optimized Graph
Construction, 9th IEEE International Symposium on Biomedical Imaging (ISBI),
Barcelona 2012.

[10] C. Guo & X. Yang, A Programming of Genetic Algorithm in Matlab7.0, Modern
Applied Science, Vol. 5, No. 1; February 2011



54


55