Reti generative avversarie (GAN): il falsario contro il detective

La partita tra generatore e discriminatore, un GAN scritto da zero, la perdita non saturante, otto cluster su una circonferenza e il collasso dei modi, cifre più nitide che con il VAE, ma non tutte, e il percorso dai GAN ai modelli di diffusione.

12 minuti Matěj Žalmánek 2026-10-16

Serie Basi di IA Parte 45 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

L’autoencoder variazionale della parte precedente genera onestamente, ma in modo sfocato. Nel 2014 Ian Goodfellow ebbe un’idea che sembra quasi un trucco: invece di misurare quanto un campione si discosta dai dati, lasciamo che a giudicarlo sia un’altra rete. Due reti giocano una partita — una falsifica, l’altra smaschera il falso — e intanto migliorano entrambe. Così sono nati i primi volti generati da una macchina che non distingui da una foto. In questa parte scriveremo le due reti da zero e vedremo perché il loro apprendimento è così capriccioso.

Segue le parti Autoencoder variazionali, Regressione logistica (sigmoide ed entropia incrociata) e Giochi e avversari.

1. Il falsario e il detective

Definizione — rete generativa avversaria (GAN)

Un GAN (Ian Goodfellow e coll., 2014) è formato da due reti. Il generatore G trasforma un rumore casuale z ~ N(0, I) in un campione G(z). Il discriminatore D restituisce la probabilità D(x) che x provenga dai dati reali. Giocano una partita a due giocatori a somma zero:

min_G max_D E_{x ~ data}[log D(x)] + E_z[log(1 − D(G(z)))].

Per G fissato, il discriminatore migliore è D*(x) = p_data(x) / (p_data(x) + p_G(x)). All’equilibrio G genera esattamente la distribuzione dei dati e D restituisce ovunque ½.

min_G max_D   E_{x ~ data}[ log D(x) ] + E_{z ~ N(0, I)}[ log(1 − D(G(z))) ]

E_{x ~ data}[log D(x)]

il discriminatore sui dati reali — è massimo (0) quando D dà 1 ai campioni veri; il logaritmo punisce senza limiti un errore commesso con sicurezza (D → 0)

E_z[log(1 − D(G(z)))]

il discriminatore sui falsi — è massimo quando dà loro 0; è l’unico termine in cui compare G, quindi il generatore impara solo da esso

max_D

il discriminatore aumenta il valore — i due termini insieme sono l’entropia incrociata binaria cambiata di segno, quindi è il normale addestramento di un classificatore «vero / falso»

min_G

il generatore diminuisce il valore — vuole che il discriminatore sbagli sui falsi; ciò che un giocatore guadagna, l’altro lo perde (somma zero)

Teorema — il discriminatore migliore e che cosa minimizza il generatore

Per G fissato il valore del gioco è ∫ [p_data(x) log D(x) + p_G(x) log(1 − D(x))] dx. In ogni punto x massimizziamo la funzione a log y + b log(1 − y) per y ∈ (0, 1), dove a = p_data(x), b = p_G(x).

Dimostrazione. La derivata a/y − b/(1 − y) si annulla per y = a/(a + b) e la funzione è concava (derivata seconda −a/y² − b/(1 − y)² < 0), quindi si tratta di un massimo. Da qui D*(x) = p_data(x) / (p_data(x) + p_G(x)). Sostituendo e semplificando (Goodfellow e coll., 2014):

V(D*, G) = −log 4 + 2 · JSD(p_data ‖ p_G),   JSD(p ‖ q) = ½ KL(p ‖ m) + ½ KL(q ‖ m),   m = ½(p + q).

La divergenza di Jensen–Shannon è non negativa e nulla esattamente per p_G = p_data. Con il discriminatore migliore il generatore minimizza quindi la JSD, e il minimo −log 4 ≈ −1,386 si raggiunge quando genera esattamente i dati. ∎

Esempio: dove la densità dei dati è 0,3 e quella dei falsi 0,1, si ha D* = 0,3 / 0,4 = 0,75 (il punto è piuttosto vero); dove il generatore esagera (dati 0,1, falsi 0,3), D* = 0,25. Dove le densità sono uguali, D* = ½ e la perdita del discriminatore (entropia incrociata binaria per campione) vale ln 2 ≈ 0,693.

Il discriminatore è un normale classificatore con sigmoide ed entropia incrociata, come la regressione logistica, solo con qualche strato in più. La magia sta nel generatore: il gradiente della sua perdita scorre con la retropropagazione attraverso il discriminatore fino all’immagine e da lì nei pesi del generatore. Il discriminatore gli dice così in quale direzione spostare ogni pixel per sembrare più credibile.

2. Apprendimento: passi alternati

Si impara a turno: un passo del discriminatore (un batch di dati reali e un batch di falsi, aumentare D su quelli veri, diminuirlo su quelli falsi), poi un passo del generatore (spostare i falsi dove D li ritiene veri). Da noi entrambe le reti hanno due strati nascosti con leaky ReLU e imparano con Adam.

Definizione — perdita non saturante del generatore

Invece di minimizzare log(1 − D(G(z))) del gioco originale, il generatore impara a massimizzare log D(G(z)), cioè a minimizzare −log D(G(z)). Le due perdite hanno lo stesso obiettivo, ma un gradiente diverso: se D = σ(s), allora |∂ log(1 − D)/∂s| = D, mentre |∂(−log D)/∂s| = 1 − D. L’hanno proposta già Goodfellow e coll. nello stesso articolo.

∂/∂s log(1 − σ(s)) = −D,    ∂/∂s (−log σ(s)) = −(1 − D)

s

logit — l’uscita del discriminatore prima della sigmoide; deriviamo rispetto a esso perché da lì il gradiente torna indietro nel discriminatore e, attraverso di esso, nel falso

D = σ(s)

probabilità che il falso sia vero; si usa σ′(s) = σ(s)(1 − σ(s)), per questo escono espressioni così semplici

log(1 − σ(s))

la perdita originale del generatore (si minimizza) — il suo gradiente ha modulo D, quindi quando il discriminatore smaschera il falso con sicurezza (D ≈ 0) è quasi nullo: saturazione

−log σ(s)

la perdita non saturante — il gradiente ha modulo 1 − D, quindi è massimo proprio per i falsi che il discriminatore ha smascherato

A essere sinceri: nei nostri piccoli esperimenti imparava anche la perdita originale, perché all’inizio il discriminatore non era così sicuro di sé. Nelle grandi reti sulle immagini, dove il discriminatore vince in fretta, la differenza è fondamentale. Da qui in poi usiamo la perdita non saturante.

Come il gradiente arrivi fino al generatore lo mostra la regola della catena. Il falso x = G(z) per il discriminatore è solo un input, quindi la retropropagazione non deve fermarsi lì:

∂L_G / ∂θ_G = ∂L_G / ∂s · ∂s / ∂x · ∂x / ∂θ_G

∂L_G / ∂s

un solo numero dalla perdita, per quella non saturante −(1 − D) — «di quanto» deve migliorare il falso

∂s / ∂x

il gradiente del discriminatore rispetto al suo input (2 numeri per la circonferenza, 64 per una cifra) — «in quale direzione» spostare ogni coordinata perché il falso sembri più vero; i pesi del discriminatore in questo passo non cambiano

∂x / ∂θ_G

la normale retropropagazione attraverso il generatore — traduce lo spostamento desiderato del falso in una modifica dei pesi del generatore

Definizione — perdita del discriminatore e softplus

Il discriminatore restituisce un logit s e D = σ(s). Per un campione vero con logit s_r e un falso con logit s_f la sua perdita è l’entropia incrociata binaria

L_D = −log σ(s_r) − log(1 − σ(s_f)) = softplus(−s_r) + softplus(s_f),   softplus(u) = ln(1 + e^u),

perché −log σ(s) = ln(1 + e^−s) e 1 − σ(s) = σ(−s). Il programma calcola softplus a partire dal logit, non da D: per s = 40, σ(s) in virgola mobile vale esattamente 1 e log(1 − D) darebbe −∞, mentre softplus(40) ≈ 40. Gradienti: ∂L_D/∂s_r = σ(s_r) − 1, ∂L_D/∂s_f = σ(s_f).

for t in range(kroku):
    # 1. passo del discriminatore: veri → 1, falsi → 0
    gD = 0
    for _ in range(davka):
        x = nahodny_vzorek(data)
        gD += D.zpet(D(x), dL_ds=sigmoid(D(x)) - 1)
        f = G(sum())                           # falso, G qui non impara
        gD += D.zpet(D(f), dL_ds=sigmoid(D(f)))
    adam_D(gD / davka)
    # 2. passo del generatore: il gradiente attraversa D fino al falso
    gG = 0
    for _ in range(davka):
        x = G(sum())
        dL_ds = sigmoid(D(x)) - 1              # non saturante −log σ(s)
        dL_dx = D.zpet_do_vstupu(dL_ds)        # pesi di D invariati
        gG += G.zpet(dL_dx)
    adam_G(gG / davka)                         # Adam con β₁ = 0,5 come in DCGAN

3. Otto cluster su una circonferenza

Un esperimento classico: i dati sono punti di otto piccoli cluster normali (σ = 0,05) disposti su una circonferenza di raggio 2. Il generatore riceve un rumore bidimensionale e restituisce un punto del piano. Misuriamo la qualità (la quota di campioni entro 3σ da uno dei centri) e la copertura (in quanti cluster cade almeno il 2 % dei campioni).

Definizione — dati, qualità e copertura

I centri dei cluster sono c_j = (r cos(2πj/8), r sin(2πj/8)) per j = 0, …, 7 con r = 2; un punto dei dati è c_j con j casuale più un rumore N(0, σ²I), σ = 0,05. Per i campioni x₁, …, x_n del generatore:

qualità = (1/n) · #{i : min_j ‖x_i − c_j‖ < 3σ},   copertura = #{j : n_j ≥ 0,02 · n},

dove n_j è il numero di campioni entro 3σ dal centro c_j. In numeri: 3σ = 0,15, centri vicini distano 2r sin(π/8) ≈ 1,53, cioè più di dieci volte tanto. Le istantanee hanno n = 400 campioni, quindi un cluster conta come coperto da 8 campioni in su.

Nemmeno un generatore perfetto ha qualità 100 %: la distanza di un punto dal centro di una distribuzione normale bidimensionale segue la distribuzione di Rayleigh, ed entro 3σ cade la quota 1 − e^−9/2 ≈ 0,989, cioè circa il 98,9 %.

Dopo 500 passi il generatore produce una nuvola sfocata (qualità 6 %), dopo 2 000 passi i punti si raccolgono in 6 cluster e alla fine (passo 8 000) li copre tutti e 8 con qualità 73 %. Il generatore non ha mai visto un solo punto reale — ha imparato tutto dal gradiente del discriminatore.

4. Collasso dei modi

Definizione — collasso dei modi (mode collapse)

Il generatore produce solo una parte della distribuzione dei dati — alcuni modi (cluster, tipi di immagini) — e tralascia gli altri. La perdita non lo punisce direttamente: il discriminatore giudica ogni campione separatamente, e un buon falso di un solo tipo per lui è convincente quanto una collezione varia. In caso di collasso completo il generatore produce quasi la stessa cosa per ogni z.

Teorema — contro un discriminatore fissato il migliore è un solo punto

Per D fissato la perdita del generatore è L_G = E_z[−log D(G(z))] ≥ −log D(x*), dove x* è il punto in cui D è massimo. L’uguaglianza vale per un generatore che manda ogni z in x*.

Dimostrazione. Per ogni z vale D(G(z)) ≤ D(x*), e poiché −log è decrescente, −log D(G(z)) ≥ −log D(x*); il valore atteso conserva la disuguaglianza. ∎

La perdita è una media sui singoli campioni e niente in essa premia la varietà. Contro un avversario fissato il collasso completo è quindi ottimale; lo impedisce solo il fatto che il discriminatore reagisce e comincia a sospettare di x*. Se il generatore salta più in fretta di quanto il discriminatore dimentichi, il gioco gira in tondo. Per questo aiutano le modifiche che danno al discriminatore una visione dell’intero batch (minibatch discrimination, Tim Salimans e coll., 2016) o un’altra distanza tra distribuzioni (Wasserstein, più sotto).

Stessa rete, stessi dati, stesse impostazioni — cambia solo il seed casuale:

Solo una delle quattro esecuzioni ha coperto tutti e otto i cluster. L’esecuzione con seed 3 si è fermata a 5 e dal passo 5 000 non si è più mossa. È tipico dei GAN: l’apprendimento non ha un’unica perdita che scende, ma una partita a due giocatori, e il risultato dipende dal caso più di quanto vorremmo.

5. Cifre: più nitide, ma non tutte

Ora le stesse cifre 8 × 8 del VAE. Generatore: rumore a otto dimensioni → 64 → 64 → 64 pixel con sigmoide; discriminatore speculare. 6 000 passi, due esecuzioni con seed diversi. Misuriamo la qualità come nella parte precedente — con la distanza del campione dalla cifra di addestramento più vicina.

I campioni del GAN sono più nitidi: distanza 0,049 e 0,042 contro 0,054 del VAE (cifre reali 0,017). Il GAN non punisce la sfocatura con la media come la perdita di ricostruzione del VAE — un’immagine sfocata il discriminatore la riconosce facilmente. Ma quante di ciascuna cifra produce il generatore?

Nei dati ogni cifra compare lo stesso numero di volte. L’esecuzione con seed 2 produce invece soprattutto sei (69 su 200), otto e tre, e le cifre 0, 1, 2, 4, 7 quasi per niente (al massimo 3 campioni). L’esecuzione con seed 1 è più varia, ma anche lì le cifre 0, 4, 9 hanno meno della metà della loro quota (al massimo 6 campioni invece di 20). È lo stesso collasso dei modi della circonferenza, solo sulle immagini: il GAN vince in nitidezza, il VAE in copertura.

6. Dai GAN alla diffusione

• DCGAN (Alec Radford e coll., 2015) ha mostrato come costruire GAN convoluzionali che si possono addestrare in modo affidabile sulle foto.
• Wasserstein GAN (Martin Arjovsky e coll., 2017) ha sostituito il classificatore con un «critico» che misura la distanza tra distribuzioni; l’apprendimento è più stabile e meno soggetto al collasso dei modi.
• StyleGAN (Tero Karras e coll., Nvidia, 2018–2020) genera volti fotorealistici in risoluzione 1024 × 1024 — il noto sito «this person does not exist».
• Intorno al 2021 i GAN sono stati superati dai modelli di diffusione (Prafulla Dhariwal e Alex Nichol: «Diffusion Models Beat GANs on Image Synthesis»). Sono più lenti, ma imparano in modo stabile e coprono tutta la distribuzione. L’idea del discriminatore però sopravvive — come perdita ausiliaria che dà nitidezza alle immagini, per esempio nei codificatori di immagini o di audio.

Perché Wasserstein aiuti si vede sull’esempio più semplice (una versione semplificata dell’esempio dell’articolo di Arjovsky e coll., 2017): i dati sono un solo punto 0, il generatore produce un solo punto θ. Finché θ ≠ 0, le distribuzioni non si sovrappongono e JSD = ln 2 ≈ 0,693 indipendentemente da quanto sia lontano θ — il gradiente rispetto a θ è nullo e il generatore non sa dove andare. La distanza di Wasserstein è |θ|, quindi indica la direzione anche da molto lontano.

W(p_data, p_G) = sup_{‖f‖L ≤ 1} ( E_{x ~ data}[f(x)] − E_z[f(G(z))] )

sup_{‖f‖L ≤ 1}

il critico f — una rete che invece di una probabilità restituisce un numero qualsiasi; la condizione «1-lipschitziana» (|f(a) − f(b)| ≤ ‖a − b‖) gli impedisce di distinguere due punti vicini in modo arbitrariamente netto, altrimenti la differenza potrebbe crescere all’infinito

E_data[f(x)]

il punteggio medio dei dati reali — il critico lo vuole il più grande possibile

E_z[f(G(z))]

il punteggio medio dei falsi — il critico lo vuole il più piccolo possibile, il generatore il più grande; la differenza è continua nei parametri del generatore, quindi il gradiente non sparisce nemmeno quando le distribuzioni non si sovrappongono

7. Riepilogo

• GAN = generatore e discriminatore in una partita; il generatore impara solo dal gradiente che gli manda il discriminatore.
• La perdita non saturante −log D(G(z)) dà al generatore un segnale forte anche all’inizio, quando il discriminatore vince.
• Sugli otto cluster solo una delle quattro esecuzioni li ha coperti tutti (7, 8, 5, 6); il risultato dipende molto dal caso.
• Sulle cifre i campioni sono più nitidi che con il VAE (0,042 contro 0,054), ma alcune cifre mancano — collasso dei modi.
• Oggi le immagini le generano soprattutto i modelli di diffusione; il discriminatore è rimasto come aiuto per la nitidezza.

Vuoi toccarlo con mano? Fai addestrare a un agente IA un piccolo GAN sugli otto cluster su una circonferenza e fallo girare cinque volte con seed diversi. Poi fagli provare un Wasserstein GAN con la stessa rete e confrontare quanti cluster copre ogni volta.

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