> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/generation-video/ai-video-generation.md).

# Génération vidéo IA

Générez des vidéos en utilisant Stable Video Diffusion, AnimateDiff et d'autres modèles.

{% 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 %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Modèles disponibles

| Modèle      | Type             | VRAM  | Durée        |
| ----------- | ---------------- | ----- | ------------ |
| SVD         | Image vers Vidéo | 16Go  | 4 secondes   |
| SVD-XT      | Image vers Vidéo | 20 Go | 4 secondes   |
| AnimateDiff | Texte vers Vidéo | 12Go  | 2-4 secondes |
| CogVideoX   | Texte vers Vidéo | 24 Go | 6 secondes   |

## Stable Video Diffusion (SVD)

### 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 gradio imageio && \
python svd_server.py
```

## 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.

### Script SVD

```python
import torch
from diffusers import StableVideoDiffusionPipeline
from PIL import Image
import imageio

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

# Charger et redimensionner l'image
image = Image.open("input.png").resize((1024, 576))

# Générer la vidéo
frames = pipe(
    image,
    decode_chunk_size=8,
    num_frames=25,
    motion_bucket_id=127,
    noise_aug_strength=0.02
).frames[0]

# Enregistrer en GIF
imageio.mimsave("output.gif", frames, fps=6)

# Enregistrer en MP4
imageio.mimsave("output.mp4", frames, fps=6)
```

### SVD avec interface Gradio

```python
import gradio as gr
import torch
from diffusers import StableVideoDiffusionPipeline
from PIL import Image
import imageio
import tempfile

pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16,
)
pipe.enable_model_cpu_offload()

def generate_video(image, motion_bucket, fps, num_frames):
    image = image.resize((1024, 576))

    frames = pipe(
        image,
        decode_chunk_size=4,
        num_frames=num_frames,
        motion_bucket_id=motion_bucket,
    ).frames[0]

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        imageio.mimsave(f.name, frames, fps=fps)
        return f.name

demo = gr.Interface(
    fn=generate_video,
    inputs=[
        gr.Image(type="pil", label="Image d'entrée"),
        gr.Slider(1, 255, value=127, label="Quantité de mouvement"),
        gr.Slider(1, 30, value=6, label="FPS"),
        gr.Slider(14, 25, value=25, label="Images")
    ],
    outputs=gr.Video(label="Generated Video"),
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## AnimateDiff

### Installation

```bash
pip install diffusers transformers accelerate
```

### Générer une vidéo à partir de texte

```python
import torch
from diffusers import AnimateDiffPipeline, MotionAdapter, DDIMScheduler
import imageio

# Charger l'adaptateur de mouvement
adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")

# Charger le pipeline
pipe = AnimateDiffPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    motion_adapter=adapter,
    torch_dtype=torch.float16,
)
pipe.scheduler = DDIMScheduler.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    subfolder="scheduler",
    clip_sample=False,
    timestep_spacing="linspace",
    beta_schedule="linear",
    steps_offset=1,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Générer
output = pipe(
    prompt="Un chat marchant dans un jardin, belles fleurs, journée ensoleillée",
    negative_prompt="mauvaise qualité, flou",
    num_frames=16,
    guidance_scale=7.5,
    num_inference_steps=25,
)

# Enregistrer
frames = output.frames[0]
imageio.mimsave("animatediff.gif", frames, fps=8)
```

### AnimateDiff avec modèle personnalisé

```python
from diffusers import AnimateDiffPipeline, MotionAdapter, EulerDiscreteScheduler

adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")

# Utiliser un checkpoint personnalisé (par ex., RealisticVision)
pipe = AnimateDiffPipeline.from_pretrained(
    "SG161222/Realistic_Vision_V5.1_noVAE",
    motion_adapter=adapter,
    torch_dtype=torch.float16,
)
```

## AnimateDiff dans ComfyUI

### Installer les nœuds

```bash
cd /workspace/ComfyUI/custom_nodes
git clone https://github.com/Kosinkadink/ComfyUI-AnimateDiff-Evolved.git
git clone https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite.git
```

### Télécharger les modèles de mouvement

```bash
cd /workspace/ComfyUI/custom_nodes/ComfyUI-AnimateDiff-Evolved/models
wget https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15_v2.ckpt
```

## CogVideoX

### Texte vers Vidéo

```python
import torch
from diffusers import CogVideoXPipeline
import imageio

pipe = CogVideoXPipeline.from_pretrained(
    "THUDM/CogVideoX-2b",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = "Un drone survolant un magnifique paysage montagneux au coucher du soleil"

video = pipe(
    prompt=prompt,
    num_videos_per_prompt=1,
    num_inference_steps=50,
    num_frames=49,
    guidance_scale=6,
).frames[0]

imageio.mimsave("cogvideo.mp4", video, fps=8)
```

## Amélioration vidéo (upscaling)

### Real-ESRGAN pour vidéo

```python
import cv2
import torch
from basicsr.archs.rrdbnet_arch import RRDBNet
from realesrgan import RealESRGANer

model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
upsampler = RealESRGANer(
    scale=4,
    model_path='RealESRGAN_x4plus.pth',
    model=model,
    tile=400,
    tile_pad=10,
    pre_pad=0,
    half=True
)

# Traiter la vidéo image par image
cap = cv2.VideoCapture("input.mp4")

# ... améliorer chaque image
```

## Interpolation (Vidéos fluides)

### FILM Frame Interpolation

```python

# Installer
pip install tensorflow tensorflow_hub

import tensorflow as tf
import tensorflow_hub as hub

model = hub.load("https://tfhub.dev/google/film/1")

def interpolate(frame1, frame2, num_interpolations=3):
    # Retourne les images interpolées entre frame1 et frame2
    ...
```

### RIFE (Temps réel)

```bash
pip install rife-ncnn-vulkan-python

from rife_ncnn_vulkan import Rife
rife = Rife(gpu_id=0)

# Interpoler les images
```

## Génération par lot de vidéos

```python
prompts = [
    "Un lanceur de fusée s'envolant dans l'espace",
    "Les vagues de l'océan s'écrasant sur les rochers",
    "Un papillon volant parmi les fleurs",
]

for i, prompt in enumerate(prompts):
    print(f"Génération {i+1}/{len(prompts)}")
    output = pipe(prompt, num_frames=16)
    imageio.mimsave(f"video_{i:03d}.mp4", output.frames[0], fps=8)
```

## Astuces mémoire

### Pour VRAM limitée

```python

# Activer le déchargement vers le CPU
pipe.enable_model_cpu_offload()

# Activer le découpage du VAE
pipe.enable_vae_slicing()

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

# Réduire le nombre d'images
num_frames = 14  # Au lieu de 25
```

### Décodage par blocs

```python
frames = pipe(
    image,
    decode_chunk_size=2,  # Décoder 2 images à la fois
    num_frames=25,
).frames[0]
```

## Conversion de sortie

### GIF vers MP4

```bash
ffmpeg -i input.gif -movflags faststart -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" output.mp4
```

### Séquence d'images vers vidéo

```bash
ffmpeg -framerate 8 -i frame_%04d.png -c:v libx264 -pix_fmt yuv420p output.mp4
```

### Ajouter de l'audio

```bash
ffmpeg -i video.mp4 -i audio.mp3 -c:v copy -c:a aac -shortest output_with_audio.mp4
```

## Performances

| Modèle      | GPU      | Images | Temps  |
| ----------- | -------- | ------ | ------ |
| SVD-XT      | RTX 3090 | 25     | \~120s |
| SVD-XT      | RTX 4090 | 25     | \~80s  |
| SVD-XT      | A100     | 25     | \~50s  |
| AnimateDiff | RTX 3090 | 16     | \~30s  |
| CogVideoX   | A100     | 49     | \~180s |

## 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 et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Dépannage

### Erreur OOM

* Réduire num\_frames
* Activer le déchargement vers le CPU
* Utiliser un decode\_chunk\_size plus petit

### Vidéo scintillante

* Augmenter num\_inference\_steps
* Essayer un motion\_bucket\_id différent
* Utiliser l'interpolation d'images

### Mauvaise qualité

* Utiliser une entrée à plus haute résolution (SVD)
* Meilleurs prompts (AnimateDiff)
* Augmenter guidance\_scale


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-video/ai-video-generation.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.