🎨 Diffusers – La Génération d'Images (Stable Diffusion)

diffusers est la bibliothèque (library) de Hugging Face 🤗 (comme transformers) dédiée aux **modèles de diffusion** (GenAI).

Elle fournit une API simple et unifiée pour **télécharger, entraîner et exécuter** des modèles SOTA (State-of-the-Art) de génération d'image et d'audio.

Elle gère des modèles comme Stable Diffusion (1.5, XL, 3), DALL-E 2/3 (via API), Kandinsky, DeepFloyd IF, etc.

Avant diffusers, chaque nouveau modèle de diffusion (Stable Diffusion, etc.) avait son propre dépôt GitHub (repository), avec un code complexe, monolithique et incompatible.

diffusers résout ce problème (de la même manière que transformers l'a fait pour BERT/GPT) :

diffusers nécessite un backend (PyTorch) et transformers (pour les encodeurs de texte comme CLIP).

Installation (pip)

# 1. (Recommandé) Installer PyTorch d'abord (avec CUDA)
# (Voir le guide PyTorch 1.3)
pip install torch

# 2. Installer les bibliothèques Hugging Face
# (diffusers = La lib)
# (transformers = Pour les Text Encoders (CLIP))
# (accelerate = Pour la gestion GPU/vitesse)
pip install diffusers transformers accelerate

# 3. (Optionnel: pour les Schedulers SOTA)
pip install "diffusers[schedulers]"

Un modèle de diffusion (Denoising Diffusion Probabilistic Model - DDPM) apprend à **inverser** un processus. Il apprend à **retirer le bruit (Denoise)**.

• Phase 1 (Forward/Training) : On prend une image, on lui ajoute du bruit (Noise) en 1000 étapes, jusqu'à obtenir un "bruit pur". Le modèle (U-Net) est entraîné à **prédire le bruit** qui a été ajouté à chaque étape.
• Phase 2 (Reverse/Inférence) : On part d'un **bruit pur** (aléatoire) et on demande au U-Net (guidé par le "prompt") de "prédire le bruit" (étape 1000), on le soustrait (légèrement), et on répète (étape 999, 998...). L'image "émerge" du bruit.

Diagramme (Inférence Text-to-Image)

+-----------+
| Prompt    | (ex: "A cat")
+-----------+
      | (CLIP Text Encoder)
      ▼
+-----------+
| Embeddings| (Vecteurs [77, 768])
+-----------+
      |
      | (Guidage)
      ▼
+-----------+   +-------------+
| Bruit Pur | ->| Boucle (U-Net)| (50x Steps)
| (Latent)  |   | (Denoise Step)| <-- (Scheduler)
+-----------+   +-------------+
      |
      ▼
+-----------+
| Latent    | (Image "débruitée")
+-----------+
      | (VAE Decoder)
      ▼
+-----------+
| Image (RGB)|
+-----------+

La DiffusionPipeline (similaire à transformers.pipeline) est l'abstraction haut niveau qui gère **tous** les composants (VAE, U-Net, CLIP, Scheduler) pour une tâche donnée (ex: Text-to-Image).

Exemple (Chargement)

from diffusers import DiffusionPipeline

model_id = "runwayml/stable-diffusion-v1-5"

# 1. Charger le pipeline (télécharge les composants)
# (Utilise le cache local si déjà téléchargé)
pipe = DiffusionPipeline.from_pretrained(
    model_id,
    # (Optionnel: optimisations)
    # torch_dtype=torch.float16 
)

# 2. Déplacer sur GPU (ESSENTIEL)
pipe = pipe.to("cuda")

# 3. (Maintenant 'pipe' est prêt à être appelé)
# image = pipe(prompt).images[0]

Les modèles (checkpoints) sont stockés sur le Hub Hugging Face (ou localement). .from_pretrained() prend l'ID du Hub.

Tâche la plus simple : Prompt (texte) -> Image.

import torch
from diffusers import StableDiffusionPipeline

# 1. Charger (SD 1.5)
pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5", 
    torch_dtype=torch.float16 // (Optimisation FP16)
)
pipe = pipe.to("cuda")

# 2. Définir le prompt
prompt = "a high quality photo of an astronaut riding a horse on Mars"

# 3. Générer (Inférence)
# (Utilise un 'generator' pour la reproductibilité (seed))
generator = torch.Generator("cuda").manual_seed(42)
image = pipe(
    prompt,
    generator=generator,
    num_inference_steps=30 // (Nb d'étapes de "denoising")
).images[0] // (Prend la 1ère image du batch)

# 4. Sauvegarder (Image PIL)
image.save("astronaut.png")

Prend un prompt ET une image d'entrée. (ex: transformer un "croquis" en photo).

from diffusers import StableDiffusionImg2ImgPipeline
from PIL import Image

# 1. Charger le pipeline Img2Img
pipe = StableDiffusionImg2ImgPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

# 2. Charger l'image d'entrée
init_image = Image.open("mon_croquis.png").convert("RGB")
init_image = init_image.resize((512, 512))

prompt = "A high quality photo of a cat, realistic"

# 3. Générer
# (strength: 0.0=garde l'image, 1.0=ignore l'image)
image = pipe(
    prompt=prompt, 
    image=init_image, 
    strength=0.75, // (75% denoising)
    guidance_scale=7.5
).images[0]

image.save("chat_realiste.png")

Remplir (ou remplacer) une partie d'une image, définie par un **masque (mask)**.

from diffusers import StableDiffusionInpaintPipeline
from PIL import Image

# 1. Charger le pipeline Inpaint
pipe = StableDiffusionInpaintPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

# 2. Charger l'image d'entrée ET le masque
init_image = Image.open("image_originale.png").resize((512, 512))
mask_image = Image.open("masque.png").resize((512, 512))
// (Masque: Blanc = à changer, Noir = à garder)

prompt = "a cute cat sitting on a bench" // (Ce qu'on veut DANS le masque)

# 3. Générer
image = pipe(
    prompt=prompt, 
    image=init_image, 
    mask_image=mask_image
).images[0]

image.save("image_modifiee.png")

Le **Scheduler** (Planificateur/Échantillonneur) est l'algorithme qui implémente la boucle de "denoising" (Phase 2 du diagramme 2.1). Il détermine *comment* soustraire le bruit à chaque étape (num_inference_steps).

Changer le Scheduler (Sampler) a un impact **massif** sur la vitesse et la qualité (certains Schedulers convergent en 10 étapes, d'autres en 50).

Changer le Scheduler

from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler

model_id = "runwayml/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(model_id).to("cuda")

// 1. Charger un nouveau Scheduler
pipe.scheduler = DPMSolverMultistepScheduler.from_config(
    pipe.scheduler.config,
    use_karras_sigmas=True
)

// 2. Générer (nécessite moins d'étapes)
image = pipe(prompt, num_inference_steps=20).images[0]

La "Classifier-Free Guidance" (CFG) est la technique qui "force" l'image à ressembler au prompt.

prompt = "A photo of a queen"
negative_prompt = "low quality, blurry, deformed, cartoon, ugly"

image = pipe(
    prompt,
    negative_prompt=negative_prompt,
    guidance_scale=7.5
).images[0]

Pourquoi Stable Diffusion est-il rapide ? Il ne "diffuse" (débruite) **pas** l'image (Pixel Space, ex: 3x512x512), mais une version compressée : le **Latent Space** (ex: 4x64x64).

Le VAE (Variational Autoencoder) est le composant qui compresse (Pixel -> Latent) et décompresse (Latent -> Pixel).

Diagramme (Pipeline VAE)

(Image d'entrée: [3, 512, 512])
      |
      ▼ (VAE Encoder)
+-------------+
| Latent      | ([4, 64, 64])
+-------------+
      |
      ▼
+-------------+
| Boucle      | (La diffusion se passe ici,
| U-Net       | c'est 48x plus petit !)
+-------------+
      |
      ▼
+-------------+
| Latent      | ([4, 64, 64])
| Débruité    |
+-------------+
      |
      ▼ (VAE Decoder)
+-------------+
| Image Sortie| ([3, 512, 512])
+-------------+

SDXL (Stable Diffusion XL) est une version (1024x1024) qui utilise un pipeline en 2 étapes : un modèle Base (génère) et un Refiner (affine les détails).

from diffusers import DiffusionPipeline
import torch

# 1. Charger le pipeline de BASE (SDXL)
base = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
    variant="fp16",
    use_safetensors=True
).to("cuda")

# 2. Charger le pipeline REFINER
refiner = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0",
    text_encoder_2=base.text_encoder_2,
    vae=base.vae,
    torch_dtype=torch.float16,
    use_safetensors=True,
).to("cuda")

prompt = "A majestic lion jumping from a big rock on a sunny day"

# 3. Étape 1: BASE (Génère le Latent)
# (output_type="latent" -> ne pas décoder)
image_latent = base(
    prompt=prompt,
    num_inference_steps=40,
    output_type="latent"
).images

# 4. Étape 2: REFINER (Affine le Latent)
image = refiner(
    prompt=prompt,
    num_inference_steps=20,
    image=image_latent
).images[0]

image.save("sdxl_lion.png")

Le "Fine-Tuning" (ré-entraîner SD) est lourd (ex: 20GB). Les **LoRA** (Low-Rank Adaptation) sont des "patchs" (petits fichiers, ~2MB à 200MB) qui "injectent" des modifications (ex: un style artistique, un visage) dans un modèle de base (ex: SD 1.5).

diffusers peut charger des LoRA (souvent au format .safetensors) par-dessus le pipeline.

pipe = DiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5", ...
).to("cuda")

# 1. Charger les poids LoRA (depuis le Hub ou local)
# (Ex: LoRA "Style Disney")
pipe.load_lora_weights("CiroN2022/disney-pixar")

# 2. Générer (Le prompt "trigger" le style)
prompt = "A photo of a man, disneypixar style"
image = pipe(prompt).images[0]

# (On peut désactiver le LoRA)
# pipe.unload_lora_weights()

ControlNet est un "module" qui ajoute un **contrôle spatial** (conditionnement) à Stable Diffusion. Il "guide" la génération en forçant l'image à respecter une "carte de contrôle".

Cartes de contrôle communes :

• Canny : Contours (edge detection).
• OpenPose : Squelette (pose du corps).
• Depth : Carte de profondeur (perspective).

Exemple (ControlNet Canny)

from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
import cv2, torch
from PIL import Image

# 1. Charger une image d'entrée (ex: une photo)
image = Image.open("photo.png")
# (Utiliser OpenCV (cv2) pour extraire les contours)
canny_image = cv2.Canny(np.array(image), 100, 200)
canny_image = Image.fromarray(canny_image)

# 2. Charger le ControlNet (pour Canny)
controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/sd-controlnet-canny",
    torch_dtype=torch.float16
)

# 3. Charger le Pipeline (ControlNet)
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

# 4. Générer (Le prompt + la carte Canny)
prompt = "A photo of a cat in the style of Van Gogh"
image = pipe(
    prompt,
    image=canny_image // (L'image de contrôle)
).images[0]
// (Output: Un chat style Van Gogh,
// MAIS avec la pose/forme de la photo originale)

Le U-Net (UNet2DConditionModel) est le **cœur** du modèle de diffusion. C'est lui qui effectue le "denoising" (débruitage).

Il prend en entrée : le Latent bruité (ex: 4x64x64) + le Prompt (Embeddings) + le Timestep (Étape).
Il prédit en sortie : le Bruit (Noise) à retirer (ou l'image débruitée).

Le Text Encoder (ex: CLIPTextModel) est le composant (de transformers) qui "comprend" le prompt. Il transforme le texte (string) en vecteurs (Embeddings) que le U-Net peut utiliser comme "guidage" (conditionnement).

Le VAE (AutoencoderKL) est l'encodeur/décodeur (voir 4.3).

• .encode() : (Pixel Space -> Latent Space). (Utilisé dans Img2Img / Inpainting).
• .decode() : (Latent Space -> Pixel Space). (Utilisé à la fin de Txt2Img pour générer l'image finale).

diffusers est devenu le "standard" open-source pour la R&D et la production en GenAI (Image/Audio).

Ressources pour apprendre et travailler avec Diffusers.

import torch
from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler

# 1. Définir le Modèle & Device
model_id = "runwayml/stable-diffusion-v1-5"
device = "cuda"

# 2. Charger le Pipeline (Base)
pipe = StableDiffusionPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16
)

# 3. (Optionnel) Changer le Scheduler (Sampler)
pipe.scheduler = DPMSolverMultistepScheduler.from_config(
    pipe.scheduler.config,
    use_karras_sigmas=True
)

# 4. (Optionnel) Charger un LoRA
# pipe.load_lora_weights("path_or_hub_id")

# 5. Envoyer au GPU
pipe = pipe.to(device)

# 6. Définir les Prompts
prompt = "photo of a cat, high quality"
negative_prompt = "blurry, low quality, cartoon"

# 7. (Optionnel) Seed
generator = torch.Generator(device).manual_seed(1234)

# 8. Générer (Inférence)
image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_inference_steps=25,
    guidance_scale=7.5,
    generator=generator
).images[0]

# 9. Sauvegarder
image.save("cat.png")