> 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-es/generacion-de-video/ltx-video-2.md).

# LTX-2 (audio + video)

Genera videos con audio nativo — foley, ambiente y sincronización labial — usando LTX-2 en GPUs de Clore.ai.

LTX-2 (enero de 2026) es el modelo fundacional de video de segunda generación de Lightricks y el primer modelo de pesos abiertos en producir **audio sincronizado junto con el video** en una sola pasada hacia adelante. Con 19B de parámetros genera clips con efectos de sonido foley, audio ambiental y voz sincronizada con los labios sin requerir un modelo de audio separado. La arquitectura se basa en la ventaja de velocidad del LTX-Video original, a la vez que amplía drásticamente las capacidades.

Alquilar una GPU en [Clore.ai](https://clore.ai/) es la forma más práctica de ejecutar un modelo de 19B parámetros — no hace falta comprar una GPU de $2,000; basta con poner en marcha una máquina y empezar a generar.

## Características clave

* **Generación nativa de audio** — efectos foley, sonido ambiental y diálogo sincronizado con los labios producidos conjuntamente con los fotogramas de video.
* **19B de parámetros** — un backbone transformador significativamente más grande que LTX-Video v1, que ofrece detalles más nítidos y un movimiento más coherente.
* **Texto a video + Imagen a video** — ambas modalidades son compatibles con salida de audio.
* **Hasta resolución 720p** — salida de mayor fidelidad que el modelo v1.
* **Espacio latente audiovisual conjunto** — un VAE unificado codifica tanto el video como el audio, manteniéndolos alineados temporalmente.
* **Pesos abiertos** — lanzado bajo una licencia permisiva para uso comercial.
* **Integración con Diffusers** — compatible con Hugging Face `diffusers` ecosistema.

## Requisitos

| Componente      | Mínimo               | Recomendado  |
| --------------- | -------------------- | ------------ |
| VRAM de GPU     | 16 GB (con descarga) | 24+ GB       |
| RAM del sistema | 32 GB                | 64 GB        |
| Disco           | 50 GB                | 80 GB        |
| Python          | 3.10+                | 3.11         |
| CUDA            | 12.8+                | 12.8+        |
| diffusers       | 0.33+                | más reciente |

**Recomendación de GPU de Clore.ai:** Un **RTX 4090** (24 GB, $0.14–0.42/h) es el mínimo para una generación cómoda en 720p con audio. Para cargas de trabajo por lotes o iteración más rápida, filtra por **dual-4090** o **A6000** listados de (48 GB) en el mercado de Clore.ai.

## Inicio rápido

```bash
# Instalar dependencias
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
pip install diffusers transformers accelerate sentencepiece
pip install imageio[ffmpeg] soundfile scipy

# Verificar GPU
python -c "import torch; print(torch.cuda.get_device_name(0), torch.cuda.get_device_properties(0).total_mem // 1024**3, 'GB')"
```

## Ejemplos de uso

### Texto a video con audio

```python
import torch
from diffusers import LTXPipeline
from diffusers.utils import export_to_video
import soundfile as sf

# Carga LTX-2 (asegúrate de tener el ID correcto del modelo cuando se publique)
pipe = LTXPipeline.from_pretrained(
    "Lightricks/LTX-Video-2",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = (
    "Un herrero golpeando metal incandescente sobre un yunque, con chispas volando, "
    "golpeteo rítmico del martillo sobre el acero, ruido ambiental del taller"
)

output = pipe(
    prompt=prompt,
    negative_prompt="silencioso, borroso, de baja calidad",
    num_frames=121,
    width=1280,
    height=720,
    num_inference_steps=40,
    guidance_scale=7.0,
    generator=torch.Generator("cuda").manual_seed(42),
)

# Exporta los fotogramas del video
export_to_video(output.frames[0], "blacksmith.mp4", fps=24)

# Exporta el audio si está disponible
if hasattr(output, "audio") and output.audio is not None:
    sf.write("blacksmith_audio.wav", output.audio, samplerate=16000)
    print("Audio guardado por separado — combínalo con ffmpeg:")
    print("  ffmpeg -i blacksmith.mp4 -i blacksmith_audio.wav -c:v copy -c:a aac output.mp4")

print("Listo: blacksmith.mp4")
```

### Imagen a video con audio sincronizado con labios

```python
import torch
from PIL import Image
from diffusers import LTXImageToVideoPipeline
from diffusers.utils import export_to_video

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

# Imagen de retrato para sincronización labial
image = Image.open("portrait.png").resize((720, 1280))

output = pipe(
    prompt="Una persona diciendo 'Bienvenidos al futuro del video con IA' con dicción clara, fondo neutro",
    image=image,
    num_frames=121,
    num_inference_steps=40,
    guidance_scale=7.0,
)

export_to_video(output.frames[0], "talking_head.mp4", fps=24)
```

### Escena ambiental con foley

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

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

# Prompt rico en audio — describe los sonidos explícitamente
prompt = (
    "Lluvia cayendo sobre un techo de hojalata en un pueblo tropical, "
    "trueno retumbando a la distancia, pájaros cantando brevemente entre ráfagas, "
    "charcos ondulándose en un camino de tierra"
)

output = pipe(
    prompt=prompt,
    num_frames=121,
    width=1280,
    height=720,
    num_inference_steps=40,
    guidance_scale=6.5,
)

export_to_video(output.frames[0], "rain_scene.mp4", fps=24)
```

## Consejos para usuarios de Clore.ai

1. **Describe los sonidos explícitamente** — la rama de audio de LTX-2 responde a las pistas de audio del prompt. "Fuego crepitando", "pasos sobre grava", "murmullo de la multitud" producen mejor foley que las descripciones vagas.
2. **La descarga a CPU es esencial** — con 19B de parámetros, el modelo necesita `enable_model_cpu_offload()` en tarjetas de 24 GB. Reserva 64 GB de RAM del sistema.
3. **Almacenamiento persistente** — el checkpoint del modelo es de \~40 GB. Monta un volumen persistente de Clore.ai y establece `HF_HOME` para evitar volver a descargarlo en cada reinicio del contenedor.
4. **Combina audio + video** — si la canalización genera el audio por separado, combínalo con: `ffmpeg -i video.mp4 -i audio.wav -c:v copy -c:a aac final.mp4`.
5. **solo bf16** — el modelo de 19B fue entrenado en bf16; fp16 causará inestabilidad numérica.
6. **Procesamiento por lotes en tmux** — ejecútalo siempre dentro de `tmux` en alquileres de Clore.ai para sobrevivir a desconexiones SSH.
7. **Verifica el ID del modelo** — como LTX-2 acaba de lanzarse (ene. de 2026), verifica el ID exacto del modelo de Hugging Face en la [página HF de Lightricks](https://huggingface.co/Lightricks) antes de ejecutarlo.

## Solución de problemas

| Problema                         | Solución                                                                                                                                                         |
| -------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError`               | Habilita `pipe.enable_model_cpu_offload()`; asegúrate de tener ≥64 GB de RAM del sistema                                                                         |
| Sin audio en la salida           | La generación de audio puede requerir un parámetro explícito o una versión actualizada de diffusers; consulta la tarjeta del modelo para ver la API más reciente |
| Desincronización de audio/video  | Recombina con ffmpeg: `ffmpeg -i video.mp4 -i audio.wav -c:v copy -c:a aac -shortest out.mp4`                                                                    |
| Generación muy lenta             | El modelo de 19B exige mucho cómputo; se esperan \~2–4 min por clip de 5 s en una RTX 4090                                                                       |
| Salidas NaN                      | Usa `torch.bfloat16` — fp16 no es compatible con esta escala de modelo                                                                                           |
| Error de espacio en disco        | El modelo pesa \~40 GB; asegúrate de tener ≥80 GB libres en disco antes de descargarlo                                                                           |
| `ModuleNotFoundError: soundfile` | `pip install soundfile` — necesario para la exportación de audio WAV                                                                                             |


---

# 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-es/generacion-de-video/ltx-video-2.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.
