AvancéDeep Learning

25 min de lecture11 vues

Diffusion Models : l'Architecture de Stable Diffusion

Plongez dans l'architecture des modèles de diffusion : forward process, U-Net débruiteur, guidance CLIP et Latent Diffusion. Comprenez ce qui propulse Stable Diffusion, SDXL et Flux.

Specialiste IA

Panorama de la génération d'images

Trois paradigmes se sont succédé pour la génération d'images haute qualité.

Paradigme	Qualité	Diversité	Contrôle	Problème
GAN (2014)	Excellente	Faible	Difficile	Mode collapse
VAE	Correcte	Bonne	Bonne	Images floues
Diffusion (2020+)	Excellente	Excellente	Excellent	:

Les modèles de diffusion dominent la génération d'images (Stable Diffusion, DALL-E 3, Midjourney v6, Imagen 3) car ils offrent le meilleur compromis : qualité maximale, diversité réelle et contrôle fin via le texte.

Le principe de diffusion : bruiter pour mieux débruiter

Forward process : ajouter du bruit progressivement

Partez d'une vraie image x_0. À chaque étape t parmi T=1000, ajoutez un peu de bruit gaussien :

x_t = √(ᾱ_t) · x_0 + √(1 - ᾱ_t) · ε    où ε ~ N(0, I)

Après T étapes, x_T est du bruit pur. Ce processus est fixe (pas de paramètres à apprendre).

Reverse process : apprendre à débruiter

L'objectif d'entraînement est simple : prédire le bruit ε ajouté à chaque étape.

# Pseudo-code de l'entraînement
pour chaque batch d'images x_0:
    t = random.randint(1, T)
    epsilon = torch.randn_like(x_0)
    x_t = q(x_0, t, epsilon)          # Bruitage forward
    epsilon_pred = unet(x_t, t)       # Prédire le bruit
    loss = MSE(epsilon_pred, epsilon)

U-Net : l'architecture du débruiteur

Le U-Net traite l'image bruitée à chaque pas de débruitage. Sa structure en "U" avec skip connections permet de reconstruire les détails précis.

Encodeur                         Décodeur
64×64×320 ──────────────────────────────→ 64×64×320
    │                                          ↑
32×32×640 ────────────────────────→ 32×32×640
    │                                    ↑
8×8×1280  →  Bottleneck (attention) →  8×8×1280

À chaque bloc : ResNet (traitement spatial) + Self-attention (relations globales) + Cross-attention (injection du texte CLIP).

CLIP : le guide textuel

CLIP (Contrastive Language-Image Pre-training) encode votre prompt en vecteurs qui guident la génération via cross-attention dans chaque bloc du U-Net.

Classifier-Free Guidance (CFG) :

# guidance_scale contrôle l'adhérence au prompt
noise_pred = noise_uncond + guidance_scale * (noise_cond - noise_uncond)
# guidance_scale élevé (>10) : très proche du prompt, moins créatif
# guidance_scale bas (<5) : plus libre, peut s'éloigner du prompt

Latent Diffusion : 49x moins de calculs

Faire de la diffusion sur des images 512×512×3 px est prohibitif. Stable Diffusion travaille dans l'espace latent d'un VAE :

Compression par un facteur 8 dans chaque dimension → 49x moins de pixels à diffuser.

Micro-exercice : générer une image avec HuggingFace Diffusers

from diffusers import StableDiffusionPipeline
import torch

pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

generator = torch.Generator("cuda").manual_seed(42)

image = pipe(
    prompt="A photorealistic cat reading a book in a cozy library, warm lighting",
    negative_prompt="blurry, distorted, low quality, cartoon",
    num_inference_steps=30,
    guidance_scale=7.5,
    generator=generator,
).images[0]

image.save("cat_reading.png")

Avec SDXL (qualité supérieure) :

from diffusers import StableDiffusionXLPipeline

pipe_xl = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
).to("cuda")

image = pipe_xl(
    prompt="A photorealistic cat reading a book in a cozy library",
    num_inference_steps=40,
    guidance_scale=5.0,
).images[0]

SD v1.5 nécessite ~6 Go de VRAM en float16. SDXL nécessite ~12 Go. Pour GPU limité, utilisez pipe.enable_model_cpu_offload().

Évolutions clés et schedulers

Modèle	Architecture	Résolution	Particularité
SD v1.5	U-Net + VAE	512×512	Fondateur, très moddable
SDXL	U-Net dual	1024×1024	2 U-Nets (base + refiner)
Flux.1	DiT (12B)	Flexible	Meilleur texte dans l'image
DALL-E 3	Diffusion + GPT	1024×1024	Prompts auto-enrichis

Scheduler	Étapes typiques	Qualité	Vitesse
DDPM	1000	Maximale	Très lente
DDIM	50	Très bonne	Bonne
DPM++ 2M	20-30	Excellente	Rapide
LCM	4-8	Bonne	Très rapide

from diffusers import DPMSolverMultistepScheduler
pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
image = pipe(prompt="...", num_inference_steps=20).images[0]  # 20 étapes suffisent

Specialiste IA — Master Intelligence Artificielle

Diplome d'un Master en Intelligence Artificielle, je travaille au quotidien sur des projets IA en entreprise. J'ai cree IwanttolearnAI pour rendre l'apprentissage de l'IA accessible a tous, gratuitement.

GitHub En savoir plus

Retour à Deep Learning

Continuer a apprendre

Deep LearningIntermédiaire

RNN et LSTM : Modéliser les Séquences

Maîtrisez les réseaux récurrents : pourquoi les RNN oublient, comment les LSTM résolvent le vanishing gradient avec leurs 3 portes, et quand les utiliser face aux Transformers.

22 min17

Deep LearningAvancé

Reinforcement Learning : Apprendre par l'Erreur

Maîtrisez le reinforcement learning : paradigme Agent/Environment, Q-Learning, DQN sur CartPole, PPO et le lien avec RLHF pour l'alignement des LLMs.

25 min10

Deep LearningIntermédiaire

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

Comprenez les réseaux adversariaux génératifs (GANs) et l'évolution vers Stable Diffusion : architecture, entraînement, applications et limites éthiques.

14 min15