GANs et Génération d'Images par IA

Epoch 1   : G produit du bruit → D détecte facilement (95%)
Epoch 100 : G produit des formes → D détecte (80%)
Epoch 1000: G produit des visages flous → D hésite (60%)
Epoch 5000: G produit des visages réalistes → D devine au hasard (50%)

Input : vecteur de bruit z (100 dimensions)
     ↓
ConvTranspose2d : 100 → 512 canaux, 4×4
BatchNorm + ReLU
     ↓
ConvTranspose2d : 512 → 256 canaux, 8×8
BatchNorm + ReLU
     ↓
ConvTranspose2d : 256 → 128 canaux, 16×16
BatchNorm + ReLU
     ↓
ConvTranspose2d : 128 → 3 canaux, 64×64
Tanh
     ↓
Output : image RGB 64×64

import torch
import torch.nn as nn

class Generator(nn.Module):
    def __init__(self, latent_dim=100):
        super().__init__()
        self.net = nn.Sequential(
            # Entrée : vecteur latent
            nn.ConvTranspose2d(latent_dim, 512, 4, 1, 0, bias=False),
            nn.BatchNorm2d(512),
            nn.ReLU(True),

            # 512 → 256, taille 8×8
            nn.ConvTranspose2d(512, 256, 4, 2, 1, bias=False),
            nn.BatchNorm2d(256),
            nn.ReLU(True),

            # 256 → 128, taille 16×16
            nn.ConvTranspose2d(256, 128, 4, 2, 1, bias=False),
            nn.BatchNorm2d(128),
            nn.ReLU(True),

            # 128 → 3 (RGB), taille 64×64
            nn.ConvTranspose2d(128, 3, 4, 2, 1, bias=False),
            nn.Tanh(),  # Sortie dans [-1, 1]
        )

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


class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            # Image 64×64 → 32×32
            nn.Conv2d(3, 128, 4, 2, 1, bias=False),
            nn.LeakyReLU(0.2, inplace=True),

            # 32×32 → 16×16
            nn.Conv2d(128, 256, 4, 2, 1, bias=False),
            nn.BatchNorm2d(256),
            nn.LeakyReLU(0.2, inplace=True),

            # 16×16 → 8×8
            nn.Conv2d(256, 512, 4, 2, 1, bias=False),
            nn.BatchNorm2d(512),
            nn.LeakyReLU(0.2, inplace=True),

            # 8×8 → 1×1
            nn.Conv2d(512, 1, 4, 1, 0, bias=False),
            nn.Sigmoid(),  # Probabilité [0, 1]
        )

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

import torch.optim as optim

# Initialisation
G = Generator().cuda()
D = Discriminator().cuda()
criterion = nn.BCELoss()

opt_G = optim.Adam(G.parameters(), lr=0.0002, betas=(0.5, 0.999))
opt_D = optim.Adam(D.parameters(), lr=0.0002, betas=(0.5, 0.999))

for epoch in range(num_epochs):
    for real_images, _ in dataloader:
        batch_size = real_images.size(0)
        real_images = real_images.cuda()

        # Labels
        real_label = torch.ones(batch_size, 1).cuda()
        fake_label = torch.zeros(batch_size, 1).cuda()

        # --- Entraîner le Discriminateur ---
        z = torch.randn(batch_size, 100).cuda()
        fake_images = G(z).detach()

        loss_real = criterion(D(real_images), real_label)
        loss_fake = criterion(D(fake_images), fake_label)
        loss_D = (loss_real + loss_fake) / 2

        opt_D.zero_grad()
        loss_D.backward()
        opt_D.step()

        # --- Entraîner le Générateur ---
        z = torch.randn(batch_size, 100).cuda()
        fake_images = G(z)
        loss_G = criterion(D(fake_images), real_label)  # On veut tromper D

        opt_G.zero_grad()
        loss_G.backward()
        opt_G.step()

    print(f"Epoch {epoch}: Loss_D={loss_D:.4f}, Loss_G={loss_G:.4f}")

from diffusers import StableDiffusionPipeline
import torch

# Charger le modèle
pipe = StableDiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
)
pipe = pipe.to("cuda")

# Générer une image
image = pipe(
    prompt="Un paysage montagneux au coucher du soleil, style peinture à l''huile",
    negative_prompt="flou, déformé, mauvaise qualité",
    num_inference_steps=30,
    guidance_scale=7.5,
).images[0]

image.save("paysage.png")