GAN: generatore e discriminatore
Teoria dei giochi min-max, instabilità dell'addestramento delle GAN, mode collapse, implementazione di DCGAN
GAN: generatore e discriminatore è una lezione Learn AI with Python gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn AI with Python, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn AI with Python include 4 lezioni in totale.
Che cos'è una GAN?
Una rete generativa avversaria contrappone due reti: un generatore che crea dati falsi e un discriminatore che stabilisce se sono reali o falsi. Le due reti competono e il generatore impara a produrre campioni convincenti.
Il gioco avversario
Immagini un falsario (generatore) e un detective (discriminatore). Il falsario migliora i falsi per ingannare il detective, mentre il detective affina il proprio occhio. Questa corsa agli armamenti spinge entrambi a migliorare, finché i falsi sembrano reali.
Il generatore
Il generatore mappa un vettore di rumore casuale in un'immagine falsa. Impara a trasformare numeri casuali privi di significato in dati strutturati dall'aspetto realistico.
class Generator(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(100, 256), nn.ReLU(),
nn.Linear(256, 784), nn.Tanh()
)
def forward(self, z):
return self.net(z)Il vettore di rumore
L'input z viene campionato da una normale standard. Vettori di rumore diversi producono immagini diverse, quindi il rumore è il "seme" della generazione. La sua dimensione (qui 100) è la dimensione latente.
z = torch.randn(batch_size, 100)
fake_images = generator(z)Il discriminatore
Il discriminatore prende un'immagine e restituisce un'unica probabilità: quanto è probabile che sia reale. Una Sigmoid restituisce un valore in [0,1], dove 1 significa reale e 0 falso.
class Discriminator(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(784, 256), nn.LeakyReLU(0.2),
nn.Linear(256, 1), nn.Sigmoid()
)Addestramento del discriminatore
Addestri D su un batch di immagini reali etichettate con 1 e di immagini false etichettate con 0. Impara ad aumentare i punteggi delle immagini reali e a ridurre quelli delle immagini false usando l'entropia incrociata binaria.
d_real = criterion(D(real), ones)
d_fake = criterion(D(fake.detach()), zeros)
d_loss = d_real + d_fake
d_loss.backward()Perché applicare detach() ai falsi?
Quando si addestra D, si usa fake.detach() affinché i gradienti non fluiscano nel generatore. In questo passaggio si aggiorna solo il discriminatore; il generatore avrà il proprio turno separatamente.
Addestramento del generatore
Ora addestri G per ingannare D: fai passare i falsi attraverso D e premi il generatore quando D restituisce reale (etichetta 1). Il generatore migliora facendo credere a D che i suoi falsi siano reali.
g_loss = criterion(D(fake), ones) # want D to say "real"
g_loss.backward()
g_optimizer.step()Addestramento alternato
Ogni iterazione alterna i due passaggi: prima si aggiorna D, poi G. Mantenerli più o meno bilanciati è fondamentale: se D diventa troppo forte, G non riceve un gradiente utile; se è troppo debole, G non ha una sfida.
# per step
# 1) update Discriminator
# 2) update GeneratorMode collapse
Un fallimento classico è il mode collapse: il generatore trova uno o pochi output che ingannano D e produce solo quelli, ignorando la varietà dei dati. Un sintomo è che ogni campione generato appare quasi identico.
Instabilità dell'addestramento
I GAN sono notoriamente instabili: le perdite oscillano, una rete può prevalere sull'altra e la convergenza è fragile. Tecniche come LeakyReLU, learning rate scelti con cura e label smoothing aiutano a stabilizzare l'addestramento.
Verifica rapida
Verifichi la propria comprensione delle GAN.
Riepilogo: GAN
Ha appreso l'architettura avversaria: un generatore trasforma un vettore di rumore in dati falsi, un discriminatore restituisce una probabilità reale/falso e i due si addestrano in modo alternato, prima D e poi G. Ha anche imparato a riconoscere il mode collapse e l'instabilità generale che rende i GAN difficili da addestrare.
Domande Frequenti
La lezione «GAN: generatore e discriminatore» è gratuita?
Sì — il testo completo di «GAN: generatore e discriminatore» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn AI with Python, passa a CoddyKit PRO. Il corso Learn AI with Python include 4 lezioni in totale.
Cosa imparerò in «GAN: generatore e discriminatore»?
Teoria dei giochi min-max, instabilità dell'addestramento delle GAN, mode collapse, implementazione di DCGAN Eserciti Learn AI with Python con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn AI with Python?
Non è richiesta alcuna esperienza precedente. Learn AI with Python su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «GAN: generatore e discriminatore»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn AI with Python?
Sì. Ogni lezione Learn AI with Python include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Autoencoder per l'apprendimento delle rappresentazioni
- Autoencoder variazionali (VAE)
- GAN: generatore e discriminatore
- GAN condizionali e style transfer