Système de contrôle flou - Fuzzy control system

Un système de contrôle flou est un système de contrôle basé sur la logique floue - un système mathématique qui analyse les valeurs d'entrée analogiques en termes de variables logiques qui prennent des valeurs continues entre 0 et 1, contrairement à la logique classique ou numérique , qui fonctionne sur des valeurs discrètes de soit 1 ou 0 (vrai ou faux, respectivement).

Aperçu

La logique floue est largement utilisée dans le contrôle des machines. Le terme « flou » fait référence au fait que la logique impliquée peut traiter des concepts qui ne peuvent pas être exprimés comme « vrai » ou « faux » mais plutôt comme « partiellement vrais ». Bien que des approches alternatives telles que les algorithmes génétiques et les réseaux de neurones puissent fonctionner aussi bien que la logique floue dans de nombreux cas, la logique floue a l'avantage que la solution au problème peut être exprimée en termes que les opérateurs humains peuvent comprendre, de sorte que leur expérience peut être utilisé dans la conception du contrôleur. Cela facilite la mécanisation de tâches déjà exécutées avec succès par des humains.

Historique et applications

La logique floue a été proposée par Lotfi A. Zadeh de l'Université de Californie à Berkeley dans un article de 1965. Il a développé ses idées dans un article de 1973 qui a introduit le concept de « variables linguistiques », qui dans cet article équivaut à une variable définie comme un ensemble flou. D'autres recherches ont suivi, avec la première application industrielle, un four à ciment construit au Danemark, mis en service en 1975.

Les systèmes flous ont été initialement mis en œuvre au Japon .

L'intérêt pour les systèmes flous a été suscité par Seiji Yasunobu et Soji Miyamoto de Hitachi , qui en 1985 ont fourni des simulations démontrant la faisabilité des systèmes de contrôle flou pour le métro de Sendai . Leurs idées ont été adoptées et des systèmes flous ont été utilisés pour contrôler l'accélération, le freinage et l'arrêt lors de l'ouverture de la ligne Namboku en 1987.
En 1987, Takeshi Yamakawa a démontré l'utilisation de la commande floue, à travers un ensemble de puces de logique floue dédiées simples, dans une expérience de « pendule inversé ». Il s'agit d'un problème de contrôle classique, dans lequel un véhicule essaie de maintenir un poteau monté sur son sommet par une charnière à la verticale en se déplaçant d'avant en arrière. Yamakawa a ensuite rendu la démonstration plus sophistiquée en montant un verre à vin contenant de l'eau et même une souris vivante au sommet du pendule : le système maintenait la stabilité dans les deux cas. Yamakawa a finalement organisé son propre laboratoire de recherche sur les systèmes flous pour l'aider à exploiter ses brevets sur le terrain.
Les ingénieurs japonais ont ensuite développé une large gamme de systèmes flous pour les applications industrielles et grand public. En 1988, le Japon a créé le Laboratoire d'ingénierie floue internationale (LIFE), un accord de coopération entre 48 entreprises pour poursuivre la recherche floue. L'entreprise automobile Volkswagen était la seule entreprise étrangère membre de LIFE, envoyant un chercheur pour une durée de trois ans.
Les biens de consommation japonais incorporent souvent des systèmes flous. Les aspirateurs Matsushita utilisent des microcontrôleurs exécutant des algorithmes flous pour interroger les capteurs de poussière et ajuster la puissance d'aspiration en conséquence. Les machines à laver Hitachi utilisent des contrôleurs flous pour charger des capteurs de poids, de mélange de tissus et de saleté et règlent automatiquement le cycle de lavage pour une utilisation optimale de l'énergie, de l'eau et du détergent.
Canon a développé un appareil photo à mise au point automatique qui utilise un dispositif à couplage de charge (CCD) pour mesurer la clarté de l'image dans six régions de son champ de vision et utilise les informations fournies pour déterminer si l'image est nette. Il suit également le taux de changement de mouvement de l'objectif pendant la mise au point et contrôle sa vitesse pour éviter les dépassements. Le système de contrôle flou de la caméra utilise 12 entrées : 6 pour obtenir les données de clarté actuelles fournies par le CCD et 6 pour mesurer le taux de changement de mouvement de l'objectif. La sortie est la position de l'objectif. Le système de contrôle flou utilise 13 règles et nécessite 1,1 kilo-octets de mémoire.
Un climatiseur industriel conçu par Mitsubishi utilise 25 règles de chauffage et 25 règles de refroidissement. Un capteur de température fournit une entrée, avec des sorties de contrôle envoyées à un onduleur , une vanne de compresseur et un moteur de ventilateur. Par rapport à la conception précédente, le contrôleur flou chauffe et refroidit cinq fois plus vite, réduit la consommation d'énergie de 24 %, augmente la stabilité de la température d'un facteur deux et utilise moins de capteurs.
D'autres applications étudiées ou mises en œuvre comprennent : la reconnaissance des caractères et de l' écriture manuscrite ; systèmes optiques flous; des robots, dont un pour la confection de compositions florales japonaises ; des hélicoptères robotisés à commande vocale (le vol stationnaire est un « acte d'équilibre » assez similaire au problème du pendule inversé) ; la robotique de rééducation pour fournir des solutions spécifiques au patient (par exemple pour contrôler la fréquence cardiaque et la pression artérielle) ; contrôle de flux de poudres dans la fabrication de films; systèmes d'ascenseurs; etc.

Des travaux sur les systèmes flous se poursuivent également en Amérique du Nord et en Europe, bien qu'à une échelle moins étendue qu'au Japon.

L' Agence américaine de protection de l'environnement a étudié le contrôle flou pour les moteurs économes en énergie , et la NASA a étudié le contrôle flou pour l'amarrage spatial automatisé : les simulations montrent qu'un système de contrôle flou peut réduire considérablement la consommation de carburant.
Des entreprises telles que Boeing , General Motors , Allen-Bradley , Chrysler , Eaton et Whirlpool ont travaillé sur la logique floue à utiliser dans les réfrigérateurs à faible consommation, les transmissions automobiles améliorées et les moteurs électriques économes en énergie.
En 1995, Maytag a introduit un lave-vaisselle « intelligent » basé sur un contrôleur flou et un « module de détection à guichet unique » qui combine une thermistance , pour la mesure de la température ; un capteur de conductivité, pour mesurer le niveau de détergent à partir des ions présents dans le linge ; un capteur de turbidité qui mesure la lumière diffusée et transmise pour mesurer la salissure du linge ; et un capteur magnétostrictif pour lire la vitesse de rotation. Le système détermine le cycle de lavage optimal pour n'importe quelle charge afin d'obtenir les meilleurs résultats avec le moins d'énergie, de détergent et d'eau. Il s'ajuste même pour les aliments séchés en suivant la dernière fois que la porte a été ouverte et estime le nombre de plats par le nombre de fois que la porte a été ouverte.
En 2017, Xiera Technologies Inc. a développé le premier auto-tuner pour la base de connaissances du contrôleur de logique floue connue sous le nom d'edeX. Cette technologie a été testée par le Mohawk College et a pu résoudre des problèmes multi-entrées multi-sorties non linéaires 2x2 et 3x3.

La recherche et le développement se poursuivent également sur les applications floues dans les logiciels, par opposition aux micrologiciels , la conception, y compris les systèmes experts flous et l'intégration de la logique floue avec les réseaux de neurones et les systèmes logiciels dits " génétiques " adaptatifs , dans le but ultime de construire " systèmes de contrôle flou autodidacte. Ces systèmes peuvent être utilisés pour contrôler des plantes dynamiques complexes et non linéaires, par exemple le corps humain.

Ensembles flous

Les variables d'entrée dans un système de contrôle flou sont en général mappées par des ensembles de fonctions d'appartenance similaires à celui-ci, appelés « ensembles flous ». Le processus de conversion d'une valeur d'entrée nette en une valeur floue est appelé "fuzzification". L'approche basée sur la logique floue avait été envisagée en concevant deux systèmes flous, l'un pour l'angle de cap d'erreur et l'autre pour le contrôle de la vitesse.

Un système de contrôle peut également avoir différents types d' entrées de commutateur , ou "ON-OFF", avec ses entrées analogiques, et ces entrées de commutateur auront bien sûr toujours une valeur de vérité égale à 1 ou 0, mais le schéma peut traiter comme des fonctions floues simplifiées qui sont soit une valeur soit une autre.

Étant donné les « mappages » des variables d'entrée dans les fonctions d'appartenance et les valeurs de vérité , le microcontrôleur prend alors des décisions quant à l'action à entreprendre, sur la base d'un ensemble de « règles », chacune de la forme :

  IF brake temperature IS warm AND speed IS not very fast 
  THEN brake pressure IS slightly decreased.

Dans cet exemple, les deux variables d'entrée sont « température de freinage » et « vitesse » qui ont des valeurs définies comme des ensembles flous. La variable de sortie, « pression de freinage » est également définie par un ensemble flou qui peut avoir des valeurs telles que « statique » ou « légèrement augmentée » ou « légèrement diminuée », etc.

Contrôle flou en détail

Les contrôleurs flous sont conceptuellement très simples. Ils se composent d'un étage d'entrée, d'un étage de traitement et d'un étage de sortie. L'étage d'entrée mappe le capteur ou d'autres entrées, telles que des commutateurs, des molettes, etc., aux fonctions d'appartenance et aux valeurs de vérité appropriées. L'étape de traitement invoque chaque règle appropriée et génère un résultat pour chacune, puis combine les résultats des règles. Enfin, l'étage de sortie reconvertit le résultat combiné en une valeur de sortie de contrôle spécifique.

La forme la plus courante des fonctions d'appartenance est triangulaire, bien que des courbes trapézoïdales et en cloche soient également utilisées, mais la forme est généralement moins importante que le nombre de courbes et leur placement. De trois à sept courbes sont généralement appropriées pour couvrir la plage requise d'une valeur d'entrée, ou « l' univers du discours » dans le jargon flou.

Comme indiqué précédemment, l'étape de traitement est basée sur un ensemble de règles logiques sous la forme d'instructions SI-ALORS, où la partie SI est appelée "l'antécédent" et la partie ALORS est appelée la "conséquence". Les systèmes de contrôle flou typiques ont des dizaines de règles.

Considérons une règle pour un thermostat :

  IF (temperature is "cold") THEN turn (heater is "high")

Cette règle utilise la valeur de vérité de l'entrée "température", qui est une valeur de vérité de "froid", pour générer un résultat dans l'ensemble flou pour la sortie "chauffage", qui est une valeur de "élevé". Ce résultat est utilisé avec les résultats d'autres règles pour finalement générer la sortie composite nette. De toute évidence, plus la valeur de vérité de "froid" est élevée, plus la valeur de vérité de "élevé" est élevée, bien que cela ne signifie pas nécessairement que la sortie elle-même sera définie sur "élevée" car ce n'est qu'une règle parmi d'autres. Dans certains cas, les fonctions d'appartenance peuvent être modifiées par des « haies » équivalentes à des adverbes. Les haies courantes incluent "environ", "près de", "près de", "approximativement", "très", "légèrement", "trop", "extrêmement" et "un peu". Ces opérations peuvent avoir des définitions précises, bien que les définitions puissent varier considérablement entre les différentes implémentations. « Très », par exemple, les fonctions d'appartenance des carrés ; puisque les valeurs d'appartenance sont toujours inférieures à 1, cela réduit la fonction d'appartenance. "Extrêmement" cube les valeurs pour donner un plus grand rétrécissement, tandis que "un peu" élargit la fonction en prenant la racine carrée.

Dans la pratique, les ensembles de règles floues ont généralement plusieurs antécédents qui sont combinés à l'aide d'opérateurs flous, tels que AND, OR et NOT, bien que, encore une fois, les définitions aient tendance à varier : AND, dans une définition populaire, utilise simplement le poids minimum de tous les antécédents, tandis que OR utilise la valeur maximale. Il existe également un opérateur NOT qui soustrait une fonction d'appartenance de 1 pour donner la fonction "complémentaire".

Il existe plusieurs façons de définir le résultat d'une règle, mais l'une des plus courantes et des plus simples est la méthode d' inférence "max-min" , dans laquelle la fonction d'appartenance de sortie reçoit la valeur de vérité générée par la prémisse.

Les règles peuvent être résolues en parallèle dans le matériel, ou séquentiellement dans le logiciel. Les résultats de toutes les règles déclenchées sont « défuzzifiés » à une valeur nette par l'une des méthodes suivantes. Il en existe des dizaines, en théorie, chacun avec des avantages ou des inconvénients divers.

La méthode "centroïde" est très populaire, dans laquelle le "centre de masse" du résultat fournit la valeur nette. Une autre approche est la méthode de la « hauteur », qui prend la valeur du plus gros contributeur. La méthode centroïde favorise la règle avec la sortie de la plus grande surface, tandis que la méthode de la hauteur favorise évidemment la règle avec la plus grande valeur de sortie.

Le diagramme ci-dessous montre l'inférence max-min et la défuzzification centroïde pour un système avec des variables d'entrée "x", "y" et "z" et une variable de sortie "n". Notez que « mu » est la nomenclature de logique floue standard pour la « valeur de vérité » :

Remarquez comment chaque règle fournit un résultat en tant que valeur de vérité d'une fonction d'appartenance particulière pour la variable de sortie. Dans la défuzzification centroïde, les valeurs sont OR, c'est-à-dire que la valeur maximale est utilisée et les valeurs ne sont pas ajoutées, et les résultats sont ensuite combinés à l'aide d'un calcul centroïde.

La conception du système de commande floue est basée sur des méthodes empiriques, essentiellement une approche méthodique des essais et erreurs . Le processus général est le suivant :

Documenter les spécifications opérationnelles et les entrées et sorties du système.
Documentez les ensembles flous pour les entrées.
Documentez l'ensemble de règles.
Déterminer la méthode de défuzzification.
Exécutez la suite de tests pour valider le système, ajustez les détails selon les besoins.
Document complet et mise en production.

Comme exemple général, considérons la conception d'un contrôleur flou pour une turbine à vapeur. Le schéma fonctionnel de ce système de contrôle se présente comme suit :

Les variables d'entrée et de sortie correspondent à l'ensemble flou suivant :

-où:

  N3:   Large negative.
  N2:   Medium negative.
  N1:   Small negative.
  Z:    Zero.
  P1:   Small positive.
  P2:   Medium positive.
  P3:   Large positive.

L'ensemble de règles comprend des règles telles que :

rule 1:  IF temperature IS cool AND pressure IS weak,   
         THEN throttle is P3.

rule 2:  IF temperature IS cool AND pressure IS low,    
         THEN throttle is P2.

rule 3:  IF temperature IS cool AND pressure IS ok,     
         THEN throttle is Z.

rule 4:  IF temperature IS cool AND pressure IS strong, 
         THEN throttle is N2.

En pratique, le contrôleur accepte les entrées et les mappe dans leurs fonctions d'appartenance et leurs valeurs de vérité. Ces mappages sont ensuite intégrés aux règles. Si la règle spécifie une relation ET entre les mappages des deux variables d'entrée, comme le font les exemples ci-dessus, le minimum des deux est utilisé comme valeur de vérité combinée ; si un OU est spécifié, le maximum est utilisé. L'état de sortie approprié est sélectionné et affecté à une valeur d'appartenance au niveau de vérité de la prémisse. Les valeurs de vérité sont alors défuzzifiées. Par exemple, supposons que la température est à l'état « froid » et que la pression est à l'état « bas » et « ok ». Les valeurs de pression garantissent que seules les règles 2 et 3 se déclenchent :

Les deux sorties sont ensuite défuzzifiées par défuzzification centroïde :

   __________________________________________________________________

                                       |          Z      P2
                                    1 -+          *       *
                                       |         * *     * *
                                       |        *   *   *   *
                                       |       *     * *     *
                                       |      *       222222222
                                       |     *       22222222222
                                       |    333333332222222222222
                                       +---33333333222222222222222-->
                                                        ^ 
                                                      +150 
   __________________________________________________________________

La valeur de sortie ajustera la manette des gaz, puis le cycle de contrôle recommencera pour générer la valeur suivante.

Construire un contrôleur flou

Envisagez de mettre en œuvre avec une puce de microcontrôleur un simple contrôleur de rétroaction :

Un ensemble flou est défini pour la variable d'erreur d'entrée « e », et la variation dérivée de l'erreur, « delta », ainsi que la « sortie », comme suit :

  LP:  large positive
  SP:  small positive
  ZE:  zero
  SN:  small negative
  LN:  large negative

Si l'erreur va de -1 à +1, avec le convertisseur analogique-numérique utilisé ayant une résolution de 0,25, alors l'ensemble flou de la variable d'entrée (qui, dans ce cas, s'applique également à la variable de sortie) peut être décrit très simplement sous forme de tableau, avec les valeurs d'erreur / delta / de sortie dans la rangée supérieure et les valeurs de vérité pour chaque fonction d'appartenance disposées dans les rangées en dessous :

  _______________________________________________________________________

              -1    -0.75  -0.5   -0.25    0     0.25   0.5    0.75    1
  _______________________________________________________________________

   mu(LP)      0      0      0      0      0      0     0.3    0.7     1
   mu(SP)      0      0      0      0     0.3    0.7     1     0.7    0.3
   mu(ZE)      0      0     0.3    0.7     1     0.7    0.3     0      0
   mu(SN)     0.3    0.7     1     0.7    0.3     0      0      0      0
   mu(LN)      1     0.7    0.3     0      0      0      0      0      0
  _______________________________________________________________________            —or, in graphical form (where each "X" has a value of 0.1):

         LN           SN           ZE           SP           LP
      +------------------------------------------------------------------+
      |                                                                  |
-1.0  |  XXXXXXXXXX   XXX          :            :            :           |
-0.75 |  XXXXXXX      XXXXXXX      :            :            :           |
-0.5  |  XXX          XXXXXXXXXX   XXX          :            :           |
-0.25 |  :            XXXXXXX      XXXXXXX      :            :           |
 0.0  |  :            XXX          XXXXXXXXXX   XXX          :           |
 0.25 |  :            :            XXXXXXX      XXXXXXX      :           |
 0.5  |  :            :            XXX          XXXXXXXXXX   XXX         |
 0.75 |  :            :            :            XXXXXXX      XXXXXXX     |
 1.0  |  :            :            :            XXX          XXXXXXXXXX  |
      |                                                                  |
      +------------------------------------------------------------------+

Supposons que ce système flou ait la base de règles suivante :

  rule 1:  IF e = ZE AND delta = ZE THEN output = ZE
  rule 2:  IF e = ZE AND delta = SP THEN output = SN
  rule 3:  IF e = SN AND delta = SN THEN output = LP
  rule 4:  IF e = LP OR  delta = LP THEN output = LN

Ces règles sont typiques des applications de contrôle en ce que les antécédents consistent en la combinaison logique des signaux d'erreur et de delta d'erreur, tandis que le résultat est une sortie de commande de contrôle. Les sorties de règle peuvent être défuzzifiées à l'aide d'un calcul de centroïde discret :

  SUM( I = 1 TO 4 OF ( mu(I) * output(I) ) ) / SUM( I = 1 TO 4 OF mu(I) )

Maintenant, supposons qu'à un instant donné :

  e     = 0.25
  delta = 0.5

Cela donne alors :

  ________________________

              e     delta
  ________________________

  mu(LP)      0      0.3
  mu(SP)     0.7      1
  mu(ZE)     0.7     0.3
  mu(SN)      0       0
  mu(LN)      0       0
  ________________________

Le fait de brancher cela dans la règle 1 donne :

  rule 1:  IF e = ZE AND delta = ZE THEN output = ZE
 
     mu(1)     = MIN( 0.7, 0.3 ) = 0.3
     output(1) = 0

-- où:

mu(1) : valeur de vérité de la fonction d'appartenance du résultat pour la règle 1. En termes de calcul du centroïde, il s'agit de la « masse » de ce résultat pour ce cas discret.
output(1) : Valeur (pour la règle 1) où la fonction d'appartenance du résultat (ZE) est maximale sur la plage de l'ensemble flou de la variable de sortie. C'est-à-dire, en termes de calcul du centroïde, l'emplacement du "centre de masse" pour ce résultat individuel. Cette valeur est indépendante de la valeur de "mu". Il identifie simplement l'emplacement de ZE le long de la plage de sortie.

Les autres règles donnent :

  rule 2:  IF e = ZE AND delta = SP THEN output = SN

     mu(2)     = MIN( 0.7, 1 ) = 0.7   
     output(2) = -0.5

  rule 3: IF e = SN AND delta = SN THEN output = LP

     mu(3)     = MIN( 0.0, 0.0 ) = 0
     output(3) = 1

  rule 4: IF e = LP OR  delta = LP THEN output = LN

     mu(4)     = MAX( 0.0, 0.3 ) = 0.3
     output(4) = -1

Le calcul du centroïde donne :

   ${\frac {mu(1)\cdot output(1)+mu(2)\cdot output(2)+mu(3)\cdot output(3)+mu(4)\cdot output(4)}{mu(1)+mu(2)+mu(3)+mu(4)}}$ 
   $={\frac {(0.3\cdot 0)+(0.7\cdot -0.5)+(0\cdot 1)+(0.3\cdot -1)}{0.3+0.7+0+0.3}}$ 
   $=-0.5$ —for the final control output. Simple. Of course the hard part is figuring out what rules actually work correctly in practice.

Si vous avez du mal à comprendre l'équation du centroïde, rappelez-vous qu'un centroïde est défini en additionnant tous les moments (emplacement fois masse) autour du centre de gravité et en égalant la somme à zéro. Donc si est le centre de gravité, est l'emplacement de chaque masse, et est chaque masse, cela donne : ${\style d'affichage X_{0}}$ ${\style d'affichage X_{i}}$ ${\style d'affichage M_{i}}$

   $0=(X_{1}-X_{0})\cdot M_{1}+(X_{2}-X_{0})\cdot M_{2}+\ldots +(X_{n}-X_{0})\cdot M_{n}$ 
   $0=(X_{1}\cdot M_{1}+X_{2}\cdot M_{2}+\ldots +X_{n}\cdot M_{n})-X_{0}\cdot (M_{1}+M_{2}+\ldots +M_{n})$ 
   $X_{0}\cdot (M_{1}+M_{2}+\ldots +M_{n})=X_{1}\cdot M_{1}+X_{2}\cdot M_{2}+\ldots +X_{n}\cdot M_{n}$ 
   $X_{0}={\frac {X_{1}\cdot M_{1}+X_{2}\cdot M_{2}+\ldots +X_{n}\cdot M_{n}}{M_{1}+M_{2}+\ldots +M_{n}}}$

Dans notre exemple, les valeurs de mu correspondent aux masses, et les valeurs de X à l'emplacement des masses (mu, cependant, ne "correspond aux masses" que si la "masse" initiale des fonctions de sortie est la même/ S'ils ne sont pas les mêmes, c'est-à-dire que certains sont des triangles étroits, tandis que d'autres peuvent être des trapèzes larges ou des triangles épaulés, alors la masse ou l'aire de la fonction de sortie doit être connue ou calculée. C'est cette masse qui est ensuite mise à l'échelle par mu et multiplié par son emplacement X_i).

Ce système peut être implémenté sur un microprocesseur standard, mais des puces floues dédiées sont désormais disponibles. Par exemple, Adaptive Logic INC de San Jose, Californie, vend une « puce floue », l'AL220, qui peut accepter quatre entrées analogiques et générer quatre sorties analogiques. Un schéma fonctionnel de la puce est présenté ci-dessous :

              +---------+                              +-------+
 analog --4-->| analog  |                              | mux / +--4--> analog
   in         |   mux   |                              |  SH   |        out
              +----+----+                              +-------+
                   |                                       ^
                   V                                       |
            +-------------+                             +--+--+
            | ADC / latch |                             | DAC |
            +------+------+                             +-----+
                   |                                       ^
                   |                                       |
                   8         +-----------------------------+
                   |         |                             |
                   |         V                             |
                   |   +-----------+      +-------------+  |
                   +-->| fuzzifier |      | defuzzifier +--+
                       +-----+-----+      +-------------+
                             |                   ^
                             |  +-------------+  |
                             |  |    rule     |  |
                             +->|  processor  +--+
                                | (50 rules)  |
                                +------+------+
                                       |
                                +------+------+
                                |  parameter  |
                                |    memory   |
                                |   256 x 8   |
                                +-------------+

    ADC:  analog-to-digital converter
    DAC:  digital-to-analog converter
    SH:   sample/hold

Freins antiblocage

A titre d'exemple, considérons un système de freinage antiblocage , dirigé par une puce de microcontrôleur. Le microcontrôleur doit prendre des décisions en fonction de la température des freins , de la vitesse et d'autres variables du système.

La variable "température" dans ce système peut être subdivisée en une plage d'"états": "froid", "froid", "modéré", "chaud", "chaud", "très chaud". Le passage d'un état à l'autre est difficile à définir.

Un seuil statique arbitraire peut être défini pour séparer "chaud" de "chaud". Par exemple, à exactement 90 degrés, les extrémités chaudes et les débuts chauds. Mais cela entraînerait un changement discontinu lorsque la valeur d'entrée dépasserait ce seuil. La transition ne se ferait pas en douceur, comme cela serait nécessaire dans les situations de freinage.

Le moyen de contourner cela est de rendre les états flous . C'est-à-dire leur permettre de passer progressivement d'un état à l'autre. Pour ce faire, il doit y avoir une relation dynamique établie entre les différents facteurs.

Commencez par définir les états de température d'entrée à l'aide de « fonctions d'appartenance » :

Avec ce schéma, l'état de la variable d'entrée ne saute plus brusquement d'un état à l'autre. Au lieu de cela, à mesure que la température change, elle perd de la valeur dans une fonction d'appartenance tout en gagnant de la valeur dans la suivante. En d'autres termes, son classement dans la catégorie du froid diminue au fur et à mesure qu'il devient mieux classé dans la catégorie plus chaud.

À n'importe quelle période échantillonnée, la "valeur de vérité" de la température du frein sera presque toujours dans une certaine mesure une partie de deux fonctions d'appartenance : c'est-à-dire : « 0,6 nominal et 0,4 chaud », ou « 0,7 nominal et 0,3 froid », et ainsi de suite.

L'exemple ci-dessus montre une application simple, utilisant l' abstraction de valeurs à partir de plusieurs valeurs. Cela ne représente qu'un seul type de données, cependant, dans ce cas, la température.

L'ajout de sophistication supplémentaire à ce système de freinage pourrait se faire par des facteurs supplémentaires tels que la traction , la vitesse, l' inertie , mis en place dans des fonctions dynamiques, selon le système flou conçu.

Interprétation logique de la commande floue

Malgré l'apparence, il existe plusieurs difficultés pour donner une interprétation logique rigoureuse des règles SI-ALORS . À titre d'exemple, interprétez une règle comme SI (la température est "froide") ALORS (le chauffage est "élevé") par la formule du premier ordre Froid(x)→Élevé(y) et supposez que r est une entrée telle que Froid(r ) est faux. Alors la formule Cold(r)→High(t) est vraie pour tout t et donc tout t donne un contrôle correct étant donné r . Une justification logique rigoureuse du contrôle flou est donnée dans le livre de Hájek (voir chapitre 7) où le contrôle flou est représenté comme une théorie de la logique de base de Hájek.

Dans Gerla 2005, une autre approche logique de la commande floue est proposée, basée sur la programmation en logique floue : Notons par f la fonction floue issue d'un système de règles SI-ALORS. Ensuite, ce système peut être traduit en un programme flou P contenant une série de règles dont la tête est "Bonne(x,y)". L'interprétation de ce prédicat dans le modèle de Herbrand le moins flou de P coïncide avec f. Cela donne d'autres outils utiles pour le contrôle flou.

Simulation qualitative floue

Avant qu'un système d'intelligence artificielle soit capable de planifier la séquence d'action, une sorte de modèle est nécessaire. Pour les jeux vidéo, le modèle est égal aux règles du jeu. Du point de vue de la programmation, les règles du jeu sont implémentées sous la forme d'un moteur physique qui accepte une action d'un joueur et calcule si l'action est valide. Une fois l'action exécutée, le jeu est en état de suivi. Si le but n'est pas seulement de jouer à des jeux mathématiques mais de déterminer les actions pour des applications du monde réel, le goulot d'étranglement le plus évident est qu'aucune règle de jeu n'est disponible. La première étape consiste à modéliser le domaine. L'identification du système peut être réalisée avec des équations mathématiques précises ou avec des règles floues .

L'utilisation de la logique floue et des systèmes ANFIS (système d'inférence floue basé sur un réseau adaptatif) pour créer le modèle avancé pour un domaine présente de nombreux inconvénients. Une simulation qualitative n'est pas en mesure de déterminer l'état de suivi correct, mais le système ne fera que deviner ce qui se passera si l'action a été entreprise. La simulation qualitative floue ne peut pas prédire les valeurs numériques exactes, mais elle utilise un langage naturel imprécis pour spéculer sur l'avenir. Il prend la situation actuelle ainsi que les actions du passé et génère l'état de suivi attendu du jeu.

La sortie du système ANFIS ne fournit pas d'informations correctes, mais seulement une notation d' ensemble flou , par exemple [0,0.2,0.4,0]. Après avoir reconverti la notation définie en valeurs numériques, la précision se détériore. Cela fait de la simulation qualitative floue un mauvais choix pour les applications pratiques.

Applications

Les systèmes de contrôle flou conviennent lorsque la complexité du processus est élevée, y compris l'incertitude et le comportement non linéaire, et qu'il n'existe pas de modèles mathématiques précis disponibles. Des applications réussies de systèmes de contrôle flou ont été signalées dans le monde entier, principalement au Japon, avec des solutions pionnières depuis les années 80.

Certaines applications rapportées dans la littérature sont :

Climatiseurs
Systèmes de mise au point automatique dans les caméras
Appareils ménagers (réfrigérateurs, machines à laver...)
Contrôle et optimisation des processus et systèmes industriels
Systèmes d'écriture
Efficacité énergétique dans les moteurs
Environnement
Systèmes experts
Arbres de décision
Robotique
Véhicules autonomes

Voir également

Les références

Lectures complémentaires

Kevin M. Passino et Stephen Yurkovich, Fuzzy Control, Addison Wesley Longman, Menlo Park, Californie, 1998 (522 pages)
Kazuo Tanaka ; Hua O. Wang (2001). Conception et analyse de systèmes de contrôle flous : une approche d'inégalité matricielle linéaire . John Wiley et fils. ISBN 978-0-471-32324-2.
Cox, E. (oct. 1992). Fondamentaux flous . Spectre IEEE, 29:10. p. 58-61.
Cox, E. (février 1993) Systèmes flous adaptatifs . Spectre IEEE, 30:2. p. 7–31.
Jan Jantzen, "Tuning Of Fuzzy PID Controllers", Université technique du Danemark, rapport 98-H 871, 30 septembre 1998. [1]
Jan Jantzen, Fondements du contrôle flou . Wiley, 2007 (209 pages) (Table des matières)
Intelligence computationnelle : une introduction méthodologique par Kruse, Borgelt, Klawonn, Moewes, Steinbrecher, Held, 2013, Springer, ISBN 9781447150121

Languages

In other projects