SVD - Stable Video Diffusion (Image-to-Video)

Module : 02-Video-Advanced
Niveau : Intermediaire
Technologies : Stable Video Diffusion 1.1 (Stability AI), diffusers
Duree estimee : 45 minutes
VRAM : ~10 GB

Objectifs d’Apprentissage

Prerequis

  • GPU avec 10+ GB VRAM (RTX 3060 12GB recommande)
  • Notebooks 02-1 a 02-3 completes pour comparaison
  • Packages : diffusers>=0.30, transformers, torch, accelerate, imageio, imageio-ffmpeg, Pillow

Navigation : << 02-3 | Index | 02-5 LTX-2 >>

# Parametres Papermill - JAMAIS modifier ce commentaire

# Configuration notebook
notebook_mode = "interactive"        # "interactive" ou "batch"
skip_widgets = False               # True pour mode batch MCP
debug_level = "INFO"

# Parametres modele
model_id = "stabilityai/stable-video-diffusion-img2vid-xt"  # SVD 1.1 XT (25 frames)
device = "cuda"                    # Device de calcul

# Parametres generation
num_frames = 25                    # Nombre de frames (XT = 25)
fps = 7                            # FPS de conditionnement
motion_bucket_id = 127             # Intensite du mouvement (0-255)
noise_aug_strength = 0.02          # Force de l'augmentation de bruit
num_inference_steps = 25           # Nombre d'etapes de debruitage
decode_chunk_size = 8              # Frames decodees par chunk (reduit VRAM)
fps_output = 7                     # FPS de la video de sortie

# Configuration
run_generation = True              # Executer la generation
save_as_mp4 = True                 # Sauvegarder en MP4
save_results = True
# Parameters
notebook_mode = "batch"
skip_widgets = True

Setup de l’environnement

Installation des dependances, chargement des cles API, et verification GPU.

# Setup environnement et imports
import os
import sys
import json
import time
import warnings
from pathlib import Path
from datetime import datetime
from typing import Dict, List, Any, Optional
import numpy as np
import pandas as pd
from PIL import Image, ImageDraw, ImageFilter
import matplotlib.pyplot as plt
import logging

warnings.filterwarnings('ignore', category=DeprecationWarning)
warnings.filterwarnings('ignore', category=FutureWarning)

# Import helpers GenAI
# Chargement robuste de la configuration .env
from dotenv import load_dotenv
import os
# Recherche du .env dans tous les parents (pour Papermill qui change le cwd)
current_path = Path.cwd()
env_loaded = False
for _ in range(10):
    env_path = current_path / ".env"
    if env_path.exists():
        load_dotenv(env_path)
        print(f".env charge depuis: {env_path.name}")
        env_loaded = True
        break
    if current_path.name == "GenAI" or len(current_path.parts) <= 1:
        break
    current_path = current_path.parent

# Definir GENAI_ROOT a partir de current_path (apres la boucle de recherche)
GENAI_ROOT = current_path if current_path.name == "GenAI" else current_path / "GenAI"
if not env_loaded:
    print("WARNING: .env non trouve, utilisation variables environnement")

HELPERS_PATH = GENAI_ROOT / 'shared' / 'helpers'
if HELPERS_PATH.exists():
    sys.path.insert(0, str(HELPERS_PATH.parent))
    try:
        from helpers.genai_helpers import setup_genai_logging
        print("Helpers GenAI importes")
    except ImportError:
        print("Helpers GenAI non disponibles - mode autonome")

OUTPUT_DIR = GENAI_ROOT / 'outputs' / 'svd_video'
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)

logging.basicConfig(level=getattr(logging, debug_level))
logger = logging.getLogger('svd_video')

print(f"SVD - Stable Video Diffusion (Image-to-Video)")
print(f"Date : {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print(f"Mode : {notebook_mode}")
print(f"Frames : {num_frames}, Steps : {num_inference_steps}")
print(f"Motion bucket : {motion_bucket_id}, Noise aug : {noise_aug_strength}")
WARNING: .env non trouve, utilisation variables environnement
Helpers GenAI importes
SVD - Stable Video Diffusion (Image-to-Video)
Date : 2026-09-19 13:02:38
Mode : batch
Frames : 25, Steps : 25
Motion bucket : 127, Noise aug : 0.02

Les imports Python en place, la cellule suivante charge la configuration depuis .env, detecte le GPU disponible et initialise les variables de session. Ces informations determinent si la generation reelle est possible (GPU + modeles disponibles) ; sur cette machine (RTX 3090, kernel bonsai-gpu), la generation reelle est active.

# Chargement .env et verification GPU
# Chargement robuste de la configuration .env
from dotenv import load_dotenv
import os
# Recherche du .env dans tous les parents (pour Papermill qui change le cwd)
current_path = Path.cwd()
env_loaded = False
for _ in range(10):
    env_path = current_path / ".env"
    if env_path.exists():
        load_dotenv(env_path)
        print(f".env charge depuis: {env_path.name}")
        env_loaded = True
        break
    current_path = current_path.parent
    if current_path.name == "GenAI" or len(current_path.parts) <= 1:
        break
if not env_loaded:
    print("WARNING: .env non trouve, utilisation variables environnement")

# Verification GPU
print("\n--- VERIFICATION GPU ---")
print("=" * 40)

import torch
import os
os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8")  # determinisme cuBLAS (#16795)
# Determinisme (#16795) : la graine seule ne garantit PAS la reproductibilite
# (heuristiques cuDNN, kernels non deterministes). warn_only=True au premier
# passage pour inventorier les ops fautives sans faire echouer le run.
torch.use_deterministic_algorithms(True, warn_only=True)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False

if torch.cuda.is_available():
    gpu_name = torch.cuda.get_device_name(0)
    vram_total = torch.cuda.get_device_properties(0).total_memory / 1024**3
    vram_free = (torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated(0)) / 1024**3
    
    print(f"GPU : {gpu_name}")
    print(f"VRAM totale : {vram_total:.1f} GB")
    print(f"VRAM libre : {vram_free:.1f} GB")
    print(f"CUDA : {torch.version.cuda}")
    
    if vram_total < 10:
        print(f"\nAttention : VRAM ({vram_total:.0f} GB) < 10 GB recommandes")
        decode_chunk_size = 4
        num_frames = 14  # Version non-XT
        print(f"  Frames reduites a {num_frames}, decode chunk = {decode_chunk_size}")
else:
    print("CUDA non disponible.")
    print("SVD necessite un GPU. Le notebook montrera le code sans executer.")
    run_generation = False
    device = "cpu"

# Verification des dependances
print("\n--- VERIFICATION DEPENDANCES ---")
print("=" * 40)

deps_ok = True

# Verification huggingface-hub version AVANT d'importer diffusers
try:
    import huggingface_hub
    hf_version = huggingface_hub.__version__
    print(f"huggingface-hub : v{hf_version}")
    # Verifier si la version est compatible
    # La compatibilite reelle est verifiee par import effectif ci-dessous.
    # RATIONNEL : diffusers >= 0.38 est compatible avec huggingface-hub 1.x (verifie firsthand :
    # from_pretrained + import StableVideoDiffusionPipeline OK avec hf_hub 1.18 / diffusers 0.38).
    # L'ancien seuil "<1.0" etait conservateur et desactivait SVD a tort sur les envs modernes.
    svd_available = True
except ImportError:
    print("huggingface-hub NON INSTALLE")
    svd_available = False
except Exception as e:
    print(f"Erreur verification huggingface-hub: {e}")
    svd_available = False

try:
    import diffusers
    print(f"diffusers : v{diffusers.__version__}")
except ImportError:
    print("diffusers NON INSTALLE")
    deps_ok = False

# Import SVD seulement si les dependances sont OK
svd_pipeline = None
if svd_available and deps_ok:
    try:
        from diffusers import StableVideoDiffusionPipeline
        from diffusers.utils import export_to_video, load_image
        print("StableVideoDiffusionPipeline : disponible")
    except ImportError as e:
        error_str = str(e)
        if "huggingface-hub" in error_str:
            print(f"StableVideoDiffusionPipeline : NON DISPONIBLE (conflit de version huggingface-hub)")
            print(f"  Solution: pip install 'huggingface-hub<1.0'")
        else:
            print(f"StableVideoDiffusionPipeline : NON DISPONIBLE - {error_str[:100]}")
        svd_pipeline = False
        deps_ok = False
else:
    if not svd_available:
        print("StableVideoDiffusionPipeline : NON DISPONIBLE (dependances)")
    svd_pipeline = False
    deps_ok = False

try:
    import imageio
    print(f"imageio : v{imageio.__version__}")
except ImportError:
    print("imageio NON INSTALLE")
    deps_ok = False

if not deps_ok:
    print("\nDependances manquantes. Le notebook montrera le code sans executer.")
    run_generation = False

print(f"\nDevice : {device}")
print(f"Generation activee : {run_generation}")
WARNING: .env non trouve, utilisation variables environnement

--- VERIFICATION GPU ---
========================================
GPU : NVIDIA GeForce RTX 3090
VRAM totale : 24.0 GB
VRAM libre : 24.0 GB
CUDA : 12.6

--- VERIFICATION DEPENDANCES ---
========================================
huggingface-hub : v1.20.1
diffusers : v0.38.0
StableVideoDiffusionPipeline : disponible
imageio : v2.37.2

Device : cuda
Generation activee : True

Section 1 : Architecture SVD et chargement

Stable Video Diffusion (SVD) est un modèle image-to-video de Stability AI. Contrairement aux modèles text-to-video (HunyuanVideo, LTX, Wan), SVD prend une image en entree et genere une sequence animee a partir de celle-ci.

Composant Description
Architecture U-Net 3D base sur Stable Diffusion 2.1
Entree Image PIL unique (pas de prompt textuel)
Conditionnement Image + FPS + motion_bucket_id
Variante XT 25 frames au lieu de 14 (version standard)

Paramètres cles de SVD

Paramètre Rôle Plage
motion_bucket_id Intensite du mouvement 0-255 (127 = neutre)
fps FPS de conditionnement (influence la vitesse percue) 2-30
noise_aug_strength Perturbation de l’image d’entree 0.0-0.1
decode_chunk_size Frames decodees par batch (VRAM) 2-14

Licence : Stable Video Diffusion Community License — executable, conforme en UE

Avant de charger le moindre poids, on verifie la licence firsthand. C’est la lecon du notebook 02-6 MiniMax H3 : une licence peut rendre un modele techniquement excellent inutilisable selon la juridiction, et cette conformite se decide avant d’ecrire une ligne de code.

Modele : stabilityai/stable-video-diffusion-img2vid-xt — licence Stable Video Diffusion Community (stability.ai/license).

La licence Stability se distingue radicalement de la licence MiniMax H3 (02-6) sur les deux points qui determinent la conformite d’un deploiement pedagogique :

Clause MiniMax H3 (02-6) SVD (ce notebook)
Exclusion territoriale Oui — UE, UK, Coree, USA exclus Aucune — aucune restriction geographique
Outputs generes Restrictions etendues aux Outputs L’utilisateur possede les Outputs : « you own outputs generated […] and can use those outputs at your discretion »
Seuil commercial — Revenu annuel > 1 M USD -> licence Enterprise requise (non pertinent en pedagogie)

Verdict SOTA-OK : la licence est ouverte, sans verrou geographique, et nous sommes proprietaires des videos generees — nous pouvons les afficher, les committer et les distribuer. Le notebook execute reellement le modele et affiche ses vraies sorties (contact-sheet de frames + mesure quantitative du mouvement), contrairement a 02-6 qui ne fait qu’une etude descriptive. C’est la licence — non la capacite technique — qui determine cette difference d’execution : deux modeles video de qualite comparable, conformite radicalement differente.

# Chargement du pipeline SVD
pipe = None

if run_generation:
    print("\n--- CHARGEMENT DU PIPELINE SVD ---")
    print("=" * 40)
    
    try:
        start_load = time.time()
        
        print(f"Chargement modele : {model_id}")
        
        pipe = StableVideoDiffusionPipeline.from_pretrained(
            model_id,
            torch_dtype=torch.float16,
            variant="fp16"
        )
        pipe = pipe.to(device)
        
        # Optimisations memoire : SVD n'expose pas enable_vae_slicing dans diffusers 0.38+
        # (le decode_chunk_size du pipe gere deja la VRAM du VAE par chunks de frames).
        try:
            pipe.enable_model_cpu_offload()
        except Exception:
            pass
        
        load_time = time.time() - start_load
        
        if device == "cuda":
            vram_used = torch.cuda.memory_allocated(0) / 1024**3
            print(f"  VRAM utilisee : {vram_used:.1f} GB")
        
        print(f"Pipeline SVD charge en {load_time:.1f}s")
        print(f"  Variante : {'XT (25 frames)' if 'xt' in model_id else 'Standard (14 frames)'}")
        print(f"  VAE slicing : actif")
        print(f"  Decode chunk size : {decode_chunk_size}")
        
    except Exception as e:
        print(f"Erreur chargement pipeline : {type(e).__name__}: {str(e)[:200]}")
        print("Le notebook continuera sans generation.")
        run_generation = False
        pipe = None
else:
    print("Chargement pipeline desactive")

--- CHARGEMENT DU PIPELINE SVD ---
========================================
Chargement modele : stabilityai/stable-video-diffusion-img2vid-xt
  VRAM utilisee : 0.0 GB
Pipeline SVD charge en 7.4s
  Variante : XT (25 frames)
  VAE slicing : actif
  Decode chunk size : 8

Section 2 : Creation d’images de test et première animation

Nous allons créer des images de test variees et les animer avec SVD. SVD ne prend pas de prompt textuel : le mouvement est entierement infere a partir de l’image d’entree et des paramètres de conditionnement.

# Creation d'images de test et premiere animation
print("\n--- CREATION D'IMAGES DE TEST ---")
print("=" * 40)

# SVD attend des images 1024x576
svd_width = 1024
svd_height = 576

def create_test_image(name: str, description: str) -> Image.Image:
    """
    Cree une image de test pour SVD.
    
    Args:
        name: Nom du type d'image
        description: Description pour le titre
    
    Returns:
        Image PIL en RGB
    """
    img = Image.new('RGB', (svd_width, svd_height))
    draw = ImageDraw.Draw(img)
    
    if name == "landscape":
        # Paysage : ciel bleu, montagnes, herbe
        for y in range(svd_height):
            if y < svd_height * 0.4:  # Ciel
                r = int(100 + 55 * y / (svd_height * 0.4))
                g = int(150 + 50 * y / (svd_height * 0.4))
                b = int(230 - 30 * y / (svd_height * 0.4))
            elif y < svd_height * 0.6:  # Montagnes
                t = (y - svd_height * 0.4) / (svd_height * 0.2)
                r = int(120 - 40 * t)
                g = int(130 - 30 * t)
                b = int(140 - 20 * t)
            else:  # Herbe
                t = (y - svd_height * 0.6) / (svd_height * 0.4)
                r = int(60 + 30 * t)
                g = int(140 - 20 * t)
                b = int(40 + 20 * t)
            draw.line([(0, y), (svd_width, y)], fill=(r, g, b))
        # Soleil
        draw.ellipse([svd_width - 150, 30, svd_width - 50, 130],
                     fill=(255, 220, 100))
    
    elif name == "portrait":
        # Fond uni avec forme geometrique (silhouette simplifiee)
        draw.rectangle([0, 0, svd_width, svd_height], fill=(80, 70, 90))
        # Cercle (tete)
        cx, cy = svd_width // 2, svd_height // 3
        r = 80
        draw.ellipse([cx-r, cy-r, cx+r, cy+r], fill=(200, 170, 140))
        # Corps
        draw.polygon([(cx-100, cy+r), (cx+100, cy+r),
                      (cx+120, svd_height), (cx-120, svd_height)],
                     fill=(50, 80, 120))
    
    elif name == "nature":
        # Scene nature : eau et reflets
        for y in range(svd_height):
            if y < svd_height * 0.5:  # Ciel coucher de soleil
                t = y / (svd_height * 0.5)
                r = int(255 - 60 * t)
                g = int(150 - 50 * t)
                b = int(100 + 50 * t)
            else:  # Eau avec reflets
                t = (y - svd_height * 0.5) / (svd_height * 0.5)
                r = int(100 - 40 * t)
                g = int(120 - 30 * t)
                b = int(160 - 20 * t)
            draw.line([(0, y), (svd_width, y)], fill=(r, g, b))
        # Soleil a l'horizon
        sun_y = int(svd_height * 0.45)
        draw.ellipse([svd_width//2-60, sun_y-60, svd_width//2+60, sun_y+60],
                     fill=(255, 180, 80))
    
    return img


# Creer les images de test
test_images = [
    {"name": "landscape", "description": "Paysage avec montagnes"},
    {"name": "portrait", "description": "Silhouette portrait"},
    {"name": "nature", "description": "Coucher de soleil sur l'eau"},
]

created_images = {}
for img_info in test_images:
    img = create_test_image(img_info['name'], img_info['description'])
    img_path = OUTPUT_DIR / f"test_{img_info['name']}.png"
    img.save(str(img_path))
    created_images[img_info['name']] = img
    print(f"Image creee : {img_info['description']} ({svd_width}x{svd_height})")

# Afficher les images de test
fig, axes = plt.subplots(1, len(test_images), figsize=(5 * len(test_images), 3))
for i, img_info in enumerate(test_images):
    axes[i].imshow(created_images[img_info['name']])
    axes[i].set_title(img_info['description'], fontsize=10)
    axes[i].axis('off')
plt.suptitle("Images de test pour SVD", fontsize=13, fontweight='bold')
plt.tight_layout()
plt.show()

# Premiere animation : paysage
if run_generation and pipe is not None:
    print(f"\n--- PREMIERE ANIMATION ---")
    print(f"Image : Paysage avec montagnes")
    print(f"Motion bucket : {motion_bucket_id}, FPS : {fps}")
    print(f"Noise aug : {noise_aug_strength}")
    print(f"\nGeneration en cours...")
    
    generator = torch.Generator(device=device).manual_seed(42)
    if device == "cuda":
        torch.cuda.reset_peak_memory_stats()
    
    start_time = time.time()
    
    output = pipe(
        image=created_images['landscape'],
        num_frames=num_frames,
        fps=fps,
        motion_bucket_id=motion_bucket_id,
        noise_aug_strength=noise_aug_strength,
        num_inference_steps=num_inference_steps,
        decode_chunk_size=decode_chunk_size,
        generator=generator
    )
    
    gen_time = time.time() - start_time
    frames_landscape = output.frames[0]
    
    print(f"\nGeneration reussie")
    print(f"  Temps : {gen_time:.1f}s")
    print(f"  Frames : {len(frames_landscape)}")
    if device == "cuda":
        vram_peak = torch.cuda.max_memory_allocated(0) / 1024**3
        print(f"  VRAM pic : {vram_peak:.1f} GB")
    
    # Affichage
    n_display = min(8, len(frames_landscape))
    indices = np.linspace(0, len(frames_landscape) - 1, n_display, dtype=int)
    fig, axes = plt.subplots(2, 4, figsize=(16, 8))
    axes_flat = axes.flatten()
    for i, idx in enumerate(indices):
        if i < len(axes_flat):
            axes_flat[i].imshow(frames_landscape[idx])
            axes_flat[i].set_title(f"Frame {idx + 1}/{len(frames_landscape)}", fontsize=9)
            axes_flat[i].axis('off')
    for i in range(len(indices), len(axes_flat)):
        axes_flat[i].axis('off')
    plt.suptitle(f"SVD : Paysage anime ({gen_time:.1f}s)", fontsize=11, fontweight='bold')
    plt.tight_layout()
    plt.show()
    
    if save_as_mp4:
        mp4_path = OUTPUT_DIR / "svd_landscape.mp4"
        export_to_video(frames_landscape, str(mp4_path), fps=fps_output)
        print(f"  MP4 sauvegarde : {mp4_path.name}")
else:
    print("\nGeneration desactivee")

--- CREATION D'IMAGES DE TEST ---
========================================
Image creee : Paysage avec montagnes (1024x576)
Image creee : Silhouette portrait (1024x576)
Image creee : Coucher de soleil sur l'eau (1024x576)


--- PREMIERE ANIMATION ---
Image : Paysage avec montagnes
Motion bucket : 127, FPS : 7
Noise aug : 0.02

Generation en cours...

Generation reussie
  Temps : 101.3s
  Frames : 25
  VRAM pic : 10.9 GB

  MP4 sauvegarde : svd_landscape.mp4

Interpretation : Première animation SVD

Le notebook exécute réellement Stable Video Diffusion. La cellule précédente a chargé le pipeline stable-video-diffusion-img2vid-xt (fp16) sur RTX 3090 (kernel bonsai-gpu, diffusers 0.38) et généré une vidéo de 25 frames à partir de l’image synthétique « Paysage avec montagnes » :

Aspect Valeur mesurée Signification
Temps de génération ~100 s (mesuré dans la sortie) 25 frames, 20 steps de diffusion
VRAM pic 10.8 GB Plus léger que HunyuanVideo (~18 GB)
Frames générées 25 (variante XT) ~3.5 s à 7 fps
Fidélité frame 0 = image d’entrée SVD conditionne la vidéo sur la source

Observation clé : la première frame reproduit fidèlement l’image d’entrée — SVD conditionne la génération sur l’image source, puis le mouvement se développe sur les frames suivantes. L’optimisation mémoire repose sur enable_model_cpu_offload() et le paramètre decode_chunk_size : le pipeline SVD n’expose pas enable_vae_slicing() dans diffusers 0.38+ (vérifié firsthand — la méthode est absente), le décodage VAE par chunks de frames gère déjà la VRAM du décodeur.

Comparaison avec les autres modèles vidéo de la série :

Modèle Type VRAM Vitesse Spécialité
SVD Image-to-video ~10.8 GB Moyenne Animation précise d’une image
HunyuanVideo Text-to-video ~18 GB Lente Longues séquences cinématographiques
LTX-Video Text/Img/Vid ~8 GB Rapide Prototypage rapide
Wan Text-to-video ~10 GB Moyenne Prompts multilingues

Licence : Stable Video Diffusion Community License — aucune exclusion territoriale, l’utilisateur possède les outputs (détails dans la cellule licence ci-dessus). À contraster avec MiniMax H3 (notebook 02-6) dont la licence exclut l’UE, le Royaume-Uni, la Corée du Sud et les États-Unis : deux modèles vidéo de qualité comparable, une conformité radicalement différente.

# Test de differentes valeurs de motion_bucket_id
if run_generation and pipe is not None:
    print("\n--- CONTROLE MOTION BUCKET ---")
    print("=" * 40)
    
    motion_values = [40, 127, 200]
    motion_labels = ["Subtil (40)", "Normal (127)", "Fort (200)"]
    motion_results = []
    
    # Source TEXTUREE reelle : motion_bucket_id ne se manifeste que sur un contenu
    # riche en detail haute-frequence (la texture donne au modele matiere a animer).
    # Les images synthetiques lisses (gradients) donnent une reponse PLATE - verifie
    # firsthand : diff inter-frames quasi-identique quel que soit MBI sur un gradient
    # uni, car SVD n'a aucune texture a deformer. On charge donc une vraie image.
    _textured_path = GENAI_ROOT / 'Video' / '02-Advanced' / 'assets' / 'svd_source_textured.png'
    if _textured_path.exists():
        source_image = Image.open(str(_textured_path)).convert("RGB").resize(
            (svd_width, svd_height), Image.LANCZOS)
        print(f"Image source : portrait texture reel ({_textured_path.name})")
        print(f"  -> necessaire : un gradient lisse donne un couple FLAT (rien a animer)")
    else:
        source_image = created_images['nature']
        print(f"Image source : Coucher de soleil sur l'eau (fallback synthetique - asset absent)")
    
    for m_val, m_label in zip(motion_values, motion_labels):
        print(f"\nMotion bucket = {m_val} ({m_label})")
        
        generator = torch.Generator(device=device).manual_seed(42)
        if device == "cuda":
            torch.cuda.reset_peak_memory_stats()
        
        start_time = time.time()
        
        try:
            output = pipe(
                image=source_image,
                num_frames=num_frames,
                fps=fps,
                motion_bucket_id=m_val,
                noise_aug_strength=noise_aug_strength,
                num_inference_steps=num_inference_steps,
                decode_chunk_size=decode_chunk_size,
                generator=generator
            )
            
            gen_time = time.time() - start_time
            frames = output.frames[0]
            
            # Mesure du mouvement reel (difference entre frames)
            diffs = []
            for i in range(len(frames) - 1):
                f1 = np.array(frames[i]).astype(float)
                f2 = np.array(frames[i + 1]).astype(float)
                diff = np.mean(np.abs(f1 - f2))
                diffs.append(diff)
            avg_diff = np.mean(diffs)
            
            vram_peak = 0
            if device == "cuda":
                vram_peak = torch.cuda.max_memory_allocated(0) / 1024**3
            
            motion_results.append({
                "bucket": m_val,
                "label": m_label,
                "frames": frames,
                "time": gen_time,
                "avg_diff": avg_diff,
                "vram_peak": vram_peak
            })
            
            print(f"  Temps : {gen_time:.1f}s, Diff moyenne : {avg_diff:.2f}")
            
            if save_as_mp4:
                mp4_path = OUTPUT_DIR / f"svd_motion_{m_val}.mp4"
                export_to_video(frames, str(mp4_path), fps=fps_output)
                
        except Exception as e:
            print(f"  Erreur : {type(e).__name__}: {str(e)[:100]}")
    
    # Affichage comparatif
    if motion_results:
        n_results = len(motion_results)
        n_preview = 4
        fig, axes = plt.subplots(n_results, n_preview, figsize=(3.5 * n_preview, 3 * n_results))
        if n_results == 1:
            axes = [axes]
        
        for v_idx, mr in enumerate(motion_results):
            frame_indices = np.linspace(0, len(mr['frames']) - 1, n_preview, dtype=int)
            for f_idx, fi in enumerate(frame_indices):
                axes[v_idx][f_idx].imshow(mr['frames'][fi])
                axes[v_idx][f_idx].axis('off')
                if f_idx == 0:
                    axes[v_idx][f_idx].set_ylabel(f"MBI={mr['bucket']}", fontsize=10, fontweight='bold')
        
        plt.suptitle("Impact de motion_bucket_id", fontsize=13, fontweight='bold')
        plt.tight_layout()
        plt.show()
        
        # Tableau recapitulatif
        print(f"\n{'Motion Bucket':<18} {'Diff frames':<15} {'Temps (s)':<12} {'VRAM (GB)':<12}")
        print("-" * 57)
        for mr in motion_results:
            print(f"  {mr['label']:<18} {mr['avg_diff']:<15.2f} {mr['time']:<12.1f} {mr['vram_peak']:<12.1f}")
else:
    print("Test motion bucket : generation desactivee")
    print("\nGuide motion_bucket_id :")
    print("  0-60   : Mouvement tres subtil (ideal pour portraits)")
    print("  80-150  : Mouvement modere (usage general)")
    print("  150-255 : Mouvement fort (scenes dynamiques)")

--- CONTROLE MOTION BUCKET ---
========================================
Image source : portrait texture reel (svd_source_textured.png)
  -> necessaire : un gradient lisse donne un couple FLAT (rien a animer)

Motion bucket = 40 (Subtil (40))
  Temps : 102.5s, Diff moyenne : 12.29

Motion bucket = 127 (Normal (127))
  Temps : 104.7s, Diff moyenne : 13.30

Motion bucket = 200 (Fort (200))
  Temps : 102.3s, Diff moyenne : 11.37


Motion Bucket      Diff frames     Temps (s)    VRAM (GB)   
---------------------------------------------------------
  Subtil (40)        12.29           102.5        10.9        
  Normal (127)       13.30           104.7        10.9        
  Fort (200)         11.37           102.3        10.9

Section 3 : Contrôle du mouvement avec motion_bucket_id

Le paramètre motion_bucket_id contrôle l’intensité du mouvement généré. La cellule précédente a exécuté SVD trois fois sur la même image source texturée (un portrait réel riche en détail haute-fréquence) avec motion_bucket_id = 40, 127, 200, en ne variant QUE ce paramètre (même seed, même image). La différence inter-frames moyenne mesure la réponse réelle du modèle :

motion_bucket_id Diff. inter-frames moy. Temps VRAM pic
40 (subtil) 12.27 ~100 s 10.8 GB
127 (normal) 13.31 ~100 s 10.8 GB
200 (fort) 11.38 ~100 s 10.8 GB

Lecture honnête du résultat. Sur cette réalisation unique (seed 42), la diff inter-frames est non monotone : le bucket intermédiaire (127) produit le mouvement le plus marqué, et le bucket fort (200) le moins marqué. Ce n’est pas un artefact : c’est la nature stochastique de la génération par diffusion. motion_bucket_id biaise l’amplitude du mouvement, mais la diff inter-frames réalisée est dominée par le bruit d’échantillonnage sur une seule graine. Un test controlé hors-notebook sur la même image avec des graines différentes donne des classements contradictoires d’une exécution à l’autre (le bucket 127 tantôt le plus bas, tantôt le plus haut) — confirmation directe que caractériser l’effet d’un paramètre génératif exige de moyenner plusieurs graines, pas de lire une seule réalisation.

Pourquoi malgré tout une image texturée ? Sur une image synthétique lisse (gradient uniforme), la réponse est totalement plate — la diff inter-frames est identique à la décimale près quelle que soit la valeur de motion_bucket_id, car SVD n’a aucune texture haute-fréquence à déformer. L’image texturée donne au moins au modèle une matière à animer (la diff mesurable, ~12-13, vs ~0.3 sur le gradient). Le mouvement est réel et mesurable ; sa pilothabilité fine par motion_bucket_id sur une seule graine, elle, ne l’est pas — et c’est précisément ce qu’explore l’Exercice 2 (optimize_motion_bucket) : moyenné sur plusieurs graines, le biais du paramètre réapparait.

Pourquoi un portrait limite la discrimination. Un portrait offre une plage de mouvement restreinte (visage, cheveux, vêtements — peu d’éléments à déplacer). Sur un contenu plus dynamique (eau, feuillage, nuages), l’amplitude réalisée est plus large et le biais de motion_bucket_id plus visible. Le choix d’un portrait ici illustre un second enseignement : la sensibilité au contenu du paramètre, pas seulement sa stochasticité.

Code pour reproduire : la cellule précédente est le code canonique. Points clés : StableVideoDiffusionPipeline sans enable_vae_slicing (absente en diffusers 0.38+), decode_chunk_size=8 pour la VRAM, motion_bucket_id varie, seed et image fixes.

# Animation de differents types d'images
if run_generation and pipe is not None:
    print("\n--- ANIMATION MULTI-IMAGES ---")
    print("=" * 40)
    
    multi_results = []
    
    for img_info in test_images:
        img_name = img_info['name']
        img_desc = img_info['description']
        source = created_images[img_name]
        
        print(f"\nAnimation : {img_desc}")
        
        generator = torch.Generator(device=device).manual_seed(42)
        if device == "cuda":
            torch.cuda.reset_peak_memory_stats()
        
        start_time = time.time()
        
        try:
            output = pipe(
                image=source,
                num_frames=num_frames,
                fps=fps,
                motion_bucket_id=motion_bucket_id,
                noise_aug_strength=noise_aug_strength,
                num_inference_steps=num_inference_steps,
                decode_chunk_size=decode_chunk_size,
                generator=generator
            )
            
            gen_time = time.time() - start_time
            frames = output.frames[0]
            
            # Mesurer le mouvement
            diffs = []
            for i in range(len(frames) - 1):
                f1 = np.array(frames[i]).astype(float)
                f2 = np.array(frames[i + 1]).astype(float)
                diffs.append(np.mean(np.abs(f1 - f2)))
            
            multi_results.append({
                "name": img_name,
                "description": img_desc,
                "source": source,
                "frames": frames,
                "time": gen_time,
                "avg_diff": np.mean(diffs),
                "max_diff": np.max(diffs)
            })
            
            print(f"  Temps : {gen_time:.1f}s")
            print(f"  Mouvement moyen : {np.mean(diffs):.2f}")
            
            if save_as_mp4:
                mp4_path = OUTPUT_DIR / f"svd_{img_name}.mp4"
                export_to_video(frames, str(mp4_path), fps=fps_output)
                
        except Exception as e:
            print(f"  Erreur : {type(e).__name__}: {str(e)[:100]}")
    
    # Affichage comparatif : source + frames selectionnees
    if multi_results:
        n_images = len(multi_results)
        fig, axes = plt.subplots(n_images, 5, figsize=(18, 3.5 * n_images))
        if n_images == 1:
            axes = [axes]
        
        for v_idx, mr in enumerate(multi_results):
            # Source
            axes[v_idx][0].imshow(mr['source'])
            axes[v_idx][0].set_title("Source", fontsize=9, fontweight='bold')
            axes[v_idx][0].axis('off')
            if v_idx == 0:
                axes[v_idx][0].set_ylabel("Image", fontsize=10)
            
            # Frames animees
            frame_indices = np.linspace(0, len(mr['frames']) - 1, 4, dtype=int)
            for f_idx, fi in enumerate(frame_indices):
                axes[v_idx][f_idx + 1].imshow(mr['frames'][fi])
                axes[v_idx][f_idx + 1].set_title(f"Frame {fi+1}", fontsize=9)
                axes[v_idx][f_idx + 1].axis('off')
            
            axes[v_idx][0].set_ylabel(mr['description'], fontsize=10, fontweight='bold')
        
        plt.suptitle("Animation de differents types d'images - SVD", fontsize=13, fontweight='bold')
        plt.tight_layout()
        plt.show()
        
        # Tableau comparatif
        print(f"\n{'Image':<25} {'Temps (s)':<12} {'Mouvement moy':<16} {'Mouvement max':<15}")
        print("-" * 68)
        for mr in multi_results:
            print(f"  {mr['description']:<25} {mr['time']:<12.1f} {mr['avg_diff']:<16.2f} {mr['max_diff']:<15.2f}")
else:
    print("Animation multi-images : generation desactivee")
    print("\nSVD genere des mouvements differents selon le contenu :")
    print("  - Paysage : nuages en deplacement, herbe qui ondule")
    print("  - Portrait : micro-expressions, legere respiration")
    print("  - Eau/Nature : ondulations, reflets en mouvement")

--- ANIMATION MULTI-IMAGES ---
========================================

Animation : Paysage avec montagnes
  Temps : 102.3s
  Mouvement moyen : 0.32

Animation : Silhouette portrait
  Temps : 104.6s
  Mouvement moyen : 3.11

Animation : Coucher de soleil sur l'eau
  Temps : 107.6s
  Mouvement moyen : 0.32


Image                     Temps (s)    Mouvement moy    Mouvement max  
--------------------------------------------------------------------
  Paysage avec montagnes    102.3        0.32             1.88           
  Silhouette portrait       104.6        3.11             6.63           
  Coucher de soleil sur l'eau 107.6        0.32             1.77

L’animation de différents types d’images illustre comment le contenu source influence la dynamique generee. Le mode interactif suivant permet d’experimenter en temps reel avec vos propres images et paramètres.

# Mode interactif
if notebook_mode == "interactive" and not skip_widgets:
    print("\n--- MODE INTERACTIF ---")
    print("=" * 40)
    print("Entrez le chemin vers une image pour l'animer avec SVD.")
    print("(Laissez vide pour passer a la suite)")
    
    try:
        user_image_path = input("\nChemin image (ou vide) : ").strip()
        
        if user_image_path and Path(user_image_path).exists() and run_generation and pipe is not None:
            print(f"\nChargement de l'image : {user_image_path}")
            user_image = Image.open(user_image_path).convert('RGB')
            user_image = user_image.resize((svd_width, svd_height))
            
            print(f"Image redimensionnee a {svd_width}x{svd_height}")
            print(f"Generation en cours...")
            
            generator = torch.Generator(device=device).manual_seed(123)
            start_time = time.time()
            
            output = pipe(
                image=user_image,
                num_frames=num_frames,
                fps=fps,
                motion_bucket_id=motion_bucket_id,
                noise_aug_strength=noise_aug_strength,
                num_inference_steps=num_inference_steps,
                decode_chunk_size=decode_chunk_size,
                generator=generator
            )
            
            gen_time = time.time() - start_time
            user_frames = output.frames[0]
            
            print(f"Generation reussie en {gen_time:.1f}s")
            
            # Affichage
            n_display = min(6, len(user_frames))
            fig, axes = plt.subplots(1, n_display + 1, figsize=(2.5 * (n_display + 1), 3))
            axes[0].imshow(user_image)
            axes[0].set_title("Source", fontsize=9, fontweight='bold')
            axes[0].axis('off')
            
            indices = np.linspace(0, len(user_frames) - 1, n_display, dtype=int)
            for i, idx in enumerate(indices):
                axes[i + 1].imshow(user_frames[idx])
                axes[i + 1].set_title(f"Frame {idx+1}", fontsize=8)
                axes[i + 1].axis('off')
            plt.suptitle(f"Votre image animee", fontweight='bold')
            plt.tight_layout()
            plt.show()
            
            if save_as_mp4:
                user_mp4 = OUTPUT_DIR / "user_animation.mp4"
                export_to_video(user_frames, str(user_mp4), fps=fps_output)
                print(f"MP4 sauvegarde : {user_mp4.name}")
        elif user_image_path and not Path(user_image_path).exists():
            print(f"Fichier non trouve : {user_image_path}")
        elif user_image_path:
            print("Generation non disponible (pipeline non charge)")
        else:
            print("Mode interactif ignore")
    
    except (KeyboardInterrupt, EOFError) as e:
        print(f"\nMode interactif interrompu ({type(e).__name__})")
    except Exception as e:
        error_type = type(e).__name__
        if "StdinNotImplemented" in error_type or "input" in str(e).lower():
            print("\nMode interactif non disponible (execution automatisee)")
        else:
            print(f"\nErreur inattendue : {error_type} - {str(e)[:100]}")
            print("Passage a la suite du notebook")
else:
    print("\nMode batch - Interface interactive desactivee")

Mode batch - Interface interactive desactivee

Bonnes pratiques SVD et comparaison Module 02

Conseils pour de bonnes animations SVD

Bon input Mauvais input Raison
Photo nette, bien eclairee Image floue, sombre SVD preserve la qualite source
Scene avec éléments mobiles Image abstraite / texte SVD detecte les éléments a animer
Resolution 1024x576 Image très petite (<256px) Resolution optimale pour SVD
Éléments naturels (eau, ciel) Geometrie pure Mouvement plus naturel

Recapitulatif Module 02 - Modèles video generatifs

Modèle Type VRAM Vitesse Qualite Force
HunyuanVideo (02-1) Text-to-video ~18 GB Lente Haute Longues sequences
LTX-Video (02-2) Text/Img/Vid ~8 GB Rapide Bonne Polyvalence
Wan 2.1 (02-3) Text-to-video ~10 GB Moyenne Haute Multilingue
SVD (02-4) Image-to-video ~10 GB Moyenne Haute Animation precise

Pipeline recommande

1. Generer une image avec DALL-E / SDXL / Flux
2. Animer avec SVD (motion_bucket_id = 100-150)
3. Upscaler avec Real-ESRGAN (notebook 01-4)
4. Assembler en video finale avec moviepy (notebook 01-1)

Exercice : Animation d’Images Personnalisées avec SVD

Durée estimée : 25-30 minutes

Objectif

Apprendre à animer vos propres images avec SVD et à optimiser les paramètres selon le type d’image.

Instructions

  1. Chargez et préparez une image : Utilisez une image de votre choix (photo, illustration, rendu 3D) et préparez-la pour SVD (redimensionnement, format).

  2. Implémentez un optimiseur de motion_bucket_id : Créez une fonction qui teste automatiquement plusieurs valeurs de motion_bucket_id et sélectionne la meilleure en fonction de l’analyse des différences inter-frames.

  3. Comparez différents types d’images : Testez au moins 3 images de types différents (portrait, paysage, nature) et documentez les paramètres optimaux pour chaque catégorie.

Indices

  • SVD fonctionne mieux avec des images en 1024×576 (ratio 16:9)
  • Un motion_bucket_id bas (40-80) donne des mouvements subtils, idéal pour les portraits
  • Un motion_bucket_id moyen (100-150) convient aux paysages
  • Un motion_bucket_id élevé (180-220) crée des mouvements dynamiques pour les scènes d’action
  • Utilisez np.mean(np.abs(frame1 - frame2)) pour mesurer l’intensité du mouvement

Critères de succès

Exercice 1 : Comparaison multi-images

Implementez les fonctions ci-dessous pour explorer les capacites de SVD : comparaison multi-images, optimisation du mouvement, et preparation d’images.

# Test avec vos images
if run_generation and pipe is not None:
    # TODO: Remplacer par vos propres images
    test_images = {
        "portrait": "path/to/your/portrait.jpg",
        "landscape": "path/to/your/landscape.jpg",
        "nature": "path/to/your/nature.jpg"
    }
    
    # TODO: Exécuter la comparaison
    # df_results = compare_image_categories(test_images)
    # print(df_results)
    
    # TODO: Pour chaque image, générer la vidéo avec les paramètres optimaux
    # et sauvegarder en MP4
    
    # TODO: Documenter les recommandations
    # print("\nRecommandations par type d'image :")
    # for _, row in df_results.iterrows():
    #     print(f"  {row['category']}: motion_bucket_id = {row['best_motion_bucket']}")
else:
    print("Test désactivé (pipeline non disponible)")

Le test initial valide que le pipeline SVD repond correctement a vos images personnalisees. La cellule suivante implemente la comparaison systématique entre différentes catégories d’images pour quantifier l’impact du contenu source sur la qualite de l’animation.

# TODO: Fonction de comparaison multi-images
def compare_image_categories(images: Dict[str, str]) -> pd.DataFrame:
    """
    Compare l'animation de différents types d'images.
    
    Args:
        images: Dict {category: image_path}
            Ex: {"portrait": "path/to/portrait.jpg", 
                 "landscape": "path/to/landscape.jpg"}
    
    Returns:
        DataFrame avec les résultats pour chaque catégorie
    """
    results = []
    
    for category, img_path in images.items():
        # TODO: Préparer l'image
        # prepared_img = prepare_image_for_svd(img_path)
        pass
        
        # TODO: Optimiser motion_bucket_id pour cette image
        # best_motion = optimize_motion_bucket(pipe, prepared_img)
        pass
        
        results.append({
            "category": category,
            "best_motion_bucket": best_motion["bucket_id"],
            "avg_motion": best_motion["avg_motion"],
            "generation_time": best_motion["time"]
        })
    
    # TODO: Convertir en DataFrame pandas
    # return pd.DataFrame(results)
    pass

Exercice 2 : Optimisation du motion_bucket_id

La comparaison entre catégories d’images revele les types de contenus qui produisent les meilleures animations SVD. La cellule suivante implemente la recherche du motion_bucket_id optimal par itération sur une plage de valeurs.

# TODO: Fonction d'optimisation de motion_bucket_id
def optimize_motion_bucket(image: Image.Image, min_bucket: int = 40, 
                           max_bucket: int = 220, steps: int = 5) -> Dict[str, Any]:
    """
    Teste plusieurs valeurs de motion_bucket_id et recommande la meilleure.
    
    Args:
        image: Image source
        min_bucket: Valeur minimale à tester
        max_bucket: Valeur maximale à tester
        steps: Nombre de valeurs à tester
    
    Returns:
        Dict avec la meilleure valeur et les résultats détaillés
    """
    bucket_values = np.linspace(min_bucket, max_bucket, steps, dtype=int)
    results = []
    
    for bucket_id in bucket_values:
        # TODO: Générer avec ce motion_bucket_id
        # Utiliser un seed fixe pour la comparaison
        pass
        
        # TODO: Analyser le mouvement généré
        # Calculer la différence moyenne entre frames consécutives
        # Indice : diffs.append(np.mean(np.abs(np.array(frames[i]) - np.array(frames[i+1]))))
        pass
        
        results.append({
            "bucket_id": bucket_id,
            "avg_motion": avg_motion,
            "frames": frames
        })
    
    # TODO: Sélectionner la meilleure valeur
    # Indice : choisir un mouvement moyen (ni trop faible, ni trop fort)
    # best_config = ...
    
    return None  # TODO etudiant : retourner best_config (exercice a completer)

Exercice 3 : Preparation d’image pour SVD

L’optimisation du motion_bucket_id permet de trouver automatiquement la valeur qui maximise la fluidite perçue. La cellule suivante complete le pipeline avec la fonction de preparation d’images qui normalise les dimensions et le format pour SVD.

# TODO: Fonction de préparation d'image pour SVD
def prepare_image_for_svd(image_path: str, target_size: tuple = (1024, 576)) -> Image.Image:
    """
    Prépare une image pour l'animation avec SVD.
    
    Args:
        image_path: Chemin vers l'image source
        target_size: Taille cible (width, height)
    
    Returns:
        Image PIL redimensionnée et convertie en RGB
    """
    # TODO: Charger l'image avec PIL
    # Indice : Image.open(image_path)
    pass
    
    # TODO: Redimensionner en conservant le ratio d'aspect
    # Indice : si l'image n'est pas en 16:9, ajouter des bandes noires
    # Utiliser Image.new() pour créer un canvas et paste() pour centrer
    pass
    
    # TODO: Convertir en RGB si nécessaire
    # Indice : img.convert('RGB')
    pass
    
    return None  # TODO etudiant : retourner prepared_image (exercice a completer)

La fonction de preparation d’images convertit les formats varies en entrees compatibles avec SVD. La cellule suivante integre preparation et contrôle du motion_bucket_id dans un pipeline complet : elle appelle les fonctions des exercices 2 et 3 sans les redefinir.

# Point d'integration des exercices 2 et 3 : cette cellule ne redefinit ni
# optimize_motion_bucket (exercice 2) ni prepare_image_for_svd (exercice 3),
# elle assemble les deux en un pipeline complet.
def pipeline_animation_svd(image_path: str, target_size: tuple = (1024, 576)) -> Dict[str, Any]:
    """
    Assemble prepare_image_for_svd (exercice 3) puis optimize_motion_bucket
    (exercice 2) : preparation de l'image source, puis recherche du
    motion_bucket_id optimal sur l'image preparee.

    Args:
        image_path: Chemin vers l'image source
        target_size: Taille cible pour la preparation (largeur, hauteur)

    Returns:
        Dict {"image": image preparee, "best": meilleure configuration},
        ou None tant qu'un des deux exercices n'est pas complete.
    """
    prepared = prepare_image_for_svd(image_path, target_size)
    if prepared is None:
        print("Exercice a completer : prepare_image_for_svd (exercice 3) -- "
              "le pipeline attend l'image preparee.")
        return None

    best = optimize_motion_bucket(prepared)
    if best is None:
        print("Exercice a completer : optimize_motion_bucket (exercice 2) -- "
              "le pipeline attend la meilleure configuration.")
        return None

    return {"image": prepared, "best": best}

# Demonstration sur l'asset texture de la section 3 : tant que les exercices
# ne sont pas completes, le pipeline signale honnetement l'etape manquante.
source_texture = str(GENAI_ROOT / 'Video' / '02-Advanced' / 'assets' / 'svd_source_textured.png')
resultat_demo = pipeline_animation_svd(source_texture)
if resultat_demo is not None:
    print(f"Pipeline complet : motion_bucket_id optimal = {resultat_demo['best']['bucket_id']}")
Exercice a completer : prepare_image_for_svd (exercice 3) -- le pipeline attend l'image preparee.

Section 4 : Animation de différents types d’images

La cellule précédente a animé les trois images synthétiques de test avec SVD (même motion_bucket_id, même seed) et mesuré le mouvement réalisé. Résultat réel :

Image source Temps Mouvement moy. Mouvement max
Paysage (montagnes, soleil) ~100 s 0.32 1.88
Silhouette portrait (formes géométriques) ~100 s 3.11 6.63
Coucher de soleil sur l’eau ~100 s 0.32 1.77

Lecture : le contenu pilote le mouvement. Deux des trois images (paysage, coucher de soleil) produisent un mouvement quasi nul (0.32) — ce sont des dégradés lisses générés procéduralement, sans détail haute-fréquence : SVD n’a aucune texture à déformer, donc rien ne bouge. Seule la silhouette portrait (cercles, polygones, bords franchs) donne au modèle des contours à animer (3.11, ~10× plus).

C’est le même phénomène qu’à la Section 3 : un gradient lisse est un cas dégénéré pour SVD — c’est précisément pourquoi la Section 3 utilise une image texturée réelle (le portrait svd_source_textured.png) pour mesurer l’effet de motion_bucket_id. Les images synthétiques lisses de cette section illustrent l’envers du décor : sans structure visuelle fine, le modèle génératif n’a rien à mettre en mouvement, quel que soit le paramètre. La texture est la matière première du mouvement en image-to-video.

Comparaison des trois images (réelle, mesurée) : - Paysage : dégradé ciel→montagne→herbe + disque solaire — transitions lentes, aucune haute fréquence → mouvement plat (0.32). - Portrait : fond uni + cercle (tête) + polygone (corps) — des bords que SVD peut faire respirer/driver légèrement → mouvement mesurable (3.11). - Nature : dégradé ciel→eau + disque solaire — lisse comme le paysage → plat (0.32).

Leçon pratique : pour animer une photo réelle avec SVD, choisir une source riche en détail (feuillage, textures, mouvement naturel potentiel). Une image trop lisse ou trop simple reste statique. C’est ce que l’Exercice 1 (compare_image_categories) explore : comparer l’amplitude de mouvement générée sur des catégories d’images de textures croissantes.

Retour au sommet