Diffusion models : L'IA qui crée images, vidéos et audio

1. Début : Bloc de marbre couvert de brouillard (bruit)
2. Processus : Retirer progressivement le brouillard
3. Guidance : Suivre une description ("statue d'un lion")
4. Résultat : Sculpture claire et détaillée

Step 0 (bruit pur):        Step 500:              Step 1000 (final):
████████████████           ░▓▓▓▒▒▒░░             🏔️ Montagne
████████████████    →      ░░▓▓▓▓▒░░      →      avec coucher
████████████████           ░▒▒▒▓▓▓░░             de soleil
(Pixels aléatoires)        (Formes vagues)       (Image claire)

# Image originale
x_0 = image  # Claire

# Step 1 : Ajouter un peu de bruit
x_1 = x_0 + ε_1  # Légèrement bruitée

# Step 2 : Ajouter encore du bruit
x_2 = x_1 + ε_2  # Plus bruitée

# ...

# Step T (ex: T=1000) : Bruit pur
x_T = bruit_gaussien  # Complètement aléatoire

x_0 → x_1 → x_2 → ... → x_T
🖼️  →  🖼  →  ▓▓  → ... → ████
Clara → Floue → Bruitée → Bruit pur

# Partir du bruit
x_T = random_noise()

# Step T-1 : Retirer un peu de bruit
x_{T-1} = denoise(x_T, prompt, T-1)

# Step T-2 : Continuer
x_{T-2} = denoise(x_{T-1}, prompt, T-2)

# ...

# Step 0 : Image finale
x_0 = image_générée  # Claire et cohérente

x_T → x_{T-1} → ... → x_1 → x_0
████ → ▓▓ → 🖼 → 🖼️
Bruit → Formes → Détails → Image finale

q(x_t | x_{t-1}) = N(x_t; √(1-β_t) x_{t-1}, β_t I)

Translation : À chaque step t, on ajoute du bruit gaussien
avec variance β_t (schedule : β_1 < β_2 < ... < β_T)

p_θ(x_{t-1} | x_t) = N(x_{t-1}; μ_θ(x_t, t), Σ_θ(x_t, t))

Translation : Le modèle prédit comment retirer le bruit à chaque step

L = E[||ε - ε_θ(x_t, t)||²]

Translation : Le modèle apprend à prédire le bruit ajouté

# Training
image_bruitée = image_originale + bruit
bruit_prédit = modèle(image_bruitée, t)
loss = ||bruit - bruit_prédit||²

# Inference
image = bruit_aléatoire
for t in reversed(range(T)):
    bruit_prédit = modèle(image, t)
    image = image - bruit_prédit  # Retirer le bruit
    # → Progressivement, l'image émerge

Input: Image bruitée x_t + Timestep t + Prompt embedding

┌─────────────────────────────────────────┐
│            ENCODER (Downsample)         │
│  Conv 64  → Conv 128 → Conv 256 → 512  │
│    ↓          ↓          ↓        ↓     │
│  [Attention] [Attention] [Attention]    │
└─────────────┬───────────────────────────┘
              │
              v
┌─────────────────────────────────────────┐
│          BOTTLENECK                     │
│  Conv 512 + Cross-Attention (prompt)    │
└─────────────┬───────────────────────────┘
              │
              v
┌─────────────────────────────────────────┐
│            DECODER (Upsample)           │
│  512 → Conv 256 → Conv 128 → Conv 64   │
│    ↑          ↑          ↑        ↑     │
│  [Attention] [Attention] [Attention]    │
│    └── Skip Connections ──┘             │
└─────────────┬───────────────────────────┘
              │
              v
Output: Bruit prédit ε_θ(x_t, t)

# t ∈ [0, 1000] → embedding 512-dim
t_emb = sinusoidal_embedding(t, dim=512)

# Injecté à chaque layer
layer_output = layer(x) + mlp(t_emb)

# Attention entre pixels de l'image
Q, K, V = Linear(x)
attention = softmax(Q @ K.T / √d) @ V
# → Cohérence spatiale

# Attention entre image et prompt
Q = Linear(image_features)
K, V = Linear(text_embedding)
attention = softmax(Q @ K.T / √d) @ V
# → Guidage par le texte

# Features de l'encoder → decoder
decoder_input = concat([decoder_features, encoder_features])
# → Préserve détails

┌──────────────────────────────────────────┐
│         IMAGE (512×512×3)                │
│              76,800 pixels               │
└──────────────┬───────────────────────────┘
               │ VAE Encoder
               v
┌──────────────────────────────────────────┐
│       LATENT (64×64×4)                   │
│           16,384 dimensions              │
│        (20× moins de données)            │
└──────────────┬───────────────────────────┘
               │ Diffusion Process
               │ (U-Net travaille ici)
               v
┌──────────────────────────────────────────┐
│    LATENT DÉBRUITÉ (64×64×4)             │
└──────────────┬───────────────────────────┘
               │ VAE Decoder
               v
┌──────────────────────────────────────────┐
│    IMAGE GÉNÉRÉE (512×512×3)             │
└──────────────────────────────────────────┘

prompt = "A beautiful mountain landscape at sunset"

# CLIP Text Encoder
text_embedding = clip_text_encoder(prompt)
# → Tensor (77, 768) : 77 tokens, 768 dimensions

# Cross-attention dans U-Net
image_features = u_net_layer(image)
attended = cross_attention(
    query=image_features,
    key_value=text_embedding
)
# → Image guidée par le texte ✅

USER INPUT: "A cat wearing a hat"
              ↓
┌─────────────────────────────────────────┐
│      CLIP TEXT ENCODER                  │
│  Prompt → Text Embedding (77×768)       │
└─────────────┬───────────────────────────┘
              │
              ├────────────────────┐
              │                    │
              v                    v
┌──────────────────────┐   ┌──────────────┐
│  RANDOM NOISE        │   │ CONDITIONING │
│  Latent (64×64×4)    │   │ Text Embed   │
└──────────┬───────────┘   └──────┬───────┘
           │                      │
           └──────┬───────────────┘
                  │
                  v
        ┌──────────────────────┐
        │     U-NET DENOISER   │
        │  + Cross-Attention   │
        │  (1000 steps)        │
        └──────────┬───────────┘
                   │
                   v
        ┌──────────────────────┐
        │  DENOISED LATENT     │
        │  (64×64×4)           │
        └──────────┬───────────┘
                   │ VAE Decoder
                   v
        ┌──────────────────────┐
        │  FINAL IMAGE         │
        │  (512×512×3)         │
        │  🐱 with 🎩         │
        └──────────────────────┘

from diffusers import StableDiffusionPipeline
import torch

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

# Prompt
prompt = "A beautiful mountain landscape at sunset, highly detailed, 4k"
negative_prompt = "blurry, low quality, distorted"

# Paramètres
num_inference_steps = 50  # Nombre de denoising steps
guidance_scale = 7.5  # Classifier-free guidance

# Génération
image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=num_inference_steps,
    guidance_scale=guidance_scale,
    height=512,
    width=512,
).images[0]

# Sauvegarder
image.save("mountain_sunset.png")

# 1. Encoder texte
text_emb = clip_text_encoder(prompt)

# 2. Bruit aléatoire dans latent space
latent = torch.randn(1, 4, 64, 64).to("cuda")

# 3. Denoising loop
for t in reversed(range(num_inference_steps)):
    # Prédire bruit
    noise_pred = unet(latent, t, text_emb)

    # Classifier-free guidance
    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond)

    # Retirer bruit
    latent = scheduler.step(noise_pred, t, latent)

# 4. Décoder latent → image
image = vae_decoder(latent)

# Sans guidance (guidance_scale = 1.0)
noise_pred = unet(latent, t, text_emb)
# → Image cohérente mais peut ignorer des détails du prompt

# Avec guidance (guidance_scale = 7.5)
# Prédire avec et sans prompt
noise_pred_text = unet(latent, t, text_emb)
noise_pred_uncond = unet(latent, t, empty_emb)

# Amplifier différence
noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
# → Image suit FORTEMENT le prompt ✅

guidance_scale = 1.0  : Image générique, peu guidée
guidance_scale = 5.0  : Bon équilibre
guidance_scale = 7.5  : Forte adhérence au prompt (défaut)
guidance_scale = 15.0 : Très guidé, peut sur-saturer

from diffusers import StableDiffusionImg2ImgPipeline

pipe = StableDiffusionImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1"
).to("cuda")

# Image source
init_image = load_image("sketch.png")

# Transformation
prompt = "Transform this sketch into a photorealistic cat"
output = pipe(
    prompt=prompt,
    image=init_image,
    strength=0.8,  # 0=identique, 1=complètement nouveau
).images[0]

from diffusers import StableDiffusionInpaintPipeline

pipe = StableDiffusionInpaintPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-inpainting"
).to("cuda")

image = load_image("photo.png")
mask = load_image("mask.png")  # Blanc = zone à régénérer

prompt = "A red sports car"
output = pipe(
    prompt=prompt,
    image=image,
    mask_image=mask
).images[0]

from diffusers import StableDiffusionControlNetPipeline, ControlNetModel

# Charger ControlNet (Canny edges)
controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny")

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1",
    controlnet=controlnet
).to("cuda")

# Image de contrôle (edges détectés)
control_image = detect_canny_edges("input.png")

# Génération guidée par structure
prompt = "A beautiful anime character"
output = pipe(
    prompt=prompt,
    image=control_image,
    num_inference_steps=20
).images[0]

Text prompt: "A woman walking in Tokyo at night"

Frame 1 → Frame 2 → ... → Frame 60
   🚶      🚶         🚶       (1 seconde)

Diffusion spatio-temporelle:
- Cohérence spatiale (dans chaque frame)
- Cohérence temporelle (entre frames)

from diffusers import AudioLDMPipeline

pipe = AudioLDMPipeline.from_pretrained("cvssp/audioldm").to("cuda")

prompt = "Techno music with heavy bass"
audio = pipe(
    prompt,
    num_inference_steps=50,
    audio_length_in_s=10.0
).audios[0]

# Sauvegarder
save_audio("techno.wav", audio, sample_rate=16000)

Prompt: "A 3D model of a medieval castle"

Process:
1. Générer multiples vues 2D (Stable Diffusion)
2. Optimiser modèle 3D pour cohérence multi-vues
3. → Mesh 3D exportable

from diffusers import StableDiffusionPipeline

# Charger modèle base
pipe = StableDiffusionPipeline.from_pretrained("sd-2-1").to("cuda")

# Charger LoRA (style spécifique)
pipe.load_lora_weights("./lora_anime_style")

# Génération avec style
prompt = "A girl in anime style"
image = pipe(prompt).images[0]

Training data: 5-10 photos d'un chien spécifique

Prompt: "A photo of [V] dog on the beach"
# [V] = identifier unique

Output: Photos de VOTRE chien sur la plage ✅

# Entraîner embedding pour concept
concept_embedding = train_textual_inversion(
    images=["cat1.jpg", "cat2.jpg", ...],
    placeholder_token="<my-cat>"
)

# Utiliser
prompt = "A photo of <my-cat> wearing sunglasses"

Problème : Anatomie incorrecte (6 doigts, positions bizarres)
Raison : Peu de données d'entraînement montrant mains clairement

Problème : Texte illisible ou incorrect
Raison : Diffusion travaille en latent space (perd précision pixel)

Problème : Objets qui défient physique (miroir sans reflet, etc.)
Raison : Modèle apprend patterns visuels, pas physique

- 50 steps × 512×512 : 5-10s sur RTX 4090
- 1000 images : 2h

Génération en 1-4 steps (vs 50)
→ 10-50× plus rapide ⚡

from diffusers import LCMScheduler

# Génération ultra-rapide
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
image = pipe(prompt, num_inference_steps=4).images[0]
# → 4 steps au lieu de 50 !

Input: Texte + Image + Audio
Output: Vidéo cohérente avec tous signaux

Génération directe de meshes 3D (pas via multi-vues)