Stable Video Diffusion

Générez des vidéos à partir d'images avec Stable Video Diffusion sur Clore.ai

Des alternatives plus récentes disponibles ! Considérez FramePack (seulement 6 Go de VRAM !), Wan2.1 (qualité supérieure), ou LTX-2 (vidéo avec audio natif).

Générez des vidéos à partir d'images en utilisant le modèle SVD de Stability AI.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Qu'est-ce que Stable Video Diffusion ?

SVD (Stable Video Diffusion) génère de courts clips vidéo à partir d'une seule image :

• Sorties de 14 ou 25 images

• Résolution 576x1024

• Génération de mouvements fluides

• Poids open source

Ressources

• HuggingFace : stabilityai/stable-video-diffusion-img2vid-xt

• GitHub : Stability-AI/generative-models

• Article : Article SVD

Exigences matérielles

Modèle	VRAM	GPU recommandé
SVD (14 images)	16Go	RTX 4090
SVD-XT (25 images)	24 Go	RTX 4090 / A100

Déploiement rapide

Image Docker :

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Ports :

22/tcp
7860/http

Commande :

pip install diffusers transformers accelerate && \
pip install gradio && \
python -c "
import gradio as gr
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import export_to_video
import torch

pipe = StableVideoDiffusionPipeline.from_pretrained(
    'stabilityai/stable-video-diffusion-img2vid-xt',
    torch_dtype=torch.float16,
    variant='fp16'
).to('cuda')

def generate(image, seed, fps):
    generator = torch.manual_seed(seed)
    frames = pipe(image, num_frames=25, generator=generator).frames[0]
    export_to_video(frames, 'output.mp4', fps=fps)
    return 'output.mp4'

gr.Interface(
    fn=generate,
    inputs=[gr.Image(type='pil'), gr.Number(value=42, label='Seed'), gr.Slider(6, 30, value=7, label='FPS')],
    outputs=gr.Video(),
    title='Stable Video Diffusion'
).launch(server_name='0.0.0.0', server_port=7860)
"

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Aller à la Mes commandes page

2. Cliquez sur votre commande

3. Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Installation

pip install diffusers transformers accelerate torch

# Pour l'export vidéo
pip install imageio[ffmpeg]

Utilisation de base

import torch
from diffusers import StableVideoDiffusionPipeline
from diffusers.utils import load_image, export_to_video

# Charger le pipeline
pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16,
    variant="fp16"
)
pipe.to("cuda")

# Charger et redimensionner l'image
image = load_image("input.jpg")
image = image.resize((1024, 576))

# Générer la vidéo
generator = torch.manual_seed(42)
frames = pipe(image, num_frames=25, generator=generator).frames[0]

# Enregistrer la vidéo
export_to_video(frames, "output.mp4", fps=7)

SVD vs SVD-XT

Fonction	SVD	SVD-XT
Images	14	25
Durée	~2 sec	~3.5 sec
VRAM	16Go	24 Go
Qualité	Bon	Meilleur

Optimisation de la mémoire

# Activer l'attention économe en mémoire
pipe.enable_model_cpu_offload()

# Ou utilisez le découpage de l'attention
pipe.enable_attention_slicing()

# Pour une VRAM très faible
pipe.enable_sequential_cpu_offload()

Traitement par lots

import os
from pathlib import Path

input_dir = Path("./images")
output_dir = Path("./videos")
output_dir.mkdir(exist_ok=True)

for img_path in input_dir.glob("*.jpg"):
    image = load_image(str(img_path)).resize((1024, 576))
    frames = pipe(image, num_frames=25).frames[0]
    export_to_video(frames, str(output_dir / f"{img_path.stem}.mp4"), fps=7)
    print(f"Generated: {img_path.stem}.mp4")

Intégration ComfyUI

SVD fonctionne très bien dans ComfyUI :

1. Installer ComfyUI

2. Télécharger le modèle SVD dans models/checkpoints/

3. Utiliser les nœuds SVD pour le flux de travail img2vid

Dépannage

Mémoire insuffisante

• Utilisez enable_model_cpu_offload()

• Réduire num_frames à 14

• Utiliser la variante fp16

Vidéo trop courte

• Utilisez SVD-XT (25 images) au lieu de SVD (14 images)

• Interpoler avec RIFE pour un résultat plus fluide

Mauvaise qualité de mouvement

• Utiliser des images d'entrée de haute qualité

• Assurez-vous que l'image est en 1024x576 (ou 576x1024)

• Essayez différentes graines

Erreurs CUDA

• Mettre à jour PyTorch et diffusers

• Vérifier la compatibilité de la version CUDA

Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Prochaines étapes

• AnimateDiff - Animer des images SD

• Interpolation RIFE - Augmenter les FPS

• Hunyuan Video - Texte en vidéo