Systèmes neuro-flous (ANFIS) : des règles floues qui apprennent à partir des données

Un système flou de Sugeno sous forme de réseau à cinq couches, l’apprentissage hybride par moindres carrés et gradient, l’apprentissage d’une fonction à partir de données bruitées, le choix du nombre de règles et le surapprentissage, la lisibilité des règles apprises et le lien avec les réseaux RBF.

13 minutes Matěj Žalmánek 2026-10-15

Série Bases de l’IA Partie 37 sur 52

Programme complet de la série 52 sur 83 sujets publiés

Ce que vous retiendrez

Comment un système flou de Sugeno s’écrit sous forme de réseau et quels paramètres y sont appris.
Pourquoi l’apprentissage hybride (moindres carrés plus gradient) devance la descente de gradient pure.
Pourquoi multiplier les règles expose au surapprentissage et ce qui reste de la lisibilité des règles apprises.

Utile à connaître avant : Commande floue : Mamdani et Sugeno, du ventilateur au pendule inversé sur un chariot, Descente de gradient : comment un modèle apprend

Les régulateurs flous des parties précédentes avaient un point faible : quelqu’un devait inventer les règles comme les fonctions d’appartenance. Quand un opérateur expérimenté existe, c’est un avantage. Quand il n’existe pas — ou quand le système doit reproduire des données mesurées —, c’est un problème. Les réseaux de neurones sont de nature opposée : ils apprennent n’importe quoi à partir des données, mais personne ne peut lire ce qu’ils ont appris. En 1993, Jyh-Shing Roger Jang a réuni les deux dans le système ANFIS (Adaptive Neuro-Fuzzy Inference System) : un système flou de Sugeno écrit sous forme de réseau, dont les paramètres sont appris à partir des données. Cette partie clôt le module sur la logique floue.

Elle fait suite à Commande floue : Mamdani et Sugeno et à Descente de gradient.

1. Un système flou sous forme de réseau

Prenons un système de Sugeno du premier ordre à une entrée et quatre règles « SI x est A_i, ALORS y = p_ix + r_i ». Chaque étape de son calcul est une couche du réseau :

ANFIS à une entrée et quatre règles ; en orange, les couches aux paramètres appris

Définition — ANFIS (Jang, 1993)

Appartenance : μ_i(x) = exp(−(x − c_i)² / 2σ_i²) — une fonction gaussienne de centre c_i et de largeur σ_i.
Force de la règle : w_i = produit des appartenances de la prémisse (avec une seule entrée, simplement μ_i(x)).
Normalisation : w̄_i = w_i / ∑_j w_j.
Conclusion : w̄_i · (p_ix + r_i).
Somme : y = ∑_i w̄_i (p_ix + r_i).

Les paramètres des prémisses sont c_i, σ_i ; les paramètres des conclusions, p_i, r_i.

En termes simples

C’est exactement le régulateur de Sugeno de la partie précédente, simplement dessiné comme un réseau. Chaque règle a sa « zone d’influence » (une colline gaussienne) et, à l’intérieur, une prédiction linéaire. La sortie est la moyenne des prédictions, pondérée selon le degré auquel l’entrée se trouve dans la zone de chaque règle. Tout le système est dérivable, et on peut donc l’entraîner exactement comme un réseau de neurones.

y = ∑_i w_i / ∑_j w_j · (p_ix + r_i)

y: sortie de tout le système pour l’entrée x — ce que l’on compare aux données et ce qui sert à mesurer l’erreur
∑_i: somme sur toutes les règles — chacune contribue, aucune n’est « choisie » ; c’est pourquoi la sortie est lisse et dérivable
w_i / ∑_j w_j: force normalisée w̄_i — la division par la somme garantit que les poids ont pour somme 1, si bien que la sortie est une moyenne pondérée des conclusions et ne dépend pas de la hauteur des collines
p_ix + r_i: conclusion linéaire de la règle — une droite locale qui décrit la fonction dans la zone de la règle ; une droite au lieu d’une constante permet de suivre aussi la pente avec peu de règles

La sortie est la moyenne des droites locales, pondérée par le degré auquel l’entrée appartient à la zone de chaque règle.

μ_i(x) = exp( − (x − c_i)² / 2σ_i² )

μ_i(x): degré d’appartenance dans [0, 1] — à quel point x est « autour de c_i » ; l’exponentielle d’un nombre négatif est toujours entre 0 et 1 et vaut exactement 1 au centre
(x − c_i)²: carré de la distance au centre — l’appartenance décroît de la même façon des deux côtés et reste lisse même au centre (avec une valeur absolue, elle y aurait une pointe et la dérivée n’existerait pas)
2σ_i²: largeur de la colline — la distance se mesure en unités de σ_i, si bien qu’à la distance σ_i du centre, l’appartenance vaut toujours e^−1/2 ≈ 0,61 ; en apprenant σ_i, on change la portée de la règle

Exemple — propagation avant au point x = 3

Prenons le système après l’époque zéro de l’apprentissage (voir plus bas) : centres c = 0, 2, 4, 6, toutes les largeurs σ = 1 et des conclusions obtenues par les moindres carrés. Pour x = 3, les distances aux centres sont 3, 1, 1, 3, et donc

appartenance et force : w = (e^−4,5 ; e^−0,5 ; e^−0,5 ; e^−4,5) = (0,0111 ; 0,6065 ; 0,6065 ; 0,0111) ;
normalisation : la somme vaut 1,2353, donc w̄ = (0,0090 ; 0,4910 ; 0,4910 ; 0,0090) ;
conclusions : les droites p_ix + r_i aux coefficients appris (9,54x + 0,01 ; 9,34x − 17,38 ; 8,56x − 36,61 ; 2,60x − 18,90) valent au point 3 (28,63 ; 10,66 ; −10,94 ; −11,09) — les coefficients sont arrondis, les valeurs calculées à partir des coefficients exacts ;
somme : y = 0,2574 + 5,2329 − 5,3698 − 0,0997 ≈ 0,021.

La vraie valeur est sin(3) = sin(3²/3) ≈ 0,141. Remarquez que la sortie naît de la soustraction de deux grandes contributions presque égales — nous y reviendrons à propos de la lisibilité.

2. L’apprentissage hybride

Nous voulons minimiser l’erreur quadratique moyenne sur les données d’entraînement. On pourrait tout faire par descente de gradient. Jang a toutefois remarqué que la sortie est linéaire en les paramètres des conclusions.

Définition — erreur quadratique moyenne et RMSE

Pour des données (x₁, y₁), …, (x_N, y_N) et une sortie du modèle ŷ(x), l’erreur quadratique moyenne est E = (1/N) ∑_k (ŷ(x_k) − y_k)², et la RMSE (root mean square error) est sa racine carrée √E. Minimiser l’une ou l’autre revient au même ; on indique pourtant la RMSE, car elle a les unités de la sortie. Toutes les erreurs de cette partie sont des RMSE.

RMSE = √( (1/N) ∑_k (ŷ(x_k) − y_k)² )

ŷ(x_k): prédiction du système au k-ième point — le seul endroit par lequel les paramètres c, σ, p, r entrent dans l’erreur
− y_k, puis au carré: écart à la valeur mesurée, élevé au carré — le signe ne compte pas, les grandes erreurs pèsent plus que les petites, et le carré se dérive sans accroc (et, pour les conclusions, permet une solution exacte par les moindres carrés)
(1/N) ∑_k: moyenne sur les points — l’erreur sur 40 points d’entraînement et sur 121 points de test est alors comparable

La racine finale ramène l’erreur dans les unités de y : une RMSE de 0,1 signifie « typiquement à 0,1 près ».

Algorithme — apprentissage hybride

Avec des prémisses fixées, y(x) = ∑_i (w̄_ix) p_i + w̄_i r_i est une fonction linéaire des paramètres des conclusions. À chaque époque, donc :

en avant : calcule w̄_i pour toutes les données et trouve exactement les paramètres des conclusions par la méthode des moindres carrés ;
en arrière : avec les conclusions ainsi trouvées, fais un pas de descente de gradient pour les centres c_i et les largeurs σ_i.

En termes simples

Là où un problème peut être résolu exactement, résolvez-le exactement ; ne laissez au gradient que ce qui ne peut pas l’être. La régression linéaire de la partie sur la statistique trouve la meilleure droite en un seul calcul — et ici, elle trouve d’un coup les meilleures conclusions linéaires de toutes les règles. Le gradient ne fait plus que déplacer et élargir les collines des fonctions d’appartenance.

Définition — moindres carrés pour les conclusions

Avec c_i, σ_i fixés, les w̄_i(x_k) ne sont que des nombres. Rangeons les paramètres des conclusions dans un vecteur θ = (p₁, r₁, …, p_n, r_n) et formons pour chaque point la ligne

a_k = (w̄₁x_k, w̄₁, …, w̄_nx_k, w̄_n), si bien que ŷ(x_k) = a_k · θ.

Les lignes forment une matrice A (N × 2n) et l’erreur vaut ‖Aθ − y‖²/N. Son minimum vérifie les équations normales A^TA θ = A^Ty — un système de 2n équations linéaires. Pour 4 règles et 40 points, A est une matrice 40 × 8 et le système compte 8 équations. Notre calcul ajoute en outre 10⁻⁶ à la diagonale de A^TA (un petit terme de crête), pour que le système reste soluble même avec des colonnes presque dépendantes, et le résout par élimination de Gauss.

Théorème — gradient par rapport au centre et à la largeur

Notons g_i = p_ix + r_i et W = ∑_j w_j. De ŷ = ∑_j w_jg_j / W, la dérivée d’un quotient donne ∂ŷ/∂w_i = (g_i − ŷ)/W. Les dérivées de la colline gaussienne sont ∂w_i/∂c_i = w_i(x − c_i)/σ_i² et ∂w_i/∂σ_i = w_i(x − c_i)²/σ_i³. Par la règle de dérivation en chaîne,

∂E/∂c_i = (2/N) ∑_k (ŷ − y_k) (g_i − ŷ) w̄_i (x_k − c_i)/σ_i²,

∂E/∂σ_i = (2/N) ∑_k (ŷ − y_k) (g_i − ŷ) w̄_i (x_k − c_i)²/σ_i³,

où ŷ, g_i et w̄_i sont pris au point x_k.

∂E/∂c_i = (2/N) ∑_k (ŷ − y_k) (g_i − ŷ) w̄_i (x_k − c_i)/σ_i²

∂E/∂c_i: comment l’erreur change si l’on déplace le centre de la i-ième colline — le pas d’apprentissage va à l’opposé de ce signe
ŷ − y_k: erreur au point — là où le système vise juste, le point ne demande rien et ne contribue pas au gradient
g_i − ŷ: en quoi la conclusion de la règle diffère de la sortie globale — donner plus de poids à la règle tire la sortie vers sa conclusion ; quand la conclusion dit la même chose que l’ensemble, déplacer la colline n’a pas de sens
w̄_i: part de la règle dans la sortie — les points éloignés de la colline, où la règle ne dit presque rien, n’influencent guère son centre
(x_k − c_i)/σ_i²: direction du déplacement — un point à droite du centre tire la colline vers la droite, un point à gauche vers la gauche ; au centre même, la colline est plate et un déplacement ne change rien

Pour la largeur, la formule est la même, seul le dernier terme devient (x_k − c_i)²/σ_i³ : les points éloignés veulent élargir ou rétrécir la colline, la direction n’a pas d’importance.

Tout l’apprentissage de l’exemple ci-dessous en pseudocode (pas η = 0,1, 300 époques) :

c = centres répartis uniformément sur [0, 6]   # pour 4 règles 0, 2, 4, 6
σ = moitié de l’écart entre les centres        # pour 4 règles 1
for epocha in 0 … 300:
    # en avant : couches 1–3, puis conclusions exactes par les moindres carrés
    wn[k][i] = w̄_i(x_k)  pour tous les points k et toutes les règles i
    A = lignes (wn[k][1]·x_k, wn[k][1], …, wn[k][n]·x_k, wn[k][n])
    p, r = résoudre (AᵀA + 10⁻⁶·I)·θ = Aᵀy
    if epocha == 300: break
    # en arrière : pas de gradient selon les formules ci-dessus
    gc, gσ = ∂E/∂c, ∂E/∂σ
    c = c − η·gc
    σ = max(0,05; σ − η·gσ)  # la colline ne doit pas disparaître

3. ANFIS apprend une fonction

La tâche : à partir de 40 échantillons bruités (bruit d’écart-type 0,1), apprendre la fonction y = sin(x²/3) sur l’intervalle [0, 6]. Vers la droite, la fonction ondule de plus en plus vite, si bien que quatre règles réparties uniformément ne sont pas idéales. Nous mesurons aussi l’erreur sur 121 points sans bruit, en dehors des données d’entraînement :

Apprentissage d’un ANFIS à quatre règles : en haut la sortie, en bas les fonctions d’appartenance

Dès l’époque zéro — avec seulement les moindres carrés pour les conclusions et des collines régulières —, l’erreur de test est de 0,394 et l’erreur sur les données d’entraînement de 0,198. Puis les prémisses commencent à apprendre. Après 100 époques, l’erreur de test vaut 0,202, et après 300 époques 0,173. Sur les données d’entraînement, elle descend à 0,107 — sous le niveau de bruit des données (0,114) ; on ne peut raisonnablement pas faire mieux. Les centres des collines n’ont que peu bougé ; le changement principal concerne les largeurs — la dernière règle à droite, là où la fonction ondule le plus vite, s’est rétrécie de 1 à 0,64.

Définition — niveau de bruit des données

Les points d’entraînement sont y_k = f(x_k) + ε_k, où f(x) = sin(x²/3) et les ε_k sont des écarts aléatoires indépendants tirés d’une loi normale d’écart-type 0,1. Le niveau de bruit est la RMSE qu’aurait la vraie fonction elle-même sur les données d’entraînement : √((1/40) ∑_k ε_k²) = 0,114. Il dépasse un peu 0,1 par pur hasard — dans nos 40 écarts tirés au sort.

Un modèle dont l’erreur sur les données d’entraînement est inférieure au niveau de bruit (0,107 < 0,114) commence déjà à copier aussi les écarts aléatoires. Avec une différence aussi faible, ce n’est pas encore gênant — l’erreur de test continue de baisser —, mais c’est un premier avertissement, auquel nous reviendrons à propos du nombre de règles.

Erreur de test : apprentissage hybride contre gradient pur hybride gradient seul en pointillés, le bruit des données

La descente de gradient pure pour tous les paramètres part de conclusions nulles et apprend beaucoup plus lentement : après 300 époques, son erreur de test est de 0,387, et même après 3 000 époques (0,188), elle ne rattrape pas l’apprentissage hybride après 300. Un pas d’apprentissage plus grand mène en outre rapidement à la divergence. Séparer le problème en une partie linéaire et une partie non linéaire en vaut la peine.

4. Combien de règles ?

Nombre de règles	2	3	4	6	8	12
Erreur sur les données d’entraînement	0,510	0,181	0,107	0,098	0,089	0,085
Erreur de test	0,590	0,177	0,173	0,172	0,566	0,319

À mesure que les règles s’ajoutent, l’erreur sur les données d’entraînement ne cesse de baisser. Sur le test, en revanche, elle augmente brusquement à partir de huit règles — le système s’est mis à apprendre le bruit : avec 40 points et 32 paramètres (8 règles × 4), il a assez de liberté pour osciller follement entre les points d’entraînement. C’est le surapprentissage, le même phénomène qu’avec une régression polynomiale trop tordue. Un nombre raisonnable de règles se situe ici entre trois et six.

Exemple — combien de paramètres compte un ANFIS

Avec une seule entrée, chaque règle a deux paramètres de prémisse (c_i, σ_i) et deux paramètres de conclusion (p_i, r_i), soit 4n au total. Pour 40 points d’entraînement :

4 règles : 16 paramètres, dont 8 linéaires — 5 points par paramètre linéaire ;
8 règles : 32 paramètres, dont 16 linéaires — 2,5 points par paramètre linéaire, et les moindres carrés ont ainsi assez de liberté pour ajuster aussi le bruit ;
12 règles : 48 paramètres — plus qu’il n’y a de points. Les moindres carrés ne déterminent certes « que » 24 conclusions à partir de 40 équations, mais les 24 autres paramètres des prémisses peuvent déplacer et rétrécir les collines exactement là où le bruit vient de s’écarter.

Une règle empirique utile : il devrait y avoir au moins plusieurs fois plus de points que de paramètres estimés à partir d’eux.

5. Ce que l’on peut lire

La promesse des systèmes neuro-flous est que le modèle appris reste lisible. Les prémisses le sont : quatre règles « autour de 0 », « autour de 2,2 », « autour de 4 » et « autour de 6,2 ». Les conclusions, non. La règle « SI x est autour de 2,2, ALORS y = 10,06 x − 13,83 » prédirait 8,25 en son centre, alors que la vraie valeur est 1,0. Les règles se compensent les unes les autres — les collines se chevauchent beaucoup et la sortie n’a de sens que comme un tout.

Exemple — comment les règles se compensent au point x = 2,195

Le centre appris de la deuxième règle est c₂ = 2,195. Là, la deuxième règle a une appartenance pleine (w₂ = 1), mais ses voisines n’ont pas une appartenance nulle : w = (0,140 ; 1 ; 0,331 ; 0,000), somme 1,471, donc

Règle	1	2	3	4
poids `w̄`_i	0,095	0,680	0,225	0,000
conclusion `g`_i	12,64	8,25	−25,64	−31,68
contribution `w̄`_i`g`_i	1,203	5,609	−5,769	0,000

La somme vaut y = 1,203 + 5,609 − 5,769 = 1,043, la vraie valeur sin(2,195²/3) = 0,999. La sortie est bonne, mais elle naît de la différence de deux contributions d’environ ±5,7 : la deuxième règle « tire trop haut » et la troisième la ramène vers le bas. Aucune règle ne dit à elle seule combien vaut y.

L’interprétabilité n’est donc pas gratuite. Des contraintes aident à la préserver : un moindre chevauchement des fonctions d’appartenance, une régularisation des conclusions, ou un Sugeno d’ordre zéro à conclusions constantes. On le paie en précision. C’est le même équilibre que partout en apprentissage automatique — entre ce que le modèle sait faire et ce que nous savons en dire.

6. ANFIS et les réseaux de neurones

La parenté avec les réseaux RBF. Jang et Sun ont montré en 1993 que les réseaux à fonctions de base radiales et les systèmes flous de Sugeno d’ordre zéro sont, sous des conditions peu restrictives, la même chose, simplement interprétée autrement.
La malédiction de la dimension. Avec n entrées et k termes par entrée, la grille des règles compte kⁿ règles — pour 10 entrées et 3 termes, plus de 59 000. C’est pourquoi on utilise ANFIS pour peu d’entrées, ou avec des règles choisies par clustering (par exemple fuzzy c-means de la partie précédente).
Les applications. La prévision de séries temporelles (le test classique est la série chaotique de Mackey–Glass), la modélisation et la commande de systèmes pour lesquels on dispose de données mesurées, mais de peu de théorie.
Aujourd’hui. Les réseaux profonds ont depuis longtemps repris les tâches à nombreuses entrées. L’idée « entraînable, mais lisible » continue pourtant de vivre dans l’IA explicable — et des couches floues sont parfois ajoutées même aux réseaux profonds, là où il faut pouvoir expliquer la sortie par des règles.

Définition — réseau à fonctions de base radiales (RBF)

Un réseau RBF normalisé à n neurones cachés calcule

y(x) = ∑_i v_i φ(‖x − c_i‖) / ∑_j φ(‖x − c_j‖),

où φ est une fonction décroissante de la distance au centre c_i (typiquement gaussienne) et les v_i sont les poids de sortie. Un système de Sugeno d’ordre zéro à appartenances gaussiennes, avec le produit comme « et », s’écrit y = ∑_i w̄_i r_i — après la substitution w_i = φ(‖x − c_i‖) et v_i = r_i, c’est exactement la même formule. Pour simplifier : règle = neurone, fonction d’appartenance = fonction de base, conclusion = poids de sortie. (Jang et Sun, 1993, énumèrent les conditions précisément : même nombre de règles et de neurones, conclusions constantes, appartenances gaussiennes de même largeur au sein d’une même règle, le produit comme « et » et la même manière de composer la sortie — moyenne pondérée ou somme pondérée.)

Exemple — la malédiction de la dimension en chiffres

Avec n entrées et k termes par entrée, la grille complète compte kⁿ règles. Une conclusion de Sugeno du premier ordre y = p₁x₁ + … + p_nx_n + r a n + 1 paramètres, si bien qu’il y a kⁿ(n + 1) paramètres linéaires. Les paramètres des prémisses ne sont que 2kn — chaque entrée a ses k collines, partagées par toutes les règles.

Pour n = 10 et k = 3 : 3¹⁰ = 59 049 règles, 59 049 · 11 = 649 539 paramètres de conclusion et 2 · 3 · 10 = 60 paramètres de prémisse. Les moindres carrés devraient résoudre un système à 649 539 inconnues — et il faudrait encore beaucoup plus de données.

7. Résumé

ANFIS est un système flou de Sugeno écrit sous forme de réseau à cinq couches : appartenance, force, normalisation, conclusion, somme.
L’apprentissage hybride trouve les conclusions linéaires exactement par les moindres carrés et affine par le gradient les centres et les largeurs des fonctions d’appartenance.
Sur la fonction sin(x²/3), l’apprentissage des prémisses a fait baisser l’erreur de test de 0,394 à 0,173 ; le gradient pur a eu besoin de dix fois plus d’époques pour un résultat moins bon.
Trop de règles mènent au surapprentissage — à partir de huit règles, l’erreur de test augmente brusquement.
Les prémisses restent lisibles, mais les conclusions se compensent les unes les autres ; l’interprétabilité doit être surveillée.

Cette partie clôt le module sur la logique floue : du mot « chaud » à un système qui apprend lui-même ses règles, en passant par la logique et les régulateurs. Envie de mettre la main à la pâte ? Demandez à un agent d’IA d’entraîner un ANFIS sur la consommation d’électricité en fonction de la température à partir de données publiques — puis regardez quelles règles ont du sens.

Vous voyez les choses autrement ? Écrivez à support@coden-app.com.