Régulation de Niveau en Logique Floue

En logique classique, toute proposition a une valeur de vérité égale à 0 (`faux`) ou à 1 (`vrai`).

En logique floue, toutes les valeurs intermédiaires entre le 0 et le 1, c'est-à-dire entre le faux et le vrai, sont admises, d'où l'adjectif "floue".

A l'origine, la logique floue provient de la théorie des sous-ensembles flous, introduite en 1965 par LA Adeh, professeur à l'Université de Californie à Berkeley.

Cette théorie propose une généralisation de la notion classique d'ensemble : un élément peut appartenir plus ou moins à un ensemble.

Le degré d'appartenance des éléments à un sous-ensemble flou d'un ensemble de référence est mesuré par une "fonctionnement d'appartenance" de l'ensemble de référence dans l'intervalle [0,1] (si cette fonction ne prend que les valeurs 0 ou 1, on retombe bien sur un sous-ensemble classique).

On peut voir les choses d'une autre manière en disant que la proposition "l'élément appartient à l'ensemble" est plus ou moins vraie, ce qui introduit la notion de proposition floue, et par conséquent la possibilité de raisonner sur ces propositions.

L'intérêt pratique de cette théorie commença à apparaître au début des années 70.

En effet, la logique floue permet d'appréhender un proccessus sur lequel on dispose de connaissances imparfaites et surtout se rapproche beaucoup de la pensée humaine, qui utilise des catégories imprécises.

Par exemple, un barragiste qui tient un niveau en manuel ne pensera probablement pas : $Q_c = ttK_i int_0^(t) epsilon(t)delta t + ttK_p epsilon$ (régulateur PI)

mais plus probablement : "le niveau est très haut et monte beaucoup, donc il faut que j'ouvre beaucoup" (régulateur flou).

Quelques commandes de processus à base de la logique floue apparurent en Europe au cours des années 1970, mais ce sont les japonnais qui popularisèrent la méthode en l'appliquant aux appareils grand public des années 80.

Aujourd'hui, la logique floue est largement utilisée par exemple pour les autofocus et pour les appareils "à un seul bouton" : on met en marche et ça se débrouille ("si le poids augmente beaucoup quand on mouille le vêtement, se dit la machine à laver floue, alors c'est vraisemblablement de la laine, donc la température doit être plutôt froide et l'essorage pas trop fort").

On a vu ce qu'était une proposition floue.

Pour commencer à raisonner en logique floue, il faut pouvoir combiner ces propositions.

Pour celà, comme en logique classique, il faut définir les 2 opérateurs de base qui sont le $NON$ et le $ET$.

Quand on a le $NON$ et le $ET$, on peut reconstruire tous les opérateurs possibles :

• le $OU$ : P $OU$ Q tel que $NON [ NON($P$) ET NON($Q$) ]$
• puis l'implication : P $rArr$ Q tel que $NON ($P$) OU $Q$
• etc..

Dans tout ce qui suit, P,Q,R et S sont des propositions et on note val(P) la valeur de vérité de P.
Si P est une proposition classique, val(P) est égale à 0 ou à 1, et si P est une proposition floue val(P) est comprise entre 0 et 1.

En logique classique, le $NON$ est défini par :

• si $val($P$) = 1$, alors $val[NON($P$) ] = 0$
  c'est-à-dire : la négation d'une proposition vraie est fausse
• si $val($P$) = 0$, alors $val[NON($P$) ] = 1$
  c'est-à-dire : la négation d'une proposition fausse est vraie

En logique floue, le $NON$ est défini par :

• si $val($P$) = 1$ alors $val[ NON($P$)] = 0$
  c'est-à-dire : la négation d'une proposition absolument vraie est absolument fausse
• si $val($P$) = 0$ alors $val[ NON($P$)] = 1$
  c'est-à-dire : la négation d'une proposition absolument fausse est absolument vraie
• si $val($P$) <= val($Q$)$ alors $val[ NON($Q$)] <= val[ NON($P$) ]$
  c'est-à-dire : si $P$ est moins vraie que $Q$, alors $NON($Q$)$ est moins vraie que $NON($P$)$

En théorie, on pourrait prendre pour le $NON$ n'importe quelle fonction vérifiant ces propriétés.
En pratique, on prend toujours : $val[ NON($P$) ] = 1 - val($P$)$

En logique classique, le $ET$ est défini par :

• si $val($P$) = 1$ et $val($Q$) = 1$, alors $val($P$ ET $Q$) = 1$ sinon $val($P$ET $Q$) = 0$

En logique floue, le $ET$ est défini par :

• $val($P$ ET $Q$) = val($Q$ ET $P$)$
  c'est à dire : $P$ ET $Q$ a la même valeur de vérité que $Q$ ET $P$ (commutativité)
• $val[ $P$ ET ( $Q$ ET $R$ ) ] = val[($P$ ET $Q$) ET $R$ ]$ (associativité)
• si $val($P$) <= val($Q$)$ et $val($R$) <= val($S$)$ alors $val($P$ ET $R$) <= val($Q$ ET $S$)
  c'est-à-dire : si $P$ est moins vraie que $Q$, et $R$ est moins vraie que $S$, alors $($P$ET$R$)$ est moins vraie que $($Q$ET$S$)$ (monotonie)
• si $val($Q$) = 1$ alors $val($P$ ET $Q$) = val($P$)$
  c'est-à-dire : si Q est absolument vraie, alors $($P$ET$Q$)$ a la même valeur de vérité que P (neutralité de la proposition vraie)

Il existe donc plusieurs façons de définir le $ET$ en logique floue. Signalons notamment :

• le $ET$ de Zadeh : $val($P$ET$Q$) = min[val($P$),val($Q$)]$
• le $ET$ probabiliste : $val($P$ET$Q$) = val($P$).val($Q$)$

Remarque :
Pour la régulation de niveau en logique floue, nous avons utilisé le ET probabiliste

Comme tout systême de commande, une commande positionne des variables de sortie en fonction de variables d'entrée.

Dans une commande floue, ceci se passe en 3 étapes :

1. Interface avec le flou: caractérisation des variables d'entrée à l'aide de propositions floues
2. Raisonnement flou: en fonction des propositions floues caractérisant les variables d'entrée, caractérisation des variables de sortie à l'aide de propositions floues
3. Interface avec le non-flou: en fonction des propositions floues caractérisant les variables de sortie, affectation d'une valeur aux variables de sortie.

Chaque variable d'entrée numérique va être caractérisée à l'aide d'un certain nombre de propositions floues.

Si $x$ est une variable d'entrée numérique et $P_1, P_2 ...P_n$ n propositions floues caratérisant $x$,
on va définir $n$ fonctions $p_1, p_2..p_n$ :
$p_i : R rarr [0,1]$, $x rarr val(P_i)$

Les fonctions utilisées sont souvent de forme triangulaire ou trapézoïdale.
C'est en effet la démarche la plus naturelle :

• on définit les valeurs de $x$ pour lesquelles $P_i$ est absolument vraie. Pour ces valeurs $p_i(x) = 1$
• on définit les valeurs de $x$ pour lesquelles $P_i$ est absolument fausse. Pour ces valeurs $p_i(x) = 0$
• on représente alors $p_i$ sous forme graphique, et on raccorde par des segments de droite.

Si $P_i$ est absolument vraie sur une seule valeur, on obtient donc une fonction triangulaire.
Si $P_i$ est absolument vraie sur un intervalle, on obtient une fonction trapézoïdale.

Exemples:

1 - $x$ est une valeur régulée à la consigne $x0$

• P est la proposition "x est bon"
• P est absolument vraie si $x = x0$
• P est absolument fausse si $x$ est différent de $x0$ de plus d'une valeur $a$

On obtient une fonction triangulaire


2 - $x$ est la température d'une piêce

• P la proposition "il fait bon" (On peut dire : il fait bon entre 20 et 25°C)
• au-dessous de 17°C, il fait froid (pas bon du tout)
• au-dessus de 30°C, il fait chaud (pas bon du tout)

On obtient une fonction trapézoïdale



3 - Pour les propositions P caractérisant $x$ de manière extrême, l'intervalle sur lequel $p(x)$ est non nul sera souvent non borné.
En reprenant l'exemple précédent, si on représente la valeur de vérité de la proposition "il fait une chaleur insupportable", on obtiendra quelque chose du type

Ayant caractérisé les variables d'entrées du systême, on cherche maintenant à caractériser les variables de sortie.
Pour celà, on utilise les rêgles qui décriront les variables de sortie en fonction des variables d'entrée.

Les rêgles sont du type :

Pour calculer la valeur de vérité de la combinaison de propositions floues relative aux variables d'entrée, il faut avoir défini les opérateurs logiques de base, c'est-à-dire choisi une "t-norme" (cf ch2).

De plus, les rêgles elles-mêmes peuvent être plus ou moins vraies. On peut donc leur affecter une valeur de vérité floue ($"comprise entre 0 et 1"$). Ceci permet d'établir une hiérarchie entre les différentes rêgles, qui n'ont pas toutes la même importance dans la commande.

Il existe plusieurs maniêres de calculer la valeur de vérité de la conclusion de la rêgle (relative aux variables de sortie), la plus simple étant de $"multiplier"$ la valeur de vérité de la prémisse de la rêgle (relative aux variables d'entrée) par la valeur de vérité de la rêgle.

On obtient ainsi, pour chaque rêgle, un $"résultat intermédiaire"$.

Comme la même proposition floue relative aux variables de sortie peut être la conclusion de plusieurs rêgles différentes, il faut ensuite "agréger les résultats intermédiaires" et pour celà définir un $"opérateur d'agrégation"$.

Si $p_i$ est la valeur de vérité de $P$ calculée avec la rêgle $R_i$ et $p$ la valeur de vérité de $P$, on peut prendre par exemple comme opérateur d'agrégation :
Si on a pris soin que $sum(p_i) <= 1$, on peut également prendre $p = sum(p_i)$

Remarque :

Exemple :

jjjj

Ayant trouvé une caractérisation floue des variables de sortie, il s'agit maintenant de leur affecter une valeur précise, non floue.

Pour celà, on peut procédé de plusieurs maniêres. Le choix de la méthode dépend du type de sortie que l'on veut obtenir.

Si la sortie ne peut prendre qu'un nombre fini de valeurs, on prendra celle dont la caratérisation se rapproche le plus des propositions floues calculées dans le raisonnement flou.

Si la sortie peut varier en continu, on utilisera une méthode barycentrique.

Exemple :