05 - GAN (Generative Adversarial Networks): Creare Dati Sintetici

Introduzione: Due Reti in Competizione

Le Generative Adversarial Networks (GAN), introdotte da Ian Goodfellow nel 2014, rappresentano uno dei paradigmi più innovativi del deep learning. L'idea e elegante nella sua semplicità: due reti neurali competono tra loro in un gioco a somma zero. Il Generatore crea dati sintetici cercando di ingannare il Discriminatore, che a sua volta impara a distinguere dati reali da quelli generati. Questa competizione spinge entrambe le reti a migliorare continuamente.

Le GAN hanno rivoluzionato la generazione di immagini: volti fotorealistici che non esistono, trasferimento di stile artistico, super-risoluzione, data augmentation e molto altro. In questo articolo esploreremo la teoria, le sfide del training e le varianti più importanti, con implementazione pratica in PyTorch.

Architettura: Generatore e Discriminatore

Il Generatore

Il Generatore G prende in input un vettore di rumore casuale z (tipicamente campionato da una distribuzione gaussiana o uniforme) e lo trasforma in un dato sintetico (es. un'immagine). L'obiettivo del generatore e produrre output cosi realistici da ingannare il discriminatore.

Il Discriminatore

Il Discriminatore D e un classificatore binario: riceve un dato (reale o generato) e produce una probabilità che sia reale. L'obiettivo del discriminatore e distinguere correttamente i dati reali da quelli generati.

La loss adversariale formalizza questo gioco: il discriminatore massimizza la probabilità di classificare correttamente, mentre il generatore minimizza la probabilità che il discriminatore rilevi i suoi output come falsi.

import torch
import torch.nn as nn

class Generator(nn.Module):
    """Generatore: rumore casuale -> immagine 64x64"""
    def __init__(self, latent_dim=100, channels=3):
        super().__init__()
        self.net = nn.Sequential(
            # latent_dim -> 512 x 4 x 4
            nn.ConvTranspose2d(latent_dim, 512, 4, 1, 0, bias=False),
            nn.BatchNorm2d(512),
            nn.ReLU(True),
            # 512 x 4 x 4 -> 256 x 8 x 8
            nn.ConvTranspose2d(512, 256, 4, 2, 1, bias=False),
            nn.BatchNorm2d(256),
            nn.ReLU(True),
            # 256 x 8 x 8 -> 128 x 16 x 16
            nn.ConvTranspose2d(256, 128, 4, 2, 1, bias=False),
            nn.BatchNorm2d(128),
            nn.ReLU(True),
            # 128 x 16 x 16 -> 64 x 32 x 32
            nn.ConvTranspose2d(128, 64, 4, 2, 1, bias=False),
            nn.BatchNorm2d(64),
            nn.ReLU(True),
            # 64 x 32 x 32 -> channels x 64 x 64
            nn.ConvTranspose2d(64, channels, 4, 2, 1, bias=False),
            nn.Tanh()  # Output in [-1, 1]
        )

    def forward(self, z):
        return self.net(z.view(z.size(0), -1, 1, 1))

class Discriminator(nn.Module):
    """Discriminatore: immagine 64x64 -> reale/falso"""
    def __init__(self, channels=3):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv2d(channels, 64, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(64, 128, 4, 2, 1, bias=False),
            nn.BatchNorm2d(128),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(128, 256, 4, 2, 1, bias=False),
            nn.BatchNorm2d(256),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(256, 512, 4, 2, 1, bias=False),
            nn.BatchNorm2d(512),
            nn.LeakyReLU(0.2, inplace=True),
            nn.Conv2d(512, 1, 4, 1, 0, bias=False),
            nn.Sigmoid()
        )

    def forward(self, img):
        return self.net(img).view(-1, 1)
      

Training Loop: Il Gioco Adversariale

Il training delle GAN alterna l'aggiornamento del discriminatore e del generatore. Ad ogni iterazione: (1) il discriminatore viene addestrato su un batch di dati reali e un batch di dati generati; (2) il generatore viene addestrato cercando di ingannare il discriminatore aggiornato.

import torch.optim as optim

# Setup
latent_dim = 100
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
G = Generator(latent_dim).to(device)
D = Discriminator().to(device)
criterion = nn.BCELoss()
optimizer_G = optim.Adam(G.parameters(), lr=0.0002, betas=(0.5, 0.999))
optimizer_D = optim.Adam(D.parameters(), lr=0.0002, betas=(0.5, 0.999))

def train_step(real_images):
    batch_size = real_images.size(0)
    real_labels = torch.ones(batch_size, 1).to(device)
    fake_labels = torch.zeros(batch_size, 1).to(device)

    # --- Addestra Discriminatore ---
    optimizer_D.zero_grad()
    # Su dati reali
    real_output = D(real_images)
    d_loss_real = criterion(real_output, real_labels)
    # Su dati generati
    z = torch.randn(batch_size, latent_dim).to(device)
    fake_images = G(z).detach()  # detach: non calcolare gradiente per G
    fake_output = D(fake_images)
    d_loss_fake = criterion(fake_output, fake_labels)
    d_loss = d_loss_real + d_loss_fake
    d_loss.backward()
    optimizer_D.step()

    # --- Addestra Generatore ---
    optimizer_G.zero_grad()
    z = torch.randn(batch_size, latent_dim).to(device)
    fake_images = G(z)
    fake_output = D(fake_images)
    g_loss = criterion(fake_output, real_labels)  # Vuole ingannare D
    g_loss.backward()
    optimizer_G.step()

    return d_loss.item(), g_loss.item()
      

Sfide del Training: Mode Collapse e Instabilita

Mode Collapse

Il mode collapse e il problema più comune delle GAN: il generatore trova pochi output che ingannano il discriminatore e continua a produrre solo quelli, ignorando la diversità dei dati reali. Invece di generare volti diversi, potrebbe produrre sempre lo stesso volto con piccole variazioni.

Training Instability

Le GAN sono notoriamente difficili da addestrare. Se il discriminatore diventa troppo forte, il gradiente per il generatore diventa quasi zero (vanishing gradient). Se il generatore domina, il discriminatore non fornisce feedback utile. Trovare il bilanciamento e una sfida continua.

Varianti Importanti

Conditional GAN (cGAN)

Le Conditional GAN aggiungono informazione condizionale (es. classe, testo) sia al generatore che al discriminatore. Questo permette di controllare la generazione: "genera un'immagine di un gatto" oppure "genera il numero 7".

CycleGAN

CycleGAN permette la traduzione tra domini senza dati accoppiati. Può trasformare foto in dipinti in stile Monet, convertire cavalli in zebre o trasformare paesaggi estivi in invernali, senza mai aver visto le stesse scene in entrambi i domini.

StyleGAN

StyleGAN (NVIDIA) ha raggiunto la generazione di volti fotorealistici ad alta risoluzione. Introduce il concetto di "stile" a diversi livelli della rete: gli stili grossolani controllano la struttura del volto, quelli fini i dettagli come texture e colore dei capelli.

Applicazioni nel Mondo Reale

• Generazione di volti: volti realistici per gaming, cinema, avatar (ThisPersonDoesNotExist.com)
• Data augmentation: generare dati di training sintetici per classi sotto-rappresentate in medicina, manifattura
• Super-risoluzione: aumentare la risoluzione di immagini (SRGAN) per fotografia, satelliti, medicina
• Image-to-image translation: sketch-to-photo, day-to-night, segmentation-to-image (Pix2Pix)
• Drug discovery: generare strutture molecolari con proprietà desiderate