Beruflich Dokumente
Kultur Dokumente
Réseaux
de Neurones
Artificiels
Le système nerveux central est constitué de cellules nerveuses et de gliales (seconds
composants du tissu nerveux assurant plusieurs fonctions dont le soutien et la nutrition des
neurones). Notre cerveau contient environ 100 milliards de neurones, dont chacun
communique avec 10 000 autres de ses voisins.
Neurone biologique
• La synapse désigne une zone de
contact fonctionnelle qui s'établit entre
deux neurones, ou entre un neurone et une
autre cellule (cellules musculaires,
récepteurs sensoriels).
• Au niveau biologique, les synapses n’ont pas
toutes la même valeur (les connexions entre
les neurones étant plus ou moins fortes)
Chaque cellule nerveuse possède un corps cellulaire qui abrite le noyau et des prolongements.
Un seul prolongement est centrifuge : l'axone. Plusieurs prolongements peuvent être
centripètes : les dendrites. Au niveau des synapses les neurones établissent des connexions
entre eux. Ce sont surtout les synapses qui conditionnent le sens de l'influx. Les neurones
forment des circuits complexes, essentiels au fonctionnement du système nerveux.
Neurone biologique
Jonction entre
deux neurones
1. Mitochondrie
2. Vésicule synaptique avec des neurotransmetteurs
3. Autorécepteur
4. Fente synaptique avec neurotransmetteur libéré
5. Récepteurs postsynaptiques activés par neurotransmetteur
6. Canal calcium
7. Exocytose d'une vésicule
8. Neurotransmetteur recapturé
Dans une synapse électrique, les membranes plasmiques des cellules pré- et postsynaptiques
sont réunies par des connexions. Le flux d'ions à travers les tunnels permet à l'influx électrique
de passer directement d'une cellule à l'autre.
1. Axone
2. Jonction
3. Fibre
musculaire
4. Myofibrille 1. Élément pré-synaptique
2. Sarcoplasme
3. Vésicules synaptiques
4. Récepteur cholinergique nicotinique
5. Mitochondrie
Le neurone reçoit, traite des informations et produit un signal qu'il conduit et transmet. Chaque
neurone est unique, n'étant ni équivalent au neurone voisin, ni interchangeable. Son originalité
tient à sa position particulière dans le système nerveux et à ses connexions déterminées avec
d'autres neurones ou avec la périphérie. De plus, la cellule nerveuse mature ne se divise pas
(notion classique) et le stock total de neurones est déterminé très tôt dans la vie d'un individu.
La cellule nerveuse est constituée d'un corps cellulaire (péricaryon) contenant le noyau, et de
prolongements cytoplasmiques qui constituent les dendrites et l'axone.
Les dendrites sont des prolongements courts conduisant l'influx nerveux vers le corps
cellulaire. Leur distribution dans l'espace définit le champ des influences auxquelles le
neurone est soumis.
L'axone est un prolongement unique. Son cône
d'implantation est une région privilégiée où nait
l'influx nerveux, c'est-à-dire l'activité intégrée du
neurone modifiée par l'environnement. L'axone
est une structure qui conduit vers d'autres
neurones ou cellules effectrices, à partir du corps
cellulaire, cet influx nerveux.
La synapse est une zone particulière de
juxtaposition des membranes plasmiques, dont l'une au moins appartient à un neurone.
Ces zones de différenciations sont destinées à la transmission unidirectionnelle de
l'influx nerveux d'une cellule à l'autre.
Chaque neurone possède en son noyau un additionneur qui somme les impulsions électriques
amplifiées par les synapses à l'entrée dans le neurone et un seuil de stimulation. Si l'excitation
totale du neurone excède le seuil de stimulation, le noyau initie une impulsion.
Neurone formel
• Un neurone formel est une représentation mathématique
et informatique du neurone biologique.
• Il reproduit certaines caractéristiques biologiques, en
particulier les dendrites, axone et synapses, au moyen de
fonctions et de valeurs numériques.
corps cellulaire
dendrites seuillage
axone
sommation
Neurone formel
• Chaque neurone reçoit un nombre de signaux xi
• Des poids réels wi sont utilisés pour décrire la force de la connexion.
• Le niveau d’activation ∑wixi détermine la force cumulative des signaux
d’entrée .
• Une fonction de transfert calcul l’état final de la sortie.
∑ƒ
Un "neurone formel" (ou simplement "neurone") est une fonction algébrique non linéaire et
bornée, dont la valeur dépend de paramètres appelés coefficients ou poids. Les variables de
cette fonction sont habituellement appelées "entrées" du neurone, et la valeur de la fonction
est appelée sa "sortie".
Un neurone est donc avant tout un opérateur mathématique, dont on peut calculer la valeur
numérique. une représentation graphique du neurone formel est indiqué sur la figure.
Les intrants pondérés par un poids (weight) et sommés, sont ensuite comparés à un seuil
d’activation et passés dans la fonction de transfert du neurone, qui produit l’extrant (output)
désiré.
Neurone formel/Biologique
La structure d’un neurone artificiel est en fait copiée sur la structure des neurones biologiques.
Les principales structures biologiques des neurones ont toutes leur équivalent artificiel. Ceci
est dans le but de reproduire leur fonctionnement de la meilleure façon possible (d’une
manière logique, simple et facilement représentable sur informatique).
Un neurone est une minuscule structure qui traite les influx nerveux qui arrivent (inputs),
chacun selon son importance relative, et qui émet un (et un seul) signal de sortie (output).
Les neurones artificiels reproduisent le même procédé, recevant chaque signal d’entrée
(input) tempéré par un poids (weight). Ces poids sont aussi appelés poids synaptiques, par
analogie.
Exemple numérique
1
1
Le vecteur d’entrée : X= 1
1
1
1
1
S wi xi 1.5 3 0.7 1.3 0.6 1 4.5
1
1
Fonction de transfert
Un réseau de neurones est, comme son nom l’indique, un ensemble de neurones en réseau, de
sorte que les signaux sortant (outputs) des neurones deviennent des signaux entrant (inputs) dans
d’autres neurones. L’architecture générale des réseaux de neurones consiste en la représentation
des neurones en couches (layers) successives, la première représentant la couche d’intrants (input
layer), la dernière étant la couche de sortie (output layer), les couches intermédiaires étant les
couches cachées (hidden layers) du réseau. Les neurones de la couche d’intrants ne sont pas
vraiment des neurones traitants (computing neurons), mais ont pour seule utilité de normaliser
l’entrée des signaux ainsi que la distribution des signaux intrants.
Réseau de neurones
• Chaque réseau de neurone est caractérisé par des propriétés globales
tel que : topologie du réseau, technique d’encodage et algorithme
d’apprentissage .
Les connexions entre les neurones qui composent le réseau décrivent la topologie du modèle.
L'apprentissage est une phase du développement d'un réseau de neurones durant laquelle le
comportement du réseau est modifié jusqu'à l'obtention du comportement désiré.
Algorithme d’apprentissage
On distingue deux grandes classes d’algorithmes
d’apprentissage :
– L’apprentissage supervisé
– L’apprentissage non supervisé
erreur
L'apprentissage "supervisé", consiste à calculer les coefficients de telle manière que les sorties
du réseau de neurones soient, pour les exemples utilisés lors de l'apprentissage, aussi proches
que possibles des sorties "désirées",
A l'issu de l'apprentissage, les poids sont fixés : c'est alors la phase d'utilisation.
Algorithme d’apprentissage
On distingue deux grandes classes d’algorithmes
d’apprentissage :
– L’apprentissage supervisé
– L’apprentissage non supervisé
Il existe également des réseaux de neurones qui s’entraînent sans besoin de supervision, c’est-à-
dire, sans que l’on ait besoin de signifier au réseau comment il doit (devrait) se comporter. Ces
réseaux, habituellement, sont toujours en train de s’entraîner.
La loi de Hebb (1949) s'applique aux connexions entre neurones, comme le représente la figure ci-
dessus.
La loi de Hebb peut être modélisée par les équations suivantes :
wij(t+1) = wij(t) +wij(t) (w(t+1) est le nouveau poids, wij(t) est l'ancien)
wij(t) = µ sortiei . sortiej (la coactivité est modélisée comme le produit des deux
valeurs d'activation)
L'algorithme d'apprentisage modifie de façon itérative (petit à petit) les poids pour
adapter la réponse obtenue à la réponse désirée. Il s'agit en fait de modifier les poids
lorsqu'il y a erreur seulement.
la règle de Widrow-Hoff ne modifie pas les poids pour les cas suivants:
– si la sortie est correcte (Dj=OUTj)
– pour les composants nuls de l'entrée (Xi=0)
La règle de Hebb ne s'applique pas dans certain cas. Un autre algorithme d'apprentissage a donc été
proposé, qui tient compte de l'erreur observée en sortie.
Si la sortie « a » du Perceptron est différente de la sortie désirée « d » pour cet exemple d'entrée alors
modification des poids: wi(t+1) = wi(t) + µ.((d - ai).xi)
Algorithme d’apprentissage
retropropagation de l’erreur
1 Calcul activations S j w ji ai 2 Calcul activations
S k wkj a j
i j
a j f S j
unités cachées unités de sortie
a k f S k
Calcul Erreur 3
Unités Unités Unités entre
d’entrée xi cachées aj de sortie yk sorties désirées
et d k Sortie désirée
sorties obtenues
ai xi ak y k
x1
aj
ek
ak ek d k ak
x2 Sortie obtenue
Calcul de l'erreur 4
xn0 sur les unités de sortie
k ek . f S k
i=1..n0 j=1..n1 k=1..n2
Calcul de l'erreur 5
w ji j ai wkj k a j sur les unités cachées
Principe d’apprentissage :
- Initialisation des poids à des valeurs aléatoires
- Présentation d’un exemple
- Propagation des signaux dans le réseau
- Calcul des erreurs et propagation en sens rétrograde
- Modification des poids de connexions
Perceptron simple
Modèle:
Vecteur d’entrée :
Calcul de la somme:
Calcul de la sortie :
Le perceptron est l’un des réseaux de neurones les plus utilisés pour des problèmes
d’approximation, de classification et de prédiction.
Composition :
p1, p2 , …, pR entrées du neurone.
Un système de trois poids liées à ces entrées.
Un biais b, assimilable à une troisième entré, mais variable.
Une fonction de transfert (ici nous utiliserons la fonction seuil)
Une seule sortie a=f(n)
Perceptron simple
Modèle avec fonction seuil:
Vecteur de sortie:
+1 si ni ≥1
ai =
0 si autrement
Malgré sa relative simplicité, la règle du perceptron s’avère très puissante. Elle converge
toujours vers une solution en un nombre fini d’itérations, mais il importe cependant de
connaître les hypothèses sous-jacentes à cette preuve : `
1. Le problème doit être linéairement séparable ; ´
2. Les poids ne sont mis a jour que lorsqu’un stimulus d’entrée est classé
incorrectement ; ´
3. Il existe une borne supérieure sur la norme des vecteurs de poids. ´
Classification des données linéairement séparables à l’aide d’un
TP1
perceptron :
DESCRIPTION DU PROBLÈME:
Deux groupes de données, appartenant à deux classes, sont définies dans un espace
d'entrée en 2 dimensions. Les classes sont linéairement séparables. La tâche consiste à
construire un Perceptron pour la classification de ces données.
Voici les commandes MATLAB pour créer ces deux classes et les tracer
graphiquement :
N = 20; % nombre d’exemples pour chaque classe
offset = 5; % décalage de la deuxième classe
x = [randn(2,N) randn(2,N)+offset]; % entrées (les deux classes)
y = [zeros(1,N) ones(1,N)]; % sorties (des 0 pour C1 et des 1 pour C2)
% tracé graphique des deux classes :
figure(1)
plotpv(x,y);
Travail demandé :
Créer un perceptron simple permettant de classifier les données.
Faire un apprentissage pour calibrer les poids
Afficher une vue du neurone et les valeurs des poids calibrés
Tracer la droite de séparation des deux classes vérifiant l’équation :
DESCRIPTION DU PROBLÈME:
On souhaite maintenant classer un groupe de données séparables en 4 catégories.
Travail demandé :
Créer un réseau Perceptron avec 2 entrées et 2 sorties pour classer les vecteurs
d'entrée en 4 catégories :
- Préparer les données d’entrée (vecteur P) et de sortie (vecteur T) du perceptron
- Faire un apprentissage du perceptron
- Tracer les lignes de classification
- Essayer le perceptron pour plusieurs entrées (par exemple : p = [0.7; 1.2])
TP3 Fonctions logiques à l’aide d’un perceptron
Travail demandé :
1. Fonction AND :
Créer un perceptron simple
Initialiser les poids à la valeur 1.
Faire un apprentissage pour la fonction logique AND
Afficher les nouveaux poids
Tester le perceptron pour un jeu d’entrées booléennes.
2. Fonction OR :
Refaire les mêmes étapes précédentes pour la fonction logique OR.
3. Fonction XOR :
On donne maintenant la table de vérité de la fonction logique XOR :
N° X1 X2 X3 Y
1 4949 7409 43500 16793
2 5369 7903 20209 22455
3 6149 9289 47640 25900
4 6655 9914 34563 25591
5 8114 8193 36581 34396
6 8447 8711 52206 38676
7 10472 9453 76788 34608
8 10508 9194 42107 35271
9 11534 10149 78902 39132
10 12719 10403 73284 46594
11 13743 10806 61871 57023
12 16168 11557 85265 59720
13 16035 11092 28585 62805
14 16112 10979 26921 61905
15 18861 12117 94457 65963
16 19270 11319 17489 72869
17 21536 12702 99820 71963
18 20783 12419 40152 74915
19 21917 13265 65490 81030
20 20878 13173 37639 86686
21 21508 13211 19425 97088
22 22261 14070 45300 108739
Travail demandé :
Préparer les données d’entrée et de sorite du MLP
Créer le MLP pour prévoir la demande future par choix de la meilleure architecture
permettant de minimiser l’erreur de prévision :
- Choix du nombre de neurones dans la couche cachée
- Choix des fonctions de transfert
- Evaluer la performance du réseau
Correction des TP
Neurone simple
close all, clear all, clc, format compact
% Neuron weights
w = [4 -2]
% Neuron bias
b = -3
% Activation function
% func = 'tansig'
% func = 'purelin'
% func = 'hardlim'
func = 'logsig'
[p1,p2] = meshgrid(-10:.25:10);
z = feval(func, [p1(:) p2(:)]*w'+b );
z = reshape(z,length(p1),length(p2));
plot3(p1,p2,z)
grid on
xlabel('Input 1')
ylabel('Input 2')
zlabel('Neuron output')
Classification 2 classes
%Define input and output data
close all, clear all, clc, format compact
% number of samples of each class
N = 20;
% define inputs and outputs
offset = 5; % offset for second class
x = [randn(2,N) randn(2,N)+offset]; % inputs
y = [zeros(1,N) ones(1,N)]; % outputs
% Plot input samples with PLOTPV (Plot perceptron input/target vectors)
figure(1)
plotpv(x,y);
Classification 4 classes
close all, clear all, clc, format compact
% number of samples of each class
K = 30;
% define classes
q = .6; % offset of classes
A = [rand(1,K)-q; rand(1,K)+q];
B = [rand(1,K)+q; rand(1,K)+q];
C = [rand(1,K)+q; rand(1,K)-q];
D = [rand(1,K)-q; rand(1,K)-q];
% plot classes
plot(A(1,:),A(2,:),'bs')
hold on
grid on
plot(B(1,:),B(2,:),'r+')
plot(C(1,:),C(2,:),'go')
plot(D(1,:),D(2,:),'m*')
% text labels for classes
text(.5-q,.5+2*q,'Class A')
text(.5+q,.5+2*q,'Class B')
text(.5+q,.5-2*q,'Class C')
text(.5-q,.5-2*q,'Class D')
% define output coding for classes
a = [0 1]';
b = [1 1]';
c = [1 0]';
d = [0 0]';
% % Why this coding doesn't work?
% a = [0 0]';
% b = [1 1]';
% d = [0 1]';
% define inputs (combine samples from all four classes)
P = [A B C D];
% define targets
T = [repmat(a,1,length(A)) repmat(b,1,length(B)) ...
repmat(c,1,length(C)) repmat(d,1,length(D)) ];
plotpv(P,T);
net = perceptron;
E = 1;
net.adaptParam.passes = 1;
linehandle = plotpc(net.IW{1},net.b{1});
n = 0;
while (sse(E) & n<1000)
n = n+1;
[net,Y,E] = adapt(net,P,T);
linehandle = plotpc(net.IW{1},net.b{1},linehandle);
drawnow;
end
% show perceptron structure
view(net);
% For example, classify an input vector of [0.7; 1.2]
p = [0.7; 1.2]
y = net(p)
% compare response with output coding (a,b,c,d)
Le OU logique
x = [0 0 1 1; 0 1 0 1];
t = [0 1 1 1];
net = perceptron;
net = train(net,x,t);
view(net)
y = net(x);
Prévisions et RNA
Modèle causal
close all, clear all, clc, format compact
% Random Seed for Reproducing NFTool results
rand('seed',1.555616964E9)
time=1:22;
plot(time,inputdata2(:,1),'b-s')
% legend({'X1'})
hold on
grid on
plot(time,inputdata2(:,2),'r-+','LineWidth',1)
% legend({'X2'})
plot(time,inputdata2(:,3),'g-o','LineWidth',1)
% legend({'X3'})
plot(time,outputdata(:,1),'r-','LineWidth',2)
% Create Network
% net3 = feedforwardnet(7)
net3=newff(s,t,3,{'tansig','purelin'},'traingd');
% net3=newff(s,t,3,{'tansig','purelin'},'traingda');
% net3=newff(s,t,3,{'tansig','purelin'},'trainlm');
net3.performFcn = 'sse';
[net3,tr3] = train(net3,s,t);
view(net3);
poids=net3.IW{1}
biais=net3.b{1}
% Simulate Network
a3= sim(net3,s);
Yhat3=a3';
plot(time,Yhat3(:,1),'b--','LineWidth',2)
legend({'X1','X2','X3','Y','Sortie RNA'})
Modèle de série temporelle
close all, clear all, clc, format compact
% Random Seed for Reproducing NFTool results
rand('seed',1.555616964E9)
ret.performFcn = 'mae';
[ret,tr] = train(ret,in,d);
% graphical plot
global x;
x=inputUnits+1:L;
global y;
y=sim(ret,in);
[m,b,r] = postreg(y,d);
%inTest=zeros(inputUnits,1);
%inTest=data(1,L-inputUnits+1:L)';
%rezTest=sim(ret,inTest);
%disp('Predicted value:'); disp(rezTest);
time = 1:22;
figure
%plot(time,data,'g:',x,d,'b*',x,y,'y-');
plot(x,d,'g-',x,y,'b-');
legend({'Observed response','Fitted response with Neural Network'},'Location','NW')
xlabel('Observations','fontsize',12,'fontweight','b');
ylabel('Response','fontsize',12,'fontweight','b');
grid on
Série temporelle saisonnière
% Random Seed for Reproducing NFTool results
rand('seed',1.555616964E9)
y = [112 115 145 171 196 204 242 284 315 340 360 417 % Jan
118 126 150 180 196 188 233 277 301 318 342 391 % Feb
132 141 178 193 236 235 267 317 356 362 406 419 % Mar
129 135 163 181 235 227 269 313 348 348 396 461 % Apr
121 125 172 183 229 234 270 318 355 363 420 472 % May
135 149 178 218 243 264 315 374 422 435 472 535 % Jun
148 170 199 230 264 302 364 413 465 491 548 622 % Jul
148 170 199 242 272 293 347 405 467 505 559 606 % Aug
136 158 184 209 237 259 312 355 404 404 463 508 % Sep
119 133 162 191 211 229 274 306 347 359 407 461 % Oct
104 114 146 172 180 203 237 271 305 310 362 390 % Nov
118 140 166 194 201 229 278 306 336 337 405 432 ]; % Dec
% load Inputs and Targets data
% load outputdata.txt;
% data=outputdata';
data=y(:);
inputUnits=12;
hiddenUnits=12;
HN=1;
L=size(data,1);
in=zeros(inputUnits,L-inputUnits);
global d;
d=zeros(1,L-inputUnits);
for i=1:L-inputUnits
in(:,i)=data(i:i+inputUnits-1);
d(i)=data(i+inputUnits);
end
% ret=newff(in,d,[hiddenUnits HN],{'tansig','tansig','purelin'},'trainlm');
% net.performFcn = 'mse';
% ret=newfit(in,d,hiddenUnits,{'tansig','purelin'},'trainlm');
% ret=newfit(in,d,hiddenUnits,{'tansig','purelin'},'traingd');
% ret=newfit(in,d,hiddenUnits,{'tansig','purelin'},'traingda');
% --------------------------------------
ret=newfit(in,d,hiddenUnits,{'stansig','purelin'},'trainlm');
% --------------------------------------
% ret=newfit(in,d,hiddenUnits,{'logsig','purelin'},'trainlm');
% ret=newfit(in,d,hiddenUnits,{'logsig','stansig'},'trainlm');
ret.trainParam.epochs=200;
ret.trainParam.lr=0.2;
ret.trainParam.goal=0.0001;
ret.performFcn = 'sse';
[ret,tr] = train(ret,in,d);
% graphical plot
global x;
x=inputUnits+1:L;
global yhat;
yhat=sim(ret,in);
[m,b,r] = postreg(yhat,d);
%inTest=zeros(inputUnits,1);
%inTest=data(1,L-inputUnits+1:L)';
%rezTest=sim(ret,inTest);
%disp('Predicted value:'); disp(rezTest);
time = 1:22;
figure
%plot(time,data,'g:',x,d,'b*',x,y,'y-');
err=x-yhat;
msepf=mse(err);
ssepf=sse(err);
maepf=mae(err);
plot(x,d,'r-',x,yhat,'b-');
legend({'Observed response','Fitted response with Neural Network'},'Location','NW')
xlabel('Observations','fontsize',12,'fontweight','b');
ylabel('Response','fontsize',12,'fontweight','b');
grid on
L'histoire des algorithmes génétiques remonte à l'année 1960 par John Holland. John Holland étudie les
systèmes évolutifs mais le premier modèle formel des algorithmes
génétiques (the Canonical Genetic Algorithm CGA) a été introduit dans son livre "Adaptation in Natural and
Artificial Systems" publié en 1975.
Les algorithmes génétiques font partie de la famille des algorithmes évolutionnaires. Ils s'inspirent de la nature :
l'individu le mieux adapté à son environnement est celui qui aura le plus de chance à survivre. Ces algorithmes
sont issus de l'évolution naturelle des espèces. A ces notions d'évolution, on ajoute des propriétés
observées en génétique (croisement, mutation, sélection, etc.) D’où le nom d'algorithmes génétiques. Ils
ont suscité l'intérêt de nombreux chercheurs commençant par Holland (J. H. Holland, 1975) , qui a
développé les principes fondamentaux, passant par Goldberg (David Edward Goldberg, 1989) qui les a
utilisé pour résoudre des problèmes d'optimisation. D’autres chercheurs ont poursuivi ces travaux et ont
développé au fur et à mesure l’ensemble des opérateurs et des mécanismes des AGs.
Le principe de base est de partir d’une population de solutions, représentées sous forme de chromosomes.
Ensuite, à chaque itération, des croisements de deux individus-parents issus de la population sont
effectués, en favorisant la sélection des plus prometteurs (fitness).
Le croisement (crossover) de deux individus combine des caractéristiques de ces derniers pour générer un
nouvel individu appelé enfant. Des mutations peuvent intervenir lors de la création d’une progéniture, ceci
permet une diversification évitant une convergence prématurée.
Ensuite, deux modes de gestion de la population peuvent être utilises. Soit chaque itération crée un
nombre d’enfants égal à la taille de la population initiale, et cette dernière est remplacée par la
population-enfant lors de l’itération suivante (gestion générationnelle).
Soit chaque itération ne combine que deux parents, leurs enfants étant alors directement intégrés en
remplaçant d’autres individus dans la population courante (gestion incrémentale).
La boucle est bouclée, et l’on recommence une phase de sélection pour la reproduction, une phase de
mutation, et ainsi de suite. Comme pour les métaheuristiques vues précédemment, un critère d’arrêt permet de
sortir de la boucle, par exemple un certain nombre d’itérations sans amélioration notable de la
performance des individus.
Les opérateurs génétiques fonctionnent au niveau génotypique tandis que le mécanisme de sélection
opère au niveau phénotypique.
En d’autre terme le génotype est la codification d’une solution réalisable potentielle à un problème
d'optimisation pour une fonction objectif f. et le phénotype est la valeur de cette solution.
Le Codage est une étape qui associe à chacun des points de l'espace de recherche (les solutions) une
structure de données. Cette structure généralement a une forte influence sur le succès des algorithmes.
Chaque individu de la population est codé en des gènes (chromosome). Plusieurs types des codages sont
utilisés dans la littérature, mais le meilleur et le plus étudié historiquement est le codage binaire. La
supériorité de ce type de codage est prouvée par Holland (J. H. Holland, 1975) en 1975. Son principe est
donc simplement de coder la solution selon une chaîne de bits qui peuvent prendre les valeurs 0 ou 1.
Un gène ici est un bit d'une solution potentielle à un problème d'optimisation. Un des avantages du
codage binaire est que l’on peut facilement coder toutes sortes d’objets : des réels, des entiers, des valeurs
booléennes, des chaînes de caractères, etc.
Cela nécessite simplement l’usage de fonctions de codage et décodage pour passer d’une représentation à
l’autre. Un autre avantage est que ce type de codage permet de créer des opérateurs de croisement et de
mutation simples (par inversion de bits par exemple).
Son principe est donc simplement de coder la solution selon une chaîne de bits qui peuvent prendre les
valeurs 0 ou 1.
Un gène ici est un bit d'une solution potentielle à un problème d'optimisation. Un des avantages du
codage binaire est que l’on peut facilement coder toutes sortes d’objets : des réels, des entiers, des valeurs
booléennes, des chaînes de caractères, etc.
Cela nécessite simplement l’usage de fonctions de codage et décodage pour passer d’une représentation à
l’autre. Un autre avantage est que ce type de codage permet de créer des opérateurs de croisement et de
mutation simples (par inversion de bits par exemple).
Un principe couramment utilisés pour l'encodage est connu comme le principe du «minimum alphabet »
(J. H. Holland, 1975). Le principe consiste à ce que le plus
petit jeu d’alphabet de gènes qui permet une expression naturelle du problème doit être choisi. Il a été
observé que l'alphabet binaire offre le nombre maximal des schémas par bit de l'information de n'importe
quel codage. Par conséquent l'encodage binaire est l’une des stratégies courantes, bien qu’il existe d'autres
types de techniques de codage comme le codage en valeur entière et le codage en nombre réel qui sont aussi
largement utilisés.
L’utilisation de la notion de population favorise
l’exploration de l’espace de recherche et la
convergence vers les solutions optimales. C'est une
des grandes forces des MOEAs. Toutefois, on
retrouve dans la littérature certaines
stratégies évolutionnaires utilisant un seul individu
(Knowles & Corne, 2000). Un mécanisme de génération de la population initiale est nécessaire pour
faire démarrer l’algorithme. Ce mécanisme doit
être capable de produire une population d'individus
diversifiée qui servira de base pour les générations
futures. Le choix de la population initiale
conditionne fortement la rapidité et l'efficacité de
l'algorithme.
Idéalement, les populations initiales devraient avoir un patrimoine génétique aussi grand que possible afin
d'être en mesure d'explorer l'ensemble de l'espace de
recherche. Tous les allèles différents possibles de chacun devraient être présents dans la population. Pour ce
faire, la population initiale est, dans la plupart des cas, choisis au hasard. Néanmoins, il arrive parfois qu'on ait
recours à une méthode heuristique qui peut être utilisé pour générer une population initiale plus adaptée.
Ainsi, la moyenne de la fonction objectif est déjà élevé au départ et peut donc aider l'algorithme
génétique pour trouver de bonnes solutions plus rapidement au risque de manque de diversité, où l’algorithme
va seulement visiter une petite partie de l'espace de recherche et ne jamais trouver les solutions optimums
globales. Nous pouvons retrouver dans la thèse de (Bourazza, 2006) un chapitre qui illustre un ensemble
simple d’algorithme de génération de populations initiales basé globalement sur des processus aléatoires,
heuristiques et guidés, puis une comparaison de leur influence sur la fonction objectif appliqué à quelque
instances du problème TSP.
La taille de la population dépendra de la complexité du problème. La définition de cette taille de la population
soulève aussi des beaucoup de question. En effet, Plus la population est grande, plus il est facile d'explorer
l'espace de recherche. Cependant, le temps requis par un AG pour converger est O (nlogn) évaluations de
fonction où n est la taille de la population. Nous parlons de convergence de l’AG lorsque tous les
individus se ressemblent assez et donc d'autres améliorations ne peuvent être effectuées que par
mutation. Goldberg a aussi montré que l'efficacité à atteindre un optimum global et éviter les locaux est
largement déterminée par la taille de la population.
Le mécanisme de sélection est l'un des principaux composants de recherche dans les algorithmes
évolutionnaires. Le principe global de sélection des parents est que leur probabilité d’être choisi croit avec
leur fitness. Une telle pression de sélection va conduire la population vers de meilleures solutions. Toutefois,
le pire des individus ne devrait pas être rejeté et ils ont une chance d'être sélectionné. Cela peut conduire à du
matériel génétique utile.
ainsi, d’autres variantes de sélection proportionnelle visent à réduire
la prédominance d'un seul ou un groupe d’individus à très grande fitness ("super individus") par des techniques
d'échantillonnage stochastique (Dumitrescu, Lazzerini, Jain, & Dumitrescu, 2000) .
La sélection roulette favorise une convergence prématurée causée par les super individus à haute valeur
fitness induite par une perte de diversité. En outre, lorsque tous les individus sont tout aussi bon ou
presque, cette stratégie de sélection n'introduit pas une pression suffisante pour sélectionner les meilleurs
candidats.
• Le respect : Un crossover est dit opérateur respectueux si les traits communs dans les deux parents sont
préservées, et dit « assorting » si la distance entre les parents
• La validité: le crossover doit produire des solutions valides au problème considéré. Et ce n’est pas une tâche
facile pour les problèmes d’optimisation avec des contraintes
ou ayant une représentation compliques on
le single-point crossover sélectionne de façon aléatoire un point coupe à l'intérieur d'un chromosome
puis échange les deux parties des chromosomes parents en ce point pour produire deux nouveaux
descendants.
de l’effet sur le phénotype engendré par la perturbation sur le génotype. Notons aussi que les idées utilisées
dans les operateurs de voisinage peuvent très bien être utilisés dans le cadre de l'opérateur de mutation
dans les algorithmes évolutionnaires.
Correction
Fonction : Génération de la population initiale
%% Create the initial population
function pop=init_pop(popsize,npar)
pop(1,:)=[1:npar];
for iz=2:popsize
pop(iz,:)=randperm(npar);
end
function dist=tspfun(pop,dcity)
% global iga x y
C=3;
EF=74;
S=7;
I=5*0.128;
F=162.152;
[Npop,Ncity]=size(pop);
%% cout economique
%% cout ecologique
%% calcul
for ic=1:Npop
dist(ic,1)=0;
for id=1:Ncity
%dist(ic,1)=dist(ic)+dcity(tour(ic,id),tour(ic,id+1)); ¨% distance
%dist(ic,1)=dist(ic)+c1t(1,1)+c3t(1,1)*dcity(tour(ic,id),tour(ic,id+1)) +ro(1,1)*dcity(tour(ic,id),tour(ic,id+1)); %
cout economique + ecologique
end % id
%dist(ic,1)=dist(ic,1)*0.5+0.5*(dist(ic,1)*S*I*F);%CO2=ASIF
%dist(ic,1)=dist(ic,1)*0.8+0.2*(dist(ic,1)*C*EF);%CO2=ASIF
end % ic
Fonction : croisement
function [e1,e2] = ox_2pts_rest_ordre(I,J,N,p1,p2)
%I,J points
%N nbre de cities
%p1.2 parents
e1=zeros(1,N);
e12=zeros(1,N);
e13=zeros(1,N-(J-I+1));
e2=zeros(1,N);
e22=zeros(1,N);
e23=zeros(1,J-I+1);
e1([I:J]) = p1([I:J]);
e2([1:I-1])=p1([1:I-1]);
e2([J+1:size(p1,2)])=p1([J+1:size(p1,2)]);
%P2-E1=E12%%%%%%%%%%%
flag=1;
if p2(c)==p1(cc)
flag=0;
end
end
if flag==1
e12(c)=p2(c);
end
end
%P2-E2=E22%%%%%%%%%%%
flag=1;
if p2(c)==p1(cc)
flag=0;
end
end
if p2(c)==p1(cc)
flag=0;
end
end
if flag==1
e22(c)=p2(c);
end
end
%E13%%%%%%%%%%%%%
cc=1;
for c=1:N
if e12(c)~=0
e13(cc) = e12(c);
cc=cc+1;
end
end
%E23%%%%%%%%%%%%%
cc=1;
for c=1:N
if e22(c)~=0
e23(cc) = e22(c);
cc=cc+1;
end
end
%E1 = E1 FINALE
cc=1;
for c=1:N
if e1(c)==0
e1(c) = e13(cc);
cc=cc+1;
end
end
%E2 = E2 FINALE
cc=1;
for c=1:N
if e2(c)==0
e2(c) = e23(cc);
cc=cc+1;
end
end
end %fct
clc
clear
global iga x y
%____________________________________________________
%% Setup the GA
xy=load('berlin52.tsp');
x=xy(:,2);
y=xy(:,3);
%_______________________________________________________
%_______________________________________________________
%% GA parameters
iga=0;
%% selection function
%pref=[pref 2*ones(1,ceil((keep+1-2)))];
end
%_______________________________________________________
pop=init_pop(popsize,npar);
for ic=1:npar
for id=1:npar
dcity(ic,id)=sqrt((x(ic)-x(id))^2+(y(ic)-y(id))^2);
end % id
end %ic
figure(4);
pclr = ~get(0,'DefaultAxesColor');
imagesc(dcity);
title('Distance Matrix');
varc(1)=var(cost);
%_______________________________________________________
while iga<maxit
%_______________________________________________________
%_______________________________________________________
for ic=1:M
mate1=pop(ma(ic),:);
mate2=pop(pa(ic),:);
indx=2*(ic-1)+1; % starts at one and skips every other one 1 3 5 ...M or M-1
%% MPX=========================
routeInsertionPoints = sort(ceil(npar*rand(1,2)));
I = routeInsertionPoints(1);
J = routeInsertionPoints(2);
[mate1,mate2] = ox_2pts_rest_ordre(I,J,npar,mate1,mate2);
pop(keep+indx,:)=mate1;
pop(keep+indx+1,:)=mate2;
end
cost=feval(ff,pop,dcity);%part=pop; costt=cost;
[cost,ind]=sort(cost);
pop=pop(ind,:);
%_______________________________________________________
%% Mutation + exploration
for kk=1:(popsize-ceil(mutRate*popsize))%
k=randi(3,1,1);
%row1=ceil(rand*(popsize-5)) + 5;
switch k
case 1 % Flip
pop(row1,I:J) = pop(row1,J:-1:I);
case 2 % Swap
case 3 % Slide
otherwise % Do Nothing
end
end
%_______________________________________________________
cost=feval(ff,pop,dcity);
[cost,ind]=sort(cost);
pop=pop(ind,:);
%_______________________________________________________
minc(iga)=min(cost);
meanc(iga)=mean(cost);
varc(iga)=var(cost);
%_______________________________________________________
%% figure
figure(1);
axis square
end %iga
%_______________________________________________________
%------------------------------------------
figure(2);
day=clock;
disp(datestr(datenum(day(1),day(2),day(3),day(4),day(5),day(6)),0))
format short g
disp(['best solution'])
disp([num2str(pop(1,:))])
subplot(3,1,2);
iters=1:maxit;
plot(iters,minc,'-r',iters,meanc,'-b');
xlabel('generation');ylabel('cost');
subplot(3,1,3);
plot(iters,varc,'-g');
legend('variancce Cost') ;
xlabel('generation');ylabel('cost');
subplot(3,1,1);
axis square