# Comparación de generación de video

Compare los principales modelos de generación de video de código abierto para su implementación en servidores GPU de Clore.ai.

{% hint style="info" %}
**Generación de video por IA** ha explotado en 2024-2025. Esta guía compara los mejores modelos de código abierto: Hunyuan Video, Wan2.1, CogVideoX, Mochi 1 y LTX-Video, cubriendo calidad, velocidad, requisitos de VRAM y casos de uso.
{% endhint %}

***

## Matriz de decisión rápida

|                         | Hunyuan Video | Wan2.1     | CogVideoX  | Mochi 1    | LTX-Video  |
| ----------------------- | ------------- | ---------- | ---------- | ---------- | ---------- |
| **Desarrollador**       | Tencent       | Alibaba    | Zhipu AI   | Genmo      | LightRicks |
| **Calidad**             | ⭐⭐⭐⭐⭐         | ⭐⭐⭐⭐⭐      | ⭐⭐⭐⭐       | ⭐⭐⭐⭐       | ⭐⭐⭐        |
| **Velocidad**           | Lento         | Medio      | Medio      | Medio      | **Rápido** |
| **VRAM mínima**         | 24GB          | 16GB       | 16GB       | 24GB       | **8GB**    |
| **Resolución máxima**   | 1280×720      | 1280×720   | 1440×960   | 848×480    | 1216×704   |
| **Duración máxima**     | 5s            | 5s         | 6s         | 5.4s       | 2min       |
| **Licencia**            | CLA           | Apache 2.0 | Apache 2.0 | Apache 2.0 | Apache 2.0 |
| **Estrellas en GitHub** | 10K+          | 7K+        | 6K+        | 4K+        | 5K+        |

***

## Resumen

### Hunyuan Video

Hunyuan Video de Tencent es ampliamente considerado el mejor modelo de generación de video de código abierto a principios de 2025. Usa una arquitectura basada en transformadores con calidad de movimiento excepcional.

**Especificaciones clave**: 13B de parámetros, 5s a 720p, requiere 24GB+ de VRAM

### Wan2.1

Wan (Wenying) 2.1 de Alibaba es un fuerte competidor de Hunyuan, ofreciendo calidad similar con requisitos mínimos de VRAM más bajos. Disponible en variantes de 1.3B y 14B de parámetros.

**Especificaciones clave**: 1.3B (lite) o 14B, 5s a 720p, 16GB+ de VRAM para 1.3B

### CogVideoX

CogVideoX de Zhipu AI se centra en seguir el texto con precisión y en video coherente de larga duración. Es particularmente fuerte para contenido cinematográfico y generación orientada a historias.

**Especificaciones clave**: 5B/10B de parámetros, 6s a 1440×960, 16GB+ de VRAM

### Mochi 1

Mochi 1 de Genmo es conocido por su movimiento suave y fluido y física realista. Utiliza una novedosa arquitectura AsymmDiT. Disponible totalmente de código abierto (pesos + código de entrenamiento).

**Especificaciones clave**: 10B de parámetros, 5.4s a 848×480, 24GB de VRAM

### LTX-Video

LTX-Video de LightRick prioriza la velocidad de inferencia por encima de todo. Puede generar video en tiempo real o casi en tiempo real en GPUs modernas — ideal para aplicaciones interactivas.

**Especificaciones clave**: 2B de parámetros, hasta 2 minutos de video, 8GB de VRAM

***

## Comparación de calidad

### Benchmark EvalCrafter (2025)

{% hint style="info" %}
La calidad es subjetiva. Estas puntuaciones reflejan el consenso de la comunidad a partir de los benchmarks VBench y EvalCrafter.
{% endhint %}

| Modelo        | Puntuación VBench | Calidad de movimiento | Alineación con el texto | Estética  |
| ------------- | ----------------- | --------------------- | ----------------------- | --------- |
| Hunyuan Video | **83.2**          | **Excelente**         | Excelente               | Excelente |
| Wan2.1 (14B)  | **82.8**          | Excelente             | Excelente               | Excelente |
| CogVideoX-5B  | 79.6              | Bueno                 | **Muy bueno**           | Bueno     |
| Mochi 1       | 77.4              | Muy bueno             | Bueno                   | Bueno     |
| LTX-Video     | 71.2              | Bueno                 | Bueno                   | Aceptable |

### Fortalezas cualitativas

| Modelo        | Mejor en                                        | Debilidades                        |
| ------------- | ----------------------------------------------- | ---------------------------------- |
| Hunyuan Video | Calidad general, cinematografía                 | Muy lento, exigente de VRAM        |
| Wan2.1        | Equilibrio de calidad/eficiencia, I2V           | Ocasionalmente sobresaturado       |
| CogVideoX     | Narrativa de larga duración, precisión de texto | Movimiento menos dinámico          |
| Mochi 1       | Movimiento fluido, física                       | Límite de resolución inferior      |
| LTX-Video     | Velocidad, videos largos                        | Brecha de calidad respecto a otros |

***

## Benchmarks de velocidad

### Tiempo de generación (A100 80GB, GPU única)

| Modelo        | 480p 5s    | 720p 5s   | 1080p 5s |
| ------------- | ---------- | --------- | -------- |
| Hunyuan Video | 45 min     | \~3 horas | ❌ 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 seg** | **3 min** | 8 min    |

{% hint style="warning" %}
**Los tiempos son aproximados** y varían con los pasos del muestreador (20-50), la escala de guía y el hardware. Use menos pasos para vistas previas.
{% endhint %}

### Con optimización (TeaCache / FORA / Step Distillation)

La inferencia optimizada puede reducir significativamente el tiempo de generación:

| Modelo        | Con caché       | Aceleración |
| ------------- | --------------- | ----------- |
| Hunyuan Video | \~15 min (720p) | 4×          |
| Wan2.1        | \~12 min (720p) | \~4×        |
| CogVideoX     | \~8 min (720p)  | \~3×        |
| LTX-Video     | \~45s (720p)    | 4×          |

***

## Requisitos de VRAM

### VRAM mínima por modelo y resolución

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

### Técnicas de optimización de memoria

#### Cuantización

```python
# CogVideoX con cuantización a 8 bits (reduce a la mitad la VRAM)
from diffusers import CogVideoXPipeline
import torch

pipe = CogVideoXPipeline.from_pretrained(
    "THUDM/CogVideoX-5b",
    torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()  # Reduce aún más la VRAM
pipe.vae.enable_slicing()
pipe.vae.enable_tiling()
```

#### Descarga a CPU (CPU Offloading)

```python
# Wan2.1 con descarga a CPU para menor 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: Análisis profundo

### Arquitectura

* **13B DiT** (Diffusion Transformer) parámetros
* Atención completa sobre todos los tokens espaciales y temporales
* Entrenado en más de 1B de clips de video

### Despliegue en Clore.ai

```bash
# Clonar e instalar
git clone https://github.com/Tencent/HunyuanVideo
cd HunyuanVideo
pip install -r requirements.txt

# Descargar pesos (~87GB)
huggingface-cli download tencent/HunyuanVideo --local-dir ./weights

# Generar
python sample_video.py \
  --video-size 720 1280 \
  --video-length 129 \
  --infer-steps 50 \
  --prompt "Un majestuoso águila planeando sobre montañas cubiertas de nieve" \
  --flow-shift 7.0 \
  --embedded-cfg-scale 6.0 \
  --save-path ./outputs
```

### Vía ComfyUI

```bash
# Instalar nodos HunyuanVideo para ComfyUI
cd ComfyUI/custom_nodes
git clone https://github.com/kijai/ComfyUI-HunyuanVideoWrapper
pip install -r ComfyUI-HunyuanVideoWrapper/requirements.txt
```

**Mejor para**: Generación de video cinematográfico de la más alta calidad, sin restricciones de VRAM

***

## Wan2.1: Análisis profundo

### Arquitectura

* **Dos variantes**: Wan2.1-T2V-1.3B y Wan2.1-T2V-14B
* **Imagen a video** (I2V) modelo también disponible
* Fuertes indicaciones multilingües (chino + inglés)

### Despliegue en Clore.ai

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

# Modelo 1.3B — cabe en 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 sereno jardín japonés con flores de cerezo cayendo",
    negative_prompt="baja calidad, borroso",
    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)
```

### Imagen a video con 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 persona camina hacia adelante con confianza",
    num_frames=81,
).frames[0]
```

**Mejor para**: Equilibrio de calidad y eficiencia, I2V, multilingüe

***

## CogVideoX: Análisis profundo

### Arquitectura

* **Transformador experto** con atención 3D completa
* **5B y 10B** variantes de parámetros
* Codificador de imagen CogView3 para calidad visual

### Despliegue en 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="Una cámara rápida de una ciudad de noche con estelas de luz de los coches",
    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)
```

**Mejor para**: Preciso texto a video, contenido narrativo, generación de larga duración

***

## Mochi 1: Análisis profundo

### Arquitectura

* **AsymmDiT** — transformador de difusión asimétrico
* Enfoque en consistencia temporal y movimiento fluido
* Totalmente de código abierto incluyendo el código de entrenamiento

### Despliegue en 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 delfín saltando entre las olas del océano al atardecer'},
)
"
```

**Mejor para**: Movimiento fluido, física realista, casos de uso de investigación

***

## LTX-Video: Análisis profundo

### Arquitectura

* **2B de parámetros** DiT — más pequeño, más rápido
* Soporte nativo **de video largo** (hasta 2 minutos)
* Diseñado para generación en tiempo real o casi en tiempo real

### Despliegue en 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="Una mariposa posándose en una flor en un jardín de verano",
    negative_prompt="peor calidad, movimiento inconsistente, borroso",
    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)
```

**Mejor para**: Generación rápida, aplicaciones interactivas, videos largos, VRAM limitada (8GB)

***

## Comparación de características

### Resumen de capacidades

| Característica        | Hunyuan | Wan2.1 | CogVideoX | Mochi | LTX |
| --------------------- | ------- | ------ | --------- | ----- | --- |
| Texto a video         | ✅       | ✅      | ✅         | ✅     | ✅   |
| Imagen a video        | ✅       | ✅      | ✅         | ❌     | ✅   |
| Video a video         | ❌       | ❌      | ✅         | ❌     | ✅   |
| ControlNet            | Parcial | ❌      | ✅         | ❌     | ❌   |
| Soporte LoRA          | ✅       | ✅      | ✅         | ❌     | ✅   |
| Nodos ComfyUI         | ✅       | ✅      | ✅         | ✅     | ✅   |
| Video largo (>10s)    | ❌       | ❌      | Parcial   | ❌     | ✅   |
| Indicaciones en chino | ✅       | ✅      | ✅         | ❌     | ❌   |

***

## Recomendaciones de GPU en Clore.ai

### Para cada modelo

| Modelo        | GPU mínima      | Recomendado  | Ideal       |
| ------------- | --------------- | ------------ | ----------- |
| 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    |

### Estimación de costo por video

```
Hunyuan Video (720p, 5s) en A100 80GB (~$1.50/hr):
  Tiempo: ~45 min → Costo: ~$1.12 por video

Wan2.1-1.3B (480p, 5s) en RTX 3090 (~$0.50/hr):
  Tiempo: ~3 min → Costo: ~$0.025 por video

LTX-Video (720p, 5s) en RTX 4090 (~$0.60/hr):
  Tiempo: ~3 min → Costo: ~$0.030 por video
```

***

## Cuándo usar cada uno

### Guía de decisión

```
¿Calidad máxima (sin límite de costo)?
  → Hunyuan Video en A100

¿Mejor equilibrio calidad/costo?
  → Wan2.1 14B en A6000

¿VRAM limitada (8-12GB)?
  → LTX-Video o Wan2.1 1.3B

¿Necesita generación rápida?
  → LTX-Video

¿Necesita Imagen a video?
  → Wan2.1 I2V o CogVideoX

¿Necesita videos largos (>10s)?
  → LTX-Video

¿Investigación/ajuste fino?
  → Mochi 1 (código de entrenamiento abierto) o CogVideoX

¿Flujo de trabajo ComfyUI?
  → Todos son compatibles, nodos Hunyuan/Wan recomendados
```

***

## Enlaces útiles

* [Hunyuan Video en GitHub](https://github.com/Tencent/HunyuanVideo)
* [Wan2.1 en HuggingFace](https://huggingface.co/Wan-AI)
* [CogVideoX en GitHub](https://github.com/THUDM/CogVideo)
* [Mochi 1 en GitHub](https://github.com/genmoai/mochi)
* [LTX-Video en GitHub](https://github.com/Lightricks/LTX-Video)
* [Tabla de clasificación de generación de video](https://huggingface.co/spaces/ArtificialAnalysis/video-generation-arena-leaderboard)

***

## Resumen

| Modelo            | Usar cuando                                      |
| ----------------- | ------------------------------------------------ |
| **Hunyuan Video** | La mejor calidad importa más, A100+ disponible   |
| **Wan2.1**        | Mejor equilibrio entre calidad y eficiencia      |
| **CogVideoX**     | Texto a video preciso, narrativa larga           |
| **Mochi 1**       | Movimiento fluido, física, investigación abierta |
| **LTX-Video**     | Velocidad, baja VRAM, videos largos              |

El ecosistema de generación de video de código abierto se mueve rápido. Para la mayoría de las implementaciones en Clore.ai, **Wan2.1** (1.3B para presupuesto, 14B para calidad) ofrece la mejor combinación de calidad, velocidad y eficiencia de recursos.


---

# Agent Instructions: 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-es/comparaciones/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.