# Generación en tiempo real 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 |