> 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/comparaisons/video-gen-comparison.md).

# Comparaison des outils de génération vidéo

Comparez les principaux modèles open source de génération vidéo pour un déploiement sur les serveurs GPU de Clore.ai.

{% hint style="info" %}
**Génération vidéo par IA** a explosé en 2024-2025. Ce guide compare les meilleurs modèles open source — Hunyuan Video, Wan2.1, CogVideoX, Mochi 1 et LTX-Video — en couvrant la qualité, la vitesse, les besoins en VRAM et les cas d’usage.
{% endhint %}

***

## Matrice de décision rapide

|                    | Hunyuan Video | Wan2.1     | CogVideoX  | Mochi 1    | LTX-Video  |
| ------------------ | ------------- | ---------- | ---------- | ---------- | ---------- |
| **Développeur**    | Tencent       | Alibaba    | Zhipu AI   | Genmo      | LightRicks |
| **Qualité**        | ⭐⭐⭐⭐⭐         | ⭐⭐⭐⭐⭐      | ⭐⭐⭐⭐       | ⭐⭐⭐⭐       | ⭐⭐⭐        |
| **Vitesse**        | Lent          | Moyen      | Moyen      | Moyen      | **Rapide** |
| **VRAM minimale**  | 24GB          | 16 Go      | 16 Go      | 24GB       | **8 Go**   |
| **Résolution max** | 1280×720      | 1280×720   | 1440×960   | 848×480    | 1216×704   |
| **Durée max**      | 5 s           | 5 s        | 6 s        | 5,4 s      | 2 min      |
| **Licence**        | CLA           | Apache 2.0 | Apache 2.0 | Apache 2.0 | Apache 2.0 |
| **Étoiles GitHub** | 10K+          | 7K+        | 6K+        | 4K+        | 5K+        |

***

## Aperçu

### Hunyuan Video

Hunyuan Video de Tencent est largement considéré comme le meilleur modèle open source de génération vidéo au début de 2025. Il utilise une architecture basée sur les transformeurs avec une qualité de mouvement exceptionnelle.

**Spécifications clés**: 13 milliards de paramètres, 5 s en 720p, nécessite 24 Go+ de VRAM

### Wan2.1

Wan (Wenying) 2.1 d'Alibaba est un concurrent sérieux de Hunyuan, offrant une qualité similaire avec des besoins minimaux en VRAM plus faibles. Disponible en variantes de paramètres 1.3B et 14B.

**Spécifications clés**: 1.3B (lite) ou 14B, 5 s en 720p, 16 Go+ de VRAM pour le 1.3B

### CogVideoX

CogVideoX de Zhipu AI se concentre sur le respect précis du texte et sur la cohérence des vidéos longues. Il est particulièrement performant pour le contenu cinématographique et la génération axée sur l’histoire.

**Spécifications clés**: paramètres 5B/10B, 6 s en 1440×960, 16 Go+ de VRAM

### Mochi 1

Mochi 1 de Genmo est connu pour ses mouvements fluides et doux ainsi que pour sa physique réaliste. Il utilise une nouvelle architecture AsymmDiT. Disponible entièrement en open source (poids + code d’entraînement).

**Spécifications clés**: 10 milliards de paramètres, 5,4 s en 848×480, 24 Go de VRAM

### LTX-Video

LTX-Video de LightRicks privilégie avant tout la vitesse d’inférence. Il peut générer des vidéos en temps réel ou quasi temps réel sur des GPU modernes — idéal pour les applications interactives.

**Spécifications clés**: 2 milliards de paramètres, jusqu’à 2 minutes de vidéo, 8 Go de VRAM

***

## Comparaison de la qualité

### Benchmark EvalCrafter (2025)

{% hint style="info" %}
La qualité est subjective. Ces scores reflètent le consensus de la communauté issu des benchmarks VBench et EvalCrafter.
{% endhint %}

| Modèle        | Score VBench | Qualité du mouvement | Correspondance au texte | Esthétique |
| ------------- | ------------ | -------------------- | ----------------------- | ---------- |
| Hunyuan Video | **83.2**     | **Excellente**       | Excellente              | Excellente |
| Wan2.1 (14B)  | **82.8**     | Excellente           | Excellente              | Excellente |
| CogVideoX-5B  | 79.6         | Bon                  | **Très bonne**          | Bon        |
| Mochi 1       | 77.4         | Très bonne           | Bon                     | Bon        |
| LTX-Video     | 71.2         | Bon                  | Bon                     | Acceptable |

### Points forts qualitatifs

| Modèle        | Meilleur pour                        | Faiblesses                              |
| ------------- | ------------------------------------ | --------------------------------------- |
| Hunyuan Video | Qualité globale, cinématographie     | Très lent, gourmand en VRAM             |
| Wan2.1        | Équilibre qualité/efficacité, I2V    | Parfois trop saturé                     |
| CogVideoX     | Narration longue, précision du texte | Mouvement moins dynamique               |
| Mochi 1       | Mouvement fluide, physique           | Limite de résolution plus basse         |
| LTX-Video     | Vitesse, vidéos longues              | Écart de qualité par rapport aux autres |

***

## Benchmarks de vitesse

### Temps de génération (A100 80 Go, GPU unique)

| Modèle        | 480p 5 s | 720p 5 s       | 1080p 5 s      |
| ------------- | -------- | -------------- | -------------- |
| Hunyuan Video | 45 min   | \~3 heures     | ❌ Hors mémoire |
| Wan2.1 (14B)  | 15 min   | 45 min         | ❌ Hors mémoire |
| Wan2.1 (1.3B) | 3 min    | 8 min          | ❌ Hors mémoire |
| CogVideoX-5B  | 10 min   | 25 min         | ❌ Hors mémoire |
| Mochi 1       | 8 min    | ❌ Hors mémoire | ❌ Hors mémoire |
| LTX-Video     | **45 s** | **3 min**      | 8 min          |

{% hint style="warning" %}
**Les temps sont approximatifs** et varient selon les étapes de l’échantillonneur (20-50), l’échelle de guidage et le matériel. Utilisez moins d’étapes pour les aperçus.
{% endhint %}

### Avec optimisation (TeaCache / FORA / distillation d’étapes)

L’inférence optimisée peut réduire considérablement le temps de génération :

| Modèle        | Avec cache      | Accélération |
| ------------- | --------------- | ------------ |
| Hunyuan Video | \~15 min (720p) | 4×           |
| Wan2.1        | \~12 min (720p) | \~4×         |
| CogVideoX     | \~8 min (720p)  | \~3×         |
| LTX-Video     | \~45 s (720p)   | 4×           |

***

## Exigences en VRAM

### VRAM minimale selon le modèle et la résolution

| Modèle        | 480p     | 720p   | 1080p |
| ------------- | -------- | ------ | ----- |
| Hunyuan Video | 24GB     | 40 Go+ | ❌     |
| Wan2.1 (14B)  | 24GB     | 40 Go+ | ❌     |
| Wan2.1 (1.3B) | **8 Go** | 16 Go  | 24GB  |
| CogVideoX-5B  | 16 Go    | 24GB   | ❌     |
| CogVideoX-2B  | **8 Go** | 16 Go  | ❌     |
| Mochi 1       | 24GB     | ❌      | ❌     |
| LTX-Video     | **8 Go** | 12 Go  | 24GB  |

### Techniques d’optimisation de la mémoire

#### Quantification

```python
# CogVideoX avec quantification en 8 bits (divise la VRAM par deux)
from diffusers import CogVideoXPipeline
import torch

pipe = CogVideoXPipeline.from_pretrained(
    "THUDM/CogVideoX-5b",
    torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()  # Réduit encore la VRAM
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()
```

#### Déchargement sur CPU

```python
# Wan2.1 avec déchargement sur CPU pour réduire la VRAM
from diffusers import WanPipeline

pipe = WanPipeline.from_pretrained(
    "Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
```

***

## Hunyuan Video : plongée approfondie

### Architecture

* **DiT 13B** (transformeur de diffusion) paramètres
* Attention complète sur tous les jetons spatiaux et temporels
* Entraîné sur plus de 1 milliard de clips vidéo

### Déploiement sur Clore.ai

```bash
# Cloner et installer
git clone https://github.com/Tencent/HunyuanVideo
cd HunyuanVideo
pip install -r requirements.txt

# Télécharger les poids (~87 Go)
huggingface-cli download tencent/HunyuanVideo --local-dir ./weights

# Générer
python sample_video.py \\
  --video-size 720 1280 \\
  --video-length 129 \\
  --infer-steps 50 \\
  --prompt "Un majestueux aigle planant au-dessus de montagnes enneigées" \\
  --flow-shift 7.0 \\
  --embedded-cfg-scale 6.0 \\
  --save-path ./outputs
```

### Via ComfyUI

```bash
# Installer les nœuds HunyuanVideo pour ComfyUI
cd ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-HunyuanVideoWrapper
pip install -r ComfyUI-HunyuanVideoWrapper/requirements.txt
```

**Idéal pour**: génération vidéo cinématographique de la plus haute qualité, sans contraintes de VRAM

***

## Wan2.1 : plongée approfondie

### Architecture

* **Deux variantes**: Wan2.1-T2V-1.3B et Wan2.1-T2V-14B
* **Image vers vidéo** modèle (I2V) également disponible
* Prompts multilingues puissants (chinois + anglais)

### Déploiement sur Clore.ai

```python
from diffusers import WanPipeline
from diffusers.utils import export_to_video
import torch

# Modèle 1.3B — tient dans 8-16 Go de VRAM
pipe = WanPipeline.from_pretrained(
    "Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")

output = pipe(
    prompt="Un jardin japonais serein avec des fleurs de cerisier qui tombent",
    negative_prompt="faible qualité, flou",
    height=480,
    width=832,
    num_frames=81,
    num_inference_steps=50,
    guidance_scale=5.0,
).frames[0]

export_to_video(output, "wan_video.mp4", fps=16)
```

### Image vers vidéo avec Wan2.1

```python
from diffusers import WanImageToVideoPipeline
from PIL import Image

pipe = WanImageToVideoPipeline.from_pretrained(
    "Wan-AI/Wan2.1-I2V-14B-480P-Diffusers",
    torch_dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()

image = Image.open("input.jpg")
output = pipe(
    image=image,
    prompt="La personne avance avec assurance",
    num_frames=81,
).frames[0]
```

**Idéal pour**: équilibre entre qualité et efficacité, I2V, multilingue

***

## CogVideoX : plongée approfondie

### Architecture

* **Transformeur expert** avec attention complète 3D
* **5B et 10B** variantes de paramètres
* Encodeur d’images CogView3 pour la qualité visuelle

### Déploiement sur Clore.ai

```python
from diffusers import CogVideoXPipeline
from diffusers.utils import export_to_video
import torch

pipe = CogVideoXPipeline.from_pretrained(
    "THUDM/CogVideoX-5b",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()

video = pipe(
    prompt="Un time-lapse d’une ville la nuit avec des traînées lumineuses de voitures",
    num_videos_per_prompt=1,
    num_inference_steps=50,
    num_frames=49,
    guidance_scale=6,
    generator=torch.Generator(device="cuda").manual_seed(42),
).frames[0]

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

**Idéal pour**: texte vers vidéo précis, contenu narratif, génération longue

***

## Mochi 1 : plongée approfondie

### Architecture

* **AsymmDiT** — transformeur de diffusion asymétrique
* Accent sur la cohérence temporelle et le mouvement fluide
* Entièrement open source, y compris le code d’entraînement

### Déploiement sur Clore.ai

```bash
pip install mochi-preview

python -c "
from mochi_preview.pipelines import DecoderModelFactory, DitModelFactory, MochiSingleGPUPipeline, T5ModelFactory
import tempfile
from pathlib import Path

pipeline = MochiSingleGPUPipeline(
    text_encoder_factory=T5ModelFactory(),
    dit_factory=DitModelFactory(model_path='./weights/mochi-dit.safetensors'),
    decoder_factory=DecoderModelFactory(model_path='./weights/mochi-vae.safetensors'),
    cpu_offload=True,
    decode_type='tiled_full',
)

video = pipeline(
    height=480, width=848,
    num_frames=163,
    num_inference_steps=64,
    sigma_schedule_type='linear_quadratic',
    cfg_schedule_type='linear',
    conditioning_args={'prompt': 'Un dauphin bondissant à travers les vagues de l’océan au coucher du soleil'},
)
"
```

**Idéal pour**: mouvement fluide, physique réaliste, cas d’usage pour la recherche

***

## LTX-Video : plongée approfondie

### Architecture

* **2B de paramètres** DiT — plus petit, plus rapide
* Natif **vidéo longue** prise en charge (jusqu’à 2 minutes)
* Conçu pour une génération en temps réel ou quasi temps réel

### Déploiement sur Clore.ai

```python
from diffusers import LTXPipeline
from diffusers.utils import export_to_video
import torch

pipe = LTXPipeline.from_pretrained(
    "Lightricks/LTX-Video",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

video = pipe(
    prompt="Un papillon se posant sur une fleur dans un jardin d’été",
    negative_prompt="pire qualité, mouvement incohérent, flou",
    width=704,
    height=480,
    num_frames=161,
    decode_timestep=0.03,
    decode_noise_scale=0.025,
    num_inference_steps=50,
).frames[0]

export_to_video(video, "ltx_video.mp4", fps=24)
```

**Idéal pour**: génération rapide, applications interactives, vidéos longues, VRAM limitée (8 Go)

***

## Comparaison des fonctionnalités

### Aperçu des capacités

| Fonctionnalité       | Hunyuan | Wan2.1 | CogVideoX | Mochi | LTX |
| -------------------- | ------- | ------ | --------- | ----- | --- |
| Texte vers vidéo     | ✅       | ✅      | ✅         | ✅     | ✅   |
| Image vers vidéo     | ✅       | ✅      | ✅         | ❌     | ✅   |
| Vidéo vers vidéo     | ❌       | ❌      | ✅         | ❌     | ✅   |
| ControlNet           | Partiel | ❌      | ✅         | ❌     | ❌   |
| Prise en charge LoRA | ✅       | ✅      | ✅         | ❌     | ✅   |
| Nœuds ComfyUI        | ✅       | ✅      | ✅         | ✅     | ✅   |
| Vidéo longue (>10 s) | ❌       | ❌      | Partiel   | ❌     | ✅   |
| Prompts chinois      | ✅       | ✅      | ✅         | ❌     | ❌   |

***

## Recommandations GPU Clore.ai

### Pour chaque modèle

| Modèle        | GPU minimum      | Recommandé    | Idéal        |
| ------------- | ---------------- | ------------- | ------------ |
| Hunyuan Video | RTX 3090 (24 Go) | A6000 (48 Go) | A100 (80 Go) |
| Wan2.1 14B    | RTX 3090 (24 Go) | A6000 (48 Go) | A100 (80 Go) |
| Wan2.1 1.3B   | RTX 3080 (10 Go) | RTX 3090      | RTX 4090     |
| CogVideoX-5B  | RTX 3090 (24 Go) | A6000 (48 Go) | A100         |
| CogVideoX-2B  | RTX 3080 (10 Go) | RTX 3090      | RTX 4090     |
| Mochi 1       | RTX 3090 (24 Go) | A6000 (48 Go) | A100         |
| LTX-Video     | RTX 3080 (10 Go) | RTX 4080      | RTX 4090     |

### Estimation du coût par vidéo

```
Hunyuan Video (720p, 5 s) sur A100 80 Go ([bare metal](https://clore.ai/bare-metal)) :
  Temps : ~45 min → Coût : ~1,12 $ par vidéo

Wan2.1-1.3B (480p, 5 s) sur RTX 3090 (0,07–0,21 $/h) :
  Temps : ~3 min → Coût : ~0,025 $ par vidéo

LTX-Video (720p, 5 s) sur RTX 4090 (0,14–0,42 $/h) :
  Temps : ~3 min → Coût : ~0,030 $ par vidéo
```

***

## Quand utiliser quoi

### Guide de décision

```
Qualité maximale (sans contrainte de coût) ?
  → Hunyuan Video sur A100

Meilleur équilibre qualité/coût ?
  → Wan2.1 14B sur A6000

VRAM limitée (8-12 Go) ?
  → LTX-Video ou Wan2.1 1.3B

Besoin d’une génération rapide ?
  → LTX-Video

Besoin d’image vers vidéo ?
  → Wan2.1 I2V ou CogVideoX

Besoin de vidéos longues (>10 s) ?
  → LTX-Video

Recherche / fine-tuning ?
  → Mochi 1 (code d’entraînement ouvert) ou CogVideoX

Workflow ComfyUI ?
  → Tous pris en charge, meilleurs nœuds pour Hunyuan/Wan
```

***

## Liens utiles

* [GitHub de Hunyuan Video](https://github.com/Tencent/HunyuanVideo)
* [Wan2.1 sur Hugging Face](https://huggingface.co/Wan-AI)
* [GitHub de CogVideoX](https://github.com/THUDM/CogVideo)
* [GitHub de Mochi 1](https://github.com/genmoai/mochi)
* [GitHub de LTX-Video](https://github.com/Lightricks/LTX-Video)
* [Classement de génération vidéo](https://huggingface.co/spaces/ArtificialAnalysis/video-generation-arena-leaderboard)

***

## Résumé

| Modèle            | À utiliser quand                               |
| ----------------- | ---------------------------------------------- |
| **Hunyuan Video** | La qualité prime et un A100+ est disponible    |
| **Wan2.1**        | Meilleur équilibre entre qualité et efficacité |
| **CogVideoX**     | Texte vers vidéo précis, narration longue      |
| **Mochi 1**       | Mouvement fluide, physique, recherche ouverte  |
| **LTX-Video**     | Vitesse, faible VRAM, vidéos longues           |

L’écosystème open source de génération vidéo évolue rapidement. Pour la plupart des déploiements sur Clore.ai, **Wan2.1** (1.3B pour le budget, 14B pour la qualité) offre la meilleure combinaison de qualité, de vitesse et d’efficacité en ressources.


---

# 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/comparaisons/video-gen-comparison.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.