Generación en tiempo real LTX-Video

Genera videos de 5 segundos más rápido que en tiempo real con LTX-Video de Lightricks en GPUs de Clore.ai.

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 de 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 integración nativa diffusers integración mediante LTXPipeline y LTXImageToVideoPipeline.

Alquilar una GPU en 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 — vídeo de 5 segundos generado en ~4 segundos en una RTX 4090.

• Texto a video — genera clips a partir de descripciones en lenguaje natural.

• Imagen a video — anima una imagen de referencia estática con movimiento y control de cámara.

• Arquitectura ligera — modelo video DiT de 2 mil millones de parámetros con un espacio latente compacto.

• Diffusers nativo — LTXPipeline y LTXImageToVideoPipeline en diffusers >= 0.32.

• Pesos abiertos — licencia Apache-2.0; se permite plenamente el uso comercial.

• VAE temporal — relación de compresión 1:192 en espacio y 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.8+	12.8+
diffusers	0.32+	más reciente

Recomendación de GPU de Clore.ai: Un RTX 4090 (24 GB, $0.14–0.42/h) es ideal para el máximo rendimiento. Un RTX 3090 (24 GB, $0.07–0.21/h) aún se ejecuta más rápido que muchos modelos competidores por una fracción del costo.

Inicio rápido

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
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

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 de dron deslizándose sobre un arrecife de coral turquesa, "
    "escuelas de peces tropicales zigzagueando debajo, 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 s 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("coral_reef.mp4 guardado")

Imagen a video

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 a la derecha, las luces de la ciudad se encienden al atardecer",
    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

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 el alféizar de una ventana iluminada por el sol, motas de polvo flotando",
    "Vista aérea de olas rompiendo sobre arena volcánica negra",
    "Lapso de tiempo 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. Benchmark de velocidad — en una RTX 4090, LTX-Video genera 121 fotogramas en ~4 segundos; úsalo como una comprobación rápida de que tu instancia alquilada está funcionando correctamente.

2. Precisión bf16 — el checkpoint se entrena en bf16; no cambies a fp16 o arriesgas 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 arranque del contenedor desperdicia tiempo.

4. Ingeniería de prompts — LTX-Video responde bien al lenguaje cinematográfico: "plano de dron", "cámara lenta", "hora dorada", "plano de seguimiento". Sé específico con el movimiento de cámara.

5. Por lotes durante la noche — LTX-Video es lo bastante rápido como para generar cientos de clips por hora en una 4090. Encola prompts desde un archivo y déjalo ejecutarse.

6. SSH + tmux — ejecuta siempre la generación dentro de una tmux sesión para que las conexiones interrumpidas no corten trabajos por lotes largos.

7. Monitoriza VRAM — watch -n1 nvidia-smi en una segunda terminal para asegurarte de que no estás recurriendo a swap.

Solución de problemas

Problema	Solución
OutOfMemoryError	Reduce 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 de ffmpeg para exportar a MP4
Primera inferencia lenta	La primera ejecución compila los kernels de CUDA y descarga los 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
El contenedor se reinició a mitad del trabajo	Establece HF_HOME a almacenamiento persistente; las descargas parciales de HF se reanudan automáticamente