# Stable Video Diffusion

{% hint style="info" %}
**Des alternatives plus récentes disponibles !** Considérez [**FramePack**](https://docs.clore.ai/guides/guides_v2-fr/generation-video/framepack) (seulement 6 Go de VRAM !), [**Wan2.1**](https://docs.clore.ai/guides/guides_v2-fr/generation-video/wan-video) (qualité supérieure), ou [**LTX-2**](https://docs.clore.ai/guides/guides_v2-fr/generation-video/ltx-video-2) (vidéo avec audio natif).
{% endhint %}

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

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## 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](https://huggingface.co/stabilityai/stable-video-diffusion-img2vid-xt)
* **GitHub :** [Stability-AI/generative-models](https://github.com/Stability-AI/generative-models)
* **Article :** [Article SVD](https://arxiv.org/abs/2311.15127)

## 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 :**

```bash
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

```bash
pip install diffusers transformers accelerate torch

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

## Utilisation de base

```python
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

```python

# 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

```python
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

{% hint style="danger" %}
**Mémoire insuffisante**
{% endhint %}

* 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*](https://clore.ai/marketplace) *pour les tarifs actuels.*

## Prochaines étapes

* AnimateDiff - Animer des images SD
* [Interpolation RIFE](https://docs.clore.ai/guides/guides_v2-fr/traitement-video/rife-interpolation) - Augmenter les FPS
* [Hunyuan Video](https://docs.clore.ai/guides/guides_v2-fr/generation-video/hunyuan-video) - Texte en vidéo