13

1
INTRODUCERE ÎN CALCULUL
EVOLUTIV

1.1 Specificul calculului evolutiv

La mijlocul anilor '70, odată cu creşterea performanţelor

calculatoarelor şi, implicit, a complexităţii problemelor reale ce se
puteau rezolva cu ajutorul calculatorului, au devenit frecvente
situaţiile în care modelele clasice de optimizare nu mai conduceau la
soluţii acceptabile pentru probleme modelabile pe calculator. Tot mai
frecvent, probleme din biologie, climatologie, chimie, mecanică,
analiza datelor, etc., probleme ale căror modele includ sute sau mii de
variabile, ale căror funcţii de optimizat prezintă multiple optime locale
şi neregularităţi nestudiate din punct de vedere numeric, rămâneau
nerezolvate sau cu soluţii aproximate grosier.

În anul 1970 profesorii Hans-Paul Schwefel (Dortmund) şi

Ingo Rechenberg (Berlin) având de rezolvat o problemă de mecanica
fluidelor, referitoare la optimizarea formei unui corp ce se deplasează
într-un fluid, au căutat o nouă tehnică de optimizare deoarece
metodele cunoscute până în acel moment nu conduceau la o soluţie
14
acceptabilă. Ideea lor a întruchipat conjectura lui Rechenberg, rămasă
până azi justificarea fundamentală a aplicării tehnicilor evolutive:
''Evoluţia naturală este, sau cuprinde, un proces de optimizare foarte
eficient, care, prin simulare, poate duce la rezolvarea de probleme
dificil de optimizat''.

1.2 Noţiuni de bază

Principalele noţiuni care permit analogia între rezolvarea

problemelor de căutare şi evoluţia naturală sunt următoarele:

Cromozomul este o mulţime ordonată de elemente, numite gene ale

căror valori determină caracteristicile unui individ. În genetică,
poziţiile pe care se află genele în cadrul cromozomului se numesc loci,
iar valorile pe care le pot lua se numesc alele. În calculul evolutiv
cromozomii sunt vectori ce conţin codificarea unei soluţii potenţiale şi
sunt numiţi indivizi. Astfel, genele nu sunt altceva decât elementele
acestor vectori.

Populaţia. O populaţie este constituită din indivizi care trăiesc intr-un

mediu la care trebuie să se adapteze. În calculul evolutiv, un individ
este de cele mai multe ori identificat cu un cromozom şi reprezintă un
element din spaţiul de căutare asociat problemei de rezolvat.
 15
Genotipul este ansamblul tuturor genelor unui individ sau chiar a
întregii populaţii. În calculul evolutiv genotipul reprezintă codificările
corespunzătoare tuturor elementelor populaţiei.

Fenotipul este ansamblul trăsăturilor determinate de către un anumit

genotip. În calculul evolutiv fenotipul reprezintă valorile obţinute prin
decodificare, adică valori din spaţiul de căutare.

Generaţia este o etapă în evoluţia unei populaţii. Dacă vedem evoluţia

ca un proces iterativ în care o populaţie se transformă în altă
populaţie atunci generaţia este o iteraţie în cadrul acestui proces.

Selecţia. Procesul de selecţie naturală are ca efect supravieţuirea

indivizilor cu grad ridicat de adecvare la mediu (fitness mare). Acelaşi
scop îl are şi mecanismul de selecţie de la algoritmii genetici şi anume
de a favoriza supravieţuirea elementelor cu grad mare de adecvare.
Aceasta asigură apropierea de soluţia problemei întrucât se
exploatează informaţiile furnizate de către cele mai bune elemente ale
populaţiei. Unul dintre principiile teoriei evoluţioniste este acela că
selecţia este un proces aleator şi nu unul determinist. Acest lucru este
întâlnit în majoritatea mecanismelor de selecţie utilizate de către
algoritmii evolutivi.

Reproducera este procesul prin care, pornind de la populaţia curentă

se construieşte o nouă populaţie. Indivizii noii populaţii (generaţii)
moştenesc caracteristici de la părinţii lor, dar pot dobândi şi
caracteristici noi ca urmare a unor procese de mutaţie care au un
caracter întâmplător. În cazul în care în procesul de reproducere
16
intervin cel puţin doi părinţi, caracteristicile moştenite de descendenţi
se obţin prin combinarea (încrucişarea) caracteristicilor părinţilor.
Mecanismele de încrucişare şi mutaţie asigură explorarea spaţiului
soluţiilor prin descoperirea de noi configuraţii.

Fitnessul sau adecvarea. În evoluţia naturală fiecare individ al

populaţiei este adaptat mai mult sau mai puţin mediului iar unul dintre
principiile teoriei evoluţioniste este acela că supravieţuiesc doar cei
mai buni indivizi. Fitnessul (adecvarea) este o măsură a gradului de
adaptare a individului la mediu. Scopul evoluţiei este ca toţi indivizii
să ajungă la o adecvare cât mai bună la mediu, ceea ce sugerează
legătura între un proces de evoluţie şi unul de optimizare. În calculul
evolutiv, gradul de adecvare al unui element al populaţiei este o
măsură a calităţii acestuia în raport cu problema care trebuie rezolvată.
Dacă este vorba de o problemă de maximizare atunci gradul de
adecvare va fi direct proporţional cu valoarea funcţiei obiectiv (un
element este cu atât mai bun cu cât valoarea acestei funcţii este mai
mare).
La aplicarea unui algoritm evolutiv în rezolvarea unei
probleme concrete trebuie alese în mod adecvat: modul de codificare a
elementelor, funcţia de adecvare si operatorii de selecţie, încrucişare şi
mutaţie. Unele dintre aceste elemente sunt strâns legate de problema
de rezolvat, iar altele mai puţin.
Structura unui algoritm evolutiv este urmatoarea
 17
Procedure AE
begin
t : 0
iniţializare P (t )
evaluare P (t )
while (not condiţie terminare) do
begin
t : t  1
selectare P (t ) din P (t  1)
modificare P (t )
evaluare P (t )
end
end.

2.2. Construirea funcţiei de adecvare

În procesul de evoluţie naturală se urmăreşte maximizarea

gradului de adecvare a indivizilor la mediu. Pentru a ne folosi de
analogia dintre procesele de căutare şi cele de evoluţie este util să
reformulăm problemele de optimizare ca probleme de maximizare
(orice problemă de minimizare poate fi transformată într-una de
maximizare prin schimbarea semnului funcţiei obiectiv). Pentru o
problemă de minimizare de forma: să se determine x *  D cu
proprietatea că f  x *   f  x  pentru orice x  D , funcţia de adecvare
18
poate fi chiar funcţia obiectiv F ( x)  f ( x) . Lucrurile devin mai
complicate în cazul problemelor cu restricţii.

Să considerăm o problemă de minimizare cu restricţii:

să se determine x *  D cu proprietatea că minimizează funcţia
obiectiv f : D  R şi satisface restricţiile:
g j ( x* )  0 , 1  j  k1 ( restricţii de tip egalitate )
h j ( x* )  0 , 1  j  k 2 ( restricţii de tip inegalitate )

O variantă de a trata restricţiile este de a folosi tehnica

penalizării, care permite includerea acestora în cadrul funcţiei de
adecvare:

  g j  x  2  b   h  x 
k1 k2
F( x )  f ( x )  a j
j 1 j 1

unde
u 2 u0
u  
0 u0

iar a şi b sunt parametri pozitivi care reflectă importanţa relativă a

încălcării restricţiilor (cu cât a şi b sunt mai mari cu atât restricţia
este mai importantă şi încălcarea ei este penalizată mai mult). Dacă se
fac diferenţieri între restricţii atunci se pot utiliza mai multe valori (
a1 , , a k1 şi b1 ,  , bk2 în loc de a si respectiv b ).

3
 19

METODE DE SELECŢIE

3.1. Introducere

Selecţia are ca scop determinarea populaţiei intermediare ce

conţine părinţii care vor fi supuşi operatorilor genetici de încrucişare
şi mutaţie precum şi determinarea elementelor ce vor face parte din
generaţia următoare. Criteriul de selecţie se bazează pe gradul de
adecvare al indivizilor la mediu, exprimat prin valoarea funcţiei de
adecvare. Nu este obligatoriu ca atât părinţii cât şi supravieţuitorii să
fie determinaţi prin selecţie, fiind posibil ca selectia să fie folosită într-
o singură etapă.

3.3. Metoda ruletei

Principiul ruletei reprezintă cea mai simplă metodă de selecţie,

fiind un algoritm stochastic ce foloseşte următoarea tehnică:

• indivizii sunt văzuţi ca segmente continuie pe o dreaptă, astfel încât

fiecare segment asociat unui individ este egal cu fitnessul său;

• se generează un număr aleator şi individul al cărui segment conţine

numărul respectiv va fi selectat
20
• se repetă pasul anterior până când este selectat numărul dorit de
indivizi.
Această tehnică este similară cu cea a ruletei, în care fiecare
segment este proporţional cu fitnessul unui individ.

Exemplul 3.1. Tabelul următor arată probabilitatea de selecţie

pentru 11 indivizi, folosind aranjarea liniară şi presiunea selectivă 2.
Individul 1 este cel mai bun şi ocupă intervalul cel mai mare, în timp
ce individul 10 este penultimul în şir şi ocupă intervalul cel mai mic;
individul 11, ultimul din şir, având fitnessul 0 nu poate fi ales pentru
reproducere.

nr 4 nr 2 nr 6 nr 5 nr 1 nr 3
individ

Probabilitatea în acest tabel se calculează ca fiind raportul dintre

fitnessul unui individ şi suma fitness-urilor tuturor indivizilor.

Numar
1 2 3 4 5 6 7 8 9 10
Individ
Fitness 2.0 1.8 1.6 1.4 1.2 1 0.8 0.6 0.4 0.2

Proba- 0.18 0.16 0.15 0.13 0.11 0.09 0.07 0.06 0.03 0.02
bilitate
selectie
 21
Dorind să selectăm 6 indivizi, se generează 6 numere aleatoare
uniform distribuite în intervalul  0, 1 . Fie acestea 0.81 , 0.32 ,
0.96 , 0.01 , 0.65 , 0.42 . Aşezând cei 10 indivizi pe o dreaptă, în
ordinea
1, 2, ... ,10, individul 1 va ocupa segmentul cuprins între 0.0 şi 0.18,
individul 2 segmentul dintre 0.18 şi 0.34, individul 3 segmentul dintre
0.34 şi 0.49, etc. Deoarece individul 6 corespunde segmentului
delimitat de 0.73 şi 0.82 iar primul număr generat (= 0.81) cade în
acest segment, individul 6 va fi selectat pentru reproducere. În mod
similar se selecteaza indivizii 1, 2, 3, 5, 9; deci, populaţia selectată
este formată din indivizii 1, 2, 3, 5, 6, 9.

3.4. Metoda fitessului proporţionat

Este metoda cea mai des utilizată şi funcţionează astfel:

• se calculează fitnessul f i al fiecărui individ i şi fitnessul mediu al
populaţiei

f 
f i

n
• individul i este selectat pentru reproducere cu probabilitatea

fi fi
pi   .
f i n f
• dacă trebuie selectaţi N indivizi, numărul N i al indivizilor ce vor
fi selectaţi cu probabilitatea pi va fi apoximativ egal cu N  pi .
22
Metoda fitnessului proporţionat poate fi implementată cu ajutorul
algoritmului ruletei.

Exemplul 3.2. Fie n  4 indivizi având f1  f 2  10 , f 3  15

şi f 4  25 . În practică, metoda ruletei poate fi implementată folosind
un vector v cu m componente şi un index aleator r , urmând ca
individul v (r ) să fie selectat la fiecare „măturare”. Luând m  12 în
exemplul nostru rezultă v  (1 1 2 2 3 3 3 4 4 4 4 4) . Pentru
r  6 va fi selectat individul v (6)  3 .

4
OPERATORI GENETICI

4.1. Încrucişarea

Încrucişarea (sau recombinarea) permite combinarea

informaţiilor provenite de la doi sau mai mulţi părinţi pentru generarea
unuia sau mai multor urmaşi. Încrucişarea depinde de modul de
codificare a datelor, aplicându-se direct asupra cromozomilor.

4.1.1. Încrucişarea binară

 23
Acest operator crează descendenţi prin combinarea unor părţi
alternative ale părinţilor.

4.1.1.2. Încrucişarea multiplă

În acest caz, se folosesc m  1 puncte de încrucişare

k i  1, 2,  , N  alese aleator, diferite între ele şi sortate crescător.
Valorile aflate între puncte de încrucişare consecutive sunt schimbate
între cei doi părinţi pentru a obţine doi descendenţi.

părinţi descendenţi

Figura 4.2

De exemplu, indivizii
p1: 01110011010
p2: 10101100101
cu 3 puncte de încrucişare date de poziţiile : 2, 6, 10
generează descendenţii
d1: 0 1| 1 0 1 1| 0 1 1 1| 1
d2: 1 0| 1 1 0 0| 0 0 1 0| 0
24
Ideea încrucişării multiple este aceea că părţi ale cromozomilor
care contribuie la îmbunătăţirea performanţei unui individ nu este
necesar să fie conţinute în subşiruri adiacente. Mai mult, încrucişarea
multiplă pare să încurajeze explorarea în spaţiul de căutare mai
degrabă decât să favorizeze convergenţa rapidă către indivizii de elită.

4.1.2. Încrucişarea
reală
4.1.2.2. Încrucişarea
intermediară

Este o metodă aplicabilă numai variabilelor reale; în acest caz

valorile variabilelor descendenţilor sunt alese în jurul şi între valorile
corespunzatoare ale părinţilor.
Descendenţii sunt generaţi după regula:
descendent = părinte 1 +  (părinte 2 - părinte 1)
unde  este un factor de scalare ales uniform şi aleator în intervalul
  d , 1  d  . În încrucişarea intermediară simplă d  0 iar în
încrucişarea intermediară extinsă d  0 ; o alegere bună este
d  0.25
Fiecare variabilă din descendent este rezultatul combinării
variabilelor corespunzătoare ale părinţilor conform formulei
anterioare, cu o nouă valoare  pentru fiecare variabilă.
În figura următoare se prezintă zonele în care iau valori părinţii şi
descendenţii lor :
 25

părinte 1 părinte 2

aria părinţilor
zona posibilă a descendeţilor

Figura 4.4

Considerăm următorii părinţi, cu trei variabile fiecare:

p1: 12 25 5
p2: 123 4 34

Considerăm următoarele valori ale lui  corespunzătoare celor doi

descendenţi:
exemplul 1: 0.5 1.1 - 0.1
exemplul 2: 0.1 0.8 0.5

Rezultă următorii descendenţi

d1: 67.5 1.9 2.1

d2: 23.1 8.2 19.5

Încrucişarea specifica
4.1.5. Încrucişarea prin drumuri
26
Trei tipuri de încrucişare sunt utilizate în cazul reprezentării prin
drumuri: parţial aplicată (PMX), de ordine (OX) şi ciclică (CX).

4.1.5.1. Încrucişarea PMX

A fost propusă de Goldberg şi Lingle [37] şi construieşte un

descendent alegând un subtraseu din unul dintre părinţi şi păstrând
ordinea şi poziţia a cât mai multe oraşe din celălalt părinte. Subtraseul
este selectat prin alegerea a două puncte aleatoare de taietură care
definesc frontierele operaţiei de interschimbare. De exemplu, părinţii

p1: 1 2 3 | 4 5 6 7 | 8 9
şi
p2: 4 5 2 |1 8 7 6 | 9 3

vor produce descendenţi în felul următor. Mai întâi, porţiunea

cuprinsă între cele două puncte de tăietură este schimbată între cei doi
părinţi, obţinându-se descendenţii:

d1:   |1 8 7 6| 

şi
d2:   |4 5 6 7| 
În acelaşi timp, se obţine aplicaţia

1  4 , 8  5 , 7  6 şi 6  7 .
 27
Apoi, se copiază în locurile libere din cei doi descendenţi elementele
corespunzătoare din părinţi, dacă acestea nu generează conflicte;
rezultă
d1:  2 3 |1 8 7 6 |  9
şi
d2:   2 | 4 5 6 7 | 9 3

Primul  din descendentul d1 (care ar trebui să fie 1, dar această

valoare este interzisă deoarece ea există deja în descendent) este
înlocuită cu 4, datorită aplicaţiei 1  4 . În mod similar, al doilea 
din descendentul d1 este înlocuit cu 5 iar caracterele  din celălalt
descendent sunt înlocuite cu 1 şi 8. În final rezultă descendenţii

d1: 4 2 3 |1 8 7 6 | 5 9
şi
d2: 1 8 2 | 4 5 6 7 | 9 3

4.1.5.2. Încrucişarea OX

A fost propusă de Davis [12] şi construieşte un descendent

alegând un subtraseu în unul dintre părinţi şi păstrând ordinea relativă
a oraşelor din celălalt părinte. De exemplu, părinţii

p1: 1 2 3 | 4 5 6 7 | 8 9
şi
p2: 4 5 2 |1 8 7 6 | 9 3
28
vor produce descendenţi în felul următor. Mai întâi, porţiunile dintre
punctele de tăietură sunt copiate în cei doi descendenţi
d1:   |4 5 6 7| 
d2:   |1 8 7 6| 
Apoi, pornind de la al doilea punct de tăietură al unuia dintre părinţi se
copiază oraşele din celălalt părinte, păstrând ordinea şi omiţând
oraşele care sunt deja prezente; când se ajunge la sfârşitul traseului se
continuă cu primul oraş. Şirul oraşelor din al doilea părinte, începând
cu al doilea punct de tăietură, este
9  3  4  5  2  1  8  7  6;

Eliminând oraşele 4, 5, 6 şi 7, care sunt deja prezente în primul

descendent, se obţine
9  3  2  1  8

Aseastă secvenţă este plasată în primul descendent, începând cu al

doilea punct de tăietură, şi rezultă

d1: 2 1 8 | 4 5 6 7 | 9 3.

Similar se obţine celălalt descendent:

d2: 3 4 5 | 1 8 7 6 | 9 2.

Pentru încrucişarea OX este importantă ordinea oraşelor şi nu poziţia

lor în reprezentare.
 29

4.2. Mutaţia

Mutaţia este cel mai simplu operator genetic şi constă în

schimbarea aleatoare a unor valori ale cromozomului pentru a
introduce noi soluţii. Scopul său este de a împiedica pierderea
ireparabilă a diversităţii, evitând, astfel, convergenţa prematură.
Diversitatea permite explorarea unor zone largi din spaţiul de căutare.
Mutaţia foloseşte ca parametru probabilitatea de mutaţie p m , care ia
valori mici; de obicei în intervalul  0.001, 0.01 .

4.2.1. Mutaţia binară

Dacă n este dimensiunea populaţiei iar l este lungimea unui

cromozom atunci numărul mediu de biţi ce vor suferi mutaţie este
N  n  l  p m . Mutaţia binară poate fi implementată sub mai multe

forme.

4.2.1.1. Mutaţia tare

Pentru fiecare poziţie a fiecărui cromozom se execută paşii:

P1: se generează un număr aleator q   0, 1
P2: dacă q  p m atunci se schimbă poziţia respectivă, în caz contrar
nu se efectuează nimic.
30
4.2.1.2. Mutaţia slabă

Pentru fiecare poziţie a fiecărui cromozom se execută paşii:

P1: se generează un număr aleator q   0, 1
P2: dacă q  p m atunci se alege aleator una din valorile 0 sau 1 şi
se
atribuie poziţiei curente, în caz contrar nu se efectuează nimic.

4.2.2. Mutaţia reală

Considerăm cromozomi cu n gene exprimate prin numere reale,

pentru fiecare genă cunoscându-se domeniul valorilor posibile.

4.2.2.1. Mutaţia uniformă

Acest tip de mutaţie înlocuieşte o singură genă a unui

cromozom selectat cu un număr real generat aleator în domeniul
parametrului reprezentat de acea genă. Se consideră că toate genele au
aceeaşi probabilitate de mutaţie. Dacă x  ( x1 ,  , x n ) este un
cromozom părinte, se alege aleator gena i ce va fi supusă mutaţiei şi
se obţine descendentul x'  ( x1 , , x'i , , xn ) , unde valoarea x'i
este aleasă aleator din domeniul parametrului de pe poziţia i .
O variantă de mutaţie uniformă este cea care perturbă toate
genele cromozomului. Această operaţie se poate efectua în mai multe
moduri:
 31
• mutaţia aditivă normală:
x'i  xi   i  N  0, i  , i  1,  , n

unde  i este un parametru real iar N  0,  i  reprezintă un număr

aleator cu repartiţia normală de medie 0 şi dispersie  i . De obicei se
lucrează cu  i   şi  i   , i  1,  , n .

• mutaţia multiplicativă:
x'i  xi  N  0,  i  , i  1,  , n

• mutaţia multiplicativă lognormală:

x'i  xi  e  N  0, i  , i  1,  , n

cu  parametru real.

4.2.2.2. Mutaţia neuniformă

Prin această operaţie, genele suferă modificări importante în

primele generaţii şi descresc treptat, până la atenuare, în generaţiile
următoare. Astfel se permite o explorare uniformă a spaţiului de
căutare în primele generaţii şi o căutare locală, datorată variaţiilor
mici, în ultimele generaţii.
Creşterea sau descreşterea valorii unei gene este dată de un
parametru aleator p : p  1 indică o creştere a valorii iar p  1
indică o descreştere. Amplitudinea schimbării este dată de funcţia
h :  0, 1,  , T    0, 1

cu proprietăţile
1) h este descrescătoare
32
2) h(T )  0
unde T este numărul maxim de iteraţii.
Un exemplu de astfel de funcţie este
b
 t 

h(t )  1  r
 1 
 T  ,

unde r este un parametru aleator din [0, 1] iar b  1 este un

parametru ce determină gradul de neuniformitate. În acest tip de
mutaţie gena i se transformă astfel:
x'i  xi   x max  xi   h(t ) dacă p  1
x'i  xi   xi  x min   h(t ) dacă p  1
unde x max şi x min reprezintă cea mai mare şi respectiv cea mai mică
componentă a lui x.

4.2.4. Mutaţia specifică

În cazul reprezentării specifice mutaţia nu mai poate acţiona

independent asupra fiecărei gene. Cele mai cunoscute tipuri de
mutaţie folosite în acest caz sunt:

• mutaţia prin schimbare, prin care se selectează aleator două gene

ale cromozomului şi se schimbă între ele valorile; de exemplu,
plecând de la cromozomul
1 2 3 4 5 6 7 8 9
 33
şi alegând genele (poziţiile) 3 şi 7 rezultă cromozomul
1 2 7 4 5 6 3 8 9

• mutaţia prin inserare: se aleg aleator două gene şi apoi una dintre
ele se inserează lângă cealaltă; de exemplu, din
1 2 3 4 5 6 7 8 9

şi poziţiile 3 şi 7 se obţine
1 2 3 7 4 5 6 8 9 .

• mutaţia prin amestec: se alege în mod aleator o porţiune din

cromozom şi se amestecă valorile din această zona; de exemplu,
plecând de la cromozomul
1 2 3 4 5 6 7 8 9

se poate obţine
1 2 5 3 6 4 7 8 9 .

• mutaţia prin inversiune: se aleg aleator două poziţii din cromozom

şi se inversează valorile situate în zona definită de acestea; de
exemplu, alegând cromozomul
1 2 3 4 5 6 7 8 9
şi poziţiile 3 şi 6 se obţine
1 2 6 5 4 3 7 8 9 .

5
34

FUNCŢIONAREA ALGORITMILOR
GENETICI

5.1. Maximizarea unei funcţii

Explicăm funcţionarea algoritmilor genetici pentru o problemă

de maximizare deoarece minimizarea funcţiei f este echivalentă cu
maximizarea funcţiei g   f . În plus, presupunem că funcţia obiectiv
f ia valori pozitive, în caz contrar putându-se aduna o constantă
pozitivă C şi maximizându-se f  C .
Presupunem că se doreşte maximizarea unei funcţii de k
variabile
f : Rk  R ;

fiecare variabilă xi ia valori într-un domeniu

Di   ai , bi   R
şi
f  x1 , , x k   0 pentru xi  Di .
Cerând o precizie de p zecimale pentru valorile variabilelor, fiecare
interval Di va trebui divizat în  bi  ai  10 subintervale egale. Fie
p

li cel mai mic întreg astfel încât

 bi  ai  10 p  2l
i
1 .
 35
Atunci, o reprezentare a variabilei x i ca un şir binar de
lungime li va satisface precizia dorită. În plus, are loc formula
bi  ai
xi  ai  zecimal  string 2  
2 li  1
unde zecimal  string 2  reprezintă valoarea zecimală a şirului binar
string .

Acum fiecare cromozom este reprezentat printr-un şir binar de

k
lungime l   li ; primii l1 biţi reprezintă o valoare din  a1 , b1  ,
i 1

următorii l 2 biţi reprezintă o valoare din  a 2 , b2  şi aşa mai departe.

Populaţia iniţială constă din n cromozomi aleşi aleator. Totuşi dacă
avem informaţii despre optimul potenţial, ele pot fi utilizate pentru a
genera populaţia iniţială. În continuare algoritmul funcţionează astfel:

• se evaluează fiecare cromozom al fiecărei generaţii, utilizând

funcţia f

• se selectează noua populaţie conform distribuţiei de probabilitate

bazată pe fitness

• se modifică cromozomii din noua populaţie prin operatori de

mutaţie şi încrucişare

• după un număr de generaţii, când nu mai sunt observate

îmbunătăţiri substanţiale, cel mai bun cromozom este selectat ca
36
soluţie optimă; deseori algoritmul se opreşte după un număr finit de
iteraţii.

Pentru procesul de selecţie vom utiliza tehnica ruletei:

• se calculează fitnessul eval  vi  pentru fiecare cromozom

vi , i  1, 2, , n

• se găseşte fitnessul total

n
F   eval  vi 
i 1

• se calculează probabilitatea de selecţie pi pentru fiecare

cromozom vi , i  1, 2, , n :
eval  vi 
pi 
F

• se calculează probabilitatea cumulată q i pentru fiecare

cromozom vi , i  1, 2, , n :
i
qi   pj
j 1

Procesul de selecţie constă în folosirea ruletei de n ori; de

fiecare dată se selectează un singur cromozom astfel:

• se generează un număr aleator a   0, 1

 37
• dacă a  q1 , se selectează primul cromozom; altfel se selectează
cromozomul vi , 2  i  n , astfel încât qi 1  a  q i .

Este evident că unii cromozomi vor fi selectaţi de mai multe

ori, cromozomii cei mai buni generând mai multe copii.
După selecţie se aplică operatorul de încrucişare. Folosind
probabilitatea de încrucişare p c se determină numărul pc  n de
cromozomi supuşi încrucişării. Se procedează astfel, pentru fiecare
cromozom din noua populaţie:

• se generează un număr aleator a   0, 1

• dacă a  pc , cromozomul curent se selectează pentru încrucişare.

În continuare se împerechează aleator cromozomii şi pentru

fiecare pereche se generează un numar aleator întreg pos  1, l  1 ,
l fiind lungimea unui cromozom iar pos este poziţia de încrucişare.
Doi cromozomi
b1b2  b pos b pos 1  bl

şi
c1c 2  c pos c pos 1  cl

sunt înlocuiţi prin descendenţii

b1b2  b pos c pos 1  c l

şi
c1c 2  c pos b pos 1  bl .
38
Se aplică, apoi, operatorul de mutaţie. Probabilitatea de mutaţie p m
dă numărul p m  l  n al biţilor ce vor suferi mutaţie. Pentru fiecare bit
al fiecărui cromozom au loc operaţiile:

• se generează un număr aleator a   0, 1

• dacă a  p m , bitul va suferi mutaţie.

În urma operaţiilor de selecţie, încrucişare şi mutaţie, noua

populaţie este gata pentru următoarea evaluare.

Următorul exemplu [59] ne arată modul de funcţionare.

Presupunem că vrem sa maximizăm funcţia

f  x1 , x 2   21.5  x1  sin  4x1   x 2  sin  20x 2 

unde
 3.0  x1  12.1 şi 4.1  x 2  5.8 .

Vom lucra cu o populaţie de dimensiune n  20 , cu probabilitatea de

încrucişare pc  0.25 şi probabilitatea de mutaţie p m  0.01 .
Cerem ca precizia să fie de patru zecimale pentru fiecare variabilă.
Deoarece domeniul lui x1 are lungimea 15.1 , precizia cerută
implică divizarea intervalului   3.0, 12.1 în cel puţin 15.1  10 4
subintervale egale. Înseamnă că sunt necesari 18 biţi pentru a
reprezenta prima parte a cromozomului: 217  151000  218 . Domeniul
lui x 2 are lungimea 1.7 iar precizia impusă determină împărţirea
intervalului  4.1, 5.8 în cel puţin 1.7  10 4 subintervale egale.
 39
Înseamnă că pentru partea a doua a cromozomului vor fi utilizaţi 15
biţi: 214  17000  215 . Lungimea totală a unui cromozom este
l  18  15  33 biţi; Primii 18 biţi codifică pe x1 iar ultimii 15 pe
x2 .
Fie, de exemplu, cromozomul

01000100101101000011 1110010100010 .

Primii 18 biţi
010001001011010000

reprezintă pe

12.1    3.0 
x1  3.0  zecimal 010001001011010000 2   
218  1
15.1
 3.0  70352   3.0  4.052426  1.052426 .
262143

Următorii 15 biţi
1111100101 00010

reprezintă pe
5.8-4.1
x2  4.1  zecimal (1111100101 00010 2 ) 
215 -1
1.7
 4.1  31906  4.1  1.655330  5.75533.
32767

Astfel cromozomul

01000100101101000011 1110010100010
40
corespunde valorilor
( x1 , x 2 )  (1.052426, 5.755330) .

Valoarea fitnessului pentru acest cromozom este

f (1.052426, 5.755330)  20.25264 .

Iniţializăm o populaţie cu 20 de cromozomi şi 33 de biţi fiecare, aleşi

aleator, şi obţinem

v1  (10011010000000111111 1010011011111)
v 2  (11100010010011011100 1010100011010)
v3  (000010000011001000001010111011101)
v 4  (100011000101101001111000001110010)
v5  (00011101100101001101011111100 0101)
v 6  (00010100001001010100101011111 1011)
v7  (00100010000011010111101101111 1011)
v8  (100001100001110100010110101100111)
v9  (010000000101100010110000001111100)
v10  (000001111 0001100000 1101000011 1011)
v11  (011001111 1101101011 0000110111 1000)
v12  (110100010 1111011010 00101010000000)
v13  (111011111 010001000110000001000110)
v14  (010010011 00000101010011110010 1001)
v15  (111011101 1011100001 0001111101 1110)
v16  (110011110 0000111111 0000110100 1011)
 41
v17  (011010111 1110011110 1000110111 1101)
v18  (011101000 0000011101 0011111010 1101)
v19  (0001010100111111111 1000011000 1100)
v 20  (101110010 1100111100 1100010111 1110)

Decodificând fiecare cromozom şi evaluând fitnessul obţinem:

eval  v1   f (6.084492 , 5.652242)  26.019600

eval  v 2   f (10.348434 , 4.380264)  7.580015
eval  v3   f (-2.516603, 4.390381)  19.526329
eval  v 4   f (5.278638, 5.593460)  17.406725
eval  v5   f (-1.255173, 4.734458)  25.341160
eval  v6   f (-1.811725, 4.391937)  18.100417
eval  v 7   f (-0.991471, 5.680258)  16.020812
eval  v8   f ( 4.910618, 4.703018)  17.959701
eval  v9   f (0.795406, 5.381472)  16.127799
eval  v10   f (-2.554851, 4.793707)  21.278435
eval v11   f (3.130078, 4.996097)  23.410669
eval v12   f (9.356179, 4.239457)  15.011619
eval  v13   f (11.134646, 5.378671)  27.316702
eval v14   f (1.335944, 5.151378)  19.876294
eval  v15   f (11.089025, 5.054515)  30.060205
42
eval v16   f (9.211598, 4.993762)  23.867227
eval v17   f (3.367514, 4.571343)  13.696165
eval v18   f (3.843020, 5.158226)  15.414128
eval  v19   f (-1.746635, 5.395584)  20.095903
eval v 20   f (7.935998, 4.757338)  13.666916

Se observă că cromozomul v15 este cel mai bun iar v 2 este

cel mai neperformant. Utilizăm metoda ruletei pentru selecţie.
Fitnessul total al populaţiei este
20
F   eval  vi   387.776822
i 1

Probabilitatea de selecţie pi pentru fiecare cromozom

vi , i  {1, 2, ..., 20} este:

eval  v1  eval  v 2 
p1   0.067099 p2   0.019547
F F

eval  v3  eval  v 4 
p3   0.050355 p4   0.044889
F F

eval  v5  eval  v 6 
p5   0.065350 p6   0.046677
F F

eval  v7  eval  v8 
p7   0.041315 p8   0.046315
F F
 43
eval  v9  eval  v10 
p9   0.041590 p10   0.054873
F F

eval  v11  eval  v12 

p11   0.060372 p12   0.038712
F F

eval  v13  eval  v14 

p13   0.070444 p14   0.051257
F F

eval  v15  eval  v16 

p15   0.077519 p16   0.061549
F F

eval  v17  eval  v18 

p17   0.035320 p18   0.039750
F F

eval  v19  eval  v 20 

p19   0.051823 p 20   0.035244
F F

Probabilităţile cumulate qi pentru fiecare cromozom sunt

q1 = 0.067090 , q 2 = 0.086647 , q 3 = 0.137001 ,

q 4 = 0.181890 , q5 = 0.247240 , q 6 = 0.293917 ,

q 7 = 0.335232 , q8 = 0.381546 , q 9 = 0.423137 ,
q10  0.478009 , q11 = 0.538381 , q12 = 0.577093 ,
q13 = 0.647537 , q14 = 0.698794 , q15 = 0.776314 ,
q16 = 0.837863 , q17 = 0.873182 , q18 = 0.912932 ,
q19 = 0.964756 , q 20 = 1.000000
44
Acum se poate aplica tehnica ruletei de 20 de ori, selectând
de fiecare dată câte un cromozom. Presupunem că au fost generate
următoarele numere aleatoare din  0, 1 :

0.513870 , 0.175741 , 0.308652 , 0.534534 , 0.947628 ,

0.171736 , 0.702231 , 0.226431 , 0.494773 , 0.424720 ,
0.703899 , 0.389647 , 0.277226 , 0.368071 , 0.983437 ,
0.005398 , 0.765682 , 0.646473 , 0.767139 , 0.780237 .

Primul număr a  0.513870 satisface relaţia q10  a  q11 , deci

cromozomul v11 este selectat pentru noua populaţie. Pentru al doilea
număr a  0.175741 avem q3  a  q 4 , deci se selectează
cromozomul v 4 , etc.
În final, noua populaţie va conţine indivizii

v '1  v11 , v' 2  v 4 , v' 3  v 7 , v ' 4  v11 , v' 5  v19 , v'6  v4 ,

v' 7  v15 , v'8  v5 , v' 9  v11 , v'10  v3 , v '11  v15 , v '12  v 9 ,

v'13  v 6 , v'14  v8 , v'15  v 20 , v '16  v1 , v '17  v10 , v'18  v13 ,

v '19  v15 , v' 20  v16 .

Acum putem aplica operatorul de încrucişare indivizilor din

noua populaţie. Luăm probabilitatea de încrucişare p c  0.25 .
Procedăm astfel:

• pentru fiecare cromozom din noua populaţie, se generează un

număr aleator a   0, 1
 45
• dacă a  0.25 , individul respectiv va fi selectat.

Presupunem ca au fost selectate următoarele secvenţe de

numere:

0.822951 , 0.151932 , 0.625477 , 0.314685 , 0.346901 ,

0.917204 , 0.519760 , 0.401154 , 0.606758 , 0.785402 ,
0.031523 , 0.869921 , 0.166525 , 0.674520 , 0.758400 ,
0.581893 , 0.389248 , 0.200232 , 0.355635 , 0.826927 .

Înseamnă că, pentru încrucişare, se selectează indivizii

v' 2 , v '11 , v '13 , v'18 . Indivizii selectaţi se împerechează aleator; de

exemplu  v' 2 , v'11  şi  v'13 , v'18  . Pentru fiecare pereche se

generează numărul pos  1, 32 , care indică poziţia punctului de
încrucişare.
Pentru prima pereche

v' 2  100011000 | 1011010011 1100000111 0010

v'11  111011101 | 1011100001 0001111101 1110 

şi pos  9 rezultă descendenţii

v"2  100011000 | 1011100001 0001111101 11

v"11  111011101 | 1011010011 1100000111 0
A doua pereche de indivizi este

v'13   00010100001001010100 | 1010111111 011

46
v'18  1110111110 1000100011 | 0000001000110 

şi pos  20 . Ei vor fi înlocuiţi prin descendenţii

v"13   00010100001001010100 | 000000100

v"18  1110111110 1000100011 | 1010111111
Acum, populaţia curentă este:

v '1 , v" 2 , v'3 , v' 4 , v'5 , v' 6 , v' 7 ,

v ' 8 , v ' 9 , v '10 , v"11 , v '12 ,

v"13 , v '14 , v '15 , v '16 , v '17 ,

v"18 , v '19 , v ' 20 .

În continuare se aplică operatorul de mutaţie cu probabilitatea

p m  0.01 . Pentru fiecare bit se generează un număr aleator
a   0, 1 şi dacă a  0.01 atunci el va suferi operaţia de mutaţie.

Generăm l  n  33  20  660 numere aleatoare; dintre ele 5 sunt mai

mari decât 0.01 : aceste valori sunt prezentate în tabelul care
urmreză.
Tabelul al doilea arată numărul individului şi poziţia bitului ce va
suferi operaţia de mutaţie.
 47
Poziţia bitului numărul aleator
112 0.000213
349 0.009945
418 0.008809
429 0.005425
602 0.002836

poziţie bit nr. individ Nr. bit în individ

112 4 13
349 11 19
418 13 22
429 13 33
602 19 8

Deci, patru cromozomi sunt afectaţi de operatorul de mutaţie, unul

dintre ei având doi biţi schimbaţi.

În final rezultă următoarea populaţie:

v1   0110011111 10110101100001101111 000

v 2  100011000101110000100011111011 110 
v3  (00100010000011010111 1011011111 011)

v4   0110011111 10 | 0 | 10101100001101111000 
v5   00010101001111111111 0000110001100
v6  100011000101101001111000001110010
v7  1110111011 01110000100011111011 110 
48
v8   0001110110 01010011010111111000 101
v9  0110011111 10110101100001101111 000
v10   000010000011001000001010111011101
v11  1110111011 01101001 | 0 | 11000001110010
v1201 0 01010 10 0 0 1 1 0 

v13   000101000010010101000 | 1 | 0000100011| 1 |

v1410 01 0 01 010 1010 1 01 

v15  101110010110011110011000101111110 
v16  10011010000000111111 1010011011111
v17   000001111000110000011010000111011
v18  1110111110 10001000111010111111 011
v19  11101110 | 0 | 101110000100011111011110 
v 20  1100111100 0001111110 0001101001011
unde biţii cuprinşi între linii verticale sunt cei care au rezultat în urma
mutaţiei. S-a încheiat o iteraţie a algoritmului, putându-se trece la
următoarea.

7
TIPURI DE ALGORITMI GENETICI
 49

7.2. Algoritmul genetic modificat

Rudolph [69] a demonstrat că algoritmul clasic nu converge

niciodată la soluţia optimă, dar versiunea modificată, care menţine cea
mai bună soluţie în populaţie, face acest lucru.
Algoritmul genetic modificat (modGA) se obţine din cel
clasic, prin modificarea pasului de selecţie.

algoritmul modGA
begin
t : 0
iniţializează P (t )
evaluează P (t )
while not (condiţie-terminare) do
begin
t : t  1
selectează părinţii din P (t  1)
selectează indivizii neperformanţi din P (t  1)
formează P (t ) prin reproducerea părinţilor
evaluează P (t )
end
end
50

În cei doi paşi de selecţie se selectează r cromozomi (nu

neapărat distincţi) pentru a fi reproduşi şi r cromozomi distincţi care
vor fi eliminaţi. Metoda de selecţie este cea a fitnessului relativ. Noua
populaţie P (t  1) va consta din adăugarea la P (t ) , în locul
indivizilor eliminaţi, a r descendenţi rezultaţi din cei r părinţi.

Se procedează astfel:

Pasul 1. Se selectează r părinţi din P (t ) . Fiecare individ selectat

este marcat ca aplicabil la exact o operaţie genetică.

Pasul 2. Se selectează N  r indivizi distincţi din P (t ) şi se

copiază în P (t  1) , unde N este dimensiunea populaţiei.

Pasul 3. Cei r părinţi selectaţi dau naştere la r descendenţi care vor

fi incluşi în P (t  1) .

7.5. Algoritmi de tip contracţie

O posibilă abordare de studiere a proprietăţilor de convergenţă

a algoritmilor genetici poate folosi teorema de punct fix a lui Banach,
care lucrează cu aplicaţii de tip „contracţie” pe spaţii metrice.
 51
Fără a restrânge cu nimic generalitatea, presupunem că lucrăm
cu probleme de maxim, adică probleme pentru care o soluţie xi este
mai bună decât soluţia x j dacă şi numai dacă eval  xi   eval  x j  ,
unde funcţia eval dă fitnessul unui individ din populaţie.
Pentru o populaţie P considerăm funcţia de evaluare Eval ; de
exemplu, pentru P   p1 , p 2 , , p n  putem defini

1 n
Eval  P    eval  pi  .
n i 1

Structura algoritmului de tip contracţie (C-GA) este

următoarea

algoritmul C-GA
begin
t : 0
iniţializează P (t )
evaluează P (t )
while not (condiţie-terminare) do
begin { se construieşte contracţia}
t : t  1
selectează P (t ) din P (t  1)
recombină P (t )
evaluează P (t )
52
if Eval  P t  1   Eval  P t  
then t : t  1
end
end
Alte abordări pot fi găsite în [45, 46].

7.6. Algoritmi cu dimensiunea variabilă a

populaţiei

Diverse studii efectuate asupra dimensiunii populaţiei au arătat

că algoritmii cu dimensiunea variabilă a populaţiei dau rezultate destul
de bune. Numărul indivizilor de la generaţia t , notat PopSize(t ) ,
va fi influenţat de cel de la generaţia anterioară
PopSize t  1  PopSize t   AuxPopSize t   D t  ,

unde AuxPopSize reprezintă populaţia intermediară care apare în

pasul de recombinare iar D t  reprezintă numărul de indivizi ce nu
vor supravieţui în generaţia următoare.
Dimensiunea populaţiei intermediare se calculează cu formula
AuxPopSize t   PopSize t    ,

unde  este un parametru al algoritmului, numit rată de reproducere.

Toti indivizii unei generaţii au aceeaşi probabilitate de a fi selectaţi
pentru reproducere.
 53
Deoarece fitnessul nu influenţeaza selecţia, vor fi folosiţi alţi
parametri: VÂRSTA şi VIAŢ A . VÂRSTA reprezintă numărul de
generaţii în care un individ a supravieţuit iar VIAŢ A se atribuie o
singură dată unui individ, după iniţializare sau după recombinare şi
păstrează o valoare constantă. Un individ este menţinut în populaţie
atâta timp cât VÂRSTA nu depăşeşte VIAŢ A .

Structura algoritmului AG-DVP (Algoritm Genetic cu

Dimensiunea Variabila a Populaţiei) este următoarea.

algoritmul AG-DVP
begin
t : 0
iniţializează P (t )
evaluează P (t )
while not (condiţie-terminare) do
begin
t : t  1
VÂRSTA : VÂRSTA  1 pentru fiecare individ din
populaţie
recombină P (t )
elimină din P (t ) toţi indivizii pentru care
VÂRSTA  VIAŢ A

evaluează P (t )
end
end
54
Parametrul VIAŢ A depinde de starea curentă a căutării genetice;
pentru aceasta se utilizeaza următorii parametri:
• AvgFit = media fitness-ului populaţiei curente
• MaxFit = valoarea maximă a fitnessului în generaţia curentă
• MinFit = valoarea minimă a fitnessului în generaţia curentă
• AbsFitMax şi AbsFitMin = valoarea maximă şi respectiv
minimă a fitnessului, obţinută până în momentul curent.

Pentru un individ i , viaţa lui VIAŢ A(i ) poate fi definită în

mai multe feluri:
• alocare proporţională:
 fitness i  
VIAŢ A i   min MinLT   , MaxLT 
 AvgFit 
• alocare liniară
fitness  i   AbsFitMin
VIAŢ A i   MinLT  2
AbsFitMax  AbsFitMin
• alocare biliniară

 fitness  i   MinFit
MinLT   AvgFit  MinFit

 dacă AvgFit  fitness  i 
1 fitness  i   AvgFit

VIAŢ A i     MinLT  MaxLT   
2 MaxFit  AvgFit


 dacă AvgFit  fitness  i 

 55
unde MaxLT şi MinLT reprezintă valoarea maximă şi respectiv
minimă a parametrului VIAŢ A iar
1
  MaxLT  MinLT  .
2

Algoritmul se poate opri când nu se mai obţin ameliorări ale

celei mai bune valori într-un număr precizat de iteraţii.

7.7. Algoritmi cu constrângeri

Există mai multe modalităţi de a mânui constrângerile:

1) rezolvarea problemei făcând abstracţie de constrângeri şi
eliminarea, apoi, a soluţiilor care nu verifică constrângerile. Aceste
soluţii vor determina o penalizare a funcţiei de evaluare; cea mai
simplă formă de penalizare constă în eliminarea soluţiilor
nerealizabile
2) utilizarea unor metode de „reparare” a soluţiei nerealizabile
dar, uneori, aceste metode sunt la fel de dificile ca şi rezolvarea
problemei
3) utilizarea unor metode de codificare care să garanteze sau să
mărească foarte mult şansele de obţinere a unor soluţii realizabile.

Exemplificăm rezolvarea unor astfel de probleme considerând

problema rucsacului [55]: „fiind date ponderile W  i  , profiturile
56
P i  şi capacitatea C, să se găsească vectorul binar
x   x1, , x n  astfel încât
n
 x i  W  i   C
i 1

şi
n
P  x    x i   P i 
i 1

are valoarea maximă.”

Trei tipuri de algoritmi sunt frecvent utilizaţi: algoritmi bazaţi pe
funcţii de penalizare ( A p [i ] ), algoritmi bazaţi pe metode de reparare
( Ar [i ] ) şi algoritmi bazaţi pe decodificare ( Ad [i ] ), unde i este
indicele unui algoritm particular din clasa respectivă.

Algoritmii A p [i ]
În cadrul acestor algoritmi soluţia este reprezentată printr-un şir
binar de lungime n . Funcţia de evaluare a unui şir x este
n
eval ( x )   x i   P i   Pen x 
i 1

unde functia de penalizare Pen(x ) are valoarea zero pentru soluţiile

realizabile x , adică pentru soluţiile care satisfac relaţia
n
 x i   W  i   C ,
i 1

si este mai mare ca zero în caz contrar.

 57
Sunt mai multe posibilităţi de definire a funcţiei de penalizare;
vom prezenta trei metode:


• metoda logaritmică A p 1 : 
  n 
Pen x   log 2 1     x i  W  i   C  
 
  i 1 


• metoda liniară A p  2 : 
 n 
Pen x      x i   W  i   C 
 i 1 


• metoda pătratică A p  3 : 
2
 n 
Pen x      x i   W  i   C 
2

 i 1 
În toate cazurile,
 P i  
  max  .
i 1, n W  i  

8
STRATEGII EVOLUTIVE
58

8.1 Generalităţi

Strategiile evolutive (SE) au apărut din necesitatea de a

rezolva probleme de optimizare de tipul: “se cere x*  D  R n cu
 
f x*  f  x  x  D , unde f : D  Rn  R si D este o regiune
mărginită determinată de restricţiile impuse asupra lui x ”. Pentru o
astfel de problemă strategiile evolutive sunt mai potrivite decât
algoritmii genetici, deoarece nu necesită codificarea binară a datelor
care are dezavantajul că limitează precizia. Strategiile evolutive
reprezintă indivizii sub forma unor vectori cu componente reale şi
folosesc mutaţia ca principal operator de evoluţie.
În strategiile evolutive avansate reprezentarea indivizilor
încorporează în ea şi parametrii de control ai strategiei. Un individ se
reprezintă ca o pereche v   x,   , unde vectorul x este un element
din spaţiul de căutare iar  2 este vectorul dispersie;  i2 reprezintă
dispersia perturbaţiei pe care o suferă componenta xi a vectorului x
în procesul de mutaţie. Vectorul  reprezintă parametrul de control al
strategiei.

8.2 Operatori de evoluţie

8.2.1 Incrucişarea
 59
Operatorul de încrucişare selectează, cu o probabilitate
uniformă, cei p părinţi. Cel mai des se utilizează cazurile p  2 şi
p   . Datorită similarităţii dintre reprezentarea indivizilor în
strategii evolutive şi în algoritmi genetici, există similaritate şi între
tipurile de încrucişare.

8.2.1.1 Încrucişarea discretă

În cazul p  2 fie x1 şi x 2 părinţii selectaţi aleator;

pentru
fiecare componentă i   1, 2,  , n se generează un număr aleator
qi   0, 1 , urmând distribuţia uniformă. Componenta yi a
descendentului va fi

x1i dacă qi  0.5

yi  
xi2 dacă qi  0.5
În cazul când se încrucişează p părinţi  x , ,  x  , componenta
1 p

yi a descendentului y este componenta xi a părintelui x

 x , ,  x  ales aleator.
1 p

8.2.1.2 Încrucişarea intermediară

În acest caz componenta yi a descendentului y este o

60
combinaţie convexă a componentelor corespunzătoare din cei p
părinţi x1 ,  , x p , aleşi aleator:
p
yi    j xij i  1, 2,  , n
j 1

şi
p
j  1, j  0.
j 1

În general se lucrează cu doi părinţi x1 , x 2 :

yi  x1i  1    xi2 , i   1, 2,  , n

cu    0, 1 ales ca fiind valoarea unei variabile aleatoare cu

distribuţie uniformă şi păstrând aceeaşi valoare pentru toate
componentele.

8.2.2. Mutaţia

Mutaţia este cel mai important operator al strategiilor evolutive.

Individul  x,   se transformă prin mutaţie în  x' ,  ' :

 x' ,  '  mut  x,   .

Vectorul x ' se obţine după legea
x'  x    N  0, 1

sau, pe componente,

x 'i  xi   'i N i  0, 1 , i   1, 2,  , n
 61
unde N i  0, 1 este o variabilă aleatoare de medie 0 şi dispersie 1.

Mutaţia asupra lui  acţionează diferit, după cum   1 sau

  1 în modelele   ,   şi    .

8.3. Funcţionarea strategiilor evolutive

Structura generală a unei strategii evolutive este cea a unui

algoritm evolutiv, apărând, în funcţie de strategie, unele diferenţe la
nivelul operatorilor.

8.3.1 Strategia (1  1)

Modelul iniţial al lui Rechenberg consideră populaţia formată

dintr-un singur individ supus operatorului de mutaţie. Folosim
următoarele notaţii:

• k = un număr de generaţii consecutive; de obicei se ia k  10n ,

unde n este dimensiunea spaţiului de căutare
• s (k ) = numărul mutaţiilor de succes din ultimele k
generaţii
consecutive

s(k )
• p(k )  = frecvenţa mutaţiilor de succes din ultimele
k
k
62
generaţii

• C= constantă, aleasă (la sugestia lui Schwefel [75]) ca fiind 0.817,

această valoare fiind obţinută pentru modelul sferei.

Algoritmul SE(1+1)
begin
t : 1 , P (t )   x (t ),  (t )
evaluează f (x)
while not cond ( P (t )) do
begin
calculează p (k )
calculează

  t  1
nc dacă p ( k ) 
5

 1
  t  1  mut  t     t  dacă p(k ) 
 5
 n 1
  t   c dacă p k  
 5
calculează
x t  1  mut  x t    x t     t  1  N  0, 1
evaluează f  x t  1 
if f  x t  1   f  x t   {selecţia}
 63
then P t  1   x t  1 ,   t  1
else P (t  1) : P (t )
t : t  1
end
end

Observaţii.
1) cond ( P (t )) reprezintă condiţia de oprire, dată de obicei
prin
numărul de generaţii
2) Schwefel a propus [68] o altă versiune a mutaţiei pentru
parametrul 
  t  1
c dacă p ( k ) 
5

 1
  t  n    t  dacă p(k ) 
 5
 1
c   t  dacă p k   5

3) Strategia (1+1) lucrează cu populaţii formate dintr-un singur
individ şi nu foloseşte încrucişarea.

8.3.2 Strategia (   1)
64
Strategia (1+1) poate fi generalizată prin mărirea numărului
părinţilor fiecărui descendent şi/sau a numărului descendenţilor unui
părinte. În strategia    1 ,   1 părinţi vor genera un singur
descendent folosind încrucişarea şi mutaţia. Încrucişarea se aplică atât
vectorului de poziţie cât şi dispersiei şi se poate folosi oricare din
operatorii prezentaţi anterior. Mutaţia se aplică urmând principiul
strategiei 1  1 , dar nu există o metodă de control a dispersiei, regula
1
nemaifiind aplicabilă în acest caz. Acest dezavantaj face ca
5
strategia    1 să fie puţin folosită.

8.3.3 Strategii multidescendent

Aceste strategii au apărut din dorinţa de a folosi metode mai

robuste şi mai generale pentru a controla parametrii mutaţiei. Din
această categorie fac parte strategiile      şi   ,   care lucrează
cu populaţii formate din   1 părinţi şi    descendenţi, ceea ce
determină o creştere a vitezei de convergenţă. Cei  indivizi ai noii
generaţii se selectează din :
• populaţia intermediară obţinută reunind cei  indivizi ai
generaţiei curente cu cei  descendenţi ai ei, în cazul strategiei
  
• din cei  descendenţi ai populaţiei curente, în cazul strategiei
 ,   .
 65

Încrucişarea. În mod empiric, s-a ajuns la concluzia că

folosirea încrucişării discrete pentru vectorii de poziţie şi a celei
convexe pentru parametrii strategiei conduce la cele mai bune
rezultate. Operatorul de încrucişare se aplică de  ori populaţiei de
 părinţi, obţinându-se o populaţie intermediară de    indivizi.
Un descendent se obţine prin încrucişarea a p părinţi, 1  p   ; de
obicei se ia p  2 sau p   .

Mutaţia. Considerăm indivizii reprezentaţi prin perechi de

forma  x,   , unde x  R n este vectorul de poziţie iar  2 este
vectorul dispersie. Notăm cu N  0, 1 un număr aleator ce urmează
distribuţia normală de medie 0 şi dispersie 1. Mutaţia standard
înlocuieşte individul  x,   cu  x' ,  ' obţinut după regulile:

 'i   i e p1 N (0, 1)  p 2 N i (0, 1)

x'i  xi   'i N i  0, 1

cu i   1, 2,  , n . Parametrii p1 şi p2 controlează mărimea

pasului mutaţiei şi respectiv schimbările individuale. Schwefel [73] a
propus pentru aceşti parametri următoarele valori
c1 c2
p1  şi p2 
2n 2 n
unde c1 şi c2 iau de obicei valoarea 1.
66
Se poate lucra cu vectorul dispersie având toate componentele
egale; fie  valoarea lor comună. În acest caz mutaţia funcţionează
după regulile

'  e pN ( 0 ,1 )
x 'i  xi   ' N i  0,1

adică toate componentele vectorului de poziţie se modifică folosind

c
aceeaşi dispersie; parametrul p ia valoarea p  .
n

Strategiile multidimensionale funcţionează după următorul algoritm

begin
t : 0
iniţializează populaţia P (t )
evaluează indivizii din P (t )
while not cond ( P (t )) do
begin
P ' (t ) : încrucişare ( P (t ))

P" (t ) : mutaţie ( P' (t ))

evaluează P" (t )
P (t  1) : selecţie  P" (t )  M 
t : t  1
 67
end
end

Numărul  trebuie să fie mai mare ca 1 iar raportul dintre numărul

descendenţilor şi cel al părinţilor trebuie să fie în favoarea

descendenţilor. Se recomandă un raport   7 şi, în mod frecvent, se

foloseşte strategia 15, 100  .

Condiţia de oprire cond se referă, de obicei, la numărul
maxim
de generaţii dar pot fi luate în consideraţie şi alte criterii, printre care
cele de mai jos:
1) diversitatea populaţiei a scăzut sub o anumită limită, semn că
ne aflăm în vecinătatea unui optim global; diversitatea poate fi
măsurată prin diferenţa calităţilor asociate celui mai bun individ şi
celui mai neperformant.
2) nu se mai obtin îmbunătăţiri semnificative ale funcţiei obiectiv

Mulţimea M poate lua una din valorile:

M  P (t ) pentru strategia     
M   pentru strategia   ,   .
68

9
PROGRAMARE EVOLUTIVĂ
ŞI PROGRAMARE GENETICĂ

Programarea evolutivă şi Programarea genetică lucrează cu

populaţii care nu mai sunt reprezentate prin şiruri binare sau reale, ca
în cazul algoritmilor genetici şi al strategiilor evolutive, ci prin
structuri mai complicate: programe, automate finite, etc. Din punct de
 69
vedere al operatorilor folosiţi, programarea evolutivă este mai
apropiată de strategiile evolutive (foloseste mutaţia ca operator
principal, încrucişarea fiind foarte rar sau deloc folosită) în timp ce
programarea genetică este mai apropiată de algoritmii genetici
(operatorul principal este cel de mutaţie).

9.1. Programare evolutivă

9.1.1. Generalităţi

Programarea evolutivă a fost iniţiată de Fogel [26, 28]cu

scopul de a genera un comportament inteligent pentru un sistem
artificial. Comportamentul inteligent se referă la abilitatea sistemului
de a realiza predicţii asupra mediului informaţional în care se află.
Sistemele sunt modelate prin automate Turing iar mediul
informaţional este reprezentat printr-o succesiune de simboluri de
intrare.

9.1.2. Funcţionarea automatului Turing

Populaţia este formată din   1 indivizi, fiecare fiind un

automat Turing. Să considerăm exemplul din figura următoare.
70

Figura 9.2

Automatul are stările S   A, B, C , alfabetul de intrare I   0, 1 ,

alfabetul de ieşire O   a, b, c . Tranziţia între două stări este data de
funcţia
 : S  I  S O
definită printr-o eticheta de forma i / o care apare pe o latură între
două stări s k şi sl , însemnând că
   s k , i     sl , o  ;
adică dacă maşina este în starea s k şi primeşte la intrare simbolul
i  I atunci ea trece în starea sl şi produce la ieşire simbolul o  O .
Prin acest mecanism, automatul transformă un şir format din
simboluri de intrare ( interpretat ca mediul maşinii) într-un şir format
din simboluri de ieşire. Performanţa automatului în raport cu mediul
poate fi măsurată pe baza capacităţii predictive a ei: se compară
 71
fiecare simbol de ieşire cu următorul simbol de intrare şi se măsoară
valoarea predicţiei cu ajutorul unei funcţii de câştig.

Paradigma programării evolutive a fost implementată de Fogel

lucrând cu o populaţie de   1 părinţi care generează  descendenţi
prin mutaţii asupra fiecărui părinte. Mutaţia a fost implementată ca o
schimbare aleatoare a componentelor automatului; o schimbare se
poate realiza în cinci moduri: schimbarea unui simbol de ieşire,
modificarea unei tranziţii, adăugarea/eliminarea unei stări,
modificarea stării iniţiale.
Pentru fiecare individ al populaţiei se alege uniform şi aleator
unul din cei cinci operatori de mutaţie. Este, însă, posibil ca asupra
aceluiaşi individ să se aplice mai mulţi operatori de mutaţie, numărul
mutaţiilor putând să fie fix sau ales conform unei distribuţii de
probabilitate. După evaluarea descendenţilor se selectează cei mai
buni  indivizi dintre părinţi şi descendenţi; deci se efectuează o
selecţie de tip      .

Fogel nu a folosit încrucişarea, de aceea mulţi cercetători din

domeniul algoritmilor genetici au criticat metoda lui, considerând că
nu e suficient de puternică. Totuşi, rezultatele teoretice şi empirice din
ultimii 30 de ani au arătat că rolul mutaţiei în algoritmi genetici a fost
subestimat iar cel al încrucişării a fost supraestimat [3, 19, 21, 50].

9.1.3. Optimizare folosind programarea

72

evolutivă

Variantele curente de programare evolutivă folosite în

probleme de optimizare cu parametri continui au multe lucruri în
comun cu strategiile evolutive, în special în privinţa reprezentării
indivizilor, a modului de efectuare a mutaţiei şi a autoadaptării
parametrilor.
Initial programarea evolutivă a lucrat cu spaţii mărginite
n
  ui , vi   R n , cu ui  vi .
i 1

Mai târziu domeniul de căutare a fost extins la I  R n , un individ

fiind un vector a  x  I . În [22] se introduce conceptul de
metaprogramare evolutivă, care presupune un mecanism de auto-
adaptare similar celui de la strategii evolutive. Pentru a încorpora
vectorul varianţelor v  Rn , spaţiul indivizilor este extins la

I  R n  Rn . Funcţia de evaluare   a  se obţine din funcţia obiectiv

f (x ) prin scalare la valori pozitive şi, eventual, prin impunerea unor

modificări aleatoare k ale parametrilor; deci  (a)    f  x  , k  ,

unde  este functia de scalare. În cazul programării evolutive
standard mutaţia transformă pe x în x ' , x'  mut 1 ,,  n ,1 ,,  n ( x) ,
după regula

x'i  xi   i N i (0, 1)
 73
 i   i   x    i

unde constantele de proporţionalitate  i şi  i sunt alese în funcţie de

problema de rezolvat; totuşi, de obicei se consideră  i  1 şi  i  0 ,
astfel că mutaţia devine

x 'i  xi   ( x)  N i (0, 1) .

În cazul meta-programării evolutive individul a  ( x, v) se

transformă prin mutaţie în a '  mut (a )  ( x' , v ' ) astfel:

x'i  xi  vi  N i (0, 1)

v'i  vi    vi  N i  0, 1

unde  are rolul de a asigura că v'i primeşte o valoare pozitivă.

Totuşi, dacă varianţa devine negativă sau zero atunci i se atribuie o
valoare mică   0 .

Se consideră că în programarea evolutivă se codifică mai

degrabă specii decât indivizi; şi cum încrucişarea nu acţionează la
nivelul speciilor, programarea evolutivă nu foloseşte acest tip de
operator. După crearea a  descendenţi din  părinţi, prin aplicarea
mutaţiei o singură dată asupra fiecărui părinte, se selectează 
indivizi din mulţimea părinţilor P (t ) reunită cu cea a descendenţilor
P ' (t ) . Se utilizează o variantă stochastică a selecţiei turneu cu
parametrul q 1 care constă în: pentru fiecare individ
a k  P (t )  P ' (t ) se selectează aleator q indivizi din P (t )  P ' (t )

şi se compară evaluarea lor cu cea a lui ak . Numărul

74
wk   0, 1, , q al indivizilor mai puţin performanţi decât a k
constituie scorul lui a k .
Formal, acesta se poate scrie

q 1
wi   

dacă  ai    ai
j 10 altfel
unde indicii  j  1, 2, , 2  sunt valori aleatoare uniforme,
calculate pentru fiecare comparare. După ce se efectuează această
operaţie pentru toţi cei 2  indivizi, ei se ordonează descrescător
după scorul wi , 1  i  2  , şi se aleg cei mai buni  indivizi care
vor forma generaţia următoare P (t  1) . Rezultă următorul algoritm

begin
t : 0
iniţializează P (0) : a1 (0), , a   0   I  ,
unde I  R n  Rn , ai  ( xi , vi ) i  1, , n
evaluează P(0) :  a1 (0), ,  a  0 
unde   a j  0      f  x j  0  , k j 
while ( T  P  t    true ) do
begin
 75
aplică mutaţia: a'i (t ) : mut  ai  t   i  1, ,  
evaluează P ' (t ) : a '1 (t ), , a '   t   calculând
 a'1 (t ), ,  a'  t    cu  a'  t      f  x'  t  , k 
i i i

selectează P (t  1) : turnq  P (t )  P ' (t ) 

t : t  1
end
end

Programarea evolutivă are numeroase aplicaţii, dintre care

amintim: optimizarea numerică continuă, dezvoltarea sistemelor de
clasificare, antrenarea reţelelor neuronale, proiectarea sistemelor de
control ce pot fi modelate prin automate finite, controlul deplasării
roboţilor.

9.2. Programare genetică

Programarea genetică reprezintă o nouă direcţie în cadrul

calculului evolutiv, dezvoltată de către J. Koza [50] în jurul anilor
1990. Programarea genetică este, de fapt, o variantă a algoritmilor
genetici care operează cu populaţii constituite din „structuri de
calcul”, din acest punct de vedere fiind similară programării evolutive.
Structurile care constituie populaţia sunt programe care atunci când
sunt executate sunt soluţii candidat ale problemei. Programarea
76
genetică a fost dezvoltată iniţial cu scopul de a genera automat
programe care să rezolve (aproximativ) anumite probleme.

9.2.1 Reprezentarea indivizilor

În programarea genetică indivizii sunt văzuţi ca arbori de

derivare asociaţi „cuvântului” pe care îl reprezintă în limbajul formal
asociat limbajului de programare utilizat.

Koza a propus ca modalitate de reprezentare scrierea prefixată

a expresiilor, care corespunde parcurgerii în preordine a arborelui de
structură al expresiei. Pentru a simplifica descrierea, considerăm că se
operează cu „programe” care sunt expresii ce conţin operatori
aritmetici, relaţionali şi logici precum şi apeluri ale unor funcţii
matematice. În acest caz, limbajul formal asociat este independent de
context şi fiecărui cuvânt (expresie) i se poate asocia un arbore de
descriere. Nodurile interioare ale arborelui sunt etichetate cu operatori
sau nume de funcţii iar cele terminale sunt etichetate cu nume de
variabile sau constante. De exemplu, expresia max( x  y, x  5  y )
va fi reprezentata prin
 77

Figura 9.3

Mulţimea nodurilor interioare se numeşte mulţimea funcţiilor

F  { f1 , f 2 ,, f n f }; în exemplul nostru

F  {max, , } . Fiecare funcţie

f i  F are aritatea (numărul argumentelor) cel puţin 1. Funcţiile din

F pot fi de diferite tipuri:

• aritmetic: , , , /
• matematic: sin, cos, exp, log
• boolean: AND, OR, NOT
• conditional: if  then  else
• repetitiv: for , while, repeat
78
Mulţimea nodurilor terminale din arborele de derivare se numeşte
muţtimea terminalelor  
T  t1 , t 2 , , t nt ; în exemplul nostru
T   x, y , 5 . Mulţimile F şi T pot fi reunite într-un grup uniform
C  F  T , dacă se consideră că terminalele sunt funcţii de aritate
zero. Pentru ca programarea genetică să funcţioneze eficient,
mulţimile F şi T trebuie să respecte două condiţii:

• cea de închidere, adică fiecare funcţie din F este aptă să accepte

ca argument orice valoare sau tip de dată ce poate fi returnat de orice
funcţie din C ; această proprietate previne erorile din timpul rulării

• cea de suficienţă, care cere ca funcţiile din C să poată exprima

soluţiile problemei, adică cel puţin o soluţie aparţine mulţimii tuturor
compunerilor posibile ale funcţiilor din C .

Există mulţimi pentru care proprietatea de închidere nu este

verificată; de exemplu:
Mulţimea 
C  , , ,x poate fi închisă sau nu, în funcţie
de
domeniul valorilor lui x . Închiderea poate fi forţată prin folosirea
funcţiilor „protejate”. Astfel de funcţii sunt:

x 1 dacă y  0 , operaţie ce va fi notată în continuare cu

•  div

y x y dacă y  0
• x  x .
 79
Suficienţa este garantată numai pentru unele probleme, când
teoria sau alte metode ne spun că o soluţie poate fi obţinută
combinând elementele lui C . De exemplu, logica ne spune că
C   AND, OR , NOT , x, y permite implementarea oricărei funcţii
booleene, deoarece conţine o multime completă de conectori. Dacă
C nu este suficientă, programarea genetică poate doar să dezvolte
programe care să realizeze o aproximare cât mai bună. De exemplu,
mulţimea C   , , , /, x, 0, 1, 2 nu poate să dea decât o
aproximare pentru exp(x) , ştiind că aceasta este o funcţie
trascedentală (nu poate fi aproximată exact cu ajutorul unor expresii
algebrice finite). În acest caz programarea genetică nu poate decât să
realizeze aproximări algebrice finite de tipul
exp( x )  1
exp( x )  1  x
x
exp( x)  1  x 
2
x2 1
exp( x)  1  x   x3
2 1 1 2  2

9.2.2 Populaţia iniţială

Arborii iniţiali sunt generaţi alegând aleator funcţii din C . De

exemplu, pentru C   , , , /, x, y, 0, 1, 2, 3 putem avea
80

Figura 9.4

Dimensiunea şi forma programelor iniţiale sunt controlate

selectând noduri din F şi T , în funcţie de adâncimea lor în arbore.
Arborii pot fi reprezentaţi şi ca liste de liste. De exemplu, pentru
primii doi arbori anteriori avem
 2 x  ,  /   x 3 2 .

Din acest motiv, iniţializarea populaţiei în programarea genetică este

bazată, de obicei, pe proceduri recursive care returneaza liste.
Metoda „full” selectează noduri din F dacă adâncimea lor nu
depăşeşte o valoare maximă si noduri din T în caz contrar. Această
 81
tehnică duce la obţinerea unei populaţii iniţiale cu frunzele la acelaşi
nivel (adâncime).

Figura 9.5

Metoda „grow” selectează noduri din C dacă adâncimea lor

este mai mică dacat o valoare minimă şi din T în caz contrar. Cum
C conţine şi elemente terminale, această metodă produce arbori
iniţiali de diferite forme şi adâncimi, ca în figura 9.6

Figura 9.6
82
Metoda „ramped half and half” combină cele două metode anterioare,
pentru a da o mai mare diversitate populaţiei iniţiale.

Metodele „full” şi „grow” pot fi implementate cu următoarea

procedură recursivă

Generează_expresie( F , T , max_adâncime, metodă)

begin
if max _ adâncime  0
then
begin
selectează tT
inserează t în arbore
end
else
begin
if metoda = full
then selectează f F
else selectează f FT
inserează f în arbore
if f F
then
begin
 83
n : aritatea lui f
for i  1 to n do
generează_expresie( F , T , max_adâncime-1,
metodă)
end
end
end

La apelul

gener ază_expresie  /, yx 210 3,3, ful 

se poate genera expresia
    x 1  2 0   /   y 3  2 x  
care corespunde arborelui următor

Figura 9.7
84
La apelul
genereaza_expresie      1 ,  x y 0 1 2 3 , 3, grow 
se genereaza expresia
   3 x   2  / 1 y   
care corespunde arborelui

Figura 9.8

9.2.3 Operatori de evoluţie

Încrucişarea constă în selectarea aleatoare a punctului de

încrucişare (nod sau arc în arbore) în fiecare părinte şi schimbarea
subarborilor care încep de la punctul de încrucişare. Un exemplu de
încrucişare este dat în figura următoare.
 85

părinţi descendenţi

Figura 9.9

În funcţie de efectul pe care îl are asupra structurii, există trei

variante de mutaţie:
• mutaţia simplă: modifică eticheta unui nod selectat aleator

Figura 9.10
86
• mutaţia de expandare: constă în înlocuirea unui nod terminal cu
un subarbore, construit după aceleaşi reguli dar care nu face parte
neapărat din populaţia curentă, aşa cum se întâmplă în cazul
încrucişării

Figura 9.11

• mutaţia de reducere: constă în înlocuirea unui subarbore cu un nod

terminal

Figura 9.12
 87
În general se poate alege un nod al arborelui şi subarborele
dominat de acel nod este înlocuit cu altul generat aleator. Astfel,
mutaţia poate fi văzută ca încrucişarea cu un arbore generat aleator.

9.2.4 Rularea programelor în Programarea

genetică

În programarea genetică programele sunt reprezentate prin

arbori sau liste; întotdeauna este posibil să transformăm o astfel de
structură într-un cod C, C++, Java, Lisp, etc. Dar, în majoritatea
cazurilor o asemenea operaţie este ineficientă deoarece
• iniţial, majoritatea programelor au un fitness foarte mic şi vor
supravieţui puţine generaţii
• multe programe (bune sau mai puţin bune) vor fi schimbate prin
încrucişare sau mutaţie şi vor trebui recompilate.

O abordare mai bună este de a interpreta programele, în loc de

a le compila. Unele limbaje de programare, cum este Lisp, au deja un
interpretor în mediul de dezvoltare a programelor. Pentru a-l utiliza
trebuie să ne asigurăm că sintaxa este corectă; de exemplu, să utilizăm
paranteze rotunde în locul celor pătrate. Pentru toate celelalte limbaje
de programare este necesară construcţia unui astfel de interpretor. A
interpreta un program înseamnă a-l parcurge în adâncime şi a evalua
toate nodurile începând cu frunzele. Parcurgerea în adâncime permite
88
evaluarea nodurilor numai după ce valorile argumentelor lor sunt
cunoscute. De exemplu,

Figura 9.13

În urma interpretării, valoarea nodului rădăcină este valoarea

programului.

O clasă de probleme în care programarea genetică s-a dovedit

foarte utilă este regresia simbolică. Aceasta este o tehnică folosită
foarte des în interpretarea datelor şi constă în găsirea coeficienţilor
unei funcţii – obţinute ca o combinaţie de funcţii elementare astfel
încât aceasta să aproximeze cât mai bine o funcţie cunoscută prin
valorile ei în puncte date. Termenul „simbolic” semnifică faptul că nu
suntem interesaţi în găsirea parametrilor optimi (numere) ci a
funcţiilor optime (expresii, reprezentări simbolice).
 89
Ca exemplu să găsim expresia simbolică care aproximează cel
mai bine mulţimea de date
  xi , yi      1.0, 0.0 ,   0.9,  0.1629 ,   0.8,  0.2624 , , 1.0, 4.0
care a fost generată folosind funcţia
y  f  x   x  x 2  x 3  x 4 , x    1, 1 .

Parametrii programului genetic sunt

• dimensiunea populaţiei = 1000
• mulţimea funcţiilor =  , , *, log, exp, sin, cos, div
• mulţimea terminalelor =  x
• adâncimea maximă = 4
• metoda de generare a populaţiei iniţiale = full
• număr de generaţii = 50
• probabilitatea de încrucişare = 0.7
• pobabilitatea de mutaţie = 0

• funcţia fitness =  yi  eval  prog , xi 

i

Câteva din programele optime obţinute la diverse generaţii sunt:

• la generatia 1
[+ [- [log [exp x] ] [+ [sin x] [- x x] ] ] [+ [exp [log x] ] [sin [log
x] ] ] ]
cu fitnessul -8.2098
• la generaţia 2
[* [+ [+ [+ x x] [div x x] ] x ] [log [exp [* x x] ] ] ]
cu fitnessul -7.0476
• la generaţia 3
90
[* [log [- [sin x] [exp x] ] ] [+ [cos [* x x] ] [+ [+ x x] [cos x] ] ] ]
cu fitnessul -4.74338
• la generaţia 6
[* [+ [+ [+ x [exp [log x] ] ] [div x x] ] x ] [log [exp x] ] ]
cu fitnessul -2.6334
Se observă că fitnessul descreşte, ceea ce înseamnă că programul
tinde spre găsirea combinaţiei optime de funcţii; de exemplu, la
iteraţia 26 se obţine fitnessul -0.841868.