> 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 de la génération vidéo

Comparez les principaux modèles open-source de génération vidéo pour le 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'utilisation.
{% 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 min.**           | 24GB          | 16GB       | 16GB       | 24GB       | **8 Go**   |
| **Résolution maximale** | 1280×720      | 1280×720   | 1440×960   | 848×480    | 1216×704   |
| **Durée maximale**      | 5s            | 5s         | 6s         | 5,4s       | 2min       |
| **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

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

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

### Wan2.1

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

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

### CogVideoX

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

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

### Mochi 1

Mochi 1 de Genmo est connu pour son mouvement fluide et sa physique réaliste. Il utilise une architecture AsymmDiT novatrice. Disponible entièrement open-source (poids + code d'entraînement).

**Spécifications clés**: 10B paramètres, 5,4s à 848×480, 24GB VRAM

### LTX-Video

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

**Spécifications clés**: 2B paramètres, jusqu'à 2 minutes de vidéo, 8GB 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 | Alignement texte | Esthétique |
| ------------- | ------------ | -------------------- | ---------------- | ---------- |
| Hunyuan Video | **83.2**     | **Excellente**       | Excellente       | Excellente |
| Wan2.1 (14B)  | **82.8**     | Excellente           | Excellente       | Excellente |
| CogVideoX-5B  | 79.6         | Bonne                | **Très bonne**   | Bonne      |
| Mochi 1       | 77.4         | Très bonne           | Bonne            | Bonne      |
| LTX-Video     | 71.2         | Bonne                | Bonne            | Acceptable |

### Forces qualitatives

| 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 inférieure         |
| LTX-Video     | Vitesse, longues vidéos              | Écart de qualité par rapport aux autres |

***

## Benchmarks de vitesse

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

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

{% hint style="warning" %}
**Les temps sont approximatifs** et varient selon les étapes du sampler (20-50), le guidance scale et le matériel. Utilisez moins d'étapes pour les aperçus.
{% endhint %}

### Avec optimisation (TeaCache / FORA / Step Distillation)

L'inférence optimisée peut réduire significativement 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     | \~45s (720p)    | 4×           |

***

## Exigences en VRAM

### VRAM minimale par modèle et résolution

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

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

#### Quantification

```python
# CogVideoX avec quantification 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éportation CPU

```python
# Wan2.1 avec déportation 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 : Analyse approfondie

### Architecture

* **DiT 13B** (Diffusion Transformer) paramètres
* Attention complète sur tous les tokens 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 (~87GB)
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 aigle majestueux 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
```

**Meilleur pour**: Génération vidéo cinématographique de la plus haute qualité, sans contraintes de VRAM

***

## Wan2.1 : Analyse approfondie

### Architecture

* **Deux variantes**: Wan2.1-T2V-1.3B et Wan2.1-T2V-14B
* **Image-to-Video** (I2V) modèle également disponible
* Entrées multilingues solides (chinois + anglais) pour les prompts

### 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-16GB 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="basse 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-to-Video 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 marche en avant avec confiance",
    num_frames=81,
).frames[0]
```

**Meilleur pour**: Équilibre qualité et efficacité, I2V, multilingue

***

## CogVideoX : Analyse approfondie

### Architecture

* **Transformer expert** avec attention 3D complète
* **Variantes de 5B et 10B** 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)
```

**Meilleur pour**: Texte-vers-vidéo précis, contenu narratif, génération longue

***

## Mochi 1 : Analyse approfondie

### Architecture

* **AsymmDiT** — diffusion transformer asymétrique
* Accent sur la cohérence temporelle et le mouvement fluide
* Entièrement open-source incluant 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 sautant à travers les vagues de l'océan au coucher du soleil'},
)
"
```

**Meilleur pour**: Mouvement fluide, physique réaliste, cas d'utilisation recherche

***

## LTX-Video : Analyse approfondie

### Architecture

* **2B de paramètres** DiT — plus petit, plus rapide
* Support natif **de vidéos longues** (jusqu'à 2 minutes)
* Conçu pour la 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)
```

**Meilleur pour**: Génération rapide, applications interactives, vidéos longues, VRAM limitée (8GB)

***

## Comparaison des fonctionnalités

### Aperçu des capacités

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

***

## Recommandations GPU Clore.ai

### Pour chaque modèle

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

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

```
Hunyuan Video (720p, 5s) sur A100 80GB (~1,50 $/h) :
  Temps : ~45 min → Coût : ~1,12 $ par vidéo

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

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

***

## Quand utiliser lequel

### Guide de décision

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

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

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

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

Besoin d'Image‑to‑Video ?
  → Wan2.1 I2V ou CogVideoX

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

Recherche / fine‑tuning ?
  → Mochi 1 (code d'entraînement open) ou CogVideoX

Flux de travail ComfyUI ?
  → Tous pris en charge, Hunyuan/Wan meilleurs nœuds
```

***

## Liens utiles

* [Hunyuan Video GitHub](https://github.com/Tencent/HunyuanVideo)
* [Wan2.1 sur HuggingFace](https://huggingface.co/Wan-AI)
* [CogVideoX GitHub](https://github.com/THUDM/CogVideo)
* [Mochi 1 GitHub](https://github.com/genmoai/mochi)
* [LTX-Video GitHub](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 meilleure qualité est primordiale, A100+ disponible |
| **Wan2.1**        | Meilleur équilibre qualité et efficacité               |
| **CogVideoX**     | Texte‑vers‑vidéo précis, longue narration              |
| **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 Clore.ai, **Wan2.1** (1,3B pour le budget, 14B pour la qualité) offre la meilleure combinaison de qualité, vitesse et efficacité des 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/comparaisons/video-gen-comparison.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.