Eddy Cingala

Algorithme Génétique
introduisant l’âge
des individus

ALGORITHME GENETIQUE
ANNEE 2002-2003
ISTASE 3

1
 UTILISATION DE L’AGE DANS UN ALGORITHME
GENETIQUE

SOMMAIRE

INTRODUCTION

I – OBJECTIFS ET CHOIX de PARAMETRES

II – EXPLICATION DU PROGRAMME

CONCLUSION

Nous construisons un algorithme génétique binaire qui

permet de sélectionner des individus en utilisant l’âge.

2
 INTRODUCTION

Les algorithmes génétiques permettent d’obtenir des réponses à des

problèmes en faisant intervenir des probabilités, du déterminisme et des
choix aléatoires. Cette part d’incertitude dépend de la modélisation que
l’on choisie et du problème. Dans le cas d’une population, une évaluation
de celle-ci et un processus d’évolution (sélection, croisement, mutation)
est nécessaire.

Nous souhaitons modifier une population initiale en prenant en

compte le génotype des individus et leur âge, qui n’a pas de lien direct
avec le génotype.

3
 I – OBJECTIFS ET PARAMETRES

Nous avons une population d’individus, assimilables à des

chromosomes, évolués suivant une fonction unidimensionnelle : la
fonction f_eval.

Nous souhaitons obtenir un ensemble de chromosomes ou individus

qui minimise la fonction d’évaluation f_eval. Celle-ci reste la même
quelque soit la génération et s’applique à tous les chromosomes.

Nous avons Npop chromosomes qui sont codés avec une suite de 0
et de 1 et qui ont tous le même nombre de bits.

Les paramètres et les choix pour les différentes étapes sont les
suivants.

1- Evaluation.

La fonction d’évaluation est une fonction qui dépend de 2

paramètres indépendants. L’évaluation f_eval est la même pour chaque
génération et pour chaque individu.

Le 1er paramètre est evaluation et il dépend uniquement du

génotype de l’individu.
X= [x1 x2]
et

Le 2e paramètres Prob_selec dépend uniquement de l’âge. C’est un

coefficient de probabilité de sélection. Nous choisissons que la probabilité
d’être sélectionné d’un individu augmente avec l’âge. Ainsi, nous
favorisons les individus âgés. L’âge de chaque individu se trouve dans le
tableau age.

4
 Cette probabilité Prob_selec (j) est la probabilité d’être sélectionné.
Elle est égale à l’évaluation de l’individu par la fonction f_eval dans le cas
où le poids de l’âge est de 1.

F_eval est une combinaison de evaluation et de Prob_selec. Nous

choisissons de faire intervenir ces 2 facteurs de la même manière et de
manière linéaire. Ainsi, nous avons des coefficients pondérés. Coeff et (1-
coeff) sont les poids respectifs de evaluation et de Prob_selec dans le
résultat de f_eval(x). Chaque individu de la population est évalué
indépendamment des autres.

F_eval(x) = coeff * evaluation(x) + (1-coeff) * Pc(x)

2- Population initiale.

La population initiale est composé de Npop individus du même âge :

1 an. Ils entrent dans le boucle sélection-croisement-mutation. Les
individus sont codés en binaire. Leurs bits sont groupés tel que le montre
le vecteur bit.

3- Sélection.

Nous sélectionnons les groupes de reproducteurs en fonction de 2

critères :
- leur évaluation par la fonction evaluation,
- leur âge qui se trouve dans un tableau age.
L’influence de l’âge sur la sélection peut se faire de plusieurs
manières. On peut favoriser ou défavoriser les jeunes, les adultes ou les
vieux plus ou moins strictement. La seule contrainte étant que la sélection
ne choisisse pas toujours les mêmes individus. Le type de sélection choisie
s’inspire de la sélection tournoi.

4- Croisement.

Le croisement s’opère en 2 étapes :

- sélection de C couples de reproducteurs qui deviendront parents,
- croisement des parents et formation de 2 enfants par couple.

Chaque couple génère 2 enfants par la méthode de croisement simple.

Nous choisissons un point de croisement pour les 2 parents, et nous

5
formons 2 enfants en échangeant une partie des chromosomes. Les
enfants ont 1 ans à leur création.
Pour ce qui est de l’âge : nous décidons que l’âge des individus intervient
sur la sélection des couples. Nous avons plusieurs possibilités qui s’offrent
à nous. Par contre, nous décidons que l’âge n’intervienne pas sur le
croisement. Le croisement se fait donc de la même manière pour tous les
individus sélectionnés parmi les reproducteurs.
Nous obtenons une population intermédiaire. L’âge des parents est
augmenté de 1. Et celui des enfants est de 1 an.

5- Mutation.

Nous effectuons une mutation sur les individus. Cette mutation

affecte tous les individus de la même manière. Nous pourrions choisir de
faire en sorte qu’elle dépendent de l’âge. Cette mutation consiste à
changer un bit donné pour chaque individu. nous changeons le 0 en 1 et
vice versa pour le point de mutation qui varie d’un individu à l’autre et qui
est choisi des manière aléatoire. On sait que cette mutation n’affecte pas
l’âge des Npop individus.

6- Test de convergence.

Nous effectuons un test de convergence. Nous décidons de prendre

un test de convergence simple. Nous avons un nombre Gmax de
générations totales et la boucle s’arrête quand il est atteint.

6
 II – EXPLICATION DU PROGRAMME

Nous expliquons les différentes étapes de l’algorithme avec le code

commenté.

1- Définition de la fonction d’évaluation.

La fonction d’évaluation est donnée par :

function p=f_eval(x,age,coeff)

% evaluation en fonction du génotype

evaluation =
20+x(1,:).*sin(2*pi*x(1,:)./3)+x(2,:).*sin(4*pi*x(2,:)) ;

% somme des ages de tous les individus

S_age = sum(age);
% probabilité d'être sélectionné qui dépend de l'age
Prob_selec = age./S_age ;

7
k = coeff;

% k coeffcient de l'impact de l'évaluation et de l'age entre 0

et 1
% le résultat p de f_eval dépend des coefficients pondérés k
et (1-k)
p = k * evaluation + (1-k) * Prob_selec ;

2- Définition de la population initiale.

Npop_init est le nombre d’individus ou chromosomes que nous souhaitons

obtenir dans la population initiale et bit est le nombre de bits des
chromosomes.

Génération d'une population :

function x = Gen_Pop_Init(Npop_init, bit)

x = round(rand(Npop_init,sum(bit)));

3- sélection :

% choix des indices de futurs individus parents parmi les

reproducteurs

function [indice_repr] = select_tournoi(pop_ordon, nb_repr,

nb)

indice_repr=[];
% taille est donc le nombre d'individus dans la population
taille = size(pop_ordon,2);
q = zeros(nb,1);

for i= 1:nb_repr
% on affecte à chaque individu un coeffcient aléatoire
for j= 1:nb
q(j) = 1+round(rand(1)*(taille-1));
end
% on trouve l'indice de l'individu qui a la plus petite
valeur
temp = find(pop_ordon==min(pop_ordon(q)));
% on prend la premier indice trouvé, et on retient cet
individu

8
 indice_repr(i) = temp(1);
end

4- Le croisement

Nous choisissons un croisement simple des parents pour obtenir les

enfants.

Croisement simple:

function [enf1, enf2] = crois_s(par1, par2)

enf1=[];
enf2=[];
% taille du chromosome qui est celle du parent
taille = size(par1,2);
% point de croisement aléatoire
point = 1 + round(rand(1)*(size(par1,2)-2));

% les enfants sont générés par croisement simple.

for i = 1 : taille
if i <= point
enf1(i) = par1(i);
enf2(i) = par2(i);
else
enf1(i) = par2(i);
enf2(i) = par1(i);
end
end

5- La mutation. La mutation simple consiste en l’inversion d’un bit

mutation :

% fonction qui effectue la mutation sur l'individu 'ind' et

qui renvoie 'ind_mut', l'individu muté

function ind_mut = mut_s(ind)

a = size(ind,2); % taille du tableau

p = 1+round(rand(1)*(a-2)); % point de mutation

if (ind(p)==0)
ind(p)=1;
else
ind(p)=0;

9
end

ind_mut=ind;

6- Fonction principale

% ********** CREATION D'UN ALOGORITHME GENETIQUE ************

***************** UTILISANT L'AGE DES INDIVIDUS **************

%-------------------------------------------------------------
%
% Les fonctions utilisées sont :
% f_f : conversion d'un individu décimale en binaire
% b_f : conversion d'un individu binaire en décimale
% gen_pop_init : generation de la population initiale
% f_eval : evaluation de la population en fonction des
% génotypes et des ages
% crois_s : fonction qui génère 2 enfants par croisement
% simple
% select_tournoi : fonction de sélection tournoi d'individus
% mut_s : fonction qui effectue une mutation aléatoire
%
% La population est un tableau x de dimensions Npop * 18 car
% les Npop individus sont codés sur 18 bits
% x_dec est population où chaque individu est codé en un
% couple de décimaux : 2 paramètres
%
%
%-------------------------------------------------------------

close all;
clear all;

Npop = 10; %% Nombre d'individus de la Population

Gmax = 20; %% Nombre d'itérations maximale, c'est
aussi le nombre de générations
parcourues
bit = [10 8]; %% Nombre de bits qui codent chacun de
2 paramètres, le chromosome est codé
sur 18 bits
%% bit[a b] signifie que a bits codent
le 1er paramètre et b bits le second
coeff= 0.6; %% k coefficient du poids de

10
 l'évaluation du génotype sur
l'évaluation globale
%% k est entre 0 et 1, (1-k) est donc
le poids de l'âge

prec = [0.01 0.01]; % Précision souhaitée sur chaque

paramètre
pm = 0.05; % Probabilité de mutation
d = [-2 8; 4 6]; % Matrice des limites de variation de
paramètres d
compteur = 1; % Variable qui compte le nombre de
générations parcourues, compteur < Gmax
age=ones(1,Npop); % Vecteur des ages initiaux des Npop
individus

% ------------- création de la population initiale -----------

x = gen_pop_init(Npop, bit)

% ------------ boucle principale de modification -------------

% -------------------- de la population ----------------------

% boucle principal qui effectue les modifications sur la

population

while (compteur < Gmax)

% conversion de x en decimal
x_dec = b_f(d,x,bit);
% evaluation par f des Npop individus et tri
phenotype = f_eval(x_dec,age,coeff);
% invividus classés par ordre
pop_ordon = sort(phenotype);
%tab_eval est le tableau des moyennes des évaluations
tab_eval(compteur) = sum(pop_ordon)/size(pop_ordon,2);
% sélection des Npop/2 meileurs individus
reproducteur = pop_ordon(1:round(Npop/2));

% variable temporaire, tableau d'indices

clear temp_ind ;
% boucle qui parcourt le tableau des meilleurs éléments
triés
for i = 1:size(reproducteur,2)
% individus ayant l'évaluation reproducteur(i)
temp_ind = find( f_eval(x_dec,age,coeff) ==
reproducteur(i));
% ind est le tableau des indices des meilleurs

11
 individus dans x
ind(i) = temp_ind(1);
end

clear tmp;

% matrice des reproducteurs qui contient size(ind,2)

reproducteurs
x = x(ind,:) ;
% matrice des ages associées aux reproducteurs
age = age(ind);

% ------------- sélection des parents potentiels

-------------------------------- parmi les reproducteurs
------------------

% nombre de représentants (parents) souhaités,

% size(ind,2) = nombre de reproducteurs
nb_repr = Npop-size(ind,2);
nb = 2;
% tableau des indices des futurs parents potentiels après la
sélection tournoi
[indice_repr] = select_tournoi(reproducteur, nb_repr, nb);

% ------------ Croisement des individus parents

--------------------------------- pour créer des enfants
-------------------

clear x_dec;
i = 1;

% indice_repr est le tableau des indices des représentants

les parents dans la population x
while i < size(indice_repr,2)

x_dec = b_f(d,x,bit)
% tableau des reproducteurs et des enfants crées dans
cette génération
reproducteur2 = f_eval(x_dec,age,coeff);
% recherche du parent par1
ind_par = find( f_eval(x_dec,age,coeff) ==
reproducteur2(indice_repr(i)));
[par1, bit2] = f_b(d,x_dec(:,ind_par),prec);
% recherche du parent par2
ind_par = find( f_eval(x_dec,age,coeff) ==
reproducteur2(indice_repr(i+1)));
[par2, bit2] = f_b(d,x_dec(:,ind_par),prec);
% création des enfants et mise à jour des tableaux x
(pour la population) et age

12
 [enf1, enf2] = crois_s(par1, par2)
x(size(x,1)+1,:)= enf1;
age(size(age)+1)=1;
x(size(x,1)+1,:)= enf2;
age(size(age)+1)=1;
i = i+2;
end

% --------------- Mutation sur les individus

-------------------------------- de la population
intermédiaire ---------------

% Nombre de couples à générer

couple = round(pm*18*size(x,1));
for i = 1:couple
% id est l'indice de l'individu qui subit la mutation
id = 1+round(rand(1)*(size(x,1)-1));
ind_mut = mut_s(x(id,:));
end

clear ind, ind_par, bit2;

% Compteur du nombre de générations

compteur = compteur+1
end

% ---------------- affichage de la population finale ---------

disp('la matrice représentant la population finale est :');
x,

% ------------ Tracé des Evaluations de la population

-------------------------en fonction de la génération
----------------

plot(tab_eval,'Color','red','LineWidth',2);
title('Evaluation en fonction des générations','color','red');
xlabel('Indice de la Génération','color','blue');
ylabel('Evaluation','color','blue');

7- La fonction B_f et la fonction F_b

/* fonction de conversion du binaire au décimal de l'individu

binaire */

function x_dec = b_f(d,x,bit)

n=1;

13
nb_var= size(d,1);
nb_ex=size(x,1);
for i=1:nb_var
pas=(d(i,2)-d(i,1))/(2^bit(i)-1);
x_dec(i,:)=(d(i,1)+pas*(sum((ones(nb_ex,1)*2.^(bit(i)-1:-
1:0)).*x(:,n:bit(i)+n-1),2)))';
n=n+bit(i);
end

/* fonction de conversion du décimal au binaire de l'individu

binaire */

function [x_bin, bit] = f_b(d,x_dec,p)

x_bin = [];
for i = 1:size(d,1)
if x_dec(i,:)>=d(i,1) & x_dec(i,:)<=d(i,2);
n= 0 ;
nbval = (d(i,2)-d(i,1))/p(i)+1;
if (nbval>=1)
while (nbval>pow2(n))
n=n+1;
end
bit(i)=n;
pas = (d(i,2)-d(i,1))/(2^n-1);
x_dec2(i,:) = (x_dec(i,:)-d(i,1))./pas;
x_bin = [x_bin rem(floor(x_dec2(i,:)' * pow2(1-
bit(i):0)),2)];
else
disp ('erreur sur les dimension de définition');
end
else
disp ('la valeur est extérieure au domaine');

end
end

8- Exemple d’exécution du programme.

Avec la fonction d’évaluation choisie, on a chercher à trouver le

minimum globale de cette dernière tout en évaluant l’âge de la population
.

Parmi le résultats trouvés on trouve l’évolution ci-dessous

concernent la moyenne des individus .

14
 Conclusion

Nous avons réalisé un AG faisant intervenir l’âge des individus. L’âge

n’intervient que dans les phases de sélection mais on pourrait le faire
intervenir dans les phases de mutation et de croisement.

Nous remarquons, au cours de l’exécution du programme, que celui-

ci ne converge par toujours vers une valeur minimale. Ceci est dû au
croisement et à la mutation. En effet, l’A.G. est décomposable en 4
étapes :
- sélection des reproducteurs,
- sélection des parents,
- croisement,
- mutation.

Les 2 premières étapes font intervenir l’évaluation (la fonction

f_eval) et tendent, par le processus de choix des minima, à faire baisser la
somme des évaluations des individus de la population. Mais le croisement

15
(essentiellement) et la mutation ont parfois un effet inverse à celui de la
sélection. Le croisement et la mutation se font de manière aléatoire de tel
sorte qu’ils vont à l’encontre de l’évolution souhaitée : les enfants ont une
évaluation élevée. La mutation peut contribuer à l’augmentation ou la
diminution de l’évaluation par f_eval. Le croisement a plus d’influence car
il agit sur plus de bits.

Ainsi, cet algorithme ne garantit pas la minimisation de l’évaluation.

L’évaluation peut aussi converger vers une valeur qui n’est pas la plus
faible qu’elle aie atteinte : le processus d’évolution est alors bloqué.

Il y a donc l’intervention de phénomènes stochastiques, englobés

dans des règles de fonctionnement de l’algorithme génétique.

16