Elaborato - Emanuelecipolla.net

Università degli Studi di Palermo
Facoltà di Ingegneria
Corso di Laurea Magistrale in Ingegneria Informatica
Tesina per l‟insegnamento di Intelligenza Artificiale
Titolare del corso: Prof. Salvatore Gaglio
Tutor: Ing. Alessandra De Paola
A cura di
Emanuele Cipolla (matricola 0578327)
Nicolò Monte (matricola 0584439)
A.A. 2011/2012

Sommario
1. Introduzione ............................................................................................................................................... 4
2. Gli algoritmi genetici ..................................................................................................................................... 4
2.1. Introduzione ............................................................................................................................................ 4
2.2. Panoramica ............................................................................................................................................. 5
2.2. Funzionamento ....................................................................................................................................... 6
2.2.1. Inizializzazione e fitness .................................................................................................................. 7
2.2.2. Selezione .......................................................................................................................................... 8
2.2.3. Ricombinazione ............................................................................................................................. 12
2.2.4. Mutazione ...................................................................................................................................... 16
2.2.5. Rimpiazzamento ............................................................................................................................ 17
2.2.5. Condizione di arresto e criteri di convergenza .............................................................................. 18
3. Algoritmi multi-obbiettivo .......................................................................................................................... 19
3.1. Le funzioni obbiettivo ......................................................................................................................... 19
3.2. La dominanza ....................................................................................................................................... 20
3.3. L‟insieme ottimo di Pareto ................................................................................................................... 21
3.4. NSGA II................................................................................................................................................ 22
3.4.1. Panoramica generale ...................................................................................................................... 22
3.4.2. Pseudo-codifica ............................................................................................................................. 25
4. Ambiente di sviluppo .................................................................................................................................. 27
5. Risultati........................................................................................................................................................ 30
5.1. Configurazione di riferimento .......................................................................................................... 30
5.2. Velocità d‟esecuzione ....................................................................................................................... 30
5.3. Prestazioni dell‟algoritmo ................................................................................................................. 30
5.4. Confronto con politiche alternative non basate sull‟intelligenza artificiale ..................................... 32
6. Sviluppi futuri .............................................................................................................................................. 34
6.1. Parallelizzazione del codice .............................................................................................................. 34
6.2. Altre tecniche di IA .......................................................................................................................... 34
6.3. Comfort ambientale spinto ............................................................................................................... 34
6.4. Interventi a funzioni di fitness .......................................................................................................... 34
6.5. Pianificatore e occupazione delle zone ............................................................................................. 35
7. Appendici .................................................................................................................................................... 36
7.1. DesignBuilder .................................................................................................................................. 36
7.2. EnergyPlus ....................................................................................................................................... 40
7.3. BCVTB ............................................................................................................................................ 43
7.4. MLE+ .............................................................................................................................................. 43
2

7.5. MATLAB ........................................................................................................................................ 44
7.6. Interfacciamento .............................................................................................................................. 44
7.7 Organizzazione del sistema realizzato ............................................................................................. 50
8. Bibliografia .............................................................................................................................................. 52
3

1. Introduzione
L‟oggetto di questo lavoro è l‟utilizzo di una tecnica di intelligenza artificiale per il coordinamento del
sistema di condizionamento di edifici. L‟obbiettivo principale è stato valutare le performance di un algoritmo
genetico multi obbiettivo, dove le funzioni di fitness discriminano gli individui in base a due vincoli
strettamente correlati tra di loro: temperatura interna all‟edificio e dispendio energetico. Verrà proposta nella
sezione 2 una introduzione formale agli algoritmi genetici, mentre nella terza verrà presentato in dettaglio
l‟algoritmo NSGA-II; sarà prerogativa della quarta sezione mostrare come l‟algoritmo sia stato sfruttato per
i nostri scopi, e descrivere sommariamente l‟ambiente costruito, atto allo studio del comportamento delle
variabili in gioco all‟interno di un sistema edificio-HVAC: una descrizione a livello implementativo di come
tali tecnologie eterogenee siano state coadiuvate tra loro è rimandata all‟ appendice. Infine, le sezioni 5 e 6
mostreranno i risultati sperimentali ottenuti e i possibili sviluppi futuri.
2. Gli algoritmi genetici
2.1. Introduzione
Un algoritmo genetico è una procedura euristica di ricerca e ottimizzazione il cui appellativo deriva dal forte
richiamo alla teoria evoluzionistica darwiniana, ragion per cui si suole descriverlo utilizzando un lessico di
tipo biologico: in questo lavoro ci si ispirerà alla visione biologica, in quanto più intuitiva ed efficace ad
inquadrarne gli aspetti salienti, fine ultimo di tale introduzione.
I primi esempi di quelli che adesso chiameremmo algoritmi genetici sono comparsi tra la fine degli anni
Cinquanta ed i primi anni Sessanta, programmati da biologi evoluzionisti che cercavano di modellare
esplicitamente alcuni aspetti dell'evoluzione naturale. Pionieristici, in questo senso, furono gli esperimenti di
Nils Aall Barricelli, un matematico italo-norvegese, presso l'Institute of Advanced Study di Princeton.
Nel 1962 vi furono, invece, le prime applicazioni a problemi di ottimizzazione di funzioni e di machine
learning da parte di ricercatori quali G.E.P. Box, G.J. Friedman, W.W. Bledsoe ed H.J. Bremermann, che
giunsero a formulare algoritmi ispirati dall'evoluzione in maniera indipendente.
Uno sviluppo di maggior successo si ebbe nel 1965, quando Ingo Rechenberg, che all'epoca lavorava alla
Technische Universität Berlin, introdusse una tecnica da lui definita strategia dell'evoluzione, sebbene fosse
più simile ad un algoritmo di ricerca in salita che agli algoritmi genetici. In questa tecnica non si parlava di
popolazione o di crossover; un genitore veniva mutato in un discendente, ed il migliore dei due veniva
mantenuto per diventare il genitore del turno successivo di mutazione. Nelle versioni successive venne
introdotta l'idea di popolazione. Le strategie dell'evoluzione vengono a tutt'oggi impiegate da ingegneri e
scienziati, specialmente in Germania.
Un ulteriore sviluppo di grande importanza si ebbe nel 1966, quando L.J. Fogel, A.J. Owens and M.J. Walsh
introdussero, negli Stati Uniti, una tecnica chiamata programmazione evolutiva. In questo metodo le possibili
soluzioni ai problemi venivano rappresentate come semplici macchine a stati finiti: in maniera simile alla
strategia di Rechenberg, il loro algoritmo funzionava mutando una delle macchine simulate e mantenendo la
migliore delle due. Anche la programmazione evolutiva è materia di ricerca ai giorni nostri.
Quel che manca alle due tecniche presentate è il riconoscimento dell'importanza del crossover.
4

Sin dal 1962, il lavoro di John Holland sui sistemi adattivi aveva gettato le fondamenta per gli sviluppi
successivi; tra le altre cose, Holland fu il primo a proporre esplicitamente il crossover ed altri operatori di
ricombinazione. Tuttavia è solo nel 1975, con la pubblicazione del libro "Adaptation in Natural and
Artificial Systems", basato su ricerche precedenti e su pubblicazioni scientifiche di Holland stesso e dei suoi
colleghi dell'Università del Michigan, che si ottiene una prima presentazione rigorosa e sistematica del
concetto di sistemi digitali adattivi che utilizzano la mutazione, la selezione ed il crossover, simulando i
processi dell'evoluzione biologica, come strategia per la risoluzione di problemi. In questo libro si tentò
anche di porre le prime basi teoretiche per gli algoritmi, introducendo la nozione di schemi. In quello stesso
anno un'importante dissertazione di Kenneth De Jong impose gli algoritmi genetici, mostrando che essi
avevano un buon comportamento con una grande varietà di funzioni di test, tra cui quelle definite su
landscape di ricerca rumorosi, discontinui e multimodali.
La pubblicazione di queste opere comportò un interesse diffuso nell'elaborazione evoluzionistica. Nella
prima metà degli anni Ottanta si applicarono gli algoritmi genetici alle situazioni più disparate, da problemi
astratti quali la colorazione dei grafi e il bin packing, a quelli concreti di ingegneria come il controllo di
flusso delle tubazioni (1983), la progettazione di reti (1987), la classificazione ed il riconoscimento di
pattern, l'ottimizzazione strutturale, fino ad arrivare, negli anni Novanta, alla programmazione automatica
(1992) ed alla modellazione di ecosistemi (1995).
All'inizio, queste applicazioni erano principalmente teoretiche. Tuttavia, con il proliferare della ricerca, gli
algoritmi genetici entrarono nel settore commerciale, sostenuti dalla crescita esponenziale della potenza di
elaborazione e dallo sviluppo di Internet. Oggi, l'elaborazione evoluzionistica è un settore in fermento, e gli
algoritmi genetici vengono utilizzati per risolvere problemi in campi quali la predizione del mercato e la
pianificazione del portafoglio azionario, l'ingegneria aerospaziale, la progettazione di microchip, la
biochimica, la biologia molecolare, la programmazione delle attività aeroportuali e delle catene di
montaggio.
2.2. Panoramica
Così come osservato da studi naturalistici, l‟idea che sta alla base di un algoritmo genetico è quella di far
evolvere una popolazione iniziale di individui, selezionandone quelli più idonei via via nella creazione delle
nuove generazioni.
L‟evoluzione ha inizio a partire da una generazione iniziale di individui il cui patrimonio genetico è scelto in
maniera causale; ogni individuo, sulla base del proprio patrimonio, sarà più o meno idoneo a sopravvivere ,
e quindi adatto a riprodursi: vengono allora selezionati gli individui che presentano maggiore idoneità, i quali
a coppie combineranno il loro patrimonio genetico per crearne dei figli; un numero modesto di altri
individui verrà selezionato per subire mutazioni genetiche, così da generare un nuovo individuo, quindi senza
alcuna discriminazione di valor di idoneità.
Una volta combinati gli individui scelti come genitori e mutati alcuni dei rimanenti altri, l‟algoritmo avrà a
disposizione un numero di individui doppio rispetto a quelli di partenza: dalla totalità degli individui a
disposizione, verranno selezionati nuovamente solo quelli più idonei e quindi più meritevoli, i quali
costituiranno la seconda generazione, e così via. L‟algoritmo prosegue iterando un numero prestabilito di
volte, finchè non si manifesta una condizione di arresto: intuitivamente si può scorgere come così facendo,
l‟idoneità media delle generazioni crescerà, grazie alla selezione degli individui in base al valore di idoneità.
Inoltre una capacità esplorativa dell‟algoritmo è garantita dalla presenza di mutazioni del patrimonio
genetico di alcuni individui della generazione corrente, in maniera trasparente al loro grado di idoneità,
5

cercando così di ottenere caratteristiche non ancora manifestatesi. In tal senso l‟algoritmo genetico si
configura come tecnica euristica di ricerca e ottimizzazione.
2.2. Funzionamento
L‟esecuzione dell‟algoritmo genetico procede per iterazioni finché un‟opportuna condizione d‟arresto non si
manifesta; ogni iterazione prevede l‟esecuzione di operazioni secondo un ordine ben preciso. Prima di
mostrare un‟analisi dettagliata delle varie fase, risulta doveroso spendere qualche parola riguardo la codifica
di un individuo. In generale, un algoritmo genetico permette di trovare un insieme di soluzioni ottime per il
problema di partenza; un individuo dell‟algoritmo ne costituisce quindi una soluzione, all‟interno dello
spazio delle possibili soluzioni. Per poter operare, l‟algoritmo ha bisogno di rappresentare in qualche
maniera i propri individui, allora assegna ad ogni individuo un‟opportuna stringa che lo rappresenta, detta
cromosoma: un cromosoma è formato da più componenti detti geni ciascuno dei quali rappresenta una
singola caratteristica della soluzione, detta, in altri termini, fattore di controllo. Il numero di componenti
presenti in ogni stringa è intrinseco al problema stesso: in termini più rigorosi, diciamo che il numero delle
componenti è pari alla dimensione dello spazio delle soluzioni.
Tra i tipi di codifiche esistono:
Codifica binaria, ottale, esadecimale e reale:
1010010|0001000|00010
10
52|10|12
Figura 1 - Esempi di codifica binaria, ottale, esadecimale e reale
I geni possono essere codificati mediante numeri rappresentati in base 2, 8, 16.
Codifica per valore: i geni possono essere qualsiasi tipo di simboli; ciò si fa per certi tipi di
problemi in cui le stringhe numeriche non bastano per rappresentare un mapping efficace tra
cromosoma e soluzione reale del problema. Per tale tipo di codifica dovranno quindi essere
specificati degli operatori specifici di combinazione e mutazione.
Codifica ad albero: ogni cromosoma è un albero di oggetti; è utile se gli oggetti sono comandi o
funzioni di un particolare programma, per questo spesso è usata in contesti di programmazione
genetica. In figura viene mostrano come si presenta un cromosoma con tale codifica.
6
122|8|A
(avanti)|(avanti)|(indietro)| (sotto) 23--4BF|++ABD--|0-++---
Figura 2 - Esempi di codifica per valore
82|8|10

2.2.1. Inizializzazione e fitness
L‟algoritmo crea individui, dove è detta dimensione della popolazione, con patrimonio genetico del tutto
casuale: questa scelta, assieme a quella per cui si introducono le mutazioni, garantisce la convergenza
dell‟algoritmo verso soluzioni ottime; ciò si può spiegare intuitivamente considerando che un patrimonio
genetico eterogeneo significa dare la possibilità all‟algoritmo, di spaziare su tutto lo spazio delle possibili
soluzioni. In qualche caso raro, come si può leggere in [1], viene specificata una particolare euristica per
costituire la prima generazione.
101|001 101|110 110|001 100|111 101|000 111|101 101|001 101|001
Figura 4 - Generazione casuale
Subito dopo aver creato la prima generazione, una particolare funzione obbiettivo, detta funzione di fitness,
ne testa l‟idoneità: il dominio di una tale funzione sarà l‟insieme di tutti i possibili geni che compongono le
stringhe, mentre il codominio sarà un valore numerico intero o reale.
Si può intuire immediatamente come la scelta di una funzione di fitness appropriata sia cruciale al
funzionamento dell‟algoritmo genetico stesso, sia da un punto di vista qualitativo, inteso come
raggiungimento o meno di soluzioni ottime, che in termini di velocità d‟esecuzione: si ricordi che l‟algoritmo
prevede il calcolo del fitness di ogni individuo di ogni generazione.
Per giustificare ulteriormente quanto appena asserito, consideriamo la figura in basso che mostra un grafico
in cui l‟asse delle ascisse rappresenta le soluzioni, mentre quello delle ordinate i valori assunti dalle prime.
Ipotizzando un problema di minimizzazione, la soluzione ottima al problema si trova nell‟area indicata in
corrispondenza del punto 2, visto che è lì che si raggiunge il minor valore di fitness. L‟area invece indicata
dal punto 1 è invece un minimo locale, per cui se ad una certa iterazione dell‟algoritmo, la popolazione è
costituita interamente da individui appartenenti all‟area 2, l‟algoritmo convergerà verso queste soluzioni che
non sono quelle ottime: ancora una volta, risalta l‟importanza del patrimonio genetico casuale alla prima
generazione .
7
Prendi(A,B)
Posa(A) Sposta(A)
Prendi(B,C) Posa(A)
Figura 3 - Codifica ad albero
Muovi(Dx)

2.2.2. Selezione
Figura 5 - Esempio di minimi locali
Si vogliono determinare le coppie di individui che verranno scelte per ricombinare il proprio patrimonio
genetico: l‟insieme di tali individui è detto mating pool (letteralmente piscina d‟accoppiamento). La
selezione partecipa attivamente all‟obbiettivo principale dell‟algoritmo secondo cui si tenta di generare
individui sempre più idonei al problema di partenza; inoltre se la selezione è progettata in maniera tale che si
favoriscono maggiormente agli individui pesantemente più idonei, si dirà che questa ha una grande influenza
di selezione (selection pressure in inglese) e ciò, velocizzerà di gran lunga la convergenza dell‟algoritmo:
d‟altro canto, una influenza di selezione troppo elevata potrebbe causare problemi di minimo o massimo
locale.
Si noti, infine, che una influenza di selezione bassa non preclude una convergenza comunque veloce, anche
se ciò accadrà con una probabilità certamente inferiore. Sotto viene riportato un breve excursus sulle più note
tecniche di selezione, come esempio si porterà un insieme di individui col proprio fitness noto, come in
figura in basso
8 1 6 2
3
2
13
19
101|001 101|110 110|001 100|111 101|000 100|101 101|001 101|001
Figura 6 - Attribuzione dei valori di fitness
A. Selezione a troncamento: Una tecnica immediata è quella per cui si ordinano gli individui secondo
il fitness crescente, se ne prendono i primi nel caso di problemi di minimizzazione (oppure gli
ultimi per quelli di massimizzazione); nella figura in basso vengono selezionati i migliori tre
individui più idonei.
1 2 2 3
6 8 13 19
101|110 100|111 100|101 101|000 110|001 101|001 101|001 101|001
Figura 7 - Individui individui ordinati secondo selezionati la fitness; quelli in rosso sono selezionati per il mating pool
8

Questa tecnica, sebbene immediata e semplice da implementare, il più delle volte comporta problemi
di minimo o massimo locale, e tronca la capacità esplorativa dell‟algoritmo in quanto è pesantemente
influenzata dal valore di fitness. Tuttavia, come si legge in [2] questa tecnica risulta efficace per
alcuni problemi.
B. Selezione a roulette: si associa ad ogni individuo una probabilità di essere selezionato, quest‟ultima
proporzionale al valore di fitness. La probabilità di un individuo i-esimo è funzione del valore di
proprio di fitness e della fitness totale di tutti gli individui della popolazione. In basso le formule per
il caso di problemi di minimo:
E per il problema di massimo:
Scegliere individui con questo meccanismo, equivale a disporli su una roulette, assegnando ad ogni
individuo un arco di circonferenza la cui lunghezza è proporzionale alla propria probabilità. La roulette viene
fatta ruotare un numero di volte pari al numero di individui della popolazione, ed ogni individuo selezionato
farà parte di quelli che ricombinati costituiranno la nuova generazione (a meno di eventuali mutazioni da
tenere in considerazione).
9

Figura 8 - Selezione a roulette
La selezione a roulette supera il problema della tecnica precedente perché da un‟opportunità, anche se
minima, di sopravvivenza anche agli individui poco idonei, caratteristica che non si scontra con la velleità
esplorativa dell‟algoritmo (oltre ad emulare in maniera più accurata l‟andamento della selezione naturale).
Purtroppo, nel caso in cui i valori di fitness siano molto diversi tra di loro, questo non sarà più vero, perché
verranno scelti, salvo sporadici casi, sempre gli stessi individui, cioè quelli più idonei.
Per gli individui riportati nell‟esempio la fitness totale avrà valore 1/64, allora e di conseguenza le
probabilità assegnate ad ogni individuo sono quelle riportate in verde.
1 1/64 2 1/128 2 1/128 3 1/192 6 1/384 8 1/512 13 1/1920 19 1/5760
101|110 100|111 100|101 101|000 110|001 101|001 101|001 101|001
Individuo 1 Individuo 2 Individuo 3 Individuo 4
Individuo 5
Figura 9 - Attribuzione di probabilità agli individui
10
Individuo 6
Individuo 7
Individuo 8

Figura 10 - Grafico relativo alla roulette per gli individui proposti
C. Selezione a rango: E‟ una variante della tecnica precedente, ne risolve il problema da cui è affetta:
la probabilità assegnata ad ogni individuo non è più calcolata rispetto alla fitness totale della
popolazione ma sarà proporzionale alla fitness relativa. In altri termini, si assegna un rango ad ogni
individuo valutandoli a coppie.
Nell‟esempio in basso l‟individuo chiamato chromosome1 ha una fitness poco superiore al secondo
individuo perciò dopo il ranking presenterà una probabilità simile. Quando si valuta il secondo
rispetto al terzo c‟è una differenza di fitness marcata, per cui la provabilità del terzo si discosterà in
maniera più significativa rispetto al secondo, e così via.
Figura 11 - Selezione a roulette vs. selezione a rango
Dopo questa operazione, anche gli individui con fitness bassa avranno buone opportunità di essere
selezionati; ciò si paga col rischio quasi certo di rallentare la convergenza dell‟algoritmo in quanto il
grado di influenza di selezione risulta diminuito.
D. Selezione a torneo: Una strategia ancora più efficiente è quella per cui si impartiscono dei tornei, in
ognuno dei quali si sceglie un numero di individui (la scelta avviene con probabilità uniforme), i
quali entreranno in competizione. Ad ogni torneo farà parte del mating pool solo l‟individuo con
fitness maggiore o i primi , a seconda dell‟implementazione. Si iterano dei tornei finché il mating
pool non è saturo. Questa è una delle tecniche preferite perché così come quella di rango supera i
problemi di possibili massimi locali (in atri termini di una convergenza troppo veloce), risulta
inoltre parallelizzabile.
11
Individuo 1
Individuo 2
Individuo 3
Individuo 4
Individuo 5
Individuo 6
Individuo 7
Individuo 8

E. Selezione sigma: E‟ una variante della selezione a rango in cui si utilizza la deviazione standard
come fattore di scala delle probabilità da assegnare a ciascun individuo: in questa maniera il grado di
influenza di fitness viene mantenuto piuttosto costante tra una generazione e l‟altra.
F. Elitarismo: Viene selezionato il miglior individuo o gli „n‟ migliori e inseriti nella popolazione
successiva senza passare per alcun ulteriore fase di selezione. Ciò è utile per prevenire che durante le
varie generazioni venga, anche se con scarsa probabilità, scartate soluzioni molto idonee: infatti tale
strategia incrementa significativamente le performance dell‟algoritmo.
G. Selezione stocastica universale: è una variante della tecnica a roulette, in cui ad ogni individuo si
assegna un segmento di lunghezza proporzionale alla propria probabilità, tali segmenti vengono
disposti su una retta formando così un segmento frutto dell‟unione di quelli relativi agli individui.
Un insieme di punti equidistanti, tanti quanti sono quelli necessari a formare il mating pool verranno
disposti su tale linea, selezionando così gli individui che in cui è caduto almeno uno dei punti.
In termini di roulette equivale a compiere una sola rotazione completa per tutto il processo di
selezione, in cui la rotazione stessa è scandita da step, dove è pari al numero di punti, e la
distanza tra una rotazione e l‟altra è paria a gradi.
Nell‟esempio in basso si suppongono 3 individui necessari a costituire il mating pool, di
conseguenza si avranno tre punti con distanza l‟uno rispetto all‟altro pari alla lunghezza del
segmento mostrato diviso 3: il posizionamento del primo punto si può scegliere in maniera random.
Come è evidente dalla figura, vengono scelti i tre individui con fitness maggiore e ciò perché
l‟esempio mostrato presenta forti differenze tra gli individui più idonei e quelli meno idonei. Infatti
tale tecnica eredita i problemi di quella da cui deriva, garantendo però che la frequenza attesa con cui
un individuo viene selezionato corrisponda a quella determinata dalla probabilità attribuitagli.
1 1/64 2 1/128 2 1/128 3 1/192 6 1/384 8 1/512 13 1/1920 19 1/5760
101|110 100|111 100|101 101|000 110|001 101|001 101|001 101|001
2.2.3. Ricombinazione
Figura 12 - (in alto) Individui con il fitness e la probabilità assegnata;
(in basso) Grafico relativo alla selezione stocastica: i cerchi in rosso
indicano i punti equidistanti di selezione
Una volta predisposto il mating pool grazie alla fase di selezione, gli individui scelti potranno ricombinare il
proprio patrimonio genetico, quest‟ultima operazione espletata da un particolare operatore chiamato
operatore di cross-over. Gli operatori di cross-over possono presentarsi in diverse tipologie, accomunate dal
fatto di garantire che l patrimonio genetico del figlio sia simile a quello dei propri genitori; come giustamente
osservato da [3] ciò permette di mantenere la convergenza anche dopo la fase di selezione in quanto, i figli
avranno molto probabilmente un patrimonio genetico tale da renderli idonei. A nostro avviso ciò non inficia
12

la capacità esplorativa dell‟algoritmo sia perché a monte rimane la presenza di sporadiche mutazione, sia
perché il patrimonio genetico di un figlio non è del tutto identico a quello del padre salvo casi fortuiti .
In qualsiasi tipologia di operatore di cross-over possiamo individuare una prima fase di selezione delle parti
dei patrimoni di trasmettere, e una seconda di ricombinazione di quest‟ultimi.
Il parametro che rappresenta quanto spesso l‟operatore di cross-over opererà, è chiamato probabilità di crossover;
quando questa avrà valore 1, allora tutti i figli saranno frutto di ricombinazione genetica, mentre
quando sarà nulla gli individui della nuova generazione saranno generati dalle copie esatte del patrimonio
genetico della generazione precedente: ciò non significa che la nuova generazione sarà la copia delle
precedente in quanto sarà compito della fase di Sostituzione comporre la generazione successiva; in questo
caso la fase di ricombinazione degenererà in una di selezione pura.
Come si vedrà in seguito, invece i vari operatori si diversificheranno tramite le ultime due fasi cioè in base a
come selezionano il patrimonio genetico da trasferire e la modalità con cui eseguono il trasferimento.
Nella descrizione dei vari operatori di cross-over ci si riferirà quasi sempre alla codifica binaria perché è
quello che emula maggiormente il corrispondente approccio biologico; da qui in poi le astine all‟interno
degli individui indicheranno i punti di taglio dell‟operatore.
2.2.3.1. Crossover ad un punto
Si individua in maniera casuale e univocamente per ogni genitore, un punto di taglio da cui si divideranno le
corrispondenti stringhe; supponendo che il numero di geni nelle stringhe sia e che il numero di componenti
delle stringa sia pari ad uno, effettuato il taglio si avranno quattro sottostringhe, di cui due contenenti i primi
elementi delle stringhe da cui deriva, e le restanti sottostringhe, gli ultimi geni. Infine per formare i
figli si combineranno le sottostringhe ad incrocio, in altri termini un figlio avrà i primi geni del primo
genitore e gli altri del secondo.
1001|11
1010|11
2.2.3.2. Cross-over a due punti
1001 11
1010 01
Tecnica simile alla precedente in cui i genitori vengono segmentati in tre porzioni tramite due punti di taglio
per ciascun individuo. Rispetto alla prima se un genitore possiede buone caratteristiche sia alla testa che alla
coda ma non nella parte centrale, queste potranno essere inglobate in un unico individuo generando molto
probabilmente un individuo migliore.
10|01|11
10|10|01
10 01 11
10 10 01
13
100101
101011
Figura 13 - Crossover ad un punto: all'estrema sinistra i genitori, al centro le porzioni di codice genetico
da trasmettere, all'estrema destra i figli
101011
100101
Figura 14 - Crossover a due punti: all'estrema sinistra i genitori, al centro le porzioni di codice genetico da
trasmettere, all'estrema destra i figli

2.2.3.3. Cross-over a n-punti
Si può estendere tutto ciò a più punti, ottenendo così l‟esplorazione nello spazio di ricerca. Tuttavia
esagerando nell‟aumento del numero di punti, si potrebbero ridurre le prestazioni dell‟algoritmo nel senso
che geni che messi l‟uno accanto all‟altro costituirebbero una caratteristica buona dell‟individuo, potrebbero
essere separati dall‟operatore. Tale fenomeno, da evitare il più possibile, è detto fenomeno di distorsione
dell‟operatore.
2.2.3.4. Cross-over uniforme
Risolve il problema appena sollevato, infatti ogni gene dei figli (i figli generati sono tipicamente due) è una
copia di un gene di uno dei due genitori; la scelta dei geni da copiare avviene in maniera casuale, per mezzo
di una maschera binaria con numero di bit pari alla lunghezza della stringa, cioè al numero di geni: se il bit
nella posizione i-esima assume valore pari ad uno, il gene i-esimo del primo figlio sarà quello della stessa
posizione del primo genitore mentre per il secondo figlio il gene, sempre nella stessa posizione ma dal
secondo genitore. La casualità sta nella scelta della maschera. Questa tecnica è quella preferita perché
l‟euristica ha dimostrato possedere una maggior capacità esplorativa. E‟ facile intuire come questa tecnica
sebbene raccomandata possegga una alta probabilità di distorsione in quanto blocchi di geni appartenenti ad
un genitore verranno quasi sicuramente smembrati.
10110011
00011010
Figura 15 - Crossover uniforme
2.2.3.4. Cross-over a tre genitori
maschera 10011010
11010110
14
00110011

Vengono scelti casualmente tre genitori dal mating-pool. Ogni bit del primo genitore è confrontato col
relativo nel secondo: se sono uguali allora tale sarà il bit corrispondente del figlio altrimenti si seleziona il bit
corrispondente dal terzo genitore.
11010001
01101001
01101100
2.2.3.4. Cross-over a mistura
È una variante di quello uniforme, in cui vengono ridisposti casualmente i bit ereditati dai genitori: ciò aiuta
ad evitare il fenomeno di distorsione poiché riordinando i geni, c‟è la possibilità che blocchi di essi,
costituenti caratteristiche buone, vengano ricomposti.
2.2.3.4. Cross-over a ordinamento
È un crossover a due punti in cui il primo figlio eredita la testa e la coda dal primo genitore e la parte centrale
anche ma con la sequenza di geni nell‟ordine in cui compaiono nel secondo. In maniera analoga viene
formato il secondo figlio. Nella prossima figura la codifica reale risulterà più adatta a cogliere le parti
ereditate.
2.2.3.4. Cross-over aritmetico
01101001
Figura 16 – Crossover a tre genitori: : all'estrema sinistra i genitori, a destra il figlio: quest’ultimo eredita
solo i bit di posizione 2 dal terzo genitore
42|13|65
23|14|56
Figura 17 - Crossover a ordinamento
423165
234156
Questa non è proprio una tecnica, bensì una famiglia che comprende molte delle tecniche già analizzate: si
caratterizza per il fatto che, i geni selezionati per essere ereditati verranno dati in pasto ad un‟operazione
aritmetica per generare i nuovi individui.
15

2.2.4. Mutazione
È la fase che avviene immediatamente dopo quella di ricombinazione. L‟operatore di mutazione si
diversifica da quello di cross-over per il fatto che mentre il secondo ricombina blocchi di patrimonio
genetico già esistente, il primo muta quanto ereditato andando a creare, salvo casi sporadici, nuovo
patrimonio genetico. Si nota subito come tale operatore accresca la capacità esplorativa dell‟algoritmo e ne
eviti la convergenza verso minimi locali. D‟altra parte eccessive occorrenze di tale operatore potrebbero
peggiorare le performance dell‟algoritmo fino a causare la perdita di convergenza, per cui la probabilità di
mutazione è mantenuta molto bassa: secondo [1] è buona norma mantenerla pari ad , dove rappresenta
la lunghezza dei cromosomi; secondo [3] è, invece, consigliato mantenerla entro l‟intervallo [0.001, 0.01]. Se
la probabilità fosse pari ad uno l‟intero cromosoma verrebbe modificato, mentre se fosse pari al 50% solo
metà dei geni del cromosoma verrebbero cambiati. In analogia a quanto visto per il cross-over anche gli
operatori di mutazione possono trovarsi in diverse varianti a seconda di quale geni vengono scelti per essere
mutati e come questi vengono mutati.
Si noti che la mutazione avviene solo sugli individui della prima generazione: in altri termini, né su quelli
appartenenti al mating-pool e nemmeno sui figli e in tal senso un individuo da mutare farà da genitore a se
stesso mutato.
2.2.4.1. Flipping
Vengono invertiti alcuni bit secondo una maschera generata casualmente per mezzo dell‟operatore logico
XOR.
genitore
10110101
maschera
10001001
2.2.4.2. Interscambio
00111100
Figura 18 - Mutazione per flipping: in rosso i bit risultato dello
XOR
Vengono scelte due posizioni casualmente e i bit relativi vengono scambiati.
10110101
Figura 19 - Mutazione per interscambio
figlio
111110001
16

2.2.4.3. Inversione
Viene scelta casualmente una posizione nel cromosoma: tutti i bit nelle posizioni successive verranno
invertiti.
10110101 10110010
Figura 20 - Mutazione per inversione
2.2.5. Rimpiazzamento
In questa fase vengono scelti quanti e quali individui comporranno la prossima generazione; i possibili
candidati sono da ricercare sia negli individui delle generazione corrente, che in quelli frutto della
ricombinazione e della mutazione. Il numero di individui appartenenti alle ultime due categorie influenza in
maniera significativa la velocità di convergenza in quanto, un numero basso di questi individui significa un
basso ricambio generazionale, per cui saranno necessarie più iterazioni per giungere a individui ottimi.
D‟altro canto, un eccessivo ricambio di individui renderebbe l‟algoritmo instabile nel senso che parecchi
individui buoni trovati nelle generazioni precedenti verrebbero sostituiti con dei nuovi non necessariamente
idonei. I metodi che verranno mostrai a breve, prendono in considerazione solo i genitori e i relativi figli ma
ciò non esclude la possibilità di implementare tecniche che prendano in considerazione anche gli individui
della generazione corrente che non hanno generato figli, selezionati mediante una delle tecniche di selezione
presentate.
2.2.5.1 Rimpiazzamento dei genitori
E‟ la tecnica più semplice: la coppia di figli sostituisce quella dei relativi genitori; è una tecnica che
sicuramente non può essere accoppiata ad una tecnica di selezione a monte, che esclude gli individui più
deboli; se così fosse un‟iterazione selezionerebbe gli individui più idonei i quali verrebbero rimpiazzati dai
figli (molto probabilmente meno idonei) per costituire la generazione successiva.
2.2.5.2 Rimpiazzamento dei genitori deboli
Si valutano le due coppie genitori-individui e andranno alla generazione successiva solo i due più forti.
Questa tecnica incrementa la fitness totale della popolazione se accoppiata ad una fase di ricombinazione in
cui la selezione dal mating-pool considera sia individui forti che individui deboli: se anche la strategia di
selezione dal mating-pool privilegiasse gli individui più forti, si strozzerebbe la capacità esplorativa
dell‟algoritmo e si propagherebbero sempre le stesse “buone” caratteristiche.
17

2.2.5.3 Rimpiazzamento casuale
È prevista anche una tecnica affidata totalmente al caso, in cui i figli prendono il posto di due qualsiasi
individui della popolazione; mantiene bene la capacità esplorativa dell‟algoritmo in quanto anche individui
poco idonei possono continuare a sopravvivere.
Le fasi di ricombinazione e Sostituzione si possono anche progettare come un‟unica fase. Sotto quest‟ottica è
possibile distinguere due tecniche per costituire la generazione successiva:
Aggiornamenti generazionali: dalla popolazione costituita da individui vengono prodotti figli
che quindi rimpiazzeranno per intero la popolazione corrente. In alternativa si può pensare una
variante meno brutale, in cui solo individui faranno da genitori, i quali produrranno figli con
. A questo punto solo i migliori individui tra i padri e i figli formeranno la prossima
generazione.
Aggiornamenti stabili: nuovi individui vengono inseriti nella popolazione non appena vengono
creati; ciò necessita il Sostituzione di individui della generazione precedente. Gli individui da
rimpiazzare possono essere scelti come quelli meno idonei nella popolazione precedente (ciò
incrementa il grado di selezione), oppure quelli che da più tempo vengono riproposti via via nelle
varie generazioni.
2.2.5. Condizione di arresto e criteri di convergenza
Le condizioni di arresto fanno capo spesso ad esigenze di tipo pratico. Tra queste citiamo:
Numero massimo di generazioni: l‟algoritmo termina non appena un prefissato numero di
generazioni è stato generato.
Tempo scaduto: il tempo ad disposizione per eseguire l‟algoritmo è stato esaurito.
Stallo generazionale: l‟algoritmo termina perché la funzione obbiettivo non riesce più a ottenere
miglioramenti tra generazioni consecutive.
Stallo generazionale nel tempo: al posto di considerare generazioni consecutive si analizza il
problema in un‟opportuna finestra temporale.
Invarianza di fitness: se per un certo numero di generazioni non c‟è una variazione della fitness
migliore registrata all‟interno della popolazione.
Esistono anche dei criteri per cui si ritiene che l‟algoritmo abbia subito convergenza, tali criteri se soddisfatti
allora causeranno l‟arresto dell‟algoritmo.
Convergenza del miglior individuo: è il criterio secondo cui l‟algoritmo verrà stoppato non
appena la popolazione corrente presenterà la fitness minore (ricordiamo che nei problemi di
minimo minore è la fitness maggiore è l‟idoneità) al di sotto di un valore di convergenza, a
monte stabilito. L‟algoritmo allora convergerà velocemente garantendo almeno una buona
soluzione.
Convergenza del peggior individuo: la convergenza sarà raggiunta non appena l‟individuo
meno idoneo, cioè con la fitness più alta, non avrà la propria fitness al di sotto del valore di
convergenza. Ciò garantisce che l‟intera popolazione abbia almeno una certa idoneità. Ciò non
significa che l‟ndividuo più idoneo sia abbastanza migliore dei quello meno idoneo.
18

Somma dei valori di fitness: La convergenza è soddisfatta se la somma delle fitness di tutti gli
individui della popolazione è minore o uguale di un certo valore; ciò assicura che ogni individuo
della popolazione stia in un certo intorno di valore di fitness. Questo criterio di convergenza si
presta bene, se accoppiato ad una tecnica di Sostituzione che elimina gli individui peggiori: se
fosse accoppiato con una tecnica di Sostituzione opposta, si avrebbe un grandissimo
rallentamento dell‟algoritmo (per giungere alla convergenza) o addirittura non convergerebbe
mai.
Convergenza in media: Come la precedente eccetto che solo la metà degli individui della
popolazione soddisfino il criterio.
3. Algoritmi multi-obbiettivo
Un algoritmo genetico multi-obbiettivo persegue più obbiettivi nel senso che, un individuo viene considerato
più o meno idoneo in relazione a più criteri; ciò non si riduce al solo banale incremento del numero di
funzioni obbiettivo da ottimizzare, ma come si vedrà, questa variante degli algoritmi genetici si
particolarizza aspetti e problematiche peculiari.
Quando si formalizza un problema in termini di algoritmi genetici multi-obbiettivo, bisogna aver cura del
fatto che spesso, quelli che inizialmente sembrerebbero obbiettivi diversi, in realtà potrebbero ridursi ad un
singola funzione obbiettivo: le condizioni per cui la variante multi-obbiettivo dell‟algoritmo genetico, risulta
allora indispensabile, sono che i problemi da ottimizzare devono essere più di uno e devono risultare in
conflitto tra loro.
A questo punto, a differenza degli algoritmi genetici finora visti, non ci si aspetta più un‟unica soluzione
ottima, ma si avrà un insieme di soluzioni ottime. Allora una prima problematica è quella di trovare dei
criteri per specificare una preferenza di una soluzione piuttosto che un‟altra.
3.1. Le funzioni obbiettivo
Come esempio anticipiamo sin da ora, che riguardo il nostro caso di studio, desideravamo ottimizzare sia il
confort ambientale, individuato dalla temperatura ambientale, che il consumo energetico, quest‟ultimo
fortemente peggiorato dalla prima (poiché maggiore è la temperatura in un edificio, maggiore sarà il
dispendio energetico); entrambi gli obbiettivi risultano allora in conflitto.
Un esempio altrettanto valido di una tale situazione è presente in [3], nel quale si tratta il problema del
percorso minimo a costo minimo.
Dati due punti A e B nel piano cartesiano, si vuole trovare il percorso a distanza minima che abbia anche un
costo minimo: entrambi sono in conflitto in quanto spesso il percorso a distanza minima non è detto che sia a
costo minimo e viceversa. Il problema è stato affrontato utilizzando le due seguenti funzioni obbiettivo da
minimizzare dove indica l‟angolo tra i due punti:
La prima funzione è quella relativa alla distanza, mentre la seconda al costo dello spostamento da A a B. Per
ispezione diretta, si può notare come il valore di minimo della prima sia raggiunto in corrispondenza
dell‟angolo nullo, e quello della seconda in corrispondenza dell‟angolo pari a 2.
19

Figura 21 - Grafico dello spazio di ricerca: andamento delle funzioni di fitness
Sopra è riportato il grafico dello spazio di ricerca (della stessa tipologia di quello in figura 5) in cui un asse
rappresenta i valori della variabile indipendente delle funzioni obbiettivo, l‟altro invece, i valori assunti dalle
funzioni obbiettivo: le soluzioni ottime dell‟esempio, saranno in un intervallo [0,2]; ad un grafico come
questo, si preferisce quasi sempre quello dello spazio degli obbiettivi, come nella prossima figura:
Figura 22 - Grafico nello spazio delle soluzioni
Questo grafico invece, mostra l‟insieme delle soluzioni dal punto di vista delle funzioni obbiettivo, infatti
per ogni asse vengono riportati i valori di una funzione obbiettivo. In particolare nella figura sopra, i punti
e sono le soluzioni ottime rispettivamente per la distanza e per il costo, mentre il punto è una buona
soluzione dal punto da entrambi i punti di vista. Un confronto più interessante risulta tra i punti e : poiché
è una soluzione per cui entrambi gli obbiettivi sono minori, possiamo affermare che questa è una soluzione
più idonea rispetto a . Dal grafico si può nuotare come i punti , e giacciano su un segmento più scuro;
tale segmento indica l‟insieme delle soluzioni per cui non è possibile stabilire delle soluzioni migliori
rispetto le altre, ovvero quelle soluzioni idonee alla stessa maniera.
Per stabilire se una soluzione sia più idonea rispetto ad un‟altra, sarà necessario un meccanismo di ranking,
che non sarà banalmente la ricaduta del proprio valore di fitness su ogni individuo, ma dovrà tener conto
della presenza di più obbiettivi.
3.2. La dominanza
20

Quello della dominanza è un concetto cruciale per la realizzazione del ranking degli algoritmi multiobbiettivo,
in quanto come abbiamo già potuto intuire, il valore di fitness non basta più per discriminare gli
individui avendo più obbiettivi: mentre l‟attribuzione di un valore di fitness, coincide col ranking per gli
algoritmi a singolo obbiettivo, invece per quelli multi-obbiettivo il ranking è qualcosa che va oltre
l‟attribuzione del fitness, quest‟ultima operazione ancora necessaria ma non sufficiente al funzionamento
dell‟algoritmo.
Supponiamo di dover risolvere un problema di ottimizzazione con „m‟ obbiettivi, e di aver già trovato un
insieme di soluzioni, per cui quella i-esima viene denotata da .
Secondo il concetto di dominanza allora una soluzione domina (nel caso di problemi di massimo) se
valgono entrambe le relazioni:
1. ;
2. per almeno un valore di
Si noti come la dominanza debba essere valutata per ogni obbiettivo, in quanto dire che la soluzione
domina quella per un solo obbiettivo non da alcuna indicazione su quale soluzione preferire, poiché
nulla si sta asserendo riguardo gli altri obbiettivi. Ciò accade perché la dominanza in se, non supera il
problema di “fondere” assieme gli obbiettivi tra di loro, per cui la dominanza si utilizza ogni qualvolta non si
esprime una preferenza tra i singoli obbiettivi.
Nel caso in cui valga la prima relazione ma non la seconda, si dirà che le soluzioni sono da preferire
indistintamente; nell‟esempio in basso le soluzioni , , , ed dominano le restanti, ma non si dominano
a vicenda. I gruppi di soluzioni che non si dominano a vicenda vengono detti fronti: per cui al primo fronte
faranno parte tutte quelle soluzioni che dominano tutte le altre, al secondo quelle che dominano tutte le altre
tranne quelle nel primo, e così via.
3.3. L’insieme ottimo di Pareto
Figura 23 - Grafico nello spazio delle soluzioni: in grigio le soluzioni dominanti
È chiaro che le soluzioni ottime per un algoritmo multi-obbiettivo saranno quelle sul primo fronte, cioè
quello contenente tutte le soluzioni non-dominate. In base a teli osservazioni, si può definire insieme ottimo
21

di Pareto, l‟insieme di tutte le soluzioni ottime del problema multi-obbiettivo, su tutto lo spazio ricerca
ammissibile. Quasi sempre tale insieme conterrà un infinito numero di elementi, per cui lo scopo ultimo
dell‟algoritmo sarà quello di costruire un insieme di soluzioni ottime che inoltre rappresenti l‟insieme ottimo
di Pareto. Poiché l‟insieme di Pareto è infinito, per formare l‟insieme che meglio lo rappresenti, purtroppo
non basteranno mai le soluzioni del primo fronte, quindi bisognerà attingere anche da quelle dei fronti
successivi.
Come le soluzioni vengono scelte dai vari fronti, risulta peculiarità di ogni algoritmo multi-obbiettivo a se
stante, ragion per cui si analizzerà nella prossima sezione, la tecnica sfruttata da NSGA-II.
Tornando al meccanismo di ranking in generale, si possono sfruttare alternative alla tecnica di dominanza,
cioè possono essere implementati dei meccanismi di preferenza degli obbiettivi, per esempio assegnando
opportuni pesi ad ogni obbiettivo: questa è una strada che il più delle volte è impraticabile perché non
sempre si può in qualche maniera quantificare l‟importanza da dare ai vari obbiettivi, per cui si preferisce
“accontentarsi” del concetto di dominanza e di una rappresentazione dell‟insieme di Pareto. Possiamo
concludere dicendo che spesso il compito di un algoritmo genetico finisce con la determinazione
dell‟insieme di soluzioni e che la scelta di quest‟ultime viene effettuata o selezionando dall‟insieme di Pareto
(o a caso o secondo una strategia premeditata) oppure per ispezione diretta da parte dell‟utente, quindi senza
mettere a frutto alcun metodo non soggettivo.
3.4. NSGA II
NSGA è un algoritmo genetico basato sulla non-dominanza per l'ottimizzazione multi-obiettivo, evoluzione
del precedente NSGA, da cui si differenzia per l'algoritmo di ordinamento utilizzato e per la selezione a
elitarismo nella fase di sostituzione delle generazioni.
Per cominciare si fornirà una panoramica teorica generale dell‟algoritmo, ricalcandone le fasi costituenti,
così come abbiamo fatto per gli algoritmi genetici a singolo obbiettivo; a conclusione di tale sezione se ne
presenterà una descrizione sotto forma di pseudo-codice.
3.4.1. Panoramica generale
3.4.1.1. Inizializzazione
Come negli algoritmi genetici a singolo obiettivo, la popolazione viene inizializzata in maniera
pseudocasuale, tenendo conto delle caratteristiche del problema.
3.4.1.2. Ranking e Ordinamento
In seguito, agli individui del primo fronte si assegna un valore di fitness pari ad 1, a quelli del secondo un
valore pari a 2 e così via.
22

Essendo NSGA-II un algoritmo multi-obiettivo, non basta assegnare la fitness: per cui verrà utilizzato il
concetto di insieme ottimo di Pareto ad ogni iterazione, per discriminare gli individui dominati da quelli non
dominati.
NSGA-II, purtroppo implementa la tecnica più semplice per costruire i fronti, la quale ha una complessità
pari a ): si considera la soluzione i-esima e la si confronta con tutte le altre - se risulta dominata da
almeno una di esse, si passa alla i+1-esima, altrimenti la si aggiunge all‟insieme delle soluzioni non
dominate.
NSGA-II garantisce inoltre una buona distribuzione delle soluzioni per rappresentare al meglio l‟insieme
ottimo di Pareto. Bisogna, perciò, costituire un insieme di soluzioni che sia il più eterogeneo possibile. La
politica perseguita è quella secondo cui gli individui dovranno essere il più possibile prelevati da zone a
bassa densità di soluzioni: allora in corrispondenza di zone affollate da soluzioni verrà data una bassa
priorità di prelevamento. In questo modo si evita la formazione di gruppi di individui vicini tra loro,
privilegiando invece una loro distribuzione il più possibile uniforme.
Tutto ciò è realizzato tramite l‟operatore matematico crowding distance: l‟idea di base dietro tale tecnica è
quella di trovare la distanza euclidea tra ciascun individuo in un fronte basandosi sui suoi m valori della
funzione obiettivo nell‟iperspazio m-dimensionale. A livello analitico, la crowding distance si presenta come
una particolare misura di distanza in cui gli individui da confrontare vengono posti sui lati di un cuboide.
Ogni lato è, quindi, legato ad un obiettivo, e per ricavare la lunghezza si considera la differenza tra i valori
obiettivo della soluzione precedente e della successiva, normalizzata rispetto alla distanza tra le soluzioni
estreme del fronte. Per queste ultime non è possibile costruire il cuboide, per cui la crowding distance
assume valore infinito (∞).
Figura 24 - Crowing distance
Essa viene attribuita in maniera univoca per ciascun fronte: la comparazione della crowding distance tra due
individui appartenenti a fronti diversi non ha quindi senso.
3.4.1.3. Selezione
Il rango e la crowding distance appena assegnati vengono utilizzati in un processo di selezione a torneo, il
cui risultato sarà la scelta dei genitori degli individui della generazione successiva: questa operazione di
selezione viene effettuata mediante un operatore, definito appositamente, detto crowded comparison
operator, indicato con . Il confronto viene effettuato in base a:
1. Il rango di non dominanza : gli individui del fronte avranno rango .
2. La crowding distance .
23

Accadrà infatti che se, alternativamente:
se p e q appartengono allo stesso fronte , , ovvero la crowding distance di p è
maggiore di quella di q
Informalmente, si può dire che fra due individui si sceglierà quello con il rango inferiore, oppure, in caso di
parità di quest‟ultimo, quello con la maggiore crowding distance.
3.4.1.4. Ricombinazione dei geni
La popolazione selezionata genererà discendenti mediante gli operatori di crossover e di mutazione, che
verrà trattata nel dettaglio a breve.
L‟operatore di crossover utilizzato è il Simulated Binary Crossover : si tratta di un operatore ad un punto, con
una tecnica casuale di prelevamento dei singoli geni dei genitori, secondo una precisa distribuzione di
probabilità.
Dati i genitori e i geni dei due figli, e , saranno scelti come segue:
La quantità è detta fattore di trasmissione, ed è estratta da un insieme casuale avente densità di probabilità
Questa distribuzione si può ottenere da un numero casuale u campionato nell‟intervallo (0,1). è l‟indice
che controlla quanto i figli saranno simili ai genitori: maggiore è questo indice, più i figli saranno simili.
Il grafico sotto mostra l‟andamento di tale distribuzione al variare dell‟indice:
24

Figura 25 - Distribuzione di probabilità del fattore di trasmissione
La mutazione invece avviene per mezzo dell‟operatorie di mutazione polinomiale: sia la componente del
figlio da mutare, varrà che:
e sono rispettivamente i limiti inferiore e superiore dello spazio decisionale per quella particolare
componente; è una piccola variazione calcolata a partire da una distribuzione polinomiale così fatta:
dove è un numero casuale campionato uniformemente nell‟intervallo (0, 1) ed è l‟indice della
distribuzione per la mutazione.
3.4.1.5. Rimpiazzamento degli individui
La popolazione di discendenti è combinata con quella della generazione corrente; viene effettuata una
selezione, che sfrutta l‟elitarismo, per determinare gli individui della generazione successiva; l‟elitarismo si
baserà sulla non-dominanza.
Gli individui si scelgono inizialmente da quelli del primo fronte: in seguito se ne scelgono ancora dagli altri
fronti basandosi sulla crowding distance, in ordine decrescente, finchè la dimensione della popolazione non
raggiunge N.
3.4.2. Pseudo-codifica
Di seguito i dettagli dei singoli passaggi dell‟algoritmo.
1. Inizializzazione della popolazione: La popolazione viene inizializzata in base al range del
problema ed ai suoi vincoli (se ve ne sono).
2. Ordinamento basato sulla non-dominanza: La popolazione inizializzata viene ordinata in base alla
25

non-dominanza tramite il seguente algoritmo:
per ogni individuo p della popolazione principale P:
i. Porre . Questo insieme conterrà tutti gli individui dominati da p.
ii. Porre . Questo sarà il numero di individui che dominano p.
iii. Per ciascun individuo q appartenente a P
o Se p domina q, aggiungi q all‟insieme : ;
o In caso contrario, incrementa il contatore di dominanza per p: .
iv. Se , ovvero nessun individuo domina p, allora p appartiene al primo fronte; si
setta il rango dell‟individuo p ad uno, ovvero . Aggiorna l‟insieme del
primo fronte aggiungendo p al fronte 1: ;
per ogni fronte i-esimo non vuoto (ovvero )
i. Porre .. Questo insieme conterrà gli individui del fronte -esimo.
ii. Per ciascun individuo q appartenente a
o Per ciascun individuo q appartenente a P
a. Decrementa il contatore della dominanza per l‟individuo q:
b. Se allora nessuno degli individui nei fronti susseguenti
potrebbe dominare q. Allora si setta . Aggiorna
l‟insieme Q con l‟individuo q: ;
iii. Incrementa il contatore del fronte di uno.
iv. Adesso l‟insieme Q è il prossimo fronte e quindi .
La crowding distance si calcola come segue:
Per ciascun fronte , composto da n individui:
o Inizializza a zero la distanza per tutti gli individui: , dove j indica l‟individuo j-
esimo del fronte .
o Per ciascuna funzione obiettivo m:
Ordina gli individui del fronte in base all‟obiettivo m: .
Assegna distanza infinita ai valori di confine per ciascun individuo di :
, .
Per i restanti k individui si assegna la distanza con la seguente relazione:
dove è il valore della m-esima funzione obiettivo del k-esimo individuo di I.
26

4. Ambiente di sviluppo
Adesso si vuole dare una descrizione, in termini generali, del sistema di simulazione, al fine di rendere
chiaro quali entità fanno da costituenti al primo e quali variabili vengono veicolate per collegarle tra di loro.
Al concludersi si tale sezione il lettore avrà una visione d‟insieme sulle tecnologie adottate e su come siano
state collegate: per chi fosse interessato ai dettagli implementativi rimandiamo all‟appendice e quindi a come
fosse stato possibile collegarle, rimandiamo all‟appendice.
Figura 26 - Panoramica del sistema proposto
Come mostra la figura in alto, gli attori principali sono l‟ambiente di calcolo Matlab e il simulatore di edifici
EnergyPlus, un software che prevede come input un file che rappresenta tutte le info relative all‟edificio (file
con estensione .idf), e un file climatico relativo all‟ipotetica zone in cui il primo è sito. L‟interfacciamento
con Matlab avviene tramite una libreria, MLE+, la quale sfruttando la tecnologia BCVTB permette di
estrapolare le variabili di EnergyPlus di interesse dell‟utente, e metterle al servizio di Matlab. Nel nostro
caso di studio l‟edificio è stato reso architetturalmente il più elementare possibile, al fine di poter effettuare
uno studio controllistico più immediato.
27

Figura 27 - Modello dell'edificio utilizzato durante le fasi di test: a destra una visione esterna, a sinistra una ripartizione delle
zone virtuali
L‟edificio come mostrano le figure è un volume monoblocco in cui si distinguono quattro zone virtuali: il
termine virtuale sta a significare che, contrariamente a quanto potrebbe suggerire l‟immagine a destra, non
esistono delle pareti di alcun tipo ma sono delle delimitazioni alle zone stesse: a ciascuna zona corrisponde
un sistema HVAC e quindi sarà possibile registrarne una propria temperatura.
Le variabili di EnergyPlus di nostro interesse sono:
1. la temperatura esterna all‟edificio;
2. le temperature delle zone dell‟edificio;
3. le temperature di set-point di riscaldamento e di raffrescamento delle quattro zone;
4. i consumi energetici delle zone.
Lo scambio di variabili è permesso dalla tecnologia BCVTB (per ulteriori dettagli si guardi l‟appendice) ed
espletato da Matlab tramite la libreria MLE+. Così facendo durante la simulazione, Matlab sarà in grado di
intercettare dall‟ingente quantità di output fornita di default da EnergyPlus, solo tali variabili, quest‟ultime
quindi alla mercè dell‟utente. Matlab di canto suo, fornisce al simulatore una soluzione costituita da una
delle possibili combinazioni delle temperature di set-point. A questo punto risulta ovvio l‟inserimento
dell‟algoritmo genetico NSGAII all‟interno dell‟architettura informativa: questo sfrutterà il simulatore per
calcolare la fitness di ogni individuo ovvero di ogni soluzione generata; l‟obbiettivo dell‟algoritmo sarà
convergere ad una soluzione che mantenga un confort ambientale vicino a quello ottimale (individuato in una
temperatura di riferimento) e minimizzi il consumo energetico.
Discorso a parte merita invece il tempo di simulazione, che viene sì specificato nel file .idf mandato in input
al simulatore, ma scandito a discrezione dell‟utente: i nostri test, come verrà mostrato, si baseranno su timestep
pari al quarto di ora.
Abbiamo scritto inoltre del codice per il plottaggio di grafici sia dell‟andamento dei valori delle variabili di
scambio durante il tempo di simulazione, sia di grandezze da questi derivati, tra cui: la temperatura media
dell‟edifico, il consumo totale di riscaldamento, il consumo totale di raffrescamento e la temperatura media
dell‟intero edificio.
Infine, per implementare l‟algoritmo NSGA-II è stata utilizzata l‟omonima libreria resa disponibile da
Aravind Seshadri mediante il sito dei contributi utente Mathworks. Nella nostra implementazione un
individuo è rappresentato da una stringa composta da 24*4*2, geni in cui ogni gene è un intero
nell‟intervallo [0-40]; ogni gene indica un temperatura di setpoint, per cui ogni condizionatore possiede un
28

set-point di riscaldamento e uno di raffrescamento; i sistemi HVAC presenti nel nostro edificio sono quattro;
una giornata di simulazione è scandita in 24 ore: allora un individuo rappresenta una possibile combinazione
dei set-point di tutti i sistemi HVAC presenti nell‟edificio, per ogni ora della giornata.
La valutazione degli individui avviene per mezzo di una simulazione di durata settimanale, e le funzioni di
fitness sono le seguenti:
Una funzione che cerca di minimizzare la differenza tra la temperatura media dell‟edificio causata da
un individuo e quella desiderata pari a 18 gradi centigradi
Una funzione che cerca di minimizzare il valore del consumo energetico causato dall‟individuo
corrente: il consumo energetico è stato calcolato facendo una media delle medie temporali dei valori
della variabili di EnergyPlus che indicano il consumo istantaneo (secondo il time-step) di ogni
HVAC.
Una modifica introdotta alla libreria è quella per cui si evita di far generare all‟algoritmo individui illegali:
un individuo illegale, per il nostro caso di studio, è quello per cui la temperatura di raffrescamento sia
inferiore a quella di riscaldamento.
Abbiamo inoltre creato script di supporto per testare singole soluzioni e per la produzione di alcuni grafici.
29

5. Risultati
In questo capitolo vengono presentati gli esperimenti effettuati sul sistema informativo predisposto: in tal
senso si è tenuto conto prima di tutto, delle prestazioni velocistiche dell‟algoritmo, individuate nel tempo di
esecuzione prima del raggiungimento di una certo numero di generazioni fissato; una sotto sezione è invece
dedicata ad un confronto tra le migliori soluzioni trovate dalla nostra implementazione, e tra una politica di
gestione del sistema HVAC, già implementata nella libreria MLE+.
5.1. Configurazione di riferimento
La configurazione di riferimento è stata scelta tra i sistemi a nostra disposizione durante la fase di sviluppo e
messa a punto . In particolare, abbiamo utilizzato per la fase di test un sistema desktop con la seguente
configurazione:
CPU AMD Athlon(tm) II X4 630 funzionante alla frequenza di 2812.936 Mhz per core;
3966 MB di memoria RAM;
Sistema operativo Debian GNU/Linux 6.0 “Squeeze”;
MATLAB 7.10.0.499 (r2010a) edizione AMD64.
La scelta di non effettuare i test su un sistema Windows - benchè nulla vi sia di legato alla piattaforma nel
nostro lavoro in sé - è stata motivata dal fatto che, perché l‟esecuzione del simulatore vada a buon fine, è
stato necessario aggiungere un ritardo artificiale di alcuni secondi all‟esecuzione della funzione di fitness
(ovvero EnergyPlus) esclusivamente su questa piattaforma: è stato infatti rilevato che era necessario
attendere del tempo affinchè il simulatore potesse chiudere tutti i file temporanei da esso stesso aperti.
Tale ritardo non ha un grande peso per un singolo individuo, ma diventa significativo se si considera un
numero importante di generazioni ed un cospicuo numero di individui per generazione.
5.2. Velocità d’esecuzione
Sono state richieste ad NSGA-II 200 iterazioni con 50 individui ciascuna. I valori di setpoint ammessi erano
tutti e soli gli interi del range [16, 22].
Per il completamento della simulazione sono state richieste all‟incirca 9,4 ore (l‟incertezza è dovuta alla
mancata precisione di calcolo della coppia di funzioni tic/toc di MATLAB). Una singola generazione viene
valutata in circa 3 minuti, mentre per l‟esecuzione di EnergyPlus su una configurazione di setpoint sono
richiesti all‟incirca 5 secondi, a cui devono essere aggiunti in media almeno 4 per la memorizzazione dei
dati.
Un discorso a parte merita la convergenza: stando ai test effettuati, l‟algoritmo risulta convergente,
producendo tutte soluzioni che si trovano sul primo fronte, dopo 10 generazioni: questo significa che sarebbe
possibile interromperne l‟esecuzione dopo 30 minuti.
5.3. Prestazioni dell’algoritmo
Tra i 50 individui dell‟ultima generazione (la duecentesima) sono stati scelti, del tutto arbitrariamente i tre
individui segnati sul grafico che segue, realizzando sovrapponendo tre screenshot di MATLAB.
30

Figura 28 - Fronte della 200-esima generazione: evidenziati gli individui scelti arbitrariamente
Si è poi proceduto ad estrarre la temperatura media raggiunta da ciascuno dei tre individui per metterla a
confronto con la temperatura desiderata. Come si potrà notare, la differenza tra ciascuna delle soluzioni
scelte e la richiesta dell‟utente è soltanto di circa ½ di grado.
31

Figura 29 - Grafico riportante temperature medie e consumi totali dei tre individui scelti per ispezione diretta del grafico in figura
28
5.4. Confronto con politiche alternative non basate sull’intelligenza artificiale
5.4.1. Introduzione
Nonostante gli algoritmi genetici vengano codificati al solo scopo di presentare sic et simpliciter delle
soluzioni per un dato problema, è sembrato opportuno, agli autori in questo contesto, presentare
un’alternativa basata su premesse differenti, in modo tale da determinare, per quanto possibile, se la scelta
di utilizzare un algoritmo genetico sia opportuna.
Abbiamo adattato una strategia d’esempio fornita con il toolkit MLE+ in modo tale che risultasse
manipolabile in maniera analoga a quanto possibile mediante la funzione di fitness fornita, ma si facesse
uso della temperatura esterna come discrimine per il cambiamento di setpoint durante una fascia d’orario
lavorativa (dalle 6 alle 18) e di un insieme di setpoint predeterminato per le rimanenti ore del giorno.
Dalle 6 alle 18 ciascun setpoint da applicare ad ogni timestep vengono sono i due valori
[20, max(TCRooLow, min(TCRooHi, TCRooLow + (outputs(:,k) -
TOutLow)*ratio))]
32

Le costanti cui si fa riferimento per il secondo valore sono:
TCRooLow = 22; % Limite inferiore della temperatura di zona
TCRooHi = 26; % Limite superiore della temperatura di zona
TOutLow = 22; % Limite inferiore della temperatura esterna
TOutHi = 24; % Limite superiore della temperatura esterna
ratio = (TCRooHi - TCRooLow)/(TOutHi - TOutLow);
Dalle 18 alle 6 del giorno successivo si utilizzano i setpoint [16 30] per tutti i condizionatori.
Per quel che riguarda la fascia d’orario lavorativa, si può notare che il range di valori ammessi si
sovrappone solo parzialmente a quello indicato per la generazione pseudocasuale di cromosomi nel
contesto dell’algoritmo genetico.
È stata prevista anche una variante ulteriormente semplificata di questa strategia, con setpoint statici scelti
arbitrariamente per le ore lavorative e pari alla minima temperatura impostabile in simulazione per quelle
notturne.
5.4.2. Confronto
Il confronto tra le soluzioni prodotte mediante l’algoritmo genetico e quelle fornite è stato effettuato
rispetto agli stessi tre individui scelti nel paragrafo precedente:
Figura 30 - Grafico riportante temperature medie e consumi totali dei tre individui scelti per ispezione diretta del grafico in figura
28, confrontati con i valori delle politiche alternative
33

La politica semplificata è chiaramente quella a dare consumo più basso al prezzo di una temperatura media
inaccettabilmente inferiore; la politica d‟esempio di MLE+, invece, ottiene risultati paragonabili agli
individui generati, al prezzo del consumo più alto fra tutte le configurazioni confrontate.
6. Sviluppi futuri
Questa sezione mostra alcuni interventi sia progettuali che implementativi, a nostro avviso immediati
sbocchi futuri del nostro lavoro; ne sarà fornita una descrizione di carattere “filosofico”, senza quindi alcuna
pretesa di rigore, in quanto gli interventi che si proporranno non sono stati esplorati in questo lavoro: gli
interessati dovranno quindi intenderli come raccomandazioni per il proseguo al nostro progetto.
6.1. Parallelizzazione del codice
In merito ai risultati velocistici mostrati precedentemente, sarà interessante fornire un‟implementazione
alternativa dell‟algoritmo, in modo di sfruttare la presenza di più dei processori attualmente in commercio.
Tale intervento sicuramente dovrà essere progettata ad hoc per evitare problemi di sincronizzazione, in
primis quelli delle generazioni di individui della stessa generazione; tuttavia, sotto un aspetto meramente
tecnico, ancora una volta la suite di sviluppo Matlab viene in ausilio al programmatore, offrendo delle
librerie di supporto alla parallelizzazione del codice.
6.2. Altre tecniche di IA
Un altro aspetto interessante da investigare, sarebbe quello di paragonare le prestazioni dell‟algoritmo
NSGA-II con un‟altra tecnica di intelligenza artificiale, piuttosto che una politica specifica votata al
condizionamento ambiente, così comevmostrato. Un possibile confronto potrebbe essere quello tra
l‟algoritmo studiato in questo lavoro ed una rete neurale, quest‟ultima supportata per mezzo di svariate
librerie da parte di Matlab.
6.3. Comfort ambientale spinto
Sicuramente il lavoro può essere reso più preciso estrapolando ulteriori variabili da EnergyPlus tra cui
l‟umidità delle zone e la velocità delle ventole dei quattro condizionatori: in situazioni più realistiche, tali
grandezze infatti, concorrono al confort ambientale all‟interno dell‟ edificio. Si potrebbe anche pensare di
complicare la struttura dell‟edificio.
6.4. Interventi a funzioni di fitness
Si potrebbe anche effettuare uno studio riguardo le funzioni di fitness, cercando di predisporne di diverse,
pur porgendo attenzione agli effetti negativi, che un intervento del genere potrebbe avere sulle prestazioni
velocistiche. In alternativa o in accoppiata a ciò, si potrebbe implementare una tecnica di gestione dei
risultati delle funzioni di fitness per mezzo della logica fuzzy, per esempio esprimendo un‟appartenenza o
meno ad un insieme, al variare del modulo delle differenza tra temperatura desiderata e temperatura fornita
34

dalla soluzione che si sta valutando. Proponiamo solo questo intervento all‟algoritmo, perché è l‟unico
permesso affinché si possa continuare a parlare di NSGA-II.
6.5. Pianificatore e occupazione delle zone
Esistono inoltre delle variabili in EnergyPlus che tengono conto della presenza di persone nelle zone
dell‟edificio e al variare del tempo di simulazione. Detto questo, si potrebbe allora implementare un
pianificatore che tenga conto dell‟andamento di tale grandezza all‟interno dell‟edifcio, per settarne
opportunatamente il sistemi di condizionamento. A tal si potrebbe attingere alle svariate pubblicazioni
presenti in letteratura, riguardanti la rappresentazione di tale grandezza: si potrebbe allora implementare un
modello matematico che modelli la presenza delle persone nelle stanze, prendendo spunto da quanto già
disponibile presso la comunità scientifica, e accoppiarlo col pianificatore. Ovviamente non è da escludere un
lavoro che in prima battuta cerchi di creare un modello matematico ex novo, e poi il pianificatore che lo
sfrutti.
Durante la progettazione dell‟edificio, persino mediante programmi per la realizzazione di edifici (si guardi
l‟appendice nella sezione DesignBuilder) è possibile impostare la presenza delle persone: in basso lo
screenshot della scheda che permette di fare ciò offerta dal programma DesignBuilder.
Figura 31 - Finestra di dialogo per la specifica della presenza di individui
35

7. Appendici
7.1. DesignBuilder
Per la progettazione dell‟edificio di esempio si è fatto uso della versione trial del software DesignBuilder 3.0,
sviluppato e commercializzato da DesignBuilder Software Ltd. Si tratta di una suite integrata che combina
caratteristiche di modellazione rapida degli edifici con la possibilità di effettuare simulazioni di efficienza
energetica: infatti, DesignBuilder integra una versione appositamente modificata del software di simulazione
EnergyPlus, che verrà analizzata fra breve.
L‟integrazione fra EnergyPlus e DesignBuilder non è stata utile per il perseguimento del progetto, in quanto è
stato necessario un controllo molto fine sul ciclo di esecuzione del simulatore, come abbiamo già detto in
precedenza. L‟utilità di DesignBuilder si è manifestata, però, allo stadio di progettazione dell‟edificio di
riferimento da simulare: infatti, le sue funzionalità di produttività rapida hanno consentito a utenti inesperti
di modellare un edificio abbastanza articolato in tempi brevi.
DesignBuilder, infatti, include un modellatore solido basato su OpenGL, che permette di assemblare modelli
di edifici posizionando, ridimensionando e tagliando “blocchi” in uno spazio tridimensionale. Realistici
elementi 3-D forniscono un feedback visuale dello spessore di ciascun elemento e dei volumi e delle aree
delle stanze; sebbene l‟edificio d‟esempio fornito presenti delle stanze rettangolari, non ci sono limitazioni di
forma o superficie di alcun genere.
I tempi di progettazione sono stati ulteriormente ridotti grazie alla presenza di modelli di dati che consentono
di caricare all‟interno del design i più comuni modelli di edifici, attività svolte, sistemi HVAC e di
illuminazione mediante una semplice selezione in un menu a tendina – volendo, è possibile fornire modelli
generati dall‟utente. Questa caratteristica, combinata con l‟ereditarietà dei dati, permette di effettuare
cambiamenti globali a livello di edificio, blocco o zona. Si può anche controllare il livello di dettaglio di
ciascun edificio, cosa che permette l‟utilizzo del tool in ognuno dei diversi stadi del processo di valutazione
del design.
DesignBuilder è stato utilizzato in questo progetto per delineare la struttura dell'edificio: a modellazione
ultimata, è stato esportato un file IDF per l'uso del modello con il software di simulazione EnergyPlus,
oggetto del prossimo paragrafo.
Riteniamo opportuno mostrare le schede che maggiormente hanno avuto impatto sull‟edificio, per quanto
riguarda il suo utilizzo all‟interno del simulatore.
36

Figura 32 - Sistema di acqua calda sanitaria
Una delle di queste è quella mostrata nella figura in alto: come si può vedere è possibile settare la presenza o
meno del sistema di acqua calda sanitaria, specificando il coefficiente di efficienza. È possibile settare
direttamente da DesignBuilder i set-point di riscaldamento e raffrescamento (compito che si rimanda
all‟algoritmo genetico) e addirittura la presenza di un sistema di illuminazione e il consumo da associare a
questo. Esiste anche un‟opzione curiosa, la prima nella scheda, quella relativa alla presenza o meno di un
periodo di vacanza: sarà compito di un‟altra piccola scheda, descriverne il collocamento annuale e
l‟intervallo temporale in giorni.
37

Figura 33 - Sistema di illuminazione
Quest‟altra scheda invece entra in dettaglio riguardo l‟illuminazione ambientale: come si può vedere anche
in questo senso DesignBuilder mostra grande versatilità. Non è stato nostro compito sondare questo aspetto,
che però rimane interessante visto che tecniche di intelligenza artificiale potrebbero da un lato essere
sfruttate per coordinare il sistema di illuminazione, quest‟ultimo componente di un certo peso del consumo
energetico totale della maggior parte di edifici.
38

Figura 34 - Configurazione sistema HVAC
In alto invece la schermata che ha richiesto maggiore perizia: tramite questa abbiamo specificato la tipologia
di HVAC da utilizzare: si è fatto riferimento ai sistemi di condizionamento tipici delle abitazioni civili, i
quali si riconoscono dalla valvola radiale posta all‟esterno dell‟edificio.
Abbiamo settato il coefficiente di efficienza termica e quello per il consumo, entrambi inoltre riportarti
all‟interno degli script per il plottaggio dei consumi energetici.
39

Figura 35 - Parametri di simulazione EnergyPlus guidata da DesignBuilder
Tramite quest‟ultima scheda è possibile rendersi conto, di come DesignBuilder non sia solamente un
programma di disegno CAD e specificazione dei materiali (di cui abbiamo tralasciato di mostrar le relative
chede), ma che sia stato progettato per interfacciarsi in maniera immediata con EnergyPlus. Già a livello di
progetto dell‟edificio, l‟utente può discriminare l‟output di EnergyPlus (declinato in una ingente quantità di
file) che sarà restituito per quel particolare edificio.
7.2. EnergyPlus
EnergyPlus è un software che si occupa di effettuare analisi di tipo energetico e simulazioni di carico termico
sulla base di una descrizione, fornita dall‟utente, di un edificio. Tale descrizione, contenente informazioni di
carattere fisico e sistemico, viene fornita sotto forma di un file nel formato IDF.
Sulla base del modello fornito EnergyPlus calcola i carichi di riscaldamento e di raffrescamento necessari a
mantenere dei setpoint di controllo termico, le condizioni sotto le quali quest‟ultimi sono raggiunti nel
sottosistema HVAC, i carichi dei ventilconvettori ed il consumo energetico delle componenti. L‟integrazione
simultanea di queste informazioni (e di molte altre) assicurano che la simulazione di EnergyPlus non dia
risultati difformi da quelli che fornirebbe l‟edificio reale.
Alcune delle caratteristiche di EnergyPlus sono le seguenti:
1. Soluzione integrata, simultanea in cui la risposta dell'edificio è strettamente integrata con quella dei
sistemi al suo interno;
40

2. Timestep definibili dall'utente in termini di frazioni di ora per l'interazione tra le zone termiche e
l'ambiente; timestep variabili per l'interazione tra le zone termiche ed i sistemi HVAC, modificati in
automatico per assicurare la stabilità della soluzione;
3. File di input, output e climatici in formato ASCII che includono le condizioni ambientali in termini
di ora o di frazioni di ora, e report standard e definibili dall'utente;
4. Tecnica di costruzione dei carichi dell'edificio basata sul bilanciamento del calore che permette il
calcolo simultaneo degli effetti radianti e convettivi, sia dell'interno che della superficie esterno durante
ciascun timestep;
5. Conduzione transiente del calore attraverso elementi dell'edificio quali muri, tetti, pavimenti
mediante funzioni di trasferimento conduttivo;
6. Modellazione del trasferimento di calore del terreno mediante collegamenti a modelli tridimensionali
alle differenze finite e tecniche analitiche semplificate;
7. Trasferimento combinato di calore e massa che tiene conto dell'assorbimento/rilascio dell'umidità o
come integrazione livello per livello nelle funzioni di trasferimento di calore per conduzione o come un vero
e proprio modello di profondità della penetrazione dell'umidità;
8. Modelli di comfort termico basati sull'attività, termometro interno, umidità;
9. Modello del cielo anisotropico, per un calcolo migliorato della radiazione solare diffusa su superfici
inclinate;
10. Calcoli avanzati sulla disposizione delle finestre, tra cui veneziane controllabili, vetri elettrocromici,
bilanciamenti di calore livello per livello che permettono un assegnazione appropriata dell'energia solare
assorbita dai vetri delle finestre: queste ultime possono essere modellate mediante gli appositi template
forniti;
11. Controlli sull'illuminazione naturale, tra cui calcoli sull'illuminamento interno, simulazione e
controllo della riflettanza delle superfici, controlli sulle lampade e sull'effetto della riduzione
dell'illuminazione artificiale su riscaldamento e raffrescamento;
12. Calcoli sull'inquinamento atmosferico che predicono la produzione di CO2, SO2, NO2, CO,
particolato ed idrocarburi per la produzione di energia sul posto e remota. EnergyPlus fornisce, nella sola
edizione Windows, un'interfaccia grafica per la specificazione degli input in caso di utilizzo interattivo.
41

Figura 36 - EP-Launch
Sulle altre piattaforme oppure nel caso si desiderino specificare parametri la cui gestione non è consentita
tramite questa interfaccia grafica è tassativamente necessario adattare un template di script d'esecuzione
RunEPlus.bat (RunEPlus.sh su sistemi di tipo UNIX) alle proprie esigenze.
Per l'utilizzo automatico è necessario sfruttare software di terze parti che effettuano il parsing dei file di testo
di output generati, o che permettono, tramite l'interfaccia esterna Ptolemy II, il controllo diretto delle
variabili.
42

7.3. BCVTB
Il Building Controls Virtual Test Bed (BCVTB) è un ambiente software che permette agli utenti di:
• accoppiare software eterogenei a scopo di co-simulazione;
• collegare hardware reale a del software di simulazione.
Per esempio, BCVTB permette di simulare un edificio con EnergyPlus ed i sistemi di controllo ed HVAC
con MATLAB, garantendo lo scambio di dati tra i software durante la simulazione.
I flussi di comunicazione tra i software supportati vengono gestiti mediante un file XML che contiene le
descrizioni degli endpoint di ciascuno di essi e le modalità per accedervi. EnergyPlus permette, mediante
appositi campi nel file IDF utilizzato per la simulazione, di specificare quali delle grandezze simulate devono
essere rese disponibili mediante l'interfaccia esterna BCVTB.
7.4. MLE+
MLE+ è una toolbox MATLAB, sviluppata da Truong X. Nghiem, per la co-simulazione con EnergyPlus: si
presenta sotto forma di oggetti nativi MATLAB che nascondono al ricercatore gran parte delle complesse
operazioni necessarie alla lettura e all'invio di dati a EnergyPlus mediante BCVTB; si presuppone che
entrambi questi software siano stati installati correttamente e siano eseguibili dalla toolbox stessa.
mlepClose.m
mlepCreate.m -
mlepDecodePacket.m
mlepEncodeData.m
mlepEncodeRealData.m
mlepEncodeStatus.m
mlepExchangeData.m
mlepProcess.m
43

mlepReadData.m
mlepWriteData.m
mlepWriteEPModel.m -
utils/mlepLoadEPResults.m
44
Output:Variable
L'utilizzo di MLE+ ha permesso di progettare il “controllore” (nel nostro caso la funzione di fitness per
l'algoritmo genetico) interamente in MATLAB pur mantenendo un completo controllo su ciascuna
simulazione di EnergyPlus eseguita. I dati raccolti sono poi stati sottoposti a processing in MATLAB stesso
per modificare opportunamente il comportamento dell'algoritmo stesso.
7.5. MATLAB
MATLAB è un ambiente interattivo e un linguaggio di calcolo tecnico di alto livello per lo sviluppo di
algoritmi, la rappresentazione grafica dei dati, l'analisi dei dati e il calcolo numerico.
MATLAB può essere utilizzato in una vasta gamma di applicazioni, incluse l'elaborazione di immagini e
segnali, le comunicazioni, la progettazione di sistemi di controllo, test e misurazioni, l'analisi e la creazione
di modelli finanziari e la biologia computazionale. I toolbox (raccolte di specifiche funzioni MATLAB,
disponibili separatamente) ampliano l'ambiente MATLAB per risolvere particolari classi di problemi in
queste aree applicative.
MATLAB offre agli utenti una serie di funzioni per documentare e condividere il proprio lavoro. Il codice
MATLAB può essere integrato con altri linguaggi e applicazioni, dando così la possibilità di distribuire le
applicazioni e gli algoritmi MATLAB.
7.6. Interfacciamento
La necessità di mettere in relazione i software di cui sopra ha reso necessaria un'attenta fase di
pianificazione. Lo schema che segue descrive il sistema realizzato nella sua interezza.

Figura 37 - Diagramma del sistema realizzato
Per rendere possibile la comunicazione tra EnergyPlus e MATLAB è stato necessario svolgere le seguenti
operazioni:
1. Modificare il file IDF abilitando l'interfaccia esterna e mutando gli scheduler esportati da
DesignBuilder in oggetti ExternalInterface:Schedule accessibili mediante BCVTB;
! MODIFICA NOSTRA: attiva ptolemy II
ExternalInterface,
PtolemyServer;
[...]
ExternalInterface:Schedule,
Blocco1:Zona2 Heating SP Sch, !- Name
Temperature, !- Schedule Type Limits Name
24; !- Initial Value
45

[...]
ExternalInterface:Schedule,
[...]
Blocco1:Zona2 Cooling SP Sch, !- Name
Temperature, !- Schedule Type Limits Name
24; !- Initial Value
ExternalInterface:Schedule,
[...]
Blocco1:Zona1 Heating SP Sch, !- Name
Temperature, !- Schedule Type Limits Name
24; !- Initial Value
ExternalInterface:Schedule,
[...]
Blocco1:Zona1 Cooling SP Sch, !- Name
Temperature, !- Schedule Type Limits Name
24; !- Initial Value
ExternalInterface:Schedule,
[...]
Blocco1:Zona1/1 Heating SP Sch, !- Name
Temperature, !- Schedule Type Limits Name
24; !- Initial Value
ExternalInterface:Schedule,
[...]
Blocco1:Zona1/1 Cooling SP Sch, !- Name
Temperature, !- Schedule Type Limits Name
24; !- Initial Value
ExternalInterface:Schedule,
Blocco1:Zona2/1 Heating SP Sch, !- Name
Temperature, !- Schedule Type Limits Name
46

[...]
24; !- Initial Value
ExternalInterface:Schedule,
Blocco1:Zona2/1 Cooling SP Sch, !- Name
Temperature, !- Schedule Type Limits Name
24; !- Initial Value
2. Creare il file XML variables.cfg contenente le variabili di schedule modificate al punto 1 (ed ogni
altra variabile d'interesse generata in output da EnergyPlus) ed i corrispondenti mapping in termini di
variabili di BCVTB. Questi ultimi vengono poi direttamente mappati mediante la toolbox MLE+ in variabili
native MATLAB.
47

48

49

7.7 Organizzazione del sistema realizzato
La necessità di mettere in relazione tramite MATLAB software eterogenei di diversa provenienza ha
suggerito di inserire in una directory apposita tutti gli script creati ex novo, e quelli della libreria modificati
sulla base delle esigenze degli autori:
confronta_tre.m
confronta_tre_esempio_semplif
icata.m
creato Crea un grafico in cui è possibile fruire
visivamente della differenza tra la temperatura
media fornita da tre individui scelti ad arbitrio di
una data generazione e quella desiderata
creato Simile al precedente, aggiunge ai grafici anche le
politiche d i confronto descritte.
estrai_individuo.m creato Estrae dalla struttura dati contenente tutti gli
individui della generazione quello dato
evaluate_objective.m modificato Valuta le funzioni obiettivo per ogni individuo
dato
fitness.m creato Invoca EnergyPlus mediante MLE+ e restituisce
le informazioni necessarie ad evaluate_objective
genetic_operator.m modificato File originariamente presente in NSGA-II,
modificato per tenere conto delle relazioni tra
setpoint di riscaldamento e raffrescamento quando
è necessario generare un nuovo individuo
grafico_fronti.m creato Mostra su un grafico i fronti costituiti dagli
individui di una data generazione
initialize_variables.m modificato File originariamente presente in NSGA-II,
modificato per tenere conto delle relazioni tra
setpoint di riscaldamento e raffrescamento quando
si prepara la prima generazione
migliore_della_generazione_pe
r_consumo.m
creato File di esempio per la scelta arbitraria di un
individuo: sceglie quello sul primo fronte con
consumo minore
mlepInit.m modificato File presente originariamente in MLE+, è stato
modificato inserendovi il path per EnergyPlus ed
MLE+
nsga_2.m modificato File presente originariamente in NSGA-II, è stato
modificato in modo tale che salvi ciascuna
generazione effettuata su un file .MAT differente,
per poter valutare l'evoluzione
objective_description_functio
n.m
modificato File presente originariamente in NSGA-II, è stato
modificato fornendo il numero di funzioni
obiettivo e variabili di decisione necessarie
50

parametri_energyplus.m creato In questo script devono essere specificati i file
IDF e climatico da usare, i coefficienti di
performance HVAC, il numero di timestep e la
durata della simulazione
pulisci_file_energyplus.m creato Cancella i file prodotti durante un'esecuzione
precedente di EnergyPlus
quando_converge.m creato Sulla base dei file contenenti le generazioni,
determina in quale di esse l‟algoritmo comincia a
convergere.
test_individuo.m creato Sottopone un dato individuo a simulazione
mediante EnergyPlus e genera alcuni grafici sulla
base delle informazioni rilevate.
test_miglior_individuo.m creato File di esempio per la scelta arbitraria di un
individuo: esegue
migliore_della_generazione_per_consumo.m su
un dato insieme di individui ed, estrattone uno, lo
sottopone a test_individuo.m
valori_riferimento.m creato Contiene i valori di riferimento da utilizzare nel
contesto delle simulazioni (in questa sede viene
presa in considerazione soltanto la temperatura
desiderata).
Per garantire che vengano aggiunti al PATH di MATLAB sia la directory sorgenti/ che quelle contenenti
NSGA-II ed MLE+, è stato predisposto uno script apposito prepara_ambiente.m che dev'essere eseguito
necessariamente prima di ogni sessione MATLAB in cui si preveda di utilizzare l'algoritmo genetico.
51

8. Bibliografia
1. Sivanandam, S.N. e Deepa, S.N. Introduction to genetic algorithms. s.l. : Springer, 2007. ISBN-10:
354073189X.
2. Dyer, D. Evolutionary Computation in Java - A practical guide to the Watchmaker framework.
Watchmaker Framework. [Online] 2010. [Riportato: 1 Giugno 2012.]
http://watchmaker.uncommons.org/manual/index.html.
3. Simi, A., Implementazione di algoritmi genetici distribuiti multiobiettivo in MATLAB(R). Dipartimento di
Ingegneria dell'Informazione, Università di Pisa. 2007. Tesi di laurea specialistica in Ingegneria Informatica.
4. Srnivas N., e Kalyanmoy, D., Using Nondominated Sorting. 1994, Evolutionary Computation.
5. Kalyanmoy, D. e Agarwal, R.B.,., Simulated Binary Crossover for Continuous Search Space. 1994,
Complex Systems.
6. Beyer, H. e Kalyanmoy, D., On Self-Adaptive Features in Real-Parameter Evolutionary Algorithm. 2001.
IEEE Transactions on Evolutionary Computation.
7. Raghuwanshi, M. e Kakde, O. Survey on multiobjective evolutionary and real coded genetic algorithms.
2004. Proceedings of the 8th Asia Pacific Symposium on Intelligent and Evolutionary Systems. p. 150-161.
8. Kalyanmoy, D. e Amarendra, K.. Real-coded Genetic Algorithms with Simulated Binary Crossover:
Studies on Multimodal and Multiobjective Problems. 1995, St udies on Mu ltimodal and M ultiobj ective
Problems.
9. Kalyanmoy, D., et al. A Fast Elitist Multi-objective Genetic Algorithm: NSGA-II. 2002. IEEE
Transactions on Evolutionary Computation.
10. Serra, Roberto. Introduzione alla complessità – Modello di Hopfield – Reti neurali – Percettroni e
Sistemi a classificatori. Facoltà di Scienze della comunicazione e dell'economia, Università degli studi di
Modena e Reggio Emilia. 2004. Appunti dal corso di “Introduzione alla complessità” svolto da Roberto
Serra e redatti da Alessandro Filisetti e Chiara Damiani.
11. Nilsson, N. e Gaglio, S.. Intelligenza artificiale. s.l. : Apogeo, 2002. ISBN 9788873037460.
52