1. UNIVERSITÀ DEGLI STUDI DI TRIESTE
Facoltà di Ingegneria
Corso di Laurea in Ingegneria dell’informazione
Curriculum in informatica
Sviluppo e studio di un algoritmo genetico
per la ricerca di un intervallo di colore
in un’immagine digitale
Relatore: Prof. Andrea SGARRO
TESI DI LAUREA DI:
ANDREA BIDINOST
MATR. 83600156
Anno Accademico 2011/2012

2. 2

3. Indice
INTRODUZIONE………………………………………...………………6
1 LA SEGMENTAZIONE ..................................................................... 7
1.1 Il colore e lo spazio di colore .................................................................................... 7
1.2 Panoramica sulla segmentazione .............................................................................. 9
1.3 Tecniche di segmentazione........................................................................................ 9
1.3.1 Segmentazione a soglia..................................................................................... 9
1.3.2 Accrescimento delle regioni.......................................................................... 11
1.3.3 Divisione e Fusione ....................................................................................... 12
1.3.4 Clustering......................................................................................................... 14
1.3.5 Segmentazione a bacini ................................................................................. 15
1.3.6 Contorni Attivi ............................................................................................... 16
2 GLI ALGORITMI GENETICI ........................................................... 19
2.1 La storia ......................................................................................................................... 19
2.2 Terminologia biologica ............................................................................................... 19
2.3 Funzionamento di un AG .......................................................................................... 23
2.4 Schema .......................................................................................................................... 24
2.5 Principali problematiche ............................................................................................. 25
2.6 Caratteristiche di un AG............................................................................................. 26
2.6.1 Numero di elementi, probabilità di incrocio e di mutazione .................. 26
2.6.2 Meccanismo di selezione ............................................................................... 26
2.6.3 Meccanismo di incrocio ................................................................................ 27
2.6 Alcune applicazioni ..................................................................................................... 27
2.6 Metodi Euristici di Ottimizzazione........................................................................... 28
3 L’ALGORITMO SVILUPPATO ........................................................ 33
3.1 Obiettivo ....................................................................................................................... 33
3.2 Descrizione dell’algoritmo ......................................................................................... 33
3.2.1 Inizializzazione ............................................................................................... 34
3.2.2 Prima generazione .......................................................................................... 34
3.2.3 Generazioni successive .................................................................................. 34
3.2.4 Interruzione..................................................................................................... 35
3.3 Implementazione ......................................................................................................... 36
3.3.1 Struttura del codice ........................................................................................ 36
3.4 Note tecniche ............................................................................................................... 43
3

4. 3.4.1 Tipo di dati restituito ..................................................................................... 43
3.4.1 Rappresentazione del genotipo .................................................................... 43
4 STUDIO DELL’ALGORITMO ......................................................... 45
4.1 Metodo di studio ....................................................................................................... 45
4.2 Definizione di coefficiente di distribuzione ................................................................... 45
4.3 Studio mediante cambiamento di parametri ......................................................... 46
4.3.1 Prima fase: 10 elementi per generazione ..................................................... 48
4.3.2 Seconda fase: 100 elementi per generazione .............................................. 55
4.3.3 Terza fase: miglior combinazione di parametri ......................................... 58
4.4 Studio attraverso immagini con diverso coefficiente di distribuzione ....................... 59
4.4.1 Riepilogo........................................................................................................... 69
4.5 Studio su un ridotto numero di generazioni ......................................................... 70
4.6 Applicazione ad un’immagine termica................................................................... 75
4.7 Applicazione per il rilevamento di una traiettoria................................................ 77
CONCLUSIONI ...................................................................................... 81
APPENDICE A ....................................................................................... 83
BIBLIOGRAFIA .................................................................................... 106
4

5. Ringraziamenti
Desidero ringraziare la mia famiglia, per avermi accompagnato in questi mesi di
duri sforzi. Ringrazio il professor A. Sgarro per avermi dato l’opportunità di
approfondire quest’interessante argomento, con pazienza e curiosità. Ringrazio
il dott. Felice Andrea Pellegrino per l’aiuto nella stesura dei primi argomenti.
Infine vorrei ringraziare i miei amici ed i miei fratelli, per essermi stati accanto
ed aver fatto il tifo per me, come sempre.
5

6. Introduzione
Il presente lavoro di tesi si propone di sviluppare e studiare il problema della
ricerca di determinate tonalità di colore all’interno di un’immagine digitalizzata,
attraverso un algoritmo genetico.
Si è voluto quindi sviluppare un software per l’implementazione di tale
algoritmo e per lo studio delle sue caratteristiche.
Nel primo capitolo viene presentata la nozione di spazio di colore e vengono
fornite brevemente ed in modo informale alcune tecniche di Segmentazione di
immagini digitali. Questi algoritmi, permettono di estrarre informazioni
dall’immagine in modo automatico.
Nel secondo capitolo viene illustrata la tecnica degli algoritmi genetici per la
risoluzione di alcuni problemi (prevalentemente di carattere geometrico-
matematico). Ne vengono descritte le caratteristiche, il funzionamento, le
potenzialità ed i limiti. Inoltre vengono presentate alcune applicazioni in cui
sono stati utilizzati.
Nel terzo capitolo viene descritto l’algoritmo sviluppato e viene mostrato il suo
funzionamento attraverso l’interfaccia grafica predisposta.
Nel quarto capitolo vengono forniti i risultati di alcuni test effettuati
sull’algoritmo, attraverso cui si è potuti giungere a conclusioni riguardanti limiti
di efficacia ed efficienza. Al termine del capitolo vengono inoltre proposte due
possibili applicazioni: il rilevamento di un’area di calore ed il tracciamento di
una traiettoria.
Al termine, in Appendice A, è riportato il codice scritto per l’implementazione.
6

7. Capitolo 1
LA SEGMENTAZIONE
1.1 Il colore e lo spazio di colore
Il colore viene percepito dall’occhio umano in base alla radiazione luminosa
emessa dall’oggetto osservato. I fotorecettori posti all’interno del bulbo oculare
possono inviare tre stimoli nervosi diversi a seconda della lunghezza d’onda del
segnale luminoso che colpisce quella particolare regione della retina.
Combinando tra lori i diversi stimoli, il nostro cervello è in grado di associare il
colore presente in quella particolare regione. È quindi naturale scegliere tre colori
“elementari” capaci di generare ognuno uno stimolo nervoso diverso. Ad
esempio, questi colori possono essere il magenta (Magenta), il giallo (Yellow) ed
il ciano (Cyan). Essi sono detti detti colori primari sottrattivi, poiché sono in
grado di generare gli altri colori in base ad una mescolanza sottrattiva1.
Figura1.1: Mescolanza sottrattiva dei colori ciano, giallo e magenta
Tuttavia, i colori possono essere generati anche tramite una mescolanza di tipo
additivo 2. I tre colori primari additivi, utilizzati nell’ambito elettronico, sono il
rosso (Red), il blu (Blue) ed il verde (Green).
1
La lunghezza d’onda del colore risultante è una radiazione “filtrata” dalla presenza di altri
colori che assorbono ognuno una componente della luce solare. Ad esempio, si può
pensare a due inchiostri, uno giallo ed uno ciano, che si sovrappongono: una parte della
luce viene assorbita dall’inchiostro giallo, un’altra parte dall’inchiostro ciano e la
rimanente viene riflessa dando origine al verde. La riflessione di tutte le radiazioni
luminose genera il bianco, mentre l’assorbimento di queste genera il nero.
2
La lunghezza d’onda del colore risultante è una radiazione “combinata”. Le radiazioni,
infatti, colpiscono nello stesso istante di tempo la retina: in questo modo, vengono
propagati stimoli nervosi per ogni lunghezza d’onda incidente. L’informazione viene poi
rielaborata dal cervello che “costruisce” il colore percepito. La presenza di tutte le
radiazioni all’interno dell’occhio genera il bianco, mentre l’assenza genera il nero.
7

8. Figura 1.2: Mescolanza additiva dei colori rosso, blu e verde
Sia per mescolanza sottrattiva che additiva, è possibile quindi generare un colore
a partire da tre colori primari. In quest’ottica è possibile descrivere uno spazio di
colore. Infatti, assegnando ad ogni colore primario un valore numerico che ne
indica l’intensità, è possibile costruire uno spazio a tre dimensioni. Una volta
stabilita la natura delle dimensioni ed i valori numerici di massimo e di minimo, è
possibile costruire un modello di colore. Il modello di colore classico per la codifica
e l’archiviazione delle immagini digitali è l’RGB, in cui le dimensioni
corrispondono ai colori primari additivi ed ogni intensità va da un valore di
minimo pari a zero, ad un valore di massimo pari a 255.
Negli anni ’70 è stato introdotto anche la dimensione A (alpha), che rappresenta
la trasparenza o l’opacità del colore stesso. Per la memorizzazione digitale di un
colore nel modello ARGB, sono necessari 4 byte, ognuno per codificare un
numero da 0 a 255 associato alla dimensione corrispondente.
8

9. 1.2 Panoramica sulla segmentazione
La segmentazione di un’immagine consiste nella divisione dell’immagine in
regioni significative. Successivamente, vi sono molteplici utilizzi. Ad esempio
l’immagine può essere partizionata per la rilevazione3 e/o il riconoscimento4 di
oggetti. Attraverso la segmentazione è possibile tracciare la traiettoria di un
oggetto presente in più fotogrammi in sequenza. Inoltre, è utilizzata nella
compressione digitale. L’immagine viene così trasformata in qualcosa di più
significativo e facile da analizzare attraverso un sistema automatico.
La segmentazione classifica i pixel dell’immagine, raggruppandoli in insiemi
aventi caratteristiche comuni (di colore, di luminosità, etc…).
Figura 1.3: Immagine originale ed esempio di immagine segmentata
1.3 Tecniche di segmentazione
1.3.1 Segmentazione a soglia (Hassan, 1989; Otsu, 1979)
Si basa sulle informazioni ottenibili dall’istogramma di colore5. Nel caso
più semplice, viene fissata una soglia di separazione in corrispondenza di
3
La rilevazione di un oggetto permette di stabilire la sua presenza o assenza all’interno
della scena
4
Il riconoscimento permette di associare una porzione dell’immagine ad uno specifico
oggetto
5
Istogramma che rappresenta la distribuzione dei colori in un’immagine. In ascissa sono
presenti le tonalità di colore (solitamente RGB) ed in ordinata il numero di pixel aventi
quella determinata tonalità. Di seguito è illustrata un’immagine con il relativo istogramma
di colore.
9

10. un certo livello di grigio presente nell’istogramma (per questo è detta
anche Sogliatura a livelli di grigio).
Figura 1.4: Istogramma di un’immagine a livelli di grigio con relativa soglia T
I pixel dell’immagine apparterranno quindi ad una regione o all’altra.
L’immagine risultante sarà in bianco e nero, dove il colore è deciso
dall’appartenenza o meno alla regione selezionata.
La Sogliatura può anche essere effettuata in base a diverse tonalità di colore.
In questo caso, si costruiscono più istogrammi e vengono fissate più soglie
di colore.
Esempio 1.1
Esempio di applicazione dell’algoritmo di “Sogliatura a livelli di grigio” ad
un’immagine in bianco e nero, nel cui istogramma sono presenti in ordinata i livelli di
grigio. In questo caso, sono state utilizzate 2 soglie per limitare le regioni delle tonalità
interessate.
Figura 1.5: Immagine originale e segmentata tramite Sogliatura a diversi livelli
10

11. Il principale vantaggio è dato dalla semplicità d’implementazione.
Tuttavia questo algoritmo non tiene conto dell’informazione spaziale degli
elementi interni alla foto.
1.3.2 Accrescimento di regioni (Y.L. Chang, 1994)
Si basa sul suddividere l’immagine in molteplici regioni distinte Ri, unendo
poi quelle regioni adiacenti che verificano una determinata condizione
H(R). L’algoritmo è suddiviso in due fasi: inizializzazione ed
accrescimento.
 Inizializzazione: L’immagine viene suddivisa in un determinato
numero di regioni elementari (al limite, una regione può contenere
un singolo pixel). Dopodiché vengono scelte quelle regioni che
presentano un alto valore della funzione di omogeneità H(Ri)6
 Accrescimento: data una condizione di omogeneità tra regioni distinte
H(Ri Rj), in maniera iterativa le coppie di regioni contigue
vengono valutate dalla funzione H ed eventualmente aggregate in
una nuova regione.
Esempio 1.2
Stabilita una certa soglia , si aggreghino le regioni Ri ed Rj solo se vale la
disequazione:
≥
Dove è il numero di pixel di contorno aventi contrasto inferiore ad una certa soglia
e comuni alle due regioni e Pm è la lunghezza del perimetro della regione più piccola.
I principali vantaggi di questa tecnica sono l’elevata qualità ottenibile
rispetto alle altre tecniche di segmentazione e l’adattabilità a qualsiasi
tipo di immagine, attraverso un’opportuna costruzione della funzione
di omogeneità.
6
Funzione che valuta la presenza e la quantità di caratteristiche comuni appartenenti ai
pixel di una determinata regione. Ad esempio, si può confrontare la luminosità, la
presenza di un certo colore elementare RGB o la varianza dalla media RGB della regione. È
possibile anche la valutazione della presenza di più caratteristiche in una stessa regione.
11

12. Tuttavia questa tecnica richiede uno studio molto accurato della fase di
inizializzazione (regioni troppo grandi possono dar luogo a pixel non
omogenei, regioni troppo piccole richiedono più tempo per essere
unite tra loro) ed è caratterizzata da un elevato onere computazionale
(dovuto alla scansione e valutazione delle singole regione ed alla
valutazione dell’omogeneità sulle varie combinazioni possibili di
regione-regione adiacente).
1.3.3 Divisione e Fusione
L’algoritmo si compone di due fasi:
 Fase di Divisione: Questa fase è ricorsiva. Inizialmente si considera
l’immagine intera e la si valuta attraverso una certa funzione di
omogeneità H(R). Se il risultato è soddisfacente, l’algoritmo
termina. Altrimenti si suddivide la regione in 4 sotto-regioni di
uguale dimensione e si itera il procedimento su ogni regione. Si
viene così a formare una struttura ad “albero quaternario”, come
mostrato in figura:
Figura 1.6: Suddivisione in una regione in sotto-regioni e albero quaternario
corrispondente
12

13.  Fase di Fusione: Poiché la fase di divisione crea blocchi sempre più
piccoli (sovra-segmentazione), è necessaria una procedura di
rilassamento ed unione di quei sotto-blocchi che darebbero luogo
ad una regione con alta funzione di densità. L’esempio sottostante
può chiarire il problema:
Esempio 1.3:
Poiché l’immagine sottostante non è omogenea, viene divisa in 4 blocchi.
Tuttavia solo un blocco dovrebbe essere separato, mentre gli altri 3
dovrebbero dare luogo alla stessa regione
R1 R 1 R2 R2
R 3 R4 R1
Per la fusione si adotta una struttura dati chiamata RAG (“Region
Adjacency Graph o grafo delle regioni adiacenti). Questo grafo
pesato contiene in ogni nodo una regione (R1,…,Rn). Soltanto le
regioni adiacenti sono collegate da un arco, il cui peso è il costo
che si sosterrebbe nel fondere insieme i due blocchi. Il costo
esprime l’incremento dell’errore in termini della funzione di
omogeneità utilizzata. A ciascuna iterazione si fondono in un unico
nodo (e in un unico blocco) le due regioni che comportano un
costo minore. La computazione termina quando tutti i costi sono
troppo elevati per sostenere una fusione.
Figura 1.7: Immagine originale. Immagine dopo la fase di Divisione e dopo la
Fusione delle zone omogenee.
13

14. Il principale vantaggio di questa tecnica è lo sfruttamento
dell’informazione sia spaziale (in termini di regioni adiacenti) che
cromatica.
La qualità della segmentazione dipende però dalla grandezza minima dei
blocchi ed aumentare la qualità del risultato comporta un maggiore onere
computazionale.
1.3.4 Clustering
Vengono costituite classi di pixel, raggruppati in base ad una determinata
caratteristica (luminanza, contrasto, livello di grigio, etc…). Dallo spazio
bidimensionale dell’immagine si passa quindi allo spazio delle
caratteristiche, nel quale vengono raggruppate le varie porzioni di
immagine aventi una o più caratteristiche comuni. Si perde così
l’informazione spaziale, che dovrà essere recuperata mediante un
raffinamento successivo (pixel adiacenti appartenenti alla stessa classe
costituiranno una regione omogenea).
Figura 1.8: Esempi di gruppi di classi e di processo di raggruppamento in base alle
caratteristiche
Il Raggruppamento è una tecnica generale di suddivisione di un insieme di
dati (detti oggetti), introdotta da Robert Tryon nel 1939 (R.C. Tryon,
1970). Le basi di un algoritmo di raggruppamento sono :
 La creazione dello spazio multidimensionale delle caratteristiche
 La definizione della funzione Fs di misura della similarità tra due
oggetti (distanza)
 La definizione del criterio di appartenenza ad una classe
14

15. La principale tecnica utilizzata è l’algoritmo K-means, che osserva i seguenti
passi:
1. Fissato un numero K di classi, si attribuisce casualmente una classe
a ciascun oggetto(pixel)
2. Per ogni classe, si calcola il centroide (punto medio) degli oggetti
3. Ogni oggetto viene assegnato alla classe al cui centroide è più vicino
4. Se l’algoritmo converge7, ci si fermi, altrimenti si riparta dal punto
2
L’algoritmo non garantisce il raggiungimento di un ottimo globale, ma può
essere ripetuto più volte per ottenere più risultati su cui scegliere la
soluzione migliore.
Inoltre, l’efficacia dipende dal numero e dalla composizione dei cluster, per
cui si può utilizzare un’esplorazione euristica dell’immagine in sostituzione
del punto 1 dell’algoritmo.
1.3.5 Segmentazione a bacini
L’idea è quella di pensare all’immagine come ad un insieme di argini e
bacini, inizialmente vuoti. Questa distinzione viene fatta in base alla
luminosità di ciascun pixel. Inizialmente i bacini sono vuoti, poi vengono
riempiti d’acqua fino a che le acque di bacini distinti non si congiungono.
A questo punto, le acque vengono separate da una “diga”. Al termine
dell’algoritmo, le dighe rappresenteranno il contorno degli oggetti presenti.
Più in dettaglio, il procedimento è il seguente:
1. Si assegni ad ogni pixel un valore di luminosità
2. Partendo dal valore inferiore di luminosità λ, si scelgano tutti quei
pixel aventi luminosità λ. I pixel adiacenti ed i pixel isolati
costituiranno il primo gruppo di regioni R1,..,Rn.
3. Si alzi il livello di luminosità λ’. I pixel adiacenti alla regione Ri si
uniranno ad essa.
4. Si continui ad alzare il livello di luminosità e ad accrescere le
regioni fino ad una soglia scelta , che si ritiene possa creare una
distinzione tra le forme presenti.
7
La convergenza è data dal non cambiamento della composizione delle partizioni o dal
raggiungimento di una distanza minima tra oggetti e centroidi determinata a priori.
15

16. 5. Superata quella soglia, ogni volta che alcune regioni si uniranno
(poiché i pixel di confine avranno una luminosità abbastanza
elevata), i pixel che dovrebbero essere annessi costituiranno invece
una parte dei contorni degli oggetti presenti
6. Al termine, tutti i contorni risulteranno uniti (formando delle
dighe) e le regioni rappresenteranno la forma dei vari oggetti
presenti (paragonabili a dei bacini pieni d’acqua).
Un esempio è dato dalla figura sottostante:
Figura 1.9: Evoluzione temporale della segmentazione "a bacini"
Il principale svantaggio di questa tecnica è che, scelto un troppo basso,
si costruiranno un numero molto elevato di piccole regioni (sovra-
segmentazione)
1.3.6 Contorni Attivi (Michael Kass, 1988)
Attraverso la tecnica dei Contorni Attivi, si vogliono distinguere gli oggetti
dal resto della scena identificandone i bordi. L’immagine viene
trasformata in una “mappa di forze” che agiscono su una linea curva
(detta snake) per farla aderire al contorno dell’oggetto desiderato. Questa
tecnica, diversamente dalle precedenti, richiede un’interazione con
l’utente, che dovrà prima di tutto tracciare il primo snake in prossimità
del bordo dell’oggetto specificato. Più in dettaglio ed in riferimento ad
un’immagine a livelli di grigio, l’algoritmo è il seguente:
1. L’utente tracci una curva chiusa (snake) in prossimità dell’oggetto
di cui si vogliono definire i bordi.
2. Si associ ad ogni pixel un valore che dipende dalla distanza al
bordo più vicino (un bordo è riconoscibile per l’elevato valore di
gradiente8) e che caratterizzerà la “forza” (energia esterna) che
8
Associando ad ogni pixel un livello nella scala di grigio, il gradiente di un pixel è
paragonabile alla variazione di intensità tra i suoi pixel “confinanti”. E’ plausibile ottenere
un alto valore di gradiente alla presenza di due oggetti distinti separati da un bordo.
16

17. eserciterà sullo snake, nell’eventualità che esso passi per quel luogo.
L’energia esterna può essere calcolata seguendo una formula del tipo:
Dove Exy rappresenta l’energia esterna associata al pixel di
coordinate (x,y) e (xb,yb) rappresentano le coordinate del bordo più
vicino.
3. Si valuti l’energia interna associata allo snake, ovvero l’attitudine ad
allungarsi ed a curvarsi (decisa a priori dall’utente), seguendo una
formula del tipo:
Dove s(x,y) è l’equazione parametrica dello snake, α è un
coefficiente legato alla tensione della curva proporzionale alla
capacità di allungamento e β è un coefficiente legato alla rigidità
della curva, inversamente proporzionale alla sua capacità di
deformazione.
4. Si facciano agire le forze esterne sulla curva, che si poserà su zone
di gradiente minore (ad energia meno elevata), modificando la
propria energia interna.
5. L’algoritmo si interrompa se la somma di forze esterne ed interne
agenti sulla curva raggiunge un minimo, altrimenti si ritorni al
punto 3.
Figura 1.10: Immagine a livelli di grigio, mappa delle forze esterne, immagine
segmentata
L’efficacia dell’algoritmo dipende dai valori iniziali scelti per α e β, nonché dalla
funzione secondo la quale calcolare energia interna ed esterna.
17

18. 18

19. Capitolo 2
GLI ALGORITMI GENETICI
2.1 La storia
Gli algoritmi genetici furono inventati formalmente da John Holland negli anni
sessanta e furono sviluppati negli anni sessanta e settanta. Lo scopo originale di
Holland era quello di studiare il fenomeno dell’adattamento delle specie così
come avviene in natura, per poi riproporlo come tecnica risolutiva nell’ambito
dei problemi nei sistemi informatici.
Nel libro intitolato “Adaptation in Natural and Artificial Systems” (Holland, 1975),
l’algoritmo genetico viene presentato come un’astrazione dell’evoluzione
biologica e vengono fornite metodologie teoriche per la modellizzazione della
realtà tramite un AG (Algoritmo Genetico).
2.2 Terminologia biologica
Per creare un collegamento con la teoria genetica anche a livello di
nomenclatura, è necessario introdurre alcuni termini che saranno poi utilizzati
nella descrizione dell’algoritmo.
Ogni AG opera su un insieme di elementi candidati a diventare soluzione di un
problema (ad esempio, un punto generico nel piano per un problema di
massimizzazione di una funzione). L’insieme di questi elementi si chiama
popolazione o generazione. Particolarità degli AG è di agire su popolazioni di “pochi
elementi” (nell’ordine delle decine o delle centinaia). Ogni elemento della
popolazione si chiama fenotipo e deve essere codificato in una struttura formata
da dati elementari, chiamati geni. La scelta della particolare struttura adottata è
fondamentale per la risoluzione del problema mediante una strategia genetica.
Scelta una struttura, una determinata sequenza di geni si chiama genotipo o
cromosoma.
19

20. Esempio 1.
Si può ad esempio codificare un punto del piano di fenotipo (5,12) come una sequenza di
bit (dove ogni bit rappresenta un gene), in cui i primi 4 bit rappresentano il numero 5 e gli
ultimi 4 rappresentano il 12. Questo è il relativo genotipo:
01001100
Ogni gene è rappresentato da un bit.
Questo punto può essere una soluzione candidata al probelma di massimizzare la funzione
f1(x) = x+2y.
Esempio 2.
Si può, ad esempio, voler codificare una funzione, come f2(x)=x2 + 3x + 1. A questo punto,
possono essere scelte 2 codifiche per i genotipi: una mediante stringhe di bit ed una
mediante albero binario.
 La codifica mediante stringhe di bit associa ad una sequenza di n bit un particolare
valore univoco.
Codificando
Carattere Codifica binaria
x 1111
2 1000
+ 0100
* 0100
3 0011
1 0001
Si ha:
11111000010000110100111101000001
x 2 + 3 * x + 1
dove ogni bit rappresenta un gene.
 La codifica mediante albero binario rappresenta i geni tramite nodi dell’albero.
Seguendo una visita in ordine posticipato, si può riconoscere la funzione
+
+ 1
^2 *
x 3 x
Ogni genotipo, quindi, codifica un fenotipo e rappresenta una possibile
soluzione del problema modellizzato. Si chiama spazio di ricerca l’insieme di tutti i
possibili valori che può assumere il fenotipo codificato mediante un particolare
genotipo.
20

21. Se il genotipo è una stringa di 4 bit, lo spazio di ricerca comprenderà 15 elementi (con o
senza segno).
Ad ogni cromosoma viene associato un valore che lo legherà (direttamente o
meno) alla probabilità di essere scelto come buona soluzione e quindi di poter
dare origine ad un elemento figlio che erediterà alcuni suoi “caratteri genetici”.
Questo valore si chiama valore di valutazione ed è calcolato tramite una funzione
detta funzione di valutazione. Può rappresentare il fenotipo stesso, la distanza tra
due punti o tra due valori (si pensi ai problemi di approssimazione o di
interpolazione) o qualsiasi altra entità. In base al valore di valutazione, viene
calcolato un altro valore, chiamato valore di idoneità calcolato tramite la funzione di
idoneità. Questo valore rappresenta la “bontà” del cromosoma come possibile
soluzione e sarà tanto maggiore quanto migliore sarà il genotipo.
Per il probelma di massimo presentato nell’ esempio 1, la funzione di valutazione potrebbe
semplicemente essere la stessa funzione:
Funzione di valutazione = f1(x,y)
Il relativo valore sarà allora:
Valore di valutazione = f1(5,12) = 5 + 2*12 = 29
La funzione di idoneità potrebbe restituire la differenza tra il valore di valutazione e la
media dei fenotipi:
Funzione di idoneità per (xi,yi) = –
Dove N rappresenta il numero degli elementi della popolazione. Una funzione di idoneità
altrettanto valida potrebbe rappresentare il rapporto tra il valore di valutazione e l’insieme di
tutti i valori di valutazione, dando luogo ad un possibile valore di probabilità:
0≤ ≤1
Per l’evoluzione della popolazione, ogni genotipo sarà soggetto (con una certa
probabilità) ad operazioni di selezione, incrocio, mutazione.
Nel processo di selezione, vengono scelti una coppia di cromosomi appartenenti
all’attuale popolazione, in base al valore della loro funzione di idoneità. Questo
processo è l’equivalente della selezione naturale.
21

22. Nel processo di incrocio, i geni dei due cormosomi scelti vengono mescolati
(totalmente a caso, oppure scegliendo uno o più punti di taglio), dando origine
ad uno o più nuovi cromosomi. Con questo processo si modellizza la
riproduzione sessuata.
Figura 2.1: Esempi di incrocio di 2 cromosomi, scegliendo uno o più punti di taglio
Nel processo di mutazione, uno o più geni del cromosoma generato vengono
mutati (un bit può venire invertito, un valore di un nodo di un albero binario
può essere cambiato, etc…). Questa operazione è l’equivalente della mutazione
genetica e potrà essere sfruttato per rendere “più variegato” il campione.
Può essere poi presente un valore obiettivo, ovvero una soglia di tolleranza entro
cui si stabilisce a priori che una determinata soluzione è accettabile per il
problema, anche se non ottima (ad esempio, la soglia di tolleranza
nell’interpolazione di funzioni). Raggiunto questo valore, il processo di
evoluzione può fermarsi.
Infine, con il termine pressione di selezione si indica il grado con cui l’algoritmo
(l’ambiente) predilige individui con alto valore di idoneità rispetto a quelli con un
basso valore di idoneità.
22

23. 2.3 Funzionamento di un AG
Ogni algoritmo genetico segue una sequenza di passi che modellizzano
l’evoluzione naturale di una popolazione in un determinato ambiente (Ehud
Lamm, 2011):
1. Si generi una popolazione casuale di N cromosomi
2. Si calcoli il valore di valutazione ed il valore di idoneità di ogni
cromosoma nella popolazione
3. Si ripetano i seguenti i seguenti passi finchè non siano stati creati N
nuovi cromosomi
a. Selezione: si scelgano casualmente 2 cromosomi dalla popolazione
attuale. La probabilità di essere scelti deve dipendere dal valore di
idoneità dei cromosomi. Tanto più è alta l’idoneità di un
cormosoma, tanto più spesso sarà scelto per la riproduzione.
b. Incrocio: si effettui con probabilità pc un incrocio dei genotipi dei
genitori scelti per creare un nuovo cromosoma, altrimenti si
scelga un genitore come nuovo elemento.
c. Mutazione: per ogni gene presente nel nuovo genotipo, lo si muti
con probabilità pm
d. Si inserisca il nuovo elemento nella nuova popolazione
4. La nuova popolazione prenda il posto della popolazione corrente
5. Se esiste ed è stato raggiunto un valore obiettivo, ci si fermi, altrimenti si
riparta dal punto 2.
Questa sequenza è da ritenersi approssimativa, poiché in base al particolare
problema affrontato, è possibile scegliere di alterare i processi di selezione,
incrocio e mutazione per ottenere risultati migliori.
23

24. 2.4 Schema
Un importante nozione nell’ambito degli AG è quella di Schema, introdotta da
Holland nel suo libro. Lo schema H rappresenta un blocco costitutivo di
soluzione, ed è codificato da una stringa di caratteri 1/0/* (non importa).
Rappresenta una determinata disposizione di caratteri all’interno di una stringa di
bit.
Il fenotipo 9 può essere rappresentato dal genotipo 1001, che appartiene agli schemi:
****, 1***, *0**, **0*, ***1, 10**, 1*0*, 1**1, *00*, *0*1, **01, 100*, 10*1, 1*01, *001,
1001
Il Teorema degli Schemi proposto da Holland afferma che, data una popolazione
all’istante t, la media di istanze di un dato schema H presente nella popolazione
successiva sarà limitata inferiormente da:
E( m(H, t+1) ) ≥ ∙ m(H, t) ∙ ∙
Dove:
t: istante dell’attuale generazione
m(H,t): numero di istanze di H presenti nella popolazione all’istante t
(H, t): idoneità media delle istanze di H all’istante t , pari a
: idoneità media della popolazione all’istante t
pc: probabilità di incorcio in un punto singolo
pm: probabilità di inversione di un bit
d(H): lunghezza di definizione di H (distanza tra i bit ben definiti definiti
più esterni)
l: lunghezza di una stringa di bit appartenente allo spazion di ricerca
o(H): ordine dello schema (numero di bit ben definiti nello schema)
Il Teorema degli Schemi implica che gli schemi brevi e di basso ordine, la cui
idoneità media sia “sopra la media generale”, saranno rappresentati da un
numero sempre più alto di elementi, in modo esponenziale nel tempo.
24

25. È da notare che questo teorema contempla solo gli effetti “distruttivi” su un dato
schema a causa delle operazioni genetiche. È un limite inferiore che non tiene
conto dei possibili effetti “costruttivi” che si possono originare a seguito di
incorci e mutazioni. Ed è proprio l’operazione di incrocio (Goldberg, 1989) una
delle principali fonti di potenza di un AG, per la sua capacità di ricombinare
istanze di buoni schemi per formare istanze di schemi di ordine superiore
altrettanto buoni o migliori.
2.5 Principali problematiche
Nella progettazione di un AG è necessario tenere in considerazione possibili
effetti indesiderati dovuti al meccanismo evolutivo.
Il principale di questi fenomeni è la convergenza veloce. Dato uno shcema che
garantisce un valore di valutazione alto, è probabile che gli schemi seguenti
convergano ad esso, portando i fenotipi ad assumere valori appartenenti ad un
insieme sempre più ristretto. Se questo accade durante le prime generazioni, si
incorre nel rischio di stabilizzarsi su un punto di ottimo locale, mentre potrebbe
essere presente un valore di ottimo globale non ancora esplorato. Per porre
rimedio a tale fenomeno, è necessario controllare la variabilità della popolazione
(ad esempio, calcolando media e varianza dei valori di valutazione) ed
eventualmente aumentare le probabilità di mutazione, o modificare i meccanismi
di selezione, incrocio e mutazione, oppure modificare la funzione di idoneità
favorendo momentaneamente anche quei fenotipi che presentano bassa idoneità.
Il fenomeno opposto è chiamato convergenza lenta. Esso si presenta nelle
popolazioni in cui non si riesce ad affermare un particolare schema, causato da
una variabilità di popolazione alta. Questo effetto può essere ridotto riducendo
le probabilità di selezione ed i valori di idoneità dei fenotipi che più si discostano
dalla media.
25

26. 2.6 Caratteristiche di un AG
Le prestazioni di un AG dipendono sia dai parametri iniziali utilizzati
dall’algoritmo, sia dalle tecniche di selezione, incrocio e mutazione adottate. Non
esiste al giorno d’oggi un modello standard per scegliere a priori i valori e le
tecniche da utilizzare.
2.6.1 Numero di elementi , probabilità di incrocio e di mutazione
DeJong (DeJong, 1975) compì una serie di prove ripetute su una sequenza di
funzioni di prova (sequenza di DeJong), ricercando una combinazione dei
parametri iniziali che desse un risultato soddisfaciente. Egli ottenne i risultati
migliori con una popolazione iniziale composta da 50-100 individui, probabilità
di incrocio prossima al 60% e probabilità di mutazione di circa lo 0.1%. Questi
valori sono oggi diventati di uso comune. Tuttavia l’uso di algoritmi genetici per
generare questi parametri (Grefenstette, 1986) ed una prova sistematica di un
vasto insieme di combinazioni di essi (Schaffer, 1989) portarono a ritenere
migliore una popolazione con 30 individui, con probabilità di incrocio del 75-
95% ed una probabilità di mutazione dello 0.1%. Altri approcci prevedono di
variare i parametri durante l’evoluzione.
2.6.2 Meccanismo di selezione
Sono stati ideati vari metodi di selezione, tra cui:
 Selezione a classifica: si ordinano gli elementi della popolazione in base al
loro valore di idoneità. Dopodichè, si scelga a caso un elemento (favorendo
le posizioni con idoneità maggiore). Questo processo mantiene una bassa
pressione di selezione. Tuttavia, valori di posizioni consecutive presentano
valori di probabilità vicini. Questo sfavorisce il caso in cui tra due
posizioni consecutive il valore di idoneità diminuisca significativamente, e si
correrebbe il rischio di una convergenza lenta.
 Selezione a torneo: si scelga un insieme di individui e si indichi come
genitore quello con maggior valore di valutazione. Gli individui vengono
poi reinseriti nella popolazione e si esegue lo stesso passo per il secondo
genitore. Questo metodo è utile per controllare le convergenze veloci e
26

27. lente, poiché è sufficiente cambiare il numero di individui scelti in ogni
fase del torneo (aumentandolo se si vuole ottenere una convergenza più
rapida, viceversa diminuendoli). Inoltre questo metodo non richiede né il
calcolo del valore di idoneità né un ordinamento particolare.
 Selezione a stato stazionario: da una generazione alla successiva vengano
“rimpiazzati” soltanto una parte degli elementi, ovvero quelli con valore di
idoneità minore. Questo permette un miglioramento graduale di tutti gli
elementi del campione, e non solo di una parte di essi. Il metodo per cui
invece vengono mantenuti soltanto pochi elementi tra una generazione e
la successiva si chiama elitarismo (DeJong, 1975).
2.6.3 Meccanismo di incrocio
L’incorcio prevede la scelta di uno o più segmenti sui due individui genitori, che
saranno uniti per dar luogo a due figli (di cui uno potrà essere eventualmente
scartato). Le principali tecniche di incrocio sono le seguenti:
 Incrocio in un punto: si scelga a caso un punto all’interno della stringa di bit
e la si divida nei due segmenti formati. È da notare che, mentre ogni bit
“interno” al genotipo ha probabilità p, i bit estremali hanno prbabilità 0
di essere scelti.
 Incrocio in più punti: si scelgano più punti all’interno della stringa,
rappresentanti l’inizio e la fine dei segmenti. Essi saranno uniti ai bit
complementari presenti nell’altro genitore. In questo modo, i bit
estremali hanno meno probabilità di essere riprodotti rispetto all’incrocio
in un punto. Per questo, tale tecnica si chiama anche incrocio parametrico
uniforme.
2.7 Alcune applicazioni
Gli AG presentano la qualità di operare in ampi spazi di ricerca altrimenti
esplorabili solo esaustivamente. Inoltre, in poche generazioni realizzano una
27

28. soluzione “sopra la media”, anche se non ottima. Negli anni, sono stati utilizzati
in diversi ambiti:
 Ottimizzazione: Goldberg (Goldberg, 1989) ottimizzò la struttura di una
pompa per l’olio, composta da sezioni di tubo e unità di compressione
per mantenere la pressione, di modo che l’energia utilizzata per azionare i
compressori fosse minimizzata in base ai vincoli della pressione minima
e massima consentita in ciascuna sezione
 Aereodinamica: attraverso gli Algoritmi Genetici sono stati progettati
profili alari che soddisfano determinate condizioni, come la
minimizzazione della risposta ad un radar o la minima perturbazione
della velocità dovuta ad un determinato cambiamento di condizioni
atmosferiche (C. Poloni, 1995)
 Progetto di reti neurali: gli AG vengono utilizzati per descrivere le reti
neurali, modellizzandone la struttura ed i relativi pesi (G.F. Miller, 1989)
 Economia: tramite AG è possibile modellizzare l’andamento economico di
particolari titoli bancari, per poter effettuare previsioni per il proprio
portafoglio (Dueck, 1990)
2.8 Metodi Euristici di Ottimizzazione
Gli AG appartengono ad una categoria chiamata Metodi Euristici di Ottimizzazione
(Winker, 2004), in particolare ai metodi di Ricerca Locale. A differenza dei modelli
di ottimizzazione standard, questi metodi non forniscono la soluzione ottima,
ma una o più soluzioni che possono comunque considerarsi “buone”.
I modelli standard di ottimizzazione (ad esempio la ricerca del massimo di una
funzione o la costruzione di una serie storica) si basano infatti su tre paradigmi:
1. La soluzione viene identificata tramite enumerazione o calcolo
differenziale
2. La soluzione, se esiste, è unica
28

29. 3. Convergenza dei classici metodi di ottimizzazione per la soluzione delle
corrispondenti condizioni di primo ordine
Non tutti i problemi possono essere risolti con questa strategia. Si pensi, ad
esempio, al problema del commesso viaggiatore, nel quale esso deve recapitare
alcuni pacchi in n città distinte, collegate da più strade, seguendo il percorso più
breve. In quanto problema NP-hard, non esiste alcun metodo di ottimizzazione
standard per ottenere il percorso più breve.
I modelli di ottimizzazione euristici, invece, si basano su caratteristiche diverse:
1. Sono basati su modelli ritrovabili in natura
2. Si basano sulla crescente potenza di calcolo
3. Sebbene migliorino la soluzione proposta, la soluzione ottima non sarà
raggiunta con certezza
Essi si dividono in Algoritmi Golosi e Metodi di Ricerca Locale.
Gli Algoritmi Golosi (Thomas H. Cormen, 2005) eseguono una sequenza di
passaggi, scegliendo sempre la “strada” che sembra portare ad un risultato
migliore di quello attuale (scelta localmente ottima).
I Metodi di Ricerca Locale non esplorano tutto lo spazio di ricerca, ma costruiscono
un “cammino” in esso, seguendo il quale si ottengono risultati via via migliori.
Sono algoritmi di Ricerca Locale:
 Ricottura simulata (Kirkpatrick, Gelatt, & Vecchi):
Il concetto deriva dalla scienza dei metalli, dove la ricottura è usata per
eliminare difetti reticolari dai cristalli, tramite il riscaldamento ed un
lento raffreddamento.
È utilizzato per trovare un minimo globale in presenza di più minimi
locali. Lo schema è il seguente:
Genera una soluzione corrente xc, un numero di passi massimi Rmax ed una
temperatura T
29

30. For r =1 To Rmax do
While (non si è ottenuto un valore accettabile) do
xn = vicino di xc
Δ = f(xn) – f(xc)
u = casuale in (0,1]
Δ
if (Δ < 0) or ( < u) then di xc = xn
End while
Diminuisci T
End for
Figura 2.2: Andamento
esponenziale del valore della
soglia di calore
 Soglia di accettazione (Dueck, 1990):
Ciò che nell’esercizio precedente era rappresentato da una temperatura
T, ora è rappresentato da un valore di soglia τ.
Genera una soluzione corrente xc, un numero di passi massimi Rmax ed una soglia
τ
For r =1 To Rmax do
While (non si è ottenuto un valore accettabile) do
xn = vicino di xc
Δ = f(xn) – f(xc)
if (Δ < τ) then di xc = xn
End while
Diminuisci τ
End for
 Ricerca tabù (Glover, 1989):
30

31. Viene mantenuta una “storia recente” degli elementi ispezionati, per non
coinvolgerli più volte nell’evoluzione.
Genera una soluzione corrente xc, ed una lista L vuota.
While (non si è ottenuto un valore accettabile) do
xn = vicino di xc non appartenente a L
Δ = f(xn) – f(xc)
if (Δ < 0) then di xc = xn ed inserisci xn in L
Elimina elementi vecchi da L
End while
 Algoritmi Genetici
31

32. 32

33. Capitolo 3
L’ALGORITMO SVILUPPATO
3.1 Obiettivo
Il problema che si vuole risolvere è quello di determinare inizialmente la
presenza o meno di un determinato intervallo di colore9 (appartenente al
modello ARGB) all’interno di un’immagine. Successivamente, è possibile
stabilire se in una certa zona è presente un particolare colore. Attraverso un
ulteriore algoritmo di interpolazione, infine, è possibile delimitare la zona in cui il
colore è stato trovato.
3.2 Descrizione dell’algoritmo
Lo scopo principale dell’algoritmo è di fornire un’insieme di punti nei quali
l’immagine presenta un colore specificato. Il risultato ottimo, ma difficilmente
raggiungibile attraverso un algoritmo di tipo genetico, sarebbe l’indicazione di
tutti i punti il cui colore appartenga ad un intervallo scelto a priori dall’utente.
Nelle seguenti pagine si intenderà come “colore” un oggetto appartenente al
modello ARGB.
Esempio 3.1:
Ricercando tutti i colori compresi nell’intervallo I ={ [255,0,0,0] ; [255,0,0,255] },
ovvero tutti i punti con opacità massima (A = 255) ed appartenenti ad una tonalità di
blu ( B = 0,1,…255) nella figura 3.1a, il risultato ottimo è l’ottenimento di un insieme
di punti ricoprenti tutte le zone interessate, come in figura 3.1b (in bianco)
Figura 3.1a: Immagine iniziale Figura 3.1b: Area obiettivo
9
Insieme di valori compresi tra due colori “estremali”. Utilizzando la rappresentazione
ARGB, in cui ogni grandezza rappresenta una dimensione in uno spazio quadrimensionale,
un intervallo è raffigurabile come un ipercubo, le cui facce sono limitate dai valori dei
colori estremali. Ad esempio, scelti come colori il rosso [255,255,0,0] ed una tonalità di
arancione meno opaco [200,247,153,59], l’intervallo di colore costituito è descrivibile
come:
I = {(α,r,g,b) : α [200,255] , r [247,255] , g [0,153] , b [0,59]}
33

34. 3.2.1 Inizializzazione
Il primo passo richiede la scelta dei parametri per l’algoritmo genetico (come
descritto nel Capitolo 2). Dovranno essere impostati i valori di probabilità di
mutazione (pMut) e di incrocio (pCross). Il numero di punti di taglio di un
cromosoma è deciso a priori scegliendo la lunghezza della porzione di
cromosoma che sarà tagliato durante l’incrocio (lSeg). Inoltre, si sceglie il
numero di elementi presenti nella popolazione (nPop). Infine vengono impostati
i colori di estremo per l’intervallo ( = {colour [ext1,ext2]}).
3.2.2 Prima generazione
Vengano creati casualmente nPop elementi (pixel) e vengano inseriti nella prima
popolazione.
Per ogni punto:
 Si calcoli il valore di valutazione come somma delle distanze euclidee tra il
colore scelto (col = [colA ,colR ,colG ,colB] )ed i colori estremali per ,
ovvero:
Fval = +
[1]
 Si aggiunga il punto generato alla popolazione
 Si consideri il colore del pixel e, se appartiene all’intervallo , si
“segnali” il punto come parte della soluzione
Al termine, si ordini la popolazione secondo il valore di valutazione in modo
crescente, ovvero mantenendo in prima posizione gli elementi meno distanti
dall’intervallo .
3.2.3 Generazioni successive
Si generi una nuova popolazione di nPop elementi, inizialmente vuota.
Dopodichè, si proceda con la fase evolutiva dell’algoritmo:
 Si scelgano 2 elementi “genitori”, seguendo una distribuzione di
probabilità sulla popolazione di tipo gaussiano. Poiché la popolazione è
stata ordinata, i primi elementi saranno scelti con maggior probabilità, e
saranno proprio quelli il cui colore è meno distante dall’intervallo . La
figura seguente schematizza la probabilità di scelta:
34

35. 0,4
0,3
0,2
0,1
1 2 3 4 … … … nPop
Figura 3.2: Distribuzione gaussiana di probabilità di
selezione sulla popolazione
 Tra i due genitori si effettui l’operazione di incrocio con probabilità
pCross, generando due elementi figli. L’incrocio venga effettuato su più
punti, utilizzando segmenti di lunghezza l ≤ lSeg, dove l è scelto con
probabilità uniforme in [0, lSeg].
Figura 3.3: Incrocio di due cromosomi genitori con segmenti di lunghezza 3
 Con probabilità pMut ogni figlio sia soggetto all’operazione di
mutazione di un gene. Nel caso la mutazione porti a figli “non
ammissibili” (rappresentanti pixel di coordinate esterne all’immagine),
si sostituisca con un elemento generato casualmente, aumentando
l’eterogeneità della popolazione, per non incorrere nella convergenza veloce
 Per ogni figlio, si valuti il valore di valutazione, lo si aggiunga alla nuova
popolazione e, nel caso il suo colore appartenga all’intervallo , lo si
“segnali” come parte della soluzione
 Al termine, si ordini la popolazione in modo crescente secondo il valore
di valutazione
3.2.4 Interruzione
Non è previsto alcun meccanismo d’interruzione interno all’algoritmo: ad ogni
passo, infatti, deve essere l’utente a scegliere di generare un’ulteriore
popolazione a partire dall’attuale.
35

36. Si noti che non è stato necessario implementare una funzione di idoneità, in quanto
il meccanismo di selezione si basa su una distribuzione gaussiana su una
popolazione ordinata: questo meccanismo di selezione fa le “veci” della funzione
di idoneità, poiché gli elementi migliori saranno scelti con probabilità più elevata.
3.3 Implementazione
L’algoritmo è stato sviluppato in linguaggio Java, versione 7. Si è utilizzato il tool
di sviluppo “NetBeans IDE 7.0.1”. Il codice è visionabile all’appendice A.
3.3.1 Struttura del codice
Per realizzare il solo algoritmo genetico, è stata realizzata la seguente struttura
di classi:
Pacchetto : pkgColouredImages
Il pacchetto descrive le classi utilizzate per una descrizione ed una
manipolazione più efficace delle immagini e dei colori.
 MyARGB
Rappresenta un colore appartenente al modello ARGB e
contiene alcuni metodi dinamici, come il calcolo della distanza
euclidea tra l’istanza ed un parametro e l’appartenenza o meno
dell’oggetto istanziato ad un intervallo di colore.
 MyImage
Descrive l’immagine su cui opera l’algoritmo genetico.
Implementa un metodo che restituisce il colore di un pixel dato
ed un metodo che modifica l’immagine stessa evidenziando i
pixel appartenenti all’attuale popolazione. Quest’ultimo
metodo, in realtà, è necessario solo in caso di interazione con
l’utente.
Pacchetto: pkgEvaluator
Contiene la classe:
 GenPixelEvaluator
36

37. Implementa la funzione di valutazione. In questa realizzazione,
essa è descritta come in [1]
Pacchetto: pkgGeneticColourItems
Descrive il funzionamento dell’algoritmo genetico. Descrive le classi per la
modellizzazione della popolazione, delle operazioni genetiche e
dell’algoritmo nel suo complesso.
 GeneticOperations
Implementa le operazioni genetiche: l’incrocio e la mutazione.
Entrambe si applicano al genotipo, codificato come stringa di
bit.
 GeneticPixel
Codifica un elemento della popolazione. Ogni pixel viene
rappresentato mediante le sue coordinate, il colore, il genotipo
ed il valore di valutazione. Il genotipo scelto è la sequenza binaria
delle coordinate X ed Y del pixel, come sintetizzato in figura:
3 x
4
(3,4) 011100
y
Figura 3.4: Coordinate cartesiane, fenotipo e genotipo relativi
I metodi pointToBits e bitToPoints trasformano le coordinate
cartesiane nel genotipo e viceversa.
Il metodo invertBitAt inverte un singolo bit nella posizione
scelta durante la mutazione con probabilità uniforme.
Il metodo crossGenotypes genera due nuovi pixel attraverso
l’incrocio descritto nelle pagine precedenti.
Il metodo compareTo confronta l’oggetto istanziato con un
parametro in base al valore di valutazione.
 Population
Descrive una popolazione in un certo istante dell’evoluzione.
Contiene informazioni quali il minimo ed il massimo valore di
37

38. valutazione presenti, nonché la media e la varianza del valore di
valutazione e del fenotipo (codificato tramite coordinate
cartesiane).
Il metodo computeStatistic assegna i valori appena descritti.
Il metodo sortPopulation ordina la popolazione in modo
crescente in base al valore di valutazione seguendo l’algoritmo di
ordinamento della classe java.util.Collections, che implementa
una variante del mergesort (Thomas H. Cormen, 2005) con un
costo di nlog(n). L’algoritmo è descritto al sito:
http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Collections.html
 Searcher
È il “cuore” dell’algoritmo. Tramite il costruttore, assegna i
parametri di input per l’Algoritmo Genetico ed implementa i
metodi per creare ed evolvere la popolazione.
Il metodo makeFirstGeneration genera una popolazione iniziale
casuale e, come nella descrizione dell’algoritmo, assegna ad ogni
elemento il valore di valutazione e restituisce la lista
(eventualmente vuota) degli elementi che soddisfano
l’appartenenza all’intervallo di colore.
Il metodo makeNextGeneration incrocia gli elementi appartenenti
all’attuale popolazione e genera una nuova popolazione. Ogni
nuovo elemento potrebbe poi subire una mutazione. Infine,
restituisce la lista degli elementi che soddisfano l’appartenenza
all’intervallo di colore.
Per realizzare l’interazione con l’utente, è stata realizzata l’interfaccia riportata
in figura:
Figura 3.5: Maschera iniziale per l'impostazione dei parametri dell'algoritmo genetico
38

39. I pacchetti per gestire l’inserimento dei dati da utente attraverso la form sono
i seguenti:
Pacchetto: pkgPrimitiveWrapper
Re-implementa un tipo di dato primitivo con una classe dinamica, che sarà
utilizzata per la sincronizzazione di thread10,11.
 MyBoolean
Descrive un oggetto di tipo booleano, implementandone i
metodi per impostarlo, modificarlo e restituirne il valore
Pacchetto: pkgSearcherFrontEnd
Contiene le classi per la gestione della form.
 MyJPanel
Descrive il pannello (contenitore di oggetti grafici) in cui verrà
visualizzata l’immagine in elaborazione. Attraverso il click del
mouse su di un pixel, mostra il valore dei parametri ARGB
relativi al colore di quel punto.
 MyFileOperator
Implementa metodi per la lettura/scrittura su un file di testo. È
stata creata per rendere più leggibile il codice.
 FrmWelcomeSearcher
Oltre ad implementare e richiamare metodi per gestire il
funzionamento della maschera, contiene alcuni metodi per
avviare l’algoritmo vero e proprio. Le operazioni al run-time
sono gestite mediante l’utilizzo di thread sincronizzati. La
10
Con il termine thread si indica una classe che implementa metodi che possono essere
lanciati e catturati al run-time. Il processo “padre” può lanciare un processo “figlio”
(thread) che sarà eseguito indipendentemente dal padre. Il padre potrà poi arrestare
(catturare) in qualunque momento l’esecuzione del figlio. Per una descrizione più
accurata, si rimanda a Tanenbaum (Tanenbaum, 2009).
11
La sincronizzazione è un problema che si presenta quando vengono lanciati più thread
dipendenti tra loro. Il problema è quello di far “comunicare” i processi attraverso un
canale. Una delle possibili soluzioni (utilizzata in questo software) è l’utilizzo di un oggetto
di tipo booleano. Ogni thread, prima di eseguire la sua porzione di codice, controlla lo
stato di questa variabile ed “agisce” di conseguenza. Per una descrizione più accurata, si
rimanda a Tanenbaum (Tanenbaum, 2009).
39

40. sincronizzazione avviene per mezzo di un oggetto di tipo
MyBoolean all’interno di un blocco sincronizzato12.
Di seguito viene illustrato il meccanismo di avvio dell’algoritmo, con uno
sguardo alle istruzioni eseguite.
1. All’inizio si scelga, tra i propri file, l’immagine su cui operare. Il software
supporta immagini di tipo JPEG, PNG e GIF.
Figura 3.6: Scelta dell’immagine
2. Scelta l’immagine, verrà richiesta la selezione di un file di testo in cui
salvare i punti trovati. Sarà possibile scegliere, per ogni generazione, di
aggiungere statistiche quali: media e varianza, valore minimo e massimo
del valore di valutazione, media e varianza delle coordinate cartesiane
nonché i valori impostati come parametri per l’algoritmo genetico e
modificabili al run-time.
3. Si scelgano i colori di estremo per l’intervallo. Essi saranno poi
“normalizzati”, ovvero verranno utilizzati due colori estremali diversi,
uno “di minimo” ed uno “di massimo”, in cui i valori dei parametri
ARGB saranno il minimo (o il massimo) tra i valori presenti nei due
colori.
12
Un blocco sincronizzato è un insieme di istruzioni che viene eseguito in mutua
esclusione. Si ha mutua esclusione quando è garantito che tutti gli oggetti utilizzati da un
thread non siano modificati da un altro thread eseguito in parallelo, che eventualmente
attenderà. Definire un insieme di istruzioni all’interno di un blocco sincronizzato significa
garantire la mutua esclusione per gli oggetti definiti al suo interno. I blocchi sincronizzati
vengono utilizzati per modificare il valore degli oggetti creati per gestire la comunicazione
e la sincronia tra thread paralleli.
40

41. Figura 3.7: Scelta dei colori di estremo per l'intervallo cercato
4. Si impostino i parametri dell’algoritmo genetico: probabilità di incrocio e
mutazione, numero di elementi della popolazione e lunghezza del
segmento di cromosoma che sarà tagliato durante l’incrocio. Per una
visione a run-time dell’evoluzione della popolazione, si scelga il colore
con cui visualizzare nell’immagine i pixel appartenenti alla generazione
corrente.
Figura 3.8: Impostazione dei
parametri per l'esecuzione
5. Si prema “Start Generate”. Il metodo associato lancia il thread
StartThread in FrmWelcomeSearcher. Questo thread disabilita i comandi
non più necessari, istanzia un oggetto di tipo Searcher e richiama i
metodi makeFirstGeneration e makeNextGeneration. Attraverso un oggetto
di tipo MyFileOperator, aggiunge i punti trovati (e le eventuali
statistiche) al file scelto come destinazione del risultato. Quando viene
invocato il metodo associato al tasto “Stop Generate”, viene lanciato un
thread di tipo StopThread in FrmWelcomeSearcher. Mediante la
sincronizzazione, questo processo blocca l’esecuzione del thread
StartThread.
41

42. Figura 3.9: Esecuzione dell'algoritmo
6. Mediante il tasto “See Result” è possibile vedere all’interno
dell’immagine i punti trovati dall’algoritmo.
Figura 3.10: Visione del risultato
Il file ottenuto mostra i risultati in una forma facilmente identificabile ed adatta
ad un parsing, come riportato in figura seguente:
Figura 3.11: File di destinazione ottenuto
42

43. 3.4 Note tecniche
3.4.1 Tipo di dati restituito
Scopo dell’algoritmo è fornire una lista di punti il cui colore rientra in un
intervallo specificato. I metodi makeFirstGeneration e makeNextGeneration,
infatti, restituiscono un oggetto di tipo ArrayList<Point>.
Il salvataggio di questi punti su un file di testo, l’aggiunta delle statistiche e
la visualizzazione a video mediante l’interfaccia progettata sono elementi
esterni all’Algoritmo Genetico, scelti per visionare, studiare e correggere il
comportamento del processo.
3.4.2 Rappresentazione del genotipo
Come descritto nella sezione “Struttura del codice”, il genotipo è stato
rappresentato tramite una concatenazione di bit. Ad ogni pixel è associata una
coppia di numeri naturali a 32 bit che ne indicano le coordinate all’interno
dell’immagine digitale. Il genotipo è una sequenza di 64 bit, rappresentata
tramite un numero intero di tipo long. I primi 32 bit rappresentano la
coordinata X, mentre gli ultimi 32 bit rappresentano la coordinata Y. Per i
metodi di conversione, si rimanda all’Appendice A,
pkgGeneticColourItems.GeneticPixel, righe 49-121.
43

44. 44

45. Capitolo 4
STUDIO DELL’ALGORITMO
4.1 Metodo di studio
Per lo studio del comportamento dell’algoritmo, si è utilizzata l’interfaccia
grafica descritta del capitolo precedente. In un primo momento si sono testate
diverse combinazioni di parametri su una stessa immagine di base. In un
secondo momento si è voluta studiare la risposta ad immagini differenti, con
diverse combinazioni di parametri in ingresso. Successivamente, si sono
analizzate le prestazioni in risposta ad un basso numero di evoluzioni. Infine, si
è voluta fornire una possibile applicazione dell’algoritmo, nella ricerca di aree di
calore in un’immagine termica e di tracciamento di traiettoria in una sequenza
di immagini.
4.2 Definizione di coefficiente di distribuzione
Per un corretto studio della risposta dell’algoritmo genetico, è necessario poter
classificare le immagini campione secondo una certa metrica. Si idealizza così
un valore da associare ad ogni immagine, detto coefficiente di distribuzione,
che indica in prima approssimazione la “ semplicità della struttura” dell’area da
ricercare.
Si definisce coefficiente di distribuzione associato all’intervallo di colore il valore:
c.d. =
dove,
 nC è il numero dei punti nell’immagine appartenenti all’intervallo
di colore specificato, ovvero:
45

46.  AC è l’area dell’insieme convesso13 più piccolo comprendente
tutti i punti con colore in
Più il c.d. si avvicina ad 1, più l’area obiettivo assume una forma compatta e
definita. Al decrescere di tale valore, i pixel di colore cercato formano insiemi
non connessi14 o non convessi.
Figura 4.1: Immagini con diverso coefficiente di distribuzione associato al valore [255,0,162,232]
(blu chiaro). Rispettivamente, da sinistra, i valori sono 1.00 , 0.80 , 0.40 e 0.24. In nero sono
evidenziati gli insiemi convessi che contengono l’area obiettivo
4.3 Studio mediante cambiamento di parametri
In questa prima fase si è scelto di ripetere più prove, variando i parametri che
caratterizzano l’algoritmo: probabilità di incrocio (pCross), probabilità di
mutazione (pMut), numero di elementi del campione e lunghezza minima del
segmento di cromosoma da tagliare (lSeg).
Sono stati considerati ai fini dello studio:
 il numero medio di punti trovati per ogni generazione (N punti)
 la media e la varianza del valore di valutazione (vv) medio di ogni
generazione, ovvero:
dove e sono rispettivamente la media e la
varianza del valore di valutazione nella generazione i-esima;
13
Un insieme si dice convesso se, presi due punti arbitrari che ne fanno parte, è possibile
costruire un segmento che li unisce, i cui punti sono anch’essi contenuti nell’insieme.
14
Un insieme si dice semplicemente connesso se, presi due punti arbitrari che ne fanno
parte, è possibile costruire una curva che li congiunge, i cui punti sono anch’essi contenuti
nell’insieme.
46

47.  la media delle coordinate cartesiane dei punti medi di ogni
generazione, ovvero:
dove è la media delle coordinate cartesiane della
generazione i-esima;
 la media della varianza della distanza dal punto [0,0] delle
coordinate medie di ogni generazione, ovvero:
dove è la varianza della distanza delle coordinate dal
punto [0,0];
 la percentuale di generazioni “improduttive” (%Gen.Im.), ovvero i
cui elementi presentano tutti un colore al di fuori dello spazio
specificato.
A lato di ciascun test è riportato l’andamento di media e varianza del valore di
valutazione al susseguirsi delle generazioni. La linea blu rappresenta il valore di
valutazione medio,la linea nera è una linea di tendenza di tale valore e la linea
rossa è la varianza. È stato ottenuto anche un grafico che mostra la posizione
del punto medio di ogni generazione (in blu).
L’algoritmo è stato lasciato evolvere per un numero prefissato di generazioni
(Ngen), in modo che si potessero stimare anche il numero di millisecondi
necessari all’esecuzione. In questo senso, è da precisare che il tempo di
lettura/scrittura dell’output su un file ed il tempo necessario al motore grafico
per visualizzare e modificare l’immagine sono stati valutati in media e
decrementati dal tempo totale. Tuttavia, per la stima del tempo di esecuzione
non sono stati calcolati i cicli di clock destinati ad altri processi in esecuzione
nello stesso istante sulla macchina.
Il calcolatore di test ha a disposizione una CPU AMD Turion®II Ultra Dual-
Core Mobile M600, 2.40 GHz e 2GB di RAM. Le immagini hanno dimensione
800x600 pixel.
47

48. 4.3.1 Prima fase: 10 elementi per generazione
Si è scelta l’immagine riportata in figura 4.2.
Figura 4.2: Immagine del primo test.
L’area obiettivo è il disco rosso (più precisamente, di colore [255,237,28,36])
di centro [400,313]. Il coefficiente di distribuzione dell’immagine rispetto al
rosso è pari a 0.81. Si è scelta una popolazione di 10 elementi per ogni
generazione, fatti evolvere per 100 generazioni.
Test 1.a
800
% pCross 10
% pMut 0.0 600
lSeg(bit) 3 400
Tempo (ms) 31
200
N punti 2.64
E[E[vv]] 599.1 0
E[Var[vv]] 52.7 0 20 40 60 80 100
E[E[x,y]] [390,328]
E[Var[z]] 44
% Gen. Im. 51
Il comportamento dell’algoritmo è completamente imprevedibile. Le prime
generazioni cadono nelle vicinanze dell’area interessata, poi si evolvono al di
fuori di essa (si nota un valore di valutazione medio molto alto). Questo è
dovuto al fatto che ci sono pochi elementi nella popolazione e che i
48

49. parametri dell’algoritmo (bassa popolazione, bassa probabilità di incrocio,
bassa lunghezza del segmento di cromosoma) non permettono
l’avvicinamento presso i punti “migliori”. Fino alla generazione 31, ogni
punto generato ha un colore non idoneo. Successivamente, alcuni punti
ricadono all’interno dell’area obiettivo, per poi uscirne (questo a
dimostrazione dell’aleatorietà dell’evoluzione). La percentuale di generazioni
improduttive è molto alta, ed il numero di punti generati al di fuori dell’area
obiettivo è del 73.6%. Tuttavia, la media delle coordinate si avvicina al
valore atteso [400,313], seppur con una notevole varianza. Questo dato è
riconducibile all’eterogeneità dei campioni ottenuti, i cui punti si
distribuiscono casualmente all’interno dell’immagine.
Test 1.b
800
% pCross 10
% pMut 50 600
lSeg(bit) 3 400
Tempo (ms) 150
200
N punti 1.79
E[E[vv]] 648.4 0
E[Var[vv]] 41.2 0 20 40 60 80 100
E[E[x,y]] [312,284]
E[Var[z]] 51
% Gen. Im. 60
In questo test si è aumentata la probabilità di mutazione al 50%. Ciò crea un
disturbo maggiore alla stabilità delle coordinate. Infatti, si nota un
andamento ancora più casuale dell’esperimento precedente, seppur con una
tendenza verso la parte “sinistra” dell’immagine. Nelle prime generazioni si
ha la “fortuna” di aver generato punti nei pressi dell’area obiettivo. Tuttavia,
questo vantaggio si perde per gli stessi motivi del test precedente. Si ha una
media di appena 1.79 punti trovati per ogni generazione, con uno spreco
49

50. dell’82.9% di punti generati. Il numero di generazioni improduttive sale al
60%, causando un aumento della media del valore di valutazione.
Com’era prevedibile, un semplice aumento della probabilità di mutazione non è
sufficiente, anzi è deleterio per l’efficacia e l’efficienza dell’algoritmo. Infatti
ogni mutazione porta il rischio di generare punti al di fuori dell’immagine.
Per com’è stato implementato l’algoritmo, questi punti vengono rimpiazzati
con punti generati casualmente; una mutazione nel 50% dei casi aumenta
quindi la presenza di punti casuali generati durante l’evoluzione.
Test 1.c
800
% pCross 10
% pMut 0,1 600
lSeg(bit) 8 400
Tempo (ms) 175
200
N punti 5.37
E[E[vv]] 365.3 0
E[Var[vv]] 94.7 0 20 40 60 80 100
E[E[x,y]] [385,325]
E[Var[z]] 43.1
% Gen. Im. 10
In questo test è stata diminuita allo 0.1% la probabilità di mutazione ed è stata
aumentata ad 8 la lunghezza di taglio del segmento di cromosoma. Si nota
un decisivo miglioramento delle prestazioni. Infatti, in media, più della metà
dei punti generati in ogni popolazione rientra nell’area obiettivo
(precisamente, 5.37 punti). Inoltre, il valor medio del valore di valutazione è
più che dimezzato rispetto al test precedente. Potendo disporre di soli 10
punti, però, la popolazione ha una grande varianza (vicina a 100) ed il valore
di valutazione non sembra stabilizzarsi. La media delle coordinate, invece, si
avvicina al valore atteso e, come si nota dall’evoluzione dei punti medi delle
generazioni, sembra stabilizzarsi nelle vicinanze dell’area obiettivo durante il
50

51. susseguirsi delle generazioni. L’efficienza migliora notevolmente, e solo il
10% delle generazioni è stato improduttivo.
L’aumento della lunghezza di taglio del segmento di cromosoma ha portato
ad una stabilizzazione dell’evoluzione. Infatti, in questo modo un quarto del
genotipo viene costantemente mantenuto, e questo permette di contrastare
la scarsa numerosità di elementi in una popolazione.
Test 1.d
800
% pCross 10
% pMut 50 600
lSeg(bit) 8 400
Tempo (ms) 100
200
N punti 1.73
E[E[vv]] 653.1 0
E[Var[vv]] 55.5 0 20 40 60 80 100
E[E[x,y]] [382,315]
E[Var[z]] 52
% Gen. Im. 47
In questo test, si sono mantenuti i parametri del test precedente, ma è stata
aumentata al 50% la probabilità di mutazione.
Come si nota, l’andamento è di nuovo casuale e disastroso, com’era
prevedibile.
51

52. Test 1.e
800
% pCross 80
% pMut 0.1 600
lSeg(bit) 3 400
Tempo (ms) 70
N punti 1.76 200
E[E[vv]] 650 0
E[Var[vv]] 47 0 20 40 60 80 100
E[E[x,y]] [439,290]
E[Var[z]] 49.6
% Gen. Im. 60
In questo test, si nota l’efficacia dell’incrocio solo dopo un certo numero di
generazioni completamente improduttive. Infatti, i punti iniziali sono stati
generati al di fuori dell’area obiettivo e nessuno di essi aveva un valore di
valutazione più basso, in modo da essere scelto con più probabilità durante
l’incrocio. Nella prima metà delle generazioni, quindi, l’alta probabilità d’incrocio
ha fatto si che fossero scelti dei punti “non buoni” per la costruzione della
generazione successiva; inoltre, il basso valore della lunghezza di taglio del
segmento di cromosoma ha contribuito alla creazione di punti di coordinate
eterogenee. Successivamente, alla 60° generazione, alcuni punti sono caduti
all’interno del disco obiettivo. La loro presenza ha favorito lo stabilizzarsi
delle successive generazioni nelle aree prossime al disco. Il basso valore di
taglio ha però mantenuto molto oscillante il valore di valutazione medio e la
sua varianza. Nemmeno la media totale delle coordinate cartesiane è buona,
ed è presente una grande varianza delle stesse. Tuttavia, una media globale
dei risultati ottenuti è un’approssimazione sommaria. Infatti, per un corretto
studio di questo test, è necessario prendere in considerazione il
comportamento “a regime”, ovvero dopo la 62° generazione (in questo caso
particolare). Uno studio dei valori a regime fornisce risultati prossimi a
quelli ottenuti “in buone condizioni”, anche se leggermente peggiori. Infatti,
52

53. considerando le generazioni successive alla 60°, si ottiene una media di 4.45
punti trovati in ogni generazione, con una media delle coordinate pari a
[393,368].
Si potrebbe pensare che il comportamento a regime, lasciando evolvere
l’algoritmo per più di 100 generazioni, potrebbe migliorare. Tuttavia, il
risultato dell’esecuzione per 1000 generazioni, mantenendo invariati i
parametri, è riportato dal seguente grafico:
800
700
600
500
400
300
200
100
0
0 200 400 600 800 1000
Come si può notare, non si ha un apprezzabile miglioramento del valore di
valutazione medio, né della sua varianza. I risultati sono pressoché analoghi al
caso precedente, dopo la 60° generazione: 4.41 punti in media trovati in
ogni generazione, con un avvicinamento delle coordinate medie al punto
[387,333]. Anche in questo caso, si nota la presenza di uno stato iniziale di
“improduttività”, che coinvolge 50 generazioni.
Questo comportamento è dovuto alla scarsa numerosità del campione.
53

54. Test 1.f
800
% pCross 90
% pMut 0.1 600
lSeg(bit) 8 400
Tempo (ms) 150
200
N punti 3.58
E[E[vv]] 506 0
E[Var[vv]] 96 0 20 40 60 80 100
E[E[x,y]] [401,337]
E[Var[z]] 48.9
% Gen. Im. 12
In questo si è tentato di combinare gli effetti di una alta probabilità di incrocio,
di una bassa probabilità di mutazione e di una lunga sequenza di bit conservata
nell’incrocio. Contrariamente alle aspettative, l’insieme di questi effetti non
porta ad un apprezzabile miglioramento dell’esecuzione. Il valore di
valutazione medio oscilla con una grande ampiezza e non si stabilizza,
mantenendo un’elevata varianza. Tuttavia la media delle coordinate è molto
buona e prossima al valore atteso. In accordo con gli studi di Holland, si
nota la predominanza del seguente schema nel genotipo dei pixel:
0000000000000000000000010*1*0***000000000000000000000001*1**0**1
La coordinata X varia da 288 a 375, mentre la coordinata Y varia da 321 a
503
La poca popolazione presente non permette, nella maggioranza dei casi, di
ottenere un’esecuzione efficiente (in termini di popolazioni improduttive
generate), né molto efficace (in termini di stabilizzazione dei punti generati).
Giunti a questo punto, sembra che in presenza di pochi elementi all’interno
delle generazioni (ipotizzabile nei casi di pochissima memoria a
disposizione), una buona strategia sia quella presentata nel test 1.c.
54

55. 4.3.2 Seconda fase: 100 elementi ad ogni generazione
In questa fase si sono ripetuti gli stessi test sulla stessa immagine, con la
stessa area obiettivo, aumentando la popolazione a 100 elementi.
Test 2.a 800
700
% pCross 10
600
% pMut 0.0 500
lSeg(bit) 3 400
300
Tempo (ms) 350
200
N punti 55.4 100
E[E[vv]] 352.1 0
0 20 40 60 80 100
E[Var[vv]] 38.2
E[E[x,y]] [387,337]
E[Var[z]] 14.3
% Gen. Im. 0
In questo primo test, si è limitata l’influenza dei parametri sull’evoluzione
della popolazione. Tuttavia, l’aumento del numero di elementi di ogni
popolazione ha permesso la stabilizzazione dei punti nei pressi del disco
obiettivo, come si nota dalla rappresentazione delle coordinate medie. La
media dei valori di valutazione è più bassa rispetto ai test precedentemente
effettuati. Anche la varianza è nettamente diminuita. Le coordinate medie si
posizionano in un’intorno del punto [387,337], ovvero nei pressi del valore
atteso. È da notare l’assenza di generazioni improduttive ed una media di
55.4 punti trovati per ogni generazione.
55

56. Test 2.b 800
% pCross 10 700
600
% pMut 50
500
lSeg(bit) 3 400
Tempo (ms) 81 300
200
N punti 53.8
100
E[E[vv]] 365.0 0
E[Var[vv]] 38.1 0 20 40 60 80 100
E[E[x,y]] [387,336]
E[Var[z]] 14.6
% Gen. Im. 0
Test 2.c
800
% pCross 10
% pMut 0.1 600
lSeg(bit) 8
400
Tempo (ms) 68
N punti 39.5 200
E[E[vv]] 478
0
E[Var[vv]] 37.0 0 20 40 60 80 100
E[E[x,y]] [390,344]
E[Var[z]] 16.3
% Gen. Im. 0
56

57. Test 2.d
800
% pCross 10
% pMut 50 600
lSeg(bit) 8 400
Tempo (ms) 280
200
N punti 41.2
E[E[vv]] 464.5 0
E[Var[vv]] 37.7 0 20 40 60 80 100
E[E[x,y]] [394,344]
E[Var[z]] 15.6
% Gen. Im. 0
Test 2.e
700
% pCross 80 600
% pMut 0.1 500
lSeg(bit) 3 400
300
Tempo (ms) 130
200
N punti 54.2
100
E[E[vv]] 362.0 0
E[Var[vv]] 38.4 0 20 40 60 80 100
E[E[x,y]] [386,333]
E[Var[z]] 14.6
% Gen. Im. 0
57

58. Test 2.f 800
% pCross 90 700
600
% pMut 0.1
500
lSeg(bit) 8 400
Tempo (ms) 350 300
200
N punti 40.7
100
E[E[vv]] 468.5 0
E[Var[vv]] 37.9 0 20 40 60 80 100
E[E[x,y]] [396,348]
E[Var[z]] 15.4
% Gen. Im. 0
Nei successivi test, si nota come l’introduzione di valori diversi nei
parametri porti ad un peggioramento dei risultati. La presenza di 100 punti
sembra “dominare” sull’evoluzione dell’algoritmo, impedendo una
stabilizzazione accurata dei punti generati. Infatti, pur evidenziando un
aumento nel valor di valutazione medio, non si può dire altrettanto delle
varianze e della media delle coordinate. Questi valori, infatti, non sembrano
risentire di particolari variazioni. Lo schema di Holland che si profila è lo
stesso riportato nel test1.f.
In conclusione, si conclude che 100 elementi costituiscono una popolazione
troppo numerosa perché i parametri dell’algoritmo abbiano effetto sui punti
generati.
4.3.3 Terza fase: miglior combinazione di parametri
Sono stati effettuati 50 test, combinando un numero di elementi non
eccessivo (40-80) con una modifica dei parametri caratterizzanti l’algoritmo.
L’esecuzione è stata lasciata evolvere per 1000 generazioni.
58

59. I test che hanno riportato i risultati migliori si possono approssimare al test
descritto nella seguente tabella:
Test 3 600
% pCross 80
500
% pMut 0.01
400
lSeg(bit) 5
Popolazione 75 300
Tempo (ms) 1500 200
N punti 52.7 100
E[E[vv]] 302.3
0
E[Var[vv]] 35.5 0 200 400 600 800 1000
E[E[x,y]] [415,328]
E[Var[z]] 12.4
% Gen. Im. 0
Si nota un valore di valutazione medio decisamente inferiore ai test 1 e 2, con
una bassa varianza. Anche la media delle coordinate si avvicina al valore
atteso, ed anche in questo caso si ha una bassa varianza. Il numero di punti
mediamente trovati su una popolazione è pari al 70.3%. Un risultato
migliore di questo non è stato ottenuto. Ciò porta a concludere che circa il
30% dei punti generati non è utilizzato.
Il tempo di esecuzione sembra dipendere solo dal numero di generazioni per
cui è lasciato evolvere l’algoritmo, ma non dai parametri di ingresso (si
confrontino a questo proposito i test 1.a, 1.b, 1.c e 2.b).
4.4 Studio attraverso immagini con diverso coefficiente di distribuzione
In questa fase di studio, è stato considerato il comportamento dell’algoritmo su
immagini con diverso valore di coefficiente di distribuzione. Obiettivo del test è
formulare alcune ipotesi sui parametri d’ingresso in funzione del coefficiente di
distribuzione per ottenere prestazioni paragonabili a quelle del test3.
59

60. Le immagini su cui saranno effettuati i test sono le seguenti:
coefficiente di distribuzione rispetto al blu: 0.86
coefficiente di distribuzione rispetto al marrone: 0.46
coefficiente di distribuzione rispetto al verde: 0.45
coefficiente di distribuzione rispetto al bianco:0.29
coefficiente di distribuzione rispetto al giallo: 0.25
coefficiente di distribuzione rispetto al giallo: 0.25
60

61. I risultati ottenuti variando i parametri caratteristici dell’algoritmo sono i
seguenti:
pCross: 80%
I punti generati ricoprono
so pressoché l’intera area obiettivo,
con una maggior concentrazione
pMut: 10% verso la parte inferiore
dell’immagine. Pur con una
Pop: 75 breve lunghezza del segmento di
taglio, si è ottenuto un risultato
accettabile, in cui il 76% dei
lSeg: 3
punti generati è stato utilizzato.
pCross: 90%
Mutazione: In questo test si è
verificato uno spreco dell’ 84%
dei punti generati. Il risultato
pMut: 50% associato ad un incremento della
probabilità di mutazione non è
Pop: 75 soddisfacente.
lSeg: 3
pCross: 10%
Incremento popolazione: Non
si notano particolari differenze
dal primo caso. I punti generati
pMut: 60% sembrano concentrarsi nelle aree
già individuate precedentemente.
Pop: 100 Tuttavia, pur aumentando la
popolazione, si è registrato un
incremento del numero di punti
lSeg: 3
utilizzati in ogni generazione,
con un risultato dell’ 80%.
pCross: 90%
Evoluzione consigliata:
I parametri fanno riferimento al
test 3. La bassa mutazione ha
pMut: 0.01% concentrato le coordinate
generate nella zona verticale
Pop: 75 centrale. L’area obiettivo è stata
ricoperta in gran parte, ma con
un numero inferiore di punti.
lSeg: 5
Anche in questo caso, la
percentuale di punti utilizzati in
ogni generazione è alta, pari al
77%.
pCross: 10%
Evoluzione libera: In questo
test si sono volute far evolvere
liberamente le generazioni, senza
pMut: 0.0% garantire particolari condizioni
di stabilità. Tuttavia, anche in
Pop: 75 questo caso il risultato è stato
soddisfacente in termini di
copertura dell’immagine e di
lSeg: 3
numero di punti utilizzati in ogni
generazione (77%).
61

62. L’esperimento suggerisce che, data un’immagine con coefficiente di distribuzione
elevato, non vi sono particolari vincoli sui parametri, posto di non utilizzare
una probabilità di mutazione alta associata ad un’alta probabilità di incrocio.
pCross: 10%
Evoluzione libera: I punti
generati si sono distribuiti con
molta concentrazione, e c’è
pMut: 0.0% stato un utilizzo del 50% dei
punti generati.
Pop: 75
lSeg: 3
pCross: 70%
Evoluzione consigliata:
Anche in questo caso si è
pMut: 0.01% ottenuta una copertura
pressoché globale dell’area
obiettivo. I punti utilizzati in
Pop: 75 ogni generazione sono stati
dell’ordine del 50%
lSeg: 5
pCross: 80%
Diminuzione popolazione:
Questo test è stato affrontato
con pochi pixel per ogni
pMut: 0.1% generazione. Ciò non ha
permesso un ricoprimento
Pop: 30 dell’area obiettivo
paragonabile agli altri test.
Tuttavia, la forma che si
lSeg: 5
otterrebbe inviluppando tutti
punti è simile a quella
rilevabile dagli altri test.
pCross: 80%
Incremento popolazione:
Un incremento della
popolazione porta (come
pMut: 0.1% potrebbe essere intuibile) ad
un maggior ricoprimento
Pop: 100 dell’immagine. Tuttavia, circa
l’84% dei punti generati ricade
al di fuori dell’area obiettivo.
lSeg: 3
62