# Generación en tiempo real con LTX-Video

LTX-Video de Lightricks es el modelo de generación de video de código abierto más rápido disponible. En una RTX 4090 produce un clip de 5 segundos a 768×512 en aproximadamente 4 segundos, más rápido que la reproducción en tiempo real. El modelo admite flujos de trabajo tanto de texto a video (T2V) como de imagen a video (I2V) mediante `diffusers` integración a través de `LTXPipeline` y `LTXImageToVideoPipeline`.

Alquilar una GPU en [Clore.ai](https://clore.ai/) te da acceso instantáneo al hardware que LTX-Video necesita, sin inversión inicial y con facturación por hora.

## Características clave

* **Más rápido que el tiempo real** — video de 5 segundos generado en \~4 segundos en una RTX 4090.
* **Texto a Video** — producir clips a partir de descripciones en lenguaje natural.
* **Imagen a video** — animar una imagen de referencia estática con control de movimiento y cámara.
* **Arquitectura ligera** — DiT de video de 2B parámetros con un espacio latente compacto.
* **diffusers nativo** — `LTXPipeline` y `LTXImageToVideoPipeline` en `diffusers >= 0.32`.
* **Pesos abiertos** — licencia Apache-2.0; uso comercial totalmente permitido.
* **VAE temporal** — relación de compresión 1:192 a través del espacio y el tiempo; decodificación eficiente.

## Requisitos

| Componente      | Mínimo | Recomendado |
| --------------- | ------ | ----------- |
| VRAM de GPU     | 16 GB  | 24 GB       |
| RAM del sistema | 16 GB  | 32 GB       |
| Disco           | 15 GB  | 30 GB       |
| Python          | 3.10+  | 3.11        |
| CUDA            | 12.1+  | 12.4        |
| diffusers       | 0.32+  | última      |

**Recomendación de GPU de Clore.ai:** Un **RTX 4090** (24 GB, \~$0.5–2/día) es ideal para el máximo rendimiento. Un **RTX 3090** (24 GB, \~$0.3–1/día) aún se ejecuta más rápido que muchos modelos competidores a una fracción del costo.

## Inicio rápido

```bash
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
pip install diffusers transformers accelerate sentencepiece imageio[ffmpeg]

python -c "import torch; print(torch.cuda.get_device_name(0))"
```

## Ejemplos de uso

### Texto a Video

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

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

prompt = (
    "Un plano con dron deslizándose sobre un arrecife de coral turquesa, "
    "cardúmenes de peces tropicales moviéndose abajo, luz de la hora dorada "
    "refractándose a través de la superficie del agua"
)

video_frames = pipe(
    prompt=prompt,
    negative_prompt="borroso, baja calidad, distorsionado",
    num_frames=121,               # ~5 seg a 24 fps
    width=768,
    height=512,
    num_inference_steps=30,
    guidance_scale=7.5,
    generator=torch.Generator("cuda").manual_seed(0),
).frames[0]

export_to_video(video_frames, "coral_reef.mp4", fps=24)
print("Saved coral_reef.mp4")
```

### Imagen a video

```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",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")

image = Image.open("cityscape.png").resize((768, 512))

video_frames = pipe(
    prompt="La cámara se desplaza lentamente hacia la derecha, las luces de la ciudad se encienden al anochecer",
    negative_prompt="estático, borroso",
    image=image,
    num_frames=121,
    num_inference_steps=30,
    guidance_scale=7.5,
).frames[0]

export_to_video(video_frames, "cityscape_animated.mp4", fps=24)
```

### Script de generación por lotes

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

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

prompts = [
    "Un gato estirándose en un alféizar bañado por el sol, partículas de polvo flotando",
    "Vista aérea de olas rompiendo en arena volcánica negra",
    "Time-lapse de nubes de tormenta avanzando sobre una pradera",
]

for i, prompt in enumerate(prompts):
    frames = pipe(
        prompt=prompt,
        num_frames=121,
        width=768,
        height=512,
        num_inference_steps=30,
        guidance_scale=7.5,
    ).frames[0]
    export_to_video(frames, f"batch_{i:03d}.mp4", fps=24)
    print(f"[{i+1}/{len(prompts)}] Hecho")
```

## Consejos para usuarios de Clore.ai

1. **Prueba de velocidad** — en una RTX 4090, LTX-Video genera 121 cuadros en \~4 segundos; usa esto como una verificación de que tu alquiler está rindiendo correctamente.
2. **precisión bf16** — el punto de control está entrenado en bf16; no cambies a fp16 o corres el riesgo de degradación de la calidad.
3. **Caché de pesos** — establece `HF_HOME=/workspace/hf_cache` en un volumen persistente. El modelo pesa \~6 GB; volver a descargarlo en cada inicio de contenedor desperdicia tiempo.
4. **Ingeniería de prompts** — LTX-Video responde bien a un lenguaje cinematográfico: "plano con dron", "cámara lenta", "hora dorada", "plano de seguimiento". Sé específico sobre el movimiento de la cámara.
5. **Procesamiento por lotes durante la noche** — LTX-Video es lo suficientemente rápido como para generar cientos de clips por hora en una 4090. Encola prompts desde un archivo y déjalo funcionar.
6. **SSH + tmux** — siempre ejecuta la generación dentro de una `tmux` sesión para que las conexiones caídas no interrumpan trabajos largos por lotes.
7. **Monitorea la VRAM** — `watch -n1 nvidia-smi` en una segunda terminal para asegurarte de que no estés alcanzando el intercambio (swap).

## Solución de problemas

| Problema                                  | Solucionar                                                                                                   |
| ----------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| `OutOfMemoryError`                        | Reducir `num_frames` a 81 o `ancho`/`alto` a 512×320                                                         |
| Modelo no encontrado en diffusers         | Actualiza: `pip install -U diffusers` — LTXPipeline requiere diffusers ≥ 0.32                                |
| Salida negra o estática                   | Asegúrate de pasar un `negative_prompt`; aumenta `guidance_scale` a 8–9                                      |
| `ImportError: imageio`                    | `pip install imageio[ffmpeg]` — se necesita el backend ffmpeg para la exportación MP4                        |
| Primera inferencia lenta                  | La primera ejecución compila kernels CUDA y descarga pesos; las ejecuciones posteriores son rápidas          |
| Artefactos de bandas de color             | Usa `torch.bfloat16` (no float16); bfloat16 tiene un rango dinámico más amplio                               |
| Contenedor reiniciado a mitad del trabajo | Establecer `HF_HOME` a almacenamiento persistente; las descargas parciales de HF se reanudan automáticamente |


---

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