Blog ENI : Toute la veille numérique !
-25€ dès 75€ sur les livres en ligne, vidéos... avec le code FUSEE25. J'en profite !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. L'Intelligence Artificielle pour les développeurs
  3. Logique floue
Extrait - L'Intelligence Artificielle pour les développeurs Concepts et implémentations en Java (2e édition)
Extraits du livre
L'Intelligence Artificielle pour les développeurs Concepts et implémentations en Java (2e édition) Revenir à la page d'achat du livre

Logique floue

Présentation du chapitre

La logique floue est une technique d’intelligence artificielle déterministe permettant de prendre des décisions. Elle permet ainsi d’avoir un comportement cohérent et reproductible en fonction de règles qui lui sont fournies. L’intelligence de cette technique se trouve dans sa capacité à gérer l’imprécision et à avoir un comportement plus souple qu’un système informatique traditionnel.

Ce chapitre commence par définir la notion d’imprécision, à ne pas confondre avec l’incertitude. Ensuite, les différents concepts sont abordés : les ensembles flous, les fonctions d’appartenance et les différents opérateurs en logique floue.

La partie suivante traite des règles floues et des étapes pour appliquer ces règles à un cas concret et en sortir un résultat utilisable (elles s’appellent respectivement fuzzification et défuzzification).

Le chapitre continue ensuite avec la présentation de différents domaines d’application de la logique floue, que l’on retrouve aujourd’hui de nos lave-linge à nos voitures en passant par les usines.

Enfin, la dernière partie consiste à montrer comment on peut implémenter un moteur de logique floue générique et évolutif...

Incertitude et imprécision

Il est important de différencier deux concepts : l’incertitude et l’imprécision. En effet, chacun va être associé à une technique d’intelligence artificielle différente. 

1. Incertitude et probabilités

L’incertitude, c’est évidemment, le contraire de la certitude. Par exemple, la règle "S’il va pleuvoir, alors je prendrai mon parapluie" est sûre (à 100 %) : se mouiller n’est pas agréable. Au contraire, l’énoncé "Demain, il devrait pleuvoir" est incertain : la météo a peut-être annoncé de la pluie, mais rien ne dit qu’il pleuvra vraiment. On peut dire que la probabilité qu’il pleuve est de 80 % par exemple. Tout énoncé dont la probabilité est différente de 100 % est incertain.

2. Imprécision et subjectivité

Au contraire, l’imprécision se manifeste lorsque l’on manque... de précision ! Dans les faits, cela se traduit par des énoncés qu’il est difficile d’évaluer : ils semblent subjectifs. Par exemple, dans la phrase "S’il fait très chaud, alors je ne mettrai pas de pull", l’imprécision se situe sur la notion de "très chaud".

On est certain...

Ensembles flous et degrés d’appartenance

Si on reprend l’exemple de notre store électrique et de la température, on aimerait définir le terme "chaud". On va donc définir pour quelles températures il fait chaud ou non.

1. Logique booléenne et logique floue

En logique booléenne (la logique classique), une valeur peut seulement être vraie ou fausse. On doit définir une valeur précise qui sert de transition. Pour définir "chaud" pour notre store, cette valeur est 25°. Au-dessus de cette température, "chaud" est vrai, au-dessous, "chaud" est faux. Il n’y a pas de valeurs intermédiaires.

images/02DP01.png

En logique floue, on va utiliser un ensemble flou. Il se différencie de l’ensemble booléen par la présence d’une "phase de transition", durant laquelle la variable se situe entre vrai et faux. Pour la température, entre 20° et 25°, il fait alors plus ou moins chaud.

Au-dessous de 20°C, il ne fait pas chaud, et au-dessus de 25°, il fait chaud à 100 %. Mais à 23°, il ne fait chaud qu’à 60 % (soit 0.6).

images/02DP02.png

2. Fonctions d’appartenance

On voit ainsi qu’en logique booléenne, on ne travaille que sur les termes "vrai" ou "faux". On passe de faux (0 %) à vrai (100 %) à 25°. En logique floue, on rajoute des états intermédiaires : de 20° à 25° on va passer progressivement de faux à vrai. Ainsi, on peut lire sur le graphique que le degré d’appartenance (ou valeur de vérité) à "chaud" pour une température de 23° est de 0.6 soit 60 %. De même, à 24°, il fait "chaud" à 80 %.

La courbe indiquant les degrés d’appartenance est appelée...

Opérateurs sur les ensembles flous

En logique classique, on a trois opérateurs de composition élémentaires : l’union (OU), l’intersection (ET) et la négation (NON). Ces opérateurs sont aussi nécessaires en logique floue, en particulier pour pouvoir composer des valeurs linguistiques (par exemple "frais OU bon") et écrire des règles.

1. Opérateurs booléens

En logique booléenne, ces trois opérateurs peuvent se représenter grâce à des diagrammes de Venn. Dans ceux-ci, les ensembles sont représentés par des cercles.

Ici, on a deux ensembles, A et B, qui se chevauchent en partie :

images/02DP11.png
La négation de l’ensemble A est dite NON A et s’écrit images/eq4.png. Elle représente l’ensemble des valeurs qui n’appartiennent pas à A. Elle est ici représentée par la zone finement hachurée :
images/02DP12.png
L’union de A et B est dite A OU B et se note A images/U.png B. Elle représente l’ensemble des valeurs appartenant à l’un ou l’autre des ensembles. Elle est ici représentée par la zone finement hachurée :
images/02DP13.png
Enfin, l’intersection lue A ET B et notée A images/Uinverse.png B, représente l’ensemble des valeurs appartenant aux deux ensembles en même temps. Elle est ici représentée par la zone finement hachurée commune aux ensembles...

Création de règles

1. Règles en logique booléenne

Dans un système classique, comme le contrôle du store du début de ce chapitre, une règle s’exprime sous la forme :

SI (condition précise) ALORS action 

On a par exemple :

SI (température ≥ 25°) ALORS baisser le store 

On peut aussi concevoir des règles plus complexes. Par exemple, on pourrait prendre en compte l’éclairage extérieur, qui se mesure en lux (car s’il y a du soleil, il faut s’en protéger). Il va de 0 (nuit noire sans étoile ni lune) à plus de 100 000 (éclairage direct du soleil). Un ciel nuageux de jour correspond à un éclairage entre 200 et 25 000 lux environ (selon l’épaisseur de nuages).

Dans notre application de contrôle de store, on pourrait donc créer la règle :

SI (température ≥ 25° ET éclairage ≥ 30 000 lux) ALORS baisser le store 

Cela pose cependant des problèmes lorsque les températures mesurées ou l’éclairage sont proches des valeurs limites.

2. Règles floues

Dans un système flou, les règles utilisent des valeurs floues au lieu des valeurs numériques. On note les expressions utilisées dans les règles sous la forme :

"Variable linguistique" EST "valeur linguistique" 

Nous...

Fuzzification et défuzzification

1. Valeur de vérité

Les différentes règles possèdent toutes une implication (la clause ALORS). Il va donc falloir exprimer à quel point la règle doit être appliquée en fonction des valeurs numériques mesurées : c’est l’étape de fuzzification.

Nous allons nous intéresser à la règle R8 :

SI température EST bon ET éclairage EST moyen ALORS store EST 
à mi-hauteur 

Nous souhaitons savoir à quel point cette règle s’applique pour une température de 21°C et un éclairage de 80000 lux.

On va donc commencer par chercher à quel point il fait BON. La figure suivante nous indique qu’à 21°C, il fait bon à 80 %.

images/02DP23.png

Nous cherchons ensuite à quel point l’éclairage est MOYEN pour 80000 lux. On peut lire qu’il l’est à 25 % :

images/02DP24.png

La règle contient donc une partie vraie à 80 % et une partie vraie à 25 %. On dira que la règle entière est vraie à 25 %, la valeur minimale (opérateur ET). C’est donc le terme le moins vrai qui donne la valeur de vérité d’une règle entière. 

2. Fuzzification et application des règles

On cherche maintenant à savoir quel sera le résultat de cette règle. Elle nous dit que le store doit être à mi-hauteur. On sait que la règle s’applique à 25 %.

On a alors de nombreux choix pour l’opérateur d’implication afin de déterminer l’ensemble flou résultant. Nous allons nous intéresser à deux d’entre eux : l’implication d’après Mamdani...

Domaines d’application

Zadeh a posé les bases théoriques de la logique floue en 1965. Les pays occidentaux ne se sont pas vraiment intéressés à cette technique à ses débuts. Au contraire, le Japon a très vite compris son intérêt, suivi plusieurs années plus tard par le reste du monde.

1. Premières utilisations

Dès 1987, le premier train contrôlé par un système à base de règles floues a vu le jour à Sendai, une ville à moins de 400 km au nord de Tokyo. Les ingénieurs voulaient alors maximiser le confort des voyageurs et minimiser la consommation d’énergie alors que le véhicule devait faire de nombreux changements de vitesse. La vitesse du train est donc le résultat de la logique floue.

Il s’est avéré que la consommation d’énergie a baissé de 10 % par rapport à un conducteur humain, et que les passagers vantent tous la souplesse de la conduite, principalement lors des arrêts et départs.

Il est toujours en circulation et a été le premier grand succès commercial de la logique floue.

2. Dans les produits électroniques

De nombreux autres constructeurs ont compris qu’un contrôleur flou pouvait améliorer le fonctionnement des machines qui nous entourent.

C’est ainsi que l’on est aujourd’hui...

Implémentation d’un moteur de logique floue

Cette partie décrit comment coder un moteur de logique floue, en utilisant les choix préconisés précédemment. Ce code est en Java, mais il peut facilement être adapté à n’importe quel autre langage objet. Il utilise Java 10, mais n’a pas besoin de librairies extérieures pour une meilleure portabilité.

Lorsque des connaissances en mathématiques sont nécessaires, les formules utilisées sont expliquées.

1. Le cœur du code : les ensembles flous

a. Point2D : un point d’une fonction d’appartenance

Nous allons commencer par créer les classes de base. Pour cela, il nous faut d’abord une classe Point2D qui nous permet de donner les coordonnées d’un point représentatif des fonctions d’appartenance. L’axe des abscisses (x) représente la valeur numérique et l’axe des ordonnées (y) la valeur d’appartenance correspondante, entre 0 et 1.

La base de cette classe est donc la suivante :

public class Point2D {  
   // Coordonnées  
   public double x;  
   public double y;  
     
   // Constructeur  
   public Point2D(double _x, double _y) {  
       x = _x;  
       y = _y;  
   }  
} 

Ultérieurement, il faudra comparer des points pour connaître leur ordre. Plutôt que de devoir comparer nous-mêmes les coordonnées x des points, nous allons implémenter l’interface Comparable à travers cette classe. Il faut donc modifier l’en-tête pour le suivant :

public class Point2D implements Comparable { 

Il faut ensuite ajouter la méthode compareTo, qui permet de savoir si le point passé en paramètre est plus petit, égal ou plus grand par rapport à l’objet en cours (la méthode doit renvoyer respectivement un nombre positif, nul ou négatif). On se contente donc de faire la différence des abscisses :

    @Override  
    public int compareTo(Object t) {  
         return (int) (x - ((Point2D) t).x);  
    } 

Enfin, la méthode...

Implémentation d’un cas pratique

Nous allons utiliser la logique floue pour contrôler un GPS de voiture, et plus précisément son niveau de zoom. En effet, en fonction de la distance au prochain changement de direction et de la vitesse à laquelle on roule, le niveau de zoom n’est pas le même : lorsqu’on se rapproche d’un changement de direction ou que l’on ralentit, le zoom augmente pour nous montrer de plus en plus de détails.

Pour avoir un rendu fluide et non saccadé, un contrôleur flou est donc utilisé. Pour cela, on commence par créer une nouvelle classe contenant juste une méthode main pour le moment :

public class ZoomGPS {  
   public static void main(String[] arg) {  
       System.out.println("Logique floue : cas du zoom d'un GPS");  
       // Code ici  
} 

On commence par créer un nouveau contrôleur flou :

       // Création du système  
       ControleurFlou controleur = new ControleurFlou("Gestion 
du zoom d'un GPS"); 

L’étape suivante consiste à définir les différentes variables linguistiques. Nous en aurons trois : Distance et Vitesse en entrée, et Zoom en sortie. Pour la distance (en mètres jusqu’au prochain changement de direction), on va créer trois valeurs linguistiques : "Faible", "Moyenne" et "Grande".

Voici le schéma reprenant ces ensembles flous :

images/02DP37.png

Au niveau du code, on va donc créer la variable linguistique Distance, puis lui ajouter les trois valeurs linguistiques, et enfin ajouter cette variable comme entrée au système :

       System.out.println("Ajout des variables d'entrée");  
       // Variable linguistique d'entrée :  
       // distance (en m, de 0 à 500 000)  
       VariableLinguistique distance = new  
VariableLinguistique("Distance", 0, 500000);   
       distance.AjouterValeurLinguistique(new  
ValeurLinguistique("Faible", new EnsembleFlouTrapezeGauche(0, 
500000, 30, 50)));   
 ...

Synthèse

La logique floue permet de prendre des décisions en fonction de règles imprécises, c’est-à-dire dont l’évaluation est soumise à interprétation.

Pour cela, on définit des variables linguistiques (comme la température) et on leur associe des valeurs linguistiques ("chaud", "froid"...). À chaque valeur, on fait correspondre un ensemble flou, déterminé par sa fonction d’appartenance : pour toutes les valeurs numériques possibles, elle associe un degré d’appartenance entre 0 (la valeur linguistique est totalement fausse) et 1 (elle est totalement vraie), en passant par des stades intermédiaires.

Une fois les variables et valeurs linguistiques déterminées, les règles à appliquer sont indiquées au système flou. On lui donne ensuite les valeurs numériques mesurées.

La première étape pour fournir une décision est la fuzzification qui consiste à associer à chaque valeur numérique son degré d’appartenance aux différentes valeurs linguistiques. Les règles peuvent alors être appliquées, et la somme des règles (constituée par l’union des ensembles flous résultants) fournit un nouvel ensemble flou.

La défuzzification est l’étape permettant...