Inteligenta Artificiala: Metode de Optimizare. Algoritmi Evolutivi

Inteligență artificială
4. Metode de optimizare (I)
Florin Leon
Universitatea Tehnică „Gheorghe Asachi” din Iași

Facultatea de Automatică și Calculatoare
http://florinleon.byethost24.com/curs_ia.html
v2022.1
Metode de optimizare (I)
1. Întâmplare și scop
2. Algoritmi evolutivi
3. Codarea problemei
4. Operatori: selecția, încrucișarea, mutația
5. Exemple de aplicare
6. Concluzii
Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 2

6. Concluzii

Întâmplarea poate genera
lucruri interesante

Întâmplarea poate genera
lucruri interesante

Probleme de optimizare
 Găsirea argumentului (vectorul x) pentru care o
funcție f(x) să fie maximă/minimă
 De exemplu: f(x) = (x-1)2 ⇒ min f(x) = 0 pentru x = 1
 Pentru dimensiuni mici ale lui x, se poate face o

căutare exhaustivă într-un anumit interval, cu o
anumită precizie
 Pentru dimensiuni mari, acest lucru devine imposibil

 Transportul mărfurilor
 Atribuirea de comenzi de transport de mărfuri către vehiculele
disponibile, care să minimizeze costurile și timpul de transport
 Optimizarea transportului feroviar

 Pe o singură linie sau incluzând perioade zilnice de întreținere
 Optimizarea depozitării
 Containere în porturi sau pachete la firmele de comerț electronic
 Învățare automată
 Antrenarea rețelelor neuronale și optimizarea structurii lor

 Design automat de produse: găsirea caracteristicilor
produselor care optimizează anumite cerințe, de
exemplu:
 Aripi de avion (portanță vs. frecare)
 Antene aerospațiale (eficiență vs. miniaturizare)
 Circuite electronice (consum de curent)

Exemplu: funcție obiectiv
fără expresie analitică
https://www.youtube.com/watch?v=FKbarpAlBkw
6. Concluzii

Prezentare generală
 Un algoritm evolutiv este o metodă
de căutare prin analogie cu selecția
naturală biologică
 Un algoritm evolutiv are o populație
de soluții potențiale care evoluează
prin aplicarea iterativă a unor
operatori stohastici
 Evoluția soluțiilor mai bune se
realizează pe baza presiunii
evolutive, adică favorizarea
soluțiilor mai adaptate

Metafora evolutivă
Algoritm evolutiv Natură
Problema de optimizare Mediu
Soluții potențiale fezabile Indivizii care trăiesc în mediu
Calitatea soluției (funcția de Gradul de adaptare al

adaptare sau fitness) individului la mediu

Evoluția
 Speciile nu au ca „scop” evoluția
 Evoluția este doar un efect, o consecință
 Organismele neadaptate mor fără să se reproducă
 Cele care supraviețuiesc suficient ca să se reproducă
reușesc acest lucru tocmai fiindcă sunt mai adaptate
la mediu
 Selecția naturală și selecția sexuală

Evoluția
 Structuri anatomice comune între specii
 Structuri comune în ADN (inclusiv prezența unor erori)
 Asemănări în stadiile embrionare incipiente (de exemplu,
fante branhiale și coadă la toate vertebratele)
 Explozia cambriană
 Apariția reproducerii sexuate
 Macroevoluția (evoluția speciilor)
 Specii intermediare fosile
 Teoria evoluției nu își propune să explice apariția vieții

Operatori genetici
 Selecția (selection)
 Alege un individ cu o probabilitate definită de calitatea
relativă a acestuia
 Încrucișarea (crossover)
 Combină aleatoriu fragmente din doi indivizi pentru a forma
unii noi
 Mutația (mutation)
 Modifică aleatoriu un individ nou creat

Componentele și fazele unui
algoritm evolutiv
Inițializare populație  Problema de rezolvat:
Selecție părinți pentru reproducere funcția de adaptare
Încrucișare
 Principii de codare:
cromozomi, gene
Mutație
 Procedura de inițializare
Introducere copil în populație  Selecția părinților
 Încrucișare
nu
Stop?  Mutație
da  Condiția de terminare
Rezultat
Algoritmii evolutivi și
algoritmii specializați
Algoritm evolutiv Algoritm specializat
Viteză În general lent În general rapid
Efort Foarte mic De obicei mare
Aplicabilitate Generală Redusă la o clasă de probleme
Performanță Bună, crește în timp De obicei foarte bună

Tipuri de algoritmi evolutivi
 Algoritmi genetici
 Codarea soluției cu șiruri de numere, de obicei binare
 Strategii evolutive
 Codarea soluției cu vectori de numere reale
 Programare genetică
 Soluțiile sunt programe (de exemplu, Lisp) sau arbori de
operații

6. Concluzii

Codarea
 Depinde de problemă
 Cele mai utilizate tipuri de codare:
 Binară
 Reală

Exemplu de codare binară
 Problema rucsacului: umplerea unui rucsac cu o
mulțime de obiecte astfel încât valoarea totală a
articolelor incluse să fie maximizată
 Constrângere: capacitatea rucsacului este limitată

Problema rucsacului
 wi – greutatea articolului i
 pi – profitul când articolul i este inclus
 C – capacitatea rucsacului
 xi – 1 dacă articolul i este inclus, 0 altfel
 Obiectiv: maximizarea
 Constrângere:
Codarea binară
 De exemplu, 6 articole incluse sau nu
 O genă = un bit (xi)
 Aléle = valori posibile ale genei (0 și 1)
 Un cromozom = un șir de gene (biți)
 Cromozomul este o soluție potențială
 011001  articolele 2, 3 și 6 incluse

Decodarea:
funcția de adaptare (fitness)
 Funcția de adaptare definește problema
 Spune cât este de bună o soluție, cât este de adaptat
un cromozom
 Cromozom: 011001
 Constrângere: w = 50 + 45 + 5 = 100  C = 100
 Constrângerea este satisfăcută
 Funcția de adaptare: p = 35 + 18 + 2 = 55

Satisfacerea constrângerilor
 Cromozom: 111001
 Constrângere: w = 100 + 50 + 45 + 5 = 200 > C = 100
 Constrângerea nu este satisfăcută

Modalități de rezolvare pentru
satisfacerea constrângerilor
 Respingerea soluției
 Funcția de adaptare F = -1 000 000
 Reduce diversitatea genetică
 Repararea soluției
 Câte o genă 1 devine 0 până este satisfăcută constrângerea
 Optimizarea hibridă
 Întâi după greutate (-w) apoi după profit
 Funcția de adaptare F = -200

Reprezentarea
întreagă sau reală
 Multe probleme de optimizare implică numere întregi
sau reale
 De exemplu, minimizarea funcției f (x, y) = x2 + y2
 Valorile întregi sau reale pot fi codate binar
 n = 6 → 110
 r = 3.14 în domeniul [1, 10] pe 8 biți cu reprezentare în
virgulă fixă
 1 → 0000 0000 (0)
 10 → 1111 1111 (255)
 r = 3.14 → (3.14 – 1) · 255 / (10 – 1) = 60 → 0011 1100
 0011 1100 → 3.12 (precizia crește cu numărul de biți)

Faleza Hamming
 O problemă a codării binare este așa-numita „faleză
Hamming” (Hamming cliff)
 01111111 → 127
 10000000 → 128
 Există o breșă în reprezentare care nu există în

problema originară
 Se poate folosi codarea Gray (cod reflectat)
 127 → 01000000
 128 → 11000000

Reprezentarea numerică
 Este mai bine să codăm variabilele numerice direct ca
întregi sau numere în virgulă mobilă
 De exemplu, pentru f (x, y) = x2 + y2, un cromozom
poate fi o pereche (x, y) = (0.12, 0.51)

Exemple: funcții reale de test
(benchmarks)
 Funcția sferă
Problema este interesantă când

n este mare, de exemplu 100

 Funcția Rastrigin generalizată

 Funcția Ackley generalizată
 Alte funcții sunt prezentate în suportul de curs și la adresa:

http://en.wikipedia.org/wiki/Test_functions_for_optimization

 Funcția Ackley generalizată

Reprezentarea prin permutări
 Unele probleme necesită ca obiectele să fie aranjate
într-o anumită ordine
 De exemplu, problema comis-voiajorului (Travelling
Salesman Problem, TSP): ce elemente apar unul
lângă altul
 Aceste probleme sunt reprezentate mai bine cu
ajutorul permutărilor
 Dacă avem n variabile, reprezentarea este o listă de
n întregi, fiecare apărând o singură dată

Exemplu: TSP
 Problema  Spațiul de căutare este
 Se dau n orașe foarte mare
 Să se găsească un tur  Pentru 30 de orașe, există
complet de lungime 30!  1032 tururi posibile
minimă
 Codarea
 Orașele sunt numerotate
1, 2, … , n
 Un tur complet este o
permutare
 De ex. dacă n = 5, atunci
[1,2,3,4,5] și [3,4,5,2,1]
sunt valide
Codarea cu chei aleatorii
 engl. “random key encoding”
 Indexul fiecărei gene în șirul sortat crescător
 Exemplu:
 Cromozom: 0.12, 0.65, 0.87, 0.02, 0.35
 Decodare: 2, 4, 5, 1, 3
 Există și tipul de codare prin permutări explicite,

dar operatorii de încrucișare și mutație sunt mai
complecși

Structuri de date

Structuri de date

Structuri de date

Pseudocod

Pseudocod

Pseudocod

6. Concluzii

Inițializarea
 Fiecare genă are un domeniu predefinit
 Genele tuturor cromozomilor din populație sunt
inițializate cu valori aleatorii din domeniile
corespunzătoare
Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html

Selecția
 Operatorul de selecție alege un părinte (cromozom)
pentru noua generație, pe baza funcției de adaptare
 Selecția acționează la nivel de individ
 Este independentă de reprezentare
 Tipuri de selecție:
 Ruletă (roulette-wheel)
 Bazată pe ranguri (rank-based)
 Eșantionare universală stohastică (stochastic universal
sampling)
 Competiție (tournament)

Ruleta
 Ideea de bază: indivizii mai adaptați au șanse mai mari de
a fi selectați
 Șansele sunt proporționale cu adaptarea
 Se atribuie fiecărui individ o parte a ruletei
 Se învârte ruleta de n ori pentru a se alege n părinți
 Același individ poate fi selectat de mai multe ori
fitness(A) = 3 1/6 = 17%
fitness(B) = 1 A BC
3/6 = 50% 2/6 = 33%
fitness(C) = 2

Implementare
 Fie S suma tuturor funcțiilor de adaptare (ale tuturor indivizilor
din populație)
 Se generează un număr aleatoriu N între 1 și S
 Se returnează cromozomul a cărui funcție de adaptare adăugată
la suma parțială este ≥ N
 Cromozom: 1 2 3 4 5 6
 Fitness: 8 2 17 7 4 11
 Suma parțială: 8 10 27 34 38 49
 N (1  N  49): 23
 Selectat: 3

Pseudocod

Pseudocod

Domeniul funcției de adaptare
 Convergență prematură
 Fitness prea mare
 Genele unui individ foarte adaptat cuceresc
populația dacă restul indivizilor sunt mai puțin
adaptați
 Algoritmul converge într-un optim local
 Prea puțină explorare, prea multă exploatare

Domeniul funcției de adaptare
 Convergență lentă
 Fitness prea mic
 După multe generații, fitness-ul mediu a convers,
dar nu s-a găsit un optim global
 Nu există suficientă diferență între fitness-ul
maxim și fitness-ul mediu
 Presiune selectivă redusă (necompetitivitate)
 Presiunea selectivă variază invers cu șansa de a fi ales
 Prea multă explorare, prea puțină exploatare

Transpunerea
funcției de adaptare
 Scalarea fitness-ului
 f '(i) = f(i) – 
  >0
 Crește presiunea selectivă, favorizează indivizii
foarte adaptați
 Soluție pentru convergența lentă
  poate fi fitness-ul minim din generația curentă
sau din ultimele n generații
  <0
 Scade presiunea selectivă, favorizează indivizii cu
adaptare medie
 Soluție pentru convergența prematură

Efectele scalării fitness-ului

Pseudocod

Rangul funcției de adaptare
 Indivizii sunt numerotați în ordinea crescătoare a
fitness-ului
 Valoarea efectivă a fitness-ului este mai puțin
importantă, contează rangul în populație
 Probabilitățile de selecție se bazează pe fitness-ul
relativ, nu absolut
 Numărul de start și incrementul influențează
rezultatele
 1, 2, 3, 4, ... (presiune selectivă mai mare)
 10, 12, 14, 16, ... (presiune selectivă mai mică)

Selecția bazată pe ranguri
 Populație cu N indivizi
 Abordarea tipică: cel mai adaptat individ primește
rangul N – 1, cel mai puțin adaptat primește rangul 0
 Sortarea populației presupune calcule suplimentare

Pseudocod

Eșantionarea universală
stohastică
 Selecția prin ruletă alege indivizi prin eșantionări repetate
 EUS utilizează o singură valoare aleatorie r pentru alegerea
tuturor indivizilor, la intervale echidistante
 Dacă trebuie aleși N indivizi, se folosesc N intervale
 În figură: N = 4, i = 0 .. N – 1
 De exemplu: F = 49, N = 4, r ∊ [0, 12), pp. 10 ⇒ 10, 22, 34, 46

Pseudocod

Selecția prin competiție
 Ruleta și rangul se bazează pe statisticile globale ale
populației
 Paralelizarea este mai dificilă
 Ideea de bază a selecției prin competiție:
 Se aleg aleatoriu k indivizi din populație și se determină cel
mai adaptat dintre aceștia
 Se repetă procedura pentru a selecta mai mulți părinți
 Este mai rapidă decât metodele de selecție prin ruletă
sau ranguri

Selecția prin competiție
 Probabilitatea selectării individului i depinde de:
 Rangul lui i
 Dimensiunea eșantionului k: un k mai mare crește
presiunea selectivă
 Participanții selectați rămân în bazinul de
împerechere (mating pool)?
 Dacă nu rămân, crește presiunea selectivă
 Cel mai adaptat individ din competiție câștigă
întotdeauna?
 Competiție deterministă sau probabilistică

Pseudocod

Competiția probabilistică
 Se alege cel mai adaptat individ cu probabilitatea p
 Se alege al doilea cel mai adaptat individ cu
probabilitatea p  (1 – p)
 Se alege al treilea cel mai adaptat individ cu
probabilitatea p  (1 – p)2 ... și așa mai departe
 De exemplu: k = 4, p = 0.7
 p1 = 70%
 p2 = 21%
 p3 = 6%
 p4 = 3%
Elitismul
 Cel mai adaptat individ este copiat direct în noua
populație
 Sau primii cei mai adaptați (mai rar)
 Asigură faptul că niciodată nu se va pierde soluția cea
mai bună

Pseudocod

Recomandare
 Alegerea unei metode de selecție depinde de
problemă. Se pot încerca mai multe variante și se
alege metoda care dă cele mai bune rezultate
 Metoda „încercare și eroare” (trial and error)
 Recomandare pentru o primă încercare: selecție prin
competiție deterministă cu doi indivizi, combinată cu
elitismul cu un singur individ

Încrucișarea
 Încrucișarea combină doi cromozomi părinți pentru a
produce un nou cromozom fiu
 Noul cromozom poate fi mai bun decât ambii părinți dacă ia
cele mai bune caracteristici de la fiecare părinte
 Se pot produce 1 sau 2 indivizi noi
 Încrucișarea are loc cu o probabilitate definită de
programator: rata de încrucișare
 Trebuie să fie mare, de obicei în intervalul (0.75, 0.95)
 Dacă se folosește elitismul, poate fi 1

Încrucișarea binară cu un punct
 Se alege un punct aleatoriu în cei doi părinți
 Se divid părinții la punctul de încrucișare
 Se creează 1 sau 2 copíi prin unirea extremelor

Pseudocod

Subiectivitatea pozițională
 engl. “positional bias”
 Performanțele încrucișării cu un punct depind de
ordinea în care sunt reprezentate variabilele
 Este mai probabil să se mențină împreună genele
alăturate
 Nu se pot menține împreună genele de la capetele
diferite ale șirului

Încrucișarea cu n puncte
 Generalizarea încrucișării cu 1 punct
 Se aleg aleatoriu n puncte de încrucișare
 Se divid părinții conform acestor puncte
 Se reunesc fragmentele, alternativ
 Tot mai există o subiectivitate pozițională

Încrucișarea uniformă
 Se generează o mască uniformă
 Masca determină ce biți sunt copiați de la fiecare
părinte
 Densitatea biților din mască determină cantitatea de
material genetic luat de la fiecare părinte

Încrucișarea reală
 Aritmetică: se creează copíi „între” părinți:
 zi =  xi + (1 – ) yi , cu 0    1
  este o variabilă aleatorie
  poate fi identic pentru toți indicii i sau diferit

 Dacă –d    1 + d, de exemplu d = 0.25, domeniul
genelor poate fi extins în timpul execuției

Pseudocod

Mutația binară
 Se modifică fiecare genă în mod independent cu o probabilitate
pm numită rată de mutație
 Trebuie să fie mică, de obicei 1-2%
 Poate avea valori între 1 / d și 1 / lc unde d este dimensiunea
populației iar lc este lungimea cromozomului
 Compromis:
 Prea puține mutații ⇒ convergență prematură (optim local)
 Prea multe mutații ⇒ căutare aleatorie

Pseudocod

Mutația reală
 Resetarea valorii unei gene la un număr aleatoriu din
domeniul ei de definiție
 Reglarea valorii unei gene (fine tuning)
 Gaussiană: media este valoarea veche, iar deviația standard
este definită de utilizator
 Liniară: valoarea veche  q%
 Rata de mutație reală poate fi mai mare decât la
mutația binară, deoarece numărul valorilor reale este
de obicei mai mic decât numărul de biți, de exemplu
10%

Pseudocod

Încrucișarea și mutația
 Au funcții diferite:
 Doar încrucișarea poate combina informațiile de la părinți
 Doar mutația poate introduce noi informații (aléle) în
populație
 Încrucișarea nu schimbă frecvența alelelor din
populație
 Pentru a atinge optimul global, de multe ori este
nevoie de o mutație „norocoasă”

Recomandări
 Se pot încerca mai întâi:
 Pentru probleme binare: încrucișarea cu un singur punct și
mutația de tip flip
 Pentru probleme reale: încrucișarea aritmetică și mutația
prin resetare
 Optimizare posibilă:
 Din doi părinți f și m, se creează în mod normal un copil c
 În noua populație, se introduce individul cu fitness maxim
dintre f, m și c

Exemplu de convergență

Criterii de terminare
 Problema finală este de a decide când să se
termine execuția algoritmului
 Mai multe metode posibile:
 După un număr prestabilit de generații
 Cel mai utilizat criteriu
 Când algoritmul a convers
 Raportul dintre fitness-ul maxim și fitness-ul mediu
(sau minim) scade sub un prag
 Îmbunătățirea fitness-ului mediu timp de două (sau mai
multe) generații scade sub un prag

Alegerea parametrilor
 Dimensiunea populației poate fi în jur de 50
 Pentru probleme simple poate fi mai mic (30), iar pentru
probleme dificile poate fi mai mare (100)
 Prea puțini cromozomi ⇒ algoritmul nu are diversitatea
necesară găsirii soluției
 Prea mulți cromozomi ⇒ algoritmul va fi mai lent, fără
a se îmbunătăți calitatea soluției
 Numărul maxim de generații variază de obicei între
100-1000

Recomandări
 Pentru o problemă cu codare reală de complexitate
medie, pot fi încercate mai întâi următoarele:
 Dimensiunea populației de 50 de indivizi
 Selecție de tip competiție deterministă cu 2 indivizi
 Încrucișare aritmetică cu probabilitatea de 0.9
 Mutație prin resetare cu probabilitatea de 0.1
 Un număr de 100 de generații

6. Concluzii

1. Licitații combinatorice
 Participanții fac oferte asupra unor combinații de articole, nu
asupra unor articole individuale
 O mulțime de articole valorează mai mult decât suma valorilor
articolelor individuale
 Aceste licitații se pot utiliza, de exemplu, pentru:
 Loturi de teren (loturile alăturate au valoare mai mare decât loturile
separate)
 Alocarea spectrului de frecvențe radio
 Alocarea publicității la televiziune
 Scopul este maximizarea câștigului pentru vânzător
 Determinarea câștigătorilor este o problemă NP-dificilă

Oferte (bids):
1) {A}: 1
2) {B}: 3
3) {C,D}: 5
4) {B,E}: 6
5) {A,E}: 7
6) {A,C}: 8
⇒ Reprezentare binară cu 6 gene
Transformate în constrângeri (un articol nu poate fi vândut decât cel mult o dată):
A: x1 + x5 + x6 <= 1
B: x2 + x4 <= 1
C: x3 + x6 <= 1
D: x3 <= 1
E: x4 + x5 <= 1

87
public override double FitnessFunction(Chromosome chromosome)
{
CheckConstraintsAndRepair(chromosome.BinaryGenes.ToCharArray(),
new int[] { 0, 4, 5 }, out string repaired); // constrângerea A
chromosome.BinaryGenes = repaired;
new int[] { 1, 3 }, out repaired); // constrângerea B
new int[] { 2, 5 }, out repaired); // constrângerea C
new int[] { 3, 4 }, out repaired); // constrângerea E
int[] bidValues = new int[] { 1, 3, 5, 6, 7, 8 };
int profitSum = 0;
for (int i = 0; i < bidValues.Length; i++)
profitSum += bidValues[i] * ConvertBinary(chromosome.BinaryGenes[i]);
return profitSum;
}

88
private void CheckConstraintsAndRepair(char[] binaryGenes, int[] v, out string repaired)
{
int sum = 0;
for (int i = 0; i < v.Length; i++)
sum += ConvertBinary(binaryGenes[v[i]]);
while (sum > 1)

{
int x = _rand.Next(v.Length);
binaryGenes[v[x]] = '0';
sum = 0;
for (int i = 0; i < v.Length; i++)
sum += ConvertBinary(binaryGenes[v[i]]);
}
var sb = new StringBuilder();

for (int i = 0; i < binaryGenes.Length; i++)
sb.Append($"{binaryGenes[i]}");
repaired = sb.ToString();
}
private int ConvertBinary(char c) => (c == '1') ? 1 : 0;

89
Caracteristici, rezultate
 Reprezentare binară
 Tratarea constrângerilor prin reparare
 Parametri: 50 indivizi, 100 generații, selecție prin

competiție, elitism, pc = 0.9, pm = 0.02
 Rezultat: 011010, F = 15 1) {A}: 1

2) {B}: 3
3) {C,D}: 5
4) {B,E}: 6
5) {A,E}: 7
6) {A,C}: 8
2. Plasarea nodurilor router în
rețele wireless de tip mesh
 Trebuie plasate 4 routere pe un grid de 10 x 20, a.î.
să fie maximizată suprafața acoperită de semnal
 Reprezentare: folosim numere întregi pentru poziția
(x, y) codate ca numere reale

{
int[,] location = FillLocation(chromosome);
int covered = 0;
int quality = 0;
for (int i = 0; i < 10; i++)

for (int j = 0; j < 20; j++)
{
if (location[i, j] != 0)
covered++;
quality += location[i, j];
}
return covered * 100 + quality; // la acoperiri egale, crește calitatea

}

92
public int[,] FillLocation(Chromosome chromosome)
{
int[,] location = new int[10, 20];
for (int r = 0; r < 4; r++)

{
int rx = (int)chromosome.RealGenes[r * 2];
int ry = (int)chromosome.RealGenes[r * 2 + 1];
SetLocation(location, rx, ry, 4); // router

SetContour(location, rx, ry, 1, 3); // primul contur (imediat) - putere 3
SetContour(location, rx, ry, 2, 2); // urmatorul contur - putere 2
SetContour(location, rx, ry, 3, 1); // ultimul contur - putere 1
}
// se pot adăuga locații de forme diverse, atenuări prin pereți,

// tipuri de routere cu puteri/costuri diferite etc.
return location;
}

93
private void SetLocation(int[,] location, int rx, int ry, int v)
{
if (rx < 0 || ry < 0)
return;
if (rx >= 20 || ry >= 10)
return;
location[ry, rx] = Math.Max(location[ry, rx], v);

}
private void SetContour(int[,] location, int rx, int ry, int d, int p)
{
for (int i = rx - d; i <= rx + d; i++)
{
SetLocation(location, i, ry - d, p);
SetLocation(location, i, ry + d, p);
}
for (int j = ry - d; j <= ry + d; j++)

{
SetLocation(location, rx - d, j, p);
SetLocation(location, rx + d, j, p);
}
}

94
Rezultate
Parametri: 100 indivizi,

100 generații, selecție
prin competiție, elitism,
pc = 0.9, pm = 0.2

3. Optimizarea traiectoriei unei
nave spațiale
 În exemplul nostru, considerăm că o navă spațială
trebuie să treacă pe lângă o planetă luând în calcul
câmpul său gravitațional și să ajungă cât mai repede
la o a doua planetă
 Variabilele de intrare sunt viteza inițială și unghiul

inițial, într-o abordare 2D

Cazuri

Cazuri

Cazuri

Cazuri

Cazuri

Cazuri
Se poate ajunge la a
doua planetă pe
ambele părți, dar care
este calea cea mai
scurta?

{
List<PointD> positions = Simulate(chromosome);
PointD target = new PointD(585 * 1e+6, -135 * 1e+6); // planeta 2
int noSteps = 10000;

double distMin = double.MaxValue;
double eps = 1e+6; // m
for (int i = 0; i < positions.Count; i++)

{
PointD p = positions[i];
double d = p.Distance(target);
if (d < distMin)
distMin = d;
if (d < eps) {
noSteps = i; break; }
}
// minimizare numar de pasi, iar daca nu s-a ajuns la traiectoria corecta,

// minimizarea distantei
return -(noSteps + distMin / 1e+9);
}

103
public List<PointD> Simulate(Chromosome chromosome)
{
double speed = chromosome.RealGenes[0];
double angle = chromosome.RealGenes[1] * Math.PI / 180.0; // unghiul e în grade
double speedX = speed * Math.Cos(angle);
double speedY = speed * Math.Sin(angle);
// definire mase planete și navă
List<PointD> positions = new List<PointD>();

PointD p = new PointD(0, 0);
double eps = 1e+6; // m
for (int t = 0; t < 1000; t++)

{
positions.Add(p);
if (p.Distance(x2, y2) < eps) // a ajuns la destinație

break;
// atracția gravitațională a primei planete

double f1 = Force(probeMass, planetMass1, p.Distance(x1, y1));
double angle1 = Math.Atan2(y1 - p.Y, x1 - p.X);
double accF1X = f1 / probeMass * Math.Cos(angle1);
double accF1Y = f1 / probeMass * Math.Sin(angle1);

104
// atracția gravitațională a celei de-a doua planete
double f2 = Force(probeMass, planetMass2, p.Distance(x2, y2));
double angle2 = Math.Atan2(y2 - p.Y, x2 - p.X);
double accF2X = f2 / probeMass * Math.Cos(angle2);
double accF2Y = f2 / probeMass * Math.Sin(angle2);
// actualizarea accelerației, vitezei și poziției
double accX = accF1X + accF2X;

double accY = accF1Y + accF2Y;
speedX += accX * f;
speedY += accY * f;
p = new PointD(p.X + speedX * f, p.Y + speedY * f);

}
return positions;
}
private double Force(double m1, double m2, double d)

{
double G = 6.674 * 1e-11; // m^3 kg^(-1) s^(-1)
return G * m1 * m2 / (d * d);
}

105
Soluții

Soluții

Soluții

Soluții

Caracteristici, rezultate
 Reprezentare reală
 Tratarea constrângerilor cu o funcție de adaptare
compusă și apropiere adaptivă
 Parametri: 100 indivizi, 100 generații, selecție prin

competiție, elitism, pc = 0.9, pm = 0.2

În lumea reală
 Problemele au mai multe dimensiuni
 Messenger Spacecraft
 A orbitat planeta Mercur între 2011-2015
 26 dimensiuni
 Cassini 2 Spacecraft
 Pământ – Venus – Pământ – Jupiter – Saturn, cu manevre
în spațiul profund (1997-2017)
 22 dimensiuni
 Dinamica obiectelor este dată de ecuații complexe

112
Concluzii
 Concept ușor de înțeles  Uneori sunt foarte lenți, mai
 Rezolvă probleme complexe lenți decât algoritmii specializați
 Acceptă funcții nediferențiabile  Găsirea unei soluții bune într-un
interval mare de timp înseamnă
 Găsesc optimul global lipsa unei soluții bune într-un
 Prezintă robustețe: căutare interval de timp acceptabil
paralelă, populație de soluții
 Ușor de paralelizat și distribuit
 Soluția se îmbunătățește în timp

Inteligenta Artificiala: Metode de Optimizare. Algoritmi Evolutivi

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Inteligenta Artificiala: Metode de Optimizare. Algoritmi Evolutivi

Încărcat de

Drepturi de autor:

Formate disponibile

Inteligență artificială

4. Metode de optimizare (I)

Universitatea Tehnică „Gheorghe Asachi” din Iași

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 2

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 3

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 4

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 5

 Pentru dimensiuni mici ale lui x, se poate face o

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 6

 Optimizarea transportului feroviar

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 7

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 8

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 10

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 11

Algoritm evolutiv Natură

Problema de optimizare Mediu

Soluții potențiale fezabile Indivizii care trăiesc în mediu

Calitatea soluției (funcția de Gradul de adaptare al

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 12

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 13

 Specii intermediare fosile

 Teoria evoluției nu își propune să explice apariția vieții

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 14

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 15

Viteză În general lent În general rapid

Efort Foarte mic De obicei mare

Aplicabilitate Generală Redusă la o clasă de probleme

Performanță Bună, crește în timp De obicei foarte bună

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 17

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 18

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 19

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 20

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 21

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 23

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 24

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 25

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 26

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 27

 Există o breșă în reprezentare care nu există în

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 28

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 29

Problema este interesantă când

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 30

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 31

 Alte funcții sunt prezentate în suportul de curs și la adresa:

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 32

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 33

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 34

 Există și tipul de codare prin permutări explicite,

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 36

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 37

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 38

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 39

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 40

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 41

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 42

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 43

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 45

fitness(A) = 3 1/6 = 17%

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 46

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 47

Florin Leon, Inteligenta artificiala, http://florinleon.byethost24.com/curs_ia.html 48