Sistemi neuro-fuzzy (ANFIS): regole fuzzy che imparano dai dati

Un sistema fuzzy di Sugeno come rete a cinque strati, apprendimento ibrido con minimi quadrati e gradiente, apprendimento di una funzione da dati rumorosi, scelta del numero di regole e overfitting, leggibilità delle regole apprese e legame con le reti RBF.

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

Serie Basi di IA Parte 37 di 52

1. Mappa dell’intelligenza artificiale: che cos’è ciascuna cosa e come si incastra tutto
2. Breve storia dell’intelligenza artificiale: da Turing ai modelli linguistici
3. Dati, modello, addestramento, inferenza: i concetti di base su un unico esempio
4. Come leggere la notazione matematica: simboli, indici, sommatorie e quantificatori
5. Insiemi e relazioni: i mattoncini con cui si costruiscono le definizioni nell’IA
6. Funzioni e applicazioni: perché ogni modello di IA è una funzione
7. Logica e dimostrazioni: le regole con cui si ragiona nell’IA
8. Grafi e alberi: la struttura su cui poggiano la ricerca e le reti neurali
9. Algebra lineare per l’apprendimento automatico: vettori, matrici e perché l’IA soprattutto moltiplica
10. Derivate, gradiente e regola della catena: come un modello capisce in quale direzione imparare
11. Discesa del gradiente: come impara un modello
12. Che cos’è la probabilità: dal lancio di un dado agli assiomi di Kolmogorov
13. Probabilità condizionata e teorema di Bayes: come cambiare una stima quando scopri qualcosa di nuovo
14. Variabile aleatoria e funzione di ripartizione: una sola funzione che dice tutto sulla distribuzione
15. Funzione di densità e funzione di massa: perché una variabile continua ha probabilità zero in un punto
16. Valore atteso, varianza e covarianza: dove si trova una distribuzione, quanto è larga e che cosa è legato a che cosa
17. Panoramica delle distribuzioni di probabilità: Bernoulli, binomiale, Poisson, uniforme, normale ed esponenziale
18. Legge dei grandi numeri e teorema del limite centrale: perché le medie si comportano in modo così prevedibile
19. Statistica e stima dei parametri: massima verosimiglianza, MAP e intervalli di confidenza
20. Teoria dell’informazione: entropia, entropia incrociata e divergenza KL — da dove vengono le funzioni di perdita
21. Ricerca nello spazio degli stati: BFS, DFS, UCS e A* con animazioni
22. Giochi e avversari: minimax, potatura alfa-beta e Monte Carlo tree search
23. Soddisfacimento di vincoli: backtracking, propagazione dei vincoli e AC-3 su un sudoku e una mappa delle regioni ceche
24. Logica e sistemi basati sulla conoscenza: concatenazione in avanti e all’indietro, risoluzione e sistemi esperti
25. Pianificazione: STRIPS, il mondo dei blocchi, euristiche dal rilassamento e pianificazione negli agenti IA
26. Ricerca locale e ricottura simulata: un commesso viaggiatore tra i capoluoghi di regione cechi
27. Algoritmi genetici: popolazione, incrocio, mutazione e selezione su uno zaino per l’escursione
28. Strategie evolutive e programmazione genetica: dalla regola di un quinto alla legge di Keplero
29. Ottimizzazione con colonie di formiche: come una traccia di feromone trova un percorso breve
30. Ottimizzazione a sciame di particelle: inerzia, esperienza propria ed esperienza dello sciame
31. Neuroevoluzione: evoluzione dei pesi e della forma delle reti neurali e l’algoritmo NEAT
32. Insiemi fuzzy e funzioni di appartenenza: come scrivere «un po’ caldo»
33. Logica fuzzy e probabilità: perché «un po’ caldo» non significa «probabilmente caldo»
34. Logica fuzzy: t-norme, implicazioni e regole SE–ALLORA
35. Controllo fuzzy: Mamdani e Sugeno, dal ventilatore al pendolo inverso su un carrello
36. Clustering fuzzy: l’algoritmo fuzzy c-means e i punti tra i cluster
37. Sistemi neuro-fuzzy (ANFIS): regole fuzzy che imparano dai dati
38. Catene di Markov: matrice di transizione, distribuzione stazionaria e PageRank
39. Modelli di Markov nascosti: l’algoritmo di Viterbi e il casinò disonesto
40. Reti bayesiane: perché l’erba è bagnata e che cosa significa per l’irrigatore
41. Filtro di Kalman: come stimare da misure imprecise dove si trova un’auto e a che velocità va
42. Tipi di apprendimento automatico: supervisionato, non supervisionato, semi-supervisionato e altri
43. Prompt, contesto e RAG: come dare a un modello le informazioni giuste
44. Autoencoder variazionali (VAE): immagini nuove da uno spazio latente continuo
45. Reti generative avversarie (GAN): il falsario contro il detective
46. Modelli di diffusione: come il rumore puro diventa un’immagine
47. Processi decisionali di Markov: stati, azioni, ricompense ed equazioni di Bellman
48. Q-learning e DQN: imparare il valore delle azioni, dalla tabella alla rete neurale
49. Policy gradient e PPO: imparare direttamente la politica
50. Come funziona un agente IA: un modello linguistico in un ciclo con strumenti
51. Programmare con agenti IA: incarico, test e controllo
52. Valutazione e sicurezza dei sistemi di IA: come misurare e come sorvegliare

Programma completo della serie 52 di 83 argomenti pubblicati

I controllori fuzzy delle parti precedenti avevano un punto debole: regole e funzioni di appartenenza doveva inventarle qualcuno. Quando un operatore esperto esiste, è un vantaggio. Quando no — o quando il sistema deve riprodurre dati misurati —, è un problema. Le reti neurali hanno la natura opposta: imparano qualunque cosa dai dati, ma quello che hanno imparato non lo legge nessuno. Nel 1993 Jyh-Shing Roger Jang unì le due cose nel sistema ANFIS (Adaptive Neuro-Fuzzy Inference System): un sistema fuzzy di Sugeno scritto come rete, i cui parametri si imparano dai dati. Con questa parte si chiude il modulo sulla logica fuzzy.

Riprende le parti Controllo fuzzy: Mamdani e Sugeno e Discesa del gradiente.

1. Un sistema fuzzy come rete

Prendiamo un sistema di Sugeno del primo ordine con un ingresso e quattro regole «SE x è A_i, ALLORA y = p_ix + r_i». Ogni passo del suo calcolo è uno strato della rete:

Definizione — ANFIS (Jang, 1993)

1. Appartenenza: μ_i(x) = exp(−(x − c_i)² / 2σ_i²) — funzione gaussiana con centro c_i e larghezza σ_i.
2. Forza della regola: w_i = prodotto delle appartenenze della premessa (con un solo ingresso è solo μ_i(x)).
3. Normalizzazione: w̄_i = w_i / ∑_j w_j.
4. Conseguente: w̄_i · (p_ix + r_i).
5. Somma: y = ∑_i w̄_i (p_ix + r_i).

I parametri delle premesse sono c_i, σ_i; i parametri dei conseguenti p_i, r_i.

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

y

l’uscita dell’intero sistema per l’ingresso x — ciò che confrontiamo con i dati durante l’apprendimento

∑_i

somma su tutte le regole — ciascuna contribuisce, nessuna viene «scelta»; per questo l’uscita è liscia e si può derivare

w_i / ∑_j w_j

forza normalizzata w̄_i — la divisione per la somma garantisce che i pesi diano insieme 1, così l’uscita è una media pesata dei conseguenti e non dipende da quanto sono alte le colline

p_ix + r_i

conseguente lineare della regola — una retta locale che descrive la funzione nella zona della regola; una retta invece di una costante permette di seguire anche la pendenza con poche regole

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

μ_i(x)

grado di appartenenza in [0, 1] — quanto x è «intorno a c_i»; l’esponenziale di un numero negativo sta sempre tra 0 e 1 e nel centro vale esattamente 1

(x − c_i)²

quadrato della distanza dal centro — l’appartenenza cala allo stesso modo da entrambi i lati ed è liscia anche nel centro (con il valore assoluto lì avrebbe una punta e la derivata non esisterebbe)

2σ_i²

larghezza della collina — la distanza si misura in unità di σ_i, quindi a distanza σ_i dal centro l’appartenenza è sempre e^−1/2 ≈ 0,61; imparando σ_i cambia fin dove la regola «arriva»

Esempio — passaggio in avanti nel punto x = 3

Prendiamo il sistema dopo l’epoca zero dell’apprendimento (vedi sotto): centri c = 0, 2, 4, 6, tutte le larghezze σ = 1 e conseguenti dai minimi quadrati. Per x = 3 le distanze dai centri sono 3, 1, 1, 3, e quindi

1. appartenenza e forza: w = (e^−4,5; e^−0,5; e^−0,5; e^−4,5) = (0,0111; 0,6065; 0,6065; 0,0111);
2. normalizzazione: la somma è 1,2353, quindi w̄ = (0,0090; 0,4910; 0,4910; 0,0090);
3. conseguenti: le rette p_ix + r_i con i coefficienti appresi (9,54x + 0,01; 9,34x − 17,38; 8,56x − 36,61; 2,60x − 18,90) hanno nel punto 3 i valori (28,63; 10,66; −10,94; −11,09) — i coefficienti sono arrotondati, i valori calcolati da quelli esatti;
4. somma: y = 0,2574 + 5,2329 − 5,3698 − 0,0997 ≈ 0,021.

Il valore vero è sin(3) = sin(3²/3) ≈ 0,141. Nota che l’uscita nasce sottraendo due contributi grandi e quasi uguali — ci torneremo parlando di leggibilità.

2. Apprendimento ibrido

Vogliamo minimizzare l’errore quadratico medio sui dati di addestramento. Si potrebbe fare tutto con la discesa del gradiente. Jang però notò che l’uscita è lineare nei parametri dei conseguenti.

Definizione — errore quadratico medio e RMSE

Per i dati (x₁, y₁), …, (x_N, y_N) e l’uscita del modello ŷ(x), l’errore quadratico medio è E = (1/N) ∑_k (ŷ(x_k) − y_k)² e l’RMSE (root mean square error) è la sua radice √E. Minimizzare l’uno o l’altra è la stessa cosa; si riporta però l’RMSE perché ha le unità dell’uscita. Tutti gli errori in questa parte sono RMSE.

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

ŷ(x_k)

previsione del sistema nel k-esimo punto — l’unico punto da cui i parametri c, σ, p, r entrano nell’errore

− y_k, poi al quadrato

scarto dal valore misurato, elevato al quadrato — il segno non conta, gli errori grandi pesano più di quelli piccoli e il quadrato si deriva senza problemi (e per i conseguenti permette la soluzione esatta con i minimi quadrati)

(1/N) ∑_k

media sui punti — l’errore sui 40 punti di addestramento e sui 121 punti di test diventa così confrontabile

Algoritmo — apprendimento ibrido

Con le premesse fisse, y(x) = ∑_i (w̄_ix) p_i + w̄_i r_i è una funzione lineare dei parametri dei conseguenti. In ogni epoca quindi:

1. in avanti: calcola w̄_i per tutti i dati e trova i parametri dei conseguenti in modo esatto con il metodo dei minimi quadrati;
2. all’indietro: con i conseguenti così trovati fai un passo di discesa del gradiente per i centri c_i e le larghezze σ_i.

Definizione — minimi quadrati per i conseguenti

Con c_i, σ_i fissi, i w̄_i(x_k) sono semplici numeri. Mettiamo i parametri dei conseguenti in un vettore θ = (p₁, r₁, …, p_n, r_n) e per ogni punto costruiamo la riga

a_k = (w̄₁x_k, w̄₁, …, w̄_nx_k, w̄_n), così che ŷ(x_k) = a_k · θ.

Le righe formano la matrice A (N × 2n) e l’errore è ‖Aθ − y‖²/N. Il suo minimo soddisfa le equazioni normali A^TA θ = A^Ty — un sistema di 2n equazioni lineari. Per 4 regole e 40 punti A è una matrice 40 × 8 e il sistema ha 8 equazioni. Il nostro calcolo aggiunge alla diagonale di A^TA anche 10⁻⁶ (un piccolo termine ridge), perché il sistema sia risolvibile anche con colonne quasi dipendenti, e lo risolve con l’eliminazione di Gauss.

Teorema — gradiente rispetto a centro e larghezza

Poniamo g_i = p_ix + r_i e W = ∑_j w_j. Da ŷ = ∑_j w_jg_j / W la derivata del quoziente dà ∂ŷ/∂w_i = (g_i − ŷ)/W. Le derivate della collina gaussiana sono ∂w_i/∂c_i = w_i(x − c_i)/σ_i² e ∂w_i/∂σ_i = w_i(x − c_i)²/σ_i³. Per la regola della catena

∂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³,

dove ŷ, g_i e w̄_i si prendono nel punto x_k.

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

∂E/∂c_i

come cambia l’errore se spostiamo il centro della i-esima collina — il passo di apprendimento va contro questo segno

ŷ − y_k

errore nel punto — dove il sistema centra il valore, il punto non chiede nulla e non contribuisce al gradiente

g_i − ŷ

quanto il conseguente della regola differisce dall’uscita complessiva — dare più peso alla regola tira l’uscita verso il suo conseguente; se il conseguente dice la stessa cosa dell’insieme, spostare la collina non ha senso

w̄_i

quota della regola nell’uscita — i punti lontani dalla collina, dove la regola quasi non parla, ne influenzano appena il centro

(x_k − c_i)/σ_i²

direzione dello spostamento — un punto a destra del centro tira la collina a destra, uno a sinistra a sinistra; proprio nel centro la collina è piatta e lo spostamento non cambia nulla

L’intero apprendimento dell’esempio qui sotto in pseudocodice (passo η = 0,1, 300 epoche):

c = centri equidistanti su [0, 6]    # per 4 regole 0, 2, 4, 6
σ = metà della distanza tra i centri # per 4 regole 1
for epocha in 0 … 300:
    # in avanti: strati 1–3, poi conseguenti esatti con i minimi quadrati
    wn[k][i] = w̄_i(x_k)  per tutti i punti k e le regole i
    A = righe (wn[k][1]·x_k, wn[k][1], …, wn[k][n]·x_k, wn[k][n])
    p, r = risolvi (AᵀA + 10⁻⁶·I)·θ = Aᵀy
    if epocha == 300: break
    # all’indietro: passo del gradiente secondo le formule sopra
    gc, gσ = ∂E/∂c, ∂E/∂σ
    c = c − η·gc
    σ = max(0,05; σ − η·gσ)  # la collina non deve sparire

3. ANFIS impara una funzione

Il compito: da 40 campioni rumorosi (rumore con deviazione standard 0,1) imparare la funzione y = sin(x²/3) sull’intervallo [0, 6]. Verso destra la funzione ondeggia sempre più in fretta, quindi quattro regole distribuite uniformemente non sono l’ideale. Misuriamo l’errore anche su 121 punti senza rumore fuori dai dati di addestramento:

Già nell’epoca zero — solo con i minimi quadrati per i conseguenti e colline uniformi — l’errore sul test è 0,394 e sui dati di addestramento 0,198. Poi cominciano a imparare le premesse. Dopo 100 epoche l’errore sul test è 0,202 e dopo 300 epoche 0,173. Sui dati di addestramento scende a 0,107 — sotto il livello del rumore nei dati (0,114); ragionevolmente non si può fare meglio. I centri delle colline si sono spostati di poco; il cambiamento principale è nelle larghezze — l’ultima regola a destra, dove la funzione ondeggia più in fretta, si è ristretta da 1 a 0,64.

Definizione — livello del rumore nei dati

I punti di addestramento sono y_k = f(x_k) + ε_k, dove f(x) = sin(x²/3) e le ε_k sono scarti casuali indipendenti da una distribuzione normale con deviazione standard 0,1. Il livello del rumore è l’RMSE che sui dati di addestramento avrebbe la funzione vera stessa: √((1/40) ∑_k ε_k²) = 0,114. È un po’ più grande di 0,1 solo per caso — nei nostri 40 scarti estratti.

Un modello che sui dati di addestramento ha un errore minore del livello del rumore (0,107 < 0,114) comincia già a copiare anche gli scarti casuali. Con una differenza così piccola non è ancora un problema — l’errore sul test continua a scendere —, ma è un primo avvertimento, a cui torneremo parlando del numero di regole.

La discesa del gradiente pura per tutti i parametri parte da conseguenti nulli e impara molto più lentamente: dopo 300 epoche ha un errore sul test di 0,387 e nemmeno dopo 3 000 epoche (0,188) raggiunge l’apprendimento ibrido dopo 300. Un passo di apprendimento più grande, inoltre, porta presto alla divergenza. Dividere il problema in una parte lineare e una non lineare conviene.

4. Quante regole?

Con l’aumentare delle regole l’errore sui dati di addestramento continua a scendere. Sul test però da otto regole sale bruscamente — il sistema ha cominciato a imparare il rumore: con 40 punti e 32 parametri (8 regole × 4) ha abbastanza libertà per oscillare selvaggiamente tra i punti di addestramento. Questo è l’overfitting, lo stesso fenomeno di una regressione polinomiale troppo curvata. Un numero ragionevole di regole qui sta tra tre e sei.

Esempio — quanti parametri ha ANFIS

Con un ingresso ogni regola ha due parametri della premessa (c_i, σ_i) e due parametri del conseguente (p_i, r_i), in totale 4n. Su 40 punti di addestramento:

• 4 regole: 16 parametri, di cui 8 lineari — a ogni parametro lineare corrispondono 5 punti;
• 8 regole: 32 parametri, di cui 16 lineari — 2,5 punti per parametro lineare, e i minimi quadrati hanno così abbastanza libertà per interpolare anche il rumore;
• 12 regole: 48 parametri — più dei punti. I minimi quadrati determinano «solo» 24 conseguenti da 40 equazioni, ma altri 24 parametri delle premesse possono spostare e restringere le colline proprio dove il rumore ha appena deviato.

Un’utile regola empirica: i punti dovrebbero essere almeno qualche volta più numerosi dei parametri che se ne stimano.

5. Che cosa si può leggere

La promessa dei sistemi neuro-fuzzy è che il modello appreso resti leggibile. Le premesse sono leggibili: quattro regole «intorno a 0», «intorno a 2,2», «intorno a 4» e «intorno a 6,2». I conseguenti invece no. La regola «SE x è intorno a 2,2, ALLORA y = 10,06 x − 13,83» nel suo centro prevederebbe 8,25, mentre il valore vero è 1,0. Le singole regole si bilanciano a vicenda — le colline si sovrappongono molto e l’uscita ha senso solo nel suo insieme.

Esempio — come si bilanciano le regole nel punto x = 2,195

Il centro appreso della seconda regola è c₂ = 2,195. Lì la seconda regola ha appartenenza piena (w₂ = 1), ma le vicine non nulla: w = (0,140; 1; 0,331; 0,000), somma 1,471, quindi

Regola	1	2	3	4
peso w̄i	0,095	0,680	0,225	0,000
conseguente gi	12,64	8,25	−25,64	−31,68
contributo w̄igi	1,203	5,609	−5,769	0,000

La somma è y = 1,203 + 5,609 − 5,769 = 1,043, il valore vero sin(2,195²/3) = 0,999. L’uscita è buona, ma nasce come differenza di due contributi intorno a ±5,7: la seconda regola «tira troppo» verso l’alto e la terza la riporta giù. Nessuna delle regole, da sola, dice quanto vale y.

L’interpretabilità quindi non è gratis. Ad aiutare a mantenerla sono i vincoli: minore sovrapposizione delle funzioni di appartenenza, regolarizzazione dei conseguenti, oppure un Sugeno di ordine zero con conseguenti costanti. Il prezzo si paga in precisione. È lo stesso equilibrio che c’è ovunque nell’apprendimento automatico — tra ciò che il modello sa fare e ciò che sappiamo dire di lui.

6. ANFIS e reti neurali

• Parentela con le reti RBF. Jang e Sun nel 1993 mostrarono che le reti a funzioni di base radiali e i sistemi fuzzy di Sugeno di ordine zero sono, a condizioni blande, la stessa cosa, solo interpretata diversamente.
• Maledizione della dimensionalità. Con n ingressi e k termini per ingresso, la griglia delle regole ha kⁿ regole — per 10 ingressi e 3 termini oltre 59 mila. Per questo ANFIS si usa con pochi ingressi, oppure con regole scelte tramite clustering (per esempio il fuzzy c-means della parte precedente).
• Applicazioni. Previsione di serie temporali (un test classico è la serie caotica di Mackey–Glass), modellazione e controllo di sistemi di cui abbiamo dati misurati, ma poca teoria.
• Oggi. Le reti profonde hanno da tempo preso in carico i compiti con molti ingressi. L’idea «addestrabile, ma leggibile» però vive ancora nell’IA spiegabile — e strati fuzzy vengono talvolta aggiunti anche alle reti profonde dove serve spiegare l’uscita con delle regole.

Definizione — rete a funzioni di base radiali (RBF)

Una rete RBF normalizzata con n neuroni nascosti calcola

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

dove φ è una funzione decrescente della distanza dal centro c_i (tipicamente gaussiana) e v_i sono i pesi di uscita. Un sistema di Sugeno di ordine zero con appartenenze gaussiane e il prodotto come «e insieme» è y = ∑_i w̄_i r_i — sostituendo w_i = φ(‖x − c_i‖) e v_i = r_i è esattamente la stessa formula. In parole semplici: regola = neurone, funzione di appartenenza = funzione di base, conseguente = peso di uscita. (Jang e Sun, 1993, elencano le condizioni con precisione: stesso numero di regole e di neuroni, conseguenti costanti, appartenenze gaussiane con la stessa larghezza all’interno di una regola, il prodotto come «e insieme» e lo stesso modo di comporre l’uscita — media pesata oppure somma pesata.)

Esempio — la maledizione della dimensionalità in numeri

Con n ingressi e k termini per ogni ingresso, la griglia completa ha kⁿ regole. Il conseguente di Sugeno del primo ordine y = p₁x₁ + … + p_nx_n + r ha n + 1 parametri, quindi i parametri lineari sono kⁿ(n + 1). I parametri delle premesse sono solo 2kn — ogni ingresso ha le sue k colline, condivise da tutte le regole.

Per n = 10 e k = 3: 3¹⁰ = 59 049 regole, 59 049 · 11 = 649 539 parametri dei conseguenti e 2 · 3 · 10 = 60 parametri delle premesse. I minimi quadrati dovrebbero risolvere un sistema con 649 539 incognite — e di dati ne servirebbero ancora molti di più.

7. Riepilogo

• ANFIS è un sistema fuzzy di Sugeno scritto come rete a cinque strati: appartenenza, forza, normalizzazione, conseguente, somma.
• L’apprendimento ibrido trova i conseguenti lineari in modo esatto con i minimi quadrati e rifinisce con il gradiente i centri e le larghezze delle funzioni di appartenenza.
• Sulla funzione sin(x²/3) l’apprendimento delle premesse ha ridotto l’errore sul test da 0,394 a 0,173; il gradiente puro ha avuto bisogno di dieci volte più epoche per un risultato peggiore.
• Troppe regole portano all’overfitting — da otto regole l’errore sul test sale bruscamente.
• Le premesse restano leggibili, ma i conseguenti si bilanciano a vicenda; l’interpretabilità va sorvegliata.

Con questa parte si chiude il modulo sulla logica fuzzy: dalla parola «caldo» attraverso la logica e i controllori fino a un sistema che le regole le impara da solo. Vuoi toccarlo con mano? Fai addestrare a un agente IA un ANFIS sul consumo di elettricità in funzione della temperatura a partire da dati pubblici — e poi guarda quali regole hanno senso.

La vedi diversamente? Scrivi a support@coden-app.com.