Université de Boumerdes M’Hamad Bougara
Faculté des Hydrocarbures et de la Chimie
Compte Rendu
TP 1 : Simulation des ensembles flous
Réalisée par :
AHADOUNE Besma
LALA BOUALI Hadjer
Partie théorique :
La logique floue :
La logique floue est une approche issue d’une théorie mathématique qui a été développée
dans les années 60 par le mathématicien Lotfi Zadeh.
Utilisée aujourd’hui en intelligence artificielle, c’est une méthode de traitement de
l'information, permettant de traiter des informations imprécises ou incertaines.
Contrairement à la logique classique, qui énonce que toute proposition est soit vraie, soit
fausse, la logique floue permet d'exprimer une proposition avec un certain degré de certitude
ou d'incertitude.
La logique floue est donc une méthode de traitement de l’information, capable de représenter
des nuances et des degrés de concordance, en utilisant des valeurs intermédiaires comprises
entre 0 (pas de similitude) et 1 (lorsque la similitude est totale).
Les ensembles flous :
Les ensembles flous (ou parties floues) ont été introduits afin de modéliser la
représentation humaine des connaissances, et ainsi améliorer les performances des
systèmes de décision qui utilisent cette modélisation. Les ensembles flous sont utilisés
soit pour modéliser l'incertitude et l'imprécision, soit pour représenter des informations
précises sous forme lexicale assimilable par un système expert.
La fonction d’appartenance :
Une partie floue A de B est caractérisée par une application de B dans [0,1]. Cette
application, appelée fonction d'appartenance et notée μA représente le degré de validité
de la proposition " x appartient à A " pour chacun des éléments x de B. Si μA(x) = 1,
l'objet x appartient totalement à A, et si μA(x) = 0, il ne lui appartient pas du tout. Pour un
élément x donné, la valeur de la fonction d'appartenance μA(x) est appelée degré
d'appartenance de l'élément x au sous-ensemble A.
Exemples de fonctions d’appartenance :
Les opérations sur les ensembles floues :
Partie pratique :
1- Fonction d’appartenance :
a)
x = 0:0.1:10;
y1=trimf(x,[2 3 4])
subplot(3,2,1);
plot(x,y1)
title('simulation de la fonction triangulur');
grid on;
y2=trapmf(x,[2 3 4 5])
subplot(3,2,2);
plot(x,y2)
title('simulation de la fonction trapezoidal');
grid on;
y3=gaussmf(x,[2 3 4 5])
subplot(3,2,3);
plot(x,y3)
title('simulation de la fonction gaussian');
grid on;
y4=gbellmf(x,[2 3 4 5])
subplot(3,2,4);
plot(x,y4)
title('simulation de la fonction generalized');
grid on;
y5=sigmf(x,[2 3 4 5])
subplot(3,2,5);
plot(x,y5)
title('simulation de la fonction signoidal');
grid on;
b)
x = 0:0.1:10;
y1=zmf(x,[3 6]);
subplot(2,2,1)
plot(x,y1)
y2=smf(x,[3 6]);
subplot(2,2,2)
plot(x,y2)
y3=pimf(x,[1 3 6 9]);
subplot(2,2,3)
plot(x,y3)
Z-Curve : Cette courbe est utilisée pour des situations où un changement abrupt se
produit à un moment précis, par exemple, un événement qui démarre et s'arrête
rapidement.
Pi-Curve : Idéale pour modéliser des processus qui augmentent et diminuent à travers des
seuils, comme l'activation puis la désactivation d'un événement.
S-Curve : Très courante dans la modélisation de transitions progressives, cette courbe est
souvent utilisée pour des phénomènes qui passent progressivement d'un état de faible
activation à un état de pleine activation.
c)
L’analyse de résultats :
Fonction Triangulaire
La fonction triangulaire est l’une des fonctions d’appartenance les plus simples et les plus
utilisées. Elle est définie par trois points : un point inférieur, un sommet et un point supérieur
Complexité computationnelle :
Opérations : Cette fonction nécessite uniquement des opérations arithmétiques simples
(multiplications, soustractions, et comparaisons), ce qui en fait une fonction O(1) en termes
de calcul pour chaque point.
Coût : La fonction triangulaire est très rapide à calculer car elle ne nécessite pas d'opérations
exponentielles complexes.
Avantages :
Extrêmement simple à calculer et à implémenter.
Très efficace pour des systèmes en temps réel ou pour de grands ensembles de données.
Inconvénients :
Peu de flexibilité pour modéliser des transitions douces ou continues, car elle est "brutale" et
donne des transitions abruptes
Fonction Trapézoïdale
La fonction trapézoïdale est similaire à la triangulaire, mais elle permet une phase de
transition plate avant que la valeur ne décroisse.
Complexité computationnelle :
Opérations : Comme la fonction triangulaire, la trapézoïdale repose sur des opérations
arithmétiques simples (comparaisons, soustractions, et multiplications), ce qui fait de cette
fonction également O(1) en termes de calcul.
Coût : Très léger, car elle n'implique pas de calculs exponentiels.
Avantages :
Plus flexible que la fonction triangulaire pour des systèmes nécessitant une phase plate avant
la descente.
Très rapide à évaluer.
Inconvénients :
Comme la fonction triangulaire, elle est limitée dans sa capacité à modéliser des transitions
très douces.
6. Fonction Gaussienne
La fonction gaussienne est une fonction d'appartenance lisse, souvent utilisée pour des
phénomènes qui suivent une distribution normale ou des transitions très progressives
Complexité computationnelle :Opérations : Cette fonction nécessite des opérations de
carrés, des multiplications et des exponentielles. Les calculs d'exponentielles et de carrés
peuvent rendre cette fonction plus coûteuse en termes de calculs, avec une complexité
de O(1) par point, mais avec un coût plus élevé par rapport aux autres fonctions sans
exponentielles.
Avantages :
Très lisse et continue, idéale pour modéliser des phénomènes naturels ou des processus
physiques.
Flexible pour modéliser des transitions progressives avec une large gamme de configurations
de courbe.
Inconvénients :
Les calculs d'exponentielles peuvent être plus coûteux que pour des fonctions d'appartenance
plus simples.
Plus complexe à implémenter que des fonctions triangulaires ou trapézoïdales.
2- Les opérations sur les ensembles flous :
a)
complement:
A=[0 0.2 0.8 0.7];
CA= 1-A;
disp('ensemble flou A:');
disp(A);
disp('CA:');
disp(CA);
intersection:
A=[0 0.2 0.8 0.7];
B=[1 0.1 0.1 0.7];
int_min=min(A,B);
int_pro=A.*B;
int_max=max(0,A+B-1);
disp('int_min:');
disp(int_min);
disp('int_pro');
disp(int_pro);
disp('int_max:');
disp(int_max);
Union :
A=[0 0.2 0.8 0.7];
B=[1 0.1 0.1 0.7];
uni_max=max(A,B);
uni_pro=A+B-A.*B;
uni_min=min(1,A+B);
disp('uni_min:');
disp(uni_min);
disp('uni_pro');
disp(uni_pro);
disp('uni_max:');
disp(uni_max);
b)
Discutions des résultats :
La T norme MIN est la plus couramment utilisée pour l'intersection dans les ensembles
flous. Si A et B contiennent des degrés d'appartenance plus faibles, l'intersection aura un
degré d'appartenance faible (en prenant la plus petite valeur entre les deux). Si l'un des
ensembles contient des valeurs faibles (proches de zéro), l'intersection aura également des
valeurs faibles, ce qui correspond à l'idée que l'élément appartient moins fortement à
l'intersection.
T-norme produit prend le produit des valeurs correspondantes des ensembles A et B.
Cette norme est plus conservatrice que la min, car elle "réduit" encore plus le degré
d'appartenance, particulièrement lorsque les valeurs des ensembles sont faibles. L'élément doit
appartenir de manière significative à les deux ensembles pour que son degré d'appartenance à
l'intersection soit élevé. Si un des deux ensembles a une valeur faible, cela diminue fortement
l'appartenance de l'élément à l'intersection.
La T-norme max (0, a + b - 1) est utilisée pour représenter une intersection plus "souple".
Elle modélise l'idée que l'élément peut être dans l'intersection si la somme des degrés
d'appartenance dépasse un certain seuil (ici 1), mais en conservant une valeur minimale de
zéro si la somme est inférieure à 1. Si la somme des degrés d'appartenance est faible, le
résultat est proche de zéro.
La S-norme max est l'opération la plus courante pour l'union dans les ensembles flous.
Elle retourne simplement la valeur maximale entre les deux éléments correspondants, ce qui
correspond à l'idée que l'élément peut appartenir à l'union même s’il n'appartient qu'à un seul
des ensembles de manière significative
La S-norme a + b - a * b est une version de l'union qui combine les valeurs de A et B tout
en évitant que la somme dépasse 1. Cette norme modélise l'idée que l'élément peut appartenir
à l'union si au moins un des ensembles a une forte appartenance, mais que l'appartenance
globale est "modérée" par un facteur multiplicatif. Cette norme est plus "souple" que le max,
elle permet une plus grande possibilité de degrés d'appartenance intermédiaires.
La S-norme min (1, a + b) permet de modéliser une union où les résultats sont plafonnés à
1. Si la somme des degrés d'appartenance est supérieure à 1, elle est réduite à 1, mais si la
somme est inférieure à 1, la valeur de l'union reste égale à la somme.
3- Les Relations flous :
Example1 :
Programme :
R=[0.1 0.3 0.5 0.6; 0.3 0.5 0.8 1; 0.2 0.9 0.7 0.1];
S=[0 0.3 ; 0.9 0.8 ; 0.4 0.7 ; 0.2 0.6];
[m,n]=size(R);
[b,p]=size(S);
for i= 1:m
for j=1:p
min_vals=min(R(i,:),S(:,j)');
RoS_max_min(i,j)=max(min_vals);
end
end
for i= 1:m
for j= 1:p
prod_vals=R(i,:).* S(:,j)';
RoS_max_dot(i,j)= max(prod_vals);
end
end
disp('Résultat de la Max-Min');
disp(RoS_max_min);
disp('Résultat de la Max-Dot');
disp(RoS_max_dot);
Résultats :
Discutions des résultats :
a) Composition Max-Min
Principe : Pour chaque élément (x,z), on prend le minimum entre chaque
paire (R(x,y),S(y,z)) pour tous les y, puis on prend le maximum de ces minima.
Effet : Cette technique tend à "réduire" l'importance des éléments faibles dans les relations. Si
un des éléments de R(x,y) ou S(y,z) est faible, cela impacte fortement l'élément composé. En
effet, le minimum entre les deux éléments sera faible si l'un d'eux est faible.
b) Composition Max-Dot
Principe : Pour chaque élément (x,z), on calcule le produit entre chaque
paire (R(x,y),S(y,z)) pour tous les y, puis on prend le maximum de ces produits.
Effet : Le produit accentue l'importance des valeurs fortes dans les relations. Si un des
éléments R(x,y) ou S(y,z) est proche de zéro, le produit sera également faible, ce qui peut
"diminuer" l'impact de cet élément dans la composition. Cependant, si les deux sont forts, le
produit sera plus important que dans la technique Max-Min.
La différence entre les techniques :
Max-Min : Reflète mieux les relations faibles entre les éléments des relations R et S,
et minimise l'impact des valeurs faibles.
Max-Dot : Tends à donner plus d'importance aux relations fortes en accentuant les
produits des valeurs.
Example 2 :
Programme :
R=[0.1 0.8 0.5 0.6 0.7 ;0.8 1 0.4 0 0.2;0 0.1 1 0.5 0.2;0.7 0.5 0.2 1 0.3;
0.2 0.9 0.5 0.3 1]
[n,n]=size(R)
for i= 1:n
for j=1:n
min_vals=min(R(i,:),R(:,j)');
R2_max_min(i,j)=max(min_vals);
end
end
for i= 1:n
for j= 1:n
prod_vals=R(i,:).* R(:,j)';
R2_max_dot(i,j)= max(prod_vals);
end
end
disp('Résultat de la Max-Min de R^2');
disp(RoR_max_min);
disp('Résultat de la Max-Dot de R^2');
disp(RoR_max_dot);
for i= 1:n
for j=1:n
min_vals=min(R2_max_min(i,:),R(:,j)');
R3_max_min(i,j)=max(min_vals);
end
end
for i= 1:n
for j= 1:n
prod_vals=R2_max_dot(i,:).* R(:,j)';
R3_max_dot(i,j)= max(prod_vals);
end
end
disp('Résultat de la Max-Min de R^3');
disp(R3_max_min);
disp('Résultat de la Max-Dot de R^3');
disp(R3_max_dot);
Résultats :
Discutions de Résultats :
R^2 (composition R∘R)
Max-Min : Pour chaque élément de R2, nous calculons le minimum entre les éléments
correspondants de R, puis nous maximisons sur chaque ligne. Cela représente une
"réduction" de l'information dans la relation, et le résultat est une matrice où les
éléments sont le maximum des minima de R.
Max-Dot : Pour chaque élément de R2, nous calculons le produit des éléments
correspondants de R, puis nous maximisons sur chaque ligne. Cela signifie que les
éléments de R2 sont souvent plus forts que ceux de R s'il y a des valeurs proches de 1
dans R.
R^3 (composition R∘R∘R)
Max-Min : Lorsque nous composons R2 avec R, les relations faibles sont à nouveau
réduites, et seules les relations fortes se maintiennent. Cela peut conduire à des
matrices R3 où la concentration des valeurs maximales est encore plus grande.
Max-Dot : Comme dans le cas de R2, la composition avec le produit renforce encore
plus les connexions fortes, rendant les éléments de R3 encore plus importants si les
relations initiales sont fortes
Les résultats obtenus par la composition des relations floues dépendent directement de la
méthode choisie :
Max-Min produit des résultats plus conservateurs, où les relations faibles sont
réduites par la minimisation.
Max-Dot tend à renforcer les connexions fortes par la multiplication des valeurs, et
donc peut amplifier certaines relations dans R2 et R3.
Les puissances successives de la relation, R2 et R3, mettent en lumière l'impact des relations
initiales sur la propagation de l'information à travers les éléments x et z.
Le programme complet de tous le TP :
x = 0:0.1:10;
y1=trimf(x,[2 3 4])
subplot(3,2,1);
plot(x,y1)
title('simulation de la fonction triangulur');
grid on;
y2=trapmf(x,[2 3 4 5])
subplot(3,2,2);
plot(x,y2)
title('simulation de la fonction trapezoidal');
grid on;
y3=gaussmf(x,[2 3 4 5])
subplot(3,2,3);
plot(x,y3)
title('simulation de la fonction gaussian');
grid on;
y4=gbellmf(x,[2 3 4 5])
subplot(3,2,4);
plot(x,y4)
title('simulation de la fonction generalized');
grid on;
y5=sigmf(x,[2 3 4 5])
subplot(3,2,5);
plot(x,y5)
title('simulation de la fonction signoidal');
grid on;
x = 0:0.1:10;
y1=zmf(x,[3 6]);
subplot(2,2,1)
plot(x,y1)
y2=smf(x,[3 6]);
subplot(2,2,2)
plot(x,y2)
y3=pimf(x,[1 3 6 9]);
subplot(2,2,3)
plot(x,y3)
A=[0 0.2 0.8 0.7];
CA= 1-A;
disp('ensemble flou A:');
disp(A);
disp('CA:');
disp(CA);
A=[0 0.2 0.8 0.7];
B=[1 0.1 0.1 0.7];
int_min=min(A,B);
int_pro=A.*B;
int_max=max(0,A+B-1);
disp('int_min:');
disp(int_min);
disp('int_pro');
disp(int_pro);
disp('int_max:');
disp(int_max);
A=[0 0.2 0.8 0.7];
B=[1 0.1 0.1 0.7];
uni_max=max(A,B);
uni_pro=A+B-A.*B;
uni_min=min(1,A+B);
disp('uni_min:');
disp(uni_min);
disp('uni_pro');
disp(uni_pro);
disp('uni_max:');
disp(uni_max);
R=[0.1 0.3 0.5 0.6; 0.3 0.5 0.8 1; 0.2 0.9 0.7 0.1];
S=[0 0.3 ; 0.9 0.8 ; 0.4 0.7 ; 0.2 0.6];
[m,n]=size(R);
[b,p]=size(S);
for i= 1:m
for j=1:p
min_vals=min(R(i,:),S(:,j)');
RoS_max_min(i,j)=max(min_vals);
end
end
for i= 1:m
for j= 1:p
prod_vals=R(i,:).* S(:,j)';
RoS_max_dot(i,j)= max(prod_vals);
end
end
disp('Résultat de la Max-Min');
disp(RoS_max_min);
disp('Résultat de la Max-Dot');
disp(RoS_max_dot);
R=[0.1 0.8 0.5 0.6 0.7;
0.8 1 0.4 0 0.2;
0 0.1 1 0.5 0.2;
0.7 0.5 0.2 1 0.3;
0.2 0.9 0.5 0.3 1]
[n,n]=size(R)
for i= 1:n
for j=1:n
min_vals=min(R(i,:),R(:,j)');
R2_max_min(i,j)=max(min_vals);
end
end
for i= 1:n
for j= 1:n
prod_vals=R(i,:).* R(:,j)';
R2_max_dot(i,j)= max(prod_vals);
end
end
disp('Résultat de la Max-Min de R^2');
disp(RoR_max_min);
disp('Résultat de la Max-Dot de R^2');
disp(RoR_max_dot);
for i= 1:n
for j=1:n
min_vals=min(R2_max_min(i,:),R(:,j)');
R3_max_min(i,j)=max(min_vals);
end
end
for i= 1:n
for j= 1:n
prod_vals=R2_max_dot(i,:).* R(:,j)';
R3_max_dot(i,j)= max(prod_vals);
end
end
disp('Résultat de la Max-Min de R^3');
disp(R3_max_min);
disp('Résultat de la Max-Dot de R^3');
disp(R3_max_dot);
