Génération en temps réel LTX-Video

Générez des vidéos de 5 secondes plus vite qu'en temps réel avec LTX-Video de Lightricks sur les GPU Clore.ai.

LTX-Video de Lightricks est le modèle de génération vidéo open source le plus rapide disponible. Sur une RTX 4090, il produit un clip de 5 secondes en 768×512 en environ 4 secondes — plus rapide que la lecture en temps réel. Le modèle prend en charge les flux de travail texte vers vidéo (T2V) et image vers vidéo (I2V) via native diffusers intégration via LTXPipeline et LTXImageToVideoPipeline.

Louer un GPU sur Clore.ai vous donne un accès instantané au matériel dont LTX-Video a besoin, sans investissement initial et avec une facturation à l’heure.

Caractéristiques clés

• Plus rapide que le temps réel — vidéo de 5 secondes générée en ~4 secondes sur une RTX 4090.

• Texte vers vidéo — produire des clips à partir de descriptions en langage naturel.

• Image vers vidéo — animer une image de référence statique avec mouvement et contrôle de la caméra.

• Architecture légère — vidéo DiT à 2B de paramètres avec un espace latent compact.

• Diffusers natifs — LTXPipeline et LTXImageToVideoPipeline dans diffusers >= 0.32.

• Poids ouverts — licence Apache-2.0 ; utilisation commerciale entièrement autorisée.

• VAE temporel — rapport de compression 1:192 dans l’espace et le temps ; décodage efficace.

Exigences

Composant	Minimum	Recommandé
VRAM GPU	16 Go	24 Go
RAM système	16 Go	32 Go
Disque	15 Go	30 Go
Python	3.10+	3.11
CUDA	12.8+	12.8+
diffusers	0.32+	dernière version

Recommandation de GPU Clore.ai : Un RTX 4090 (24 Go, 0,14–0,42 $/h) est idéal pour un débit maximal. Un RTX 3090 (24 Go, 0,07–0,21 $/h) fonctionne toujours plus vite que de nombreux modèles concurrents pour une fraction du coût.

Démarrage rapide

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))"

Exemples d'utilisation

Texte vers vidéo

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 plan aérien glissant au-dessus d’un récif corallien turquoise, "
    "des bancs de poissons tropicaux filant en dessous, lumière de l’heure dorée "
    "se réfractant à travers la surface de l’eau"
)

video_frames = pipe(
    prompt=prompt,
    negative_prompt="flou, basse qualité, déformé",
    num_frames=121,               # ~5 s à 24 ips
    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 enregistré")

Image vers vidéo

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 caméra effectue lentement un panoramique vers la droite, les lumières de la ville s’allument au crépuscule",
    negative_prompt="statique, flou",
    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 génération par lots

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 chat qui s’étire sur un rebord de fenêtre ensoleillé, des poussières flottant dans l’air",
    "Vue aérienne de vagues s’écrasant sur du sable volcanique noir",
    "Time-lapse de nuages d’orage roulant au-dessus d’une prairie",
]

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)}] Terminé")

Conseils pour les utilisateurs de Clore.ai

1. Benchmark de vitesse — sur une RTX 4090, LTX-Video génère 121 images en ~4 secondes ; utilisez cela comme vérification rapide que votre location fonctionne correctement.

2. Précision bf16 — le checkpoint est entraîné en bf16 ; ne passez pas en fp16 ou vous risquez une dégradation de la qualité.

3. Mettre en cache les poids — définissez HF_HOME=/workspace/hf_cache sur un volume persistant. Le modèle fait ~6 Go ; le retélécharger à chaque démarrage du conteneur gaspille du temps.

4. Ingénierie des prompts — LTX-Video répond bien au langage cinématographique : "plan de drone", "ralenti", "heure dorée", "plan de suivi". Soyez précis sur le mouvement de caméra.

5. En lot pendant la nuit — LTX-Video est assez rapide pour générer des centaines de clips par heure sur une 4090. Mettez les prompts en file depuis un fichier et laissez-le tourner.

6. SSH + tmux — exécutez toujours la génération dans une tmux session afin que les connexions interrompues n’interrompent pas les longs traitements par lots.

7. Surveiller la VRAM — watch -n1 nvidia-smi dans un second terminal pour vous assurer que vous ne tombez pas sur le swap.

Dépannage

Problème	Correctif
OutOfMemoryError	Réduisez num_frames à 81 ou largeur/hauteur à 512×320
Modèle introuvable dans diffusers	Mise à niveau : pip install -U diffusers — LTXPipeline nécessite diffusers ≥ 0.32
Sortie noire ou statique	Assurez-vous de passer un negative_prompt ; augmentez guidance_scale à 8–9
ImportError : imageio	pip install imageio[ffmpeg] — backend ffmpeg nécessaire pour l’export MP4
Première inférence lente	La première exécution compile les kernels CUDA et télécharge les poids ; les exécutions suivantes sont rapides
Artifacts de banding des couleurs	Utilisez torch.bfloat16 (pas float16) ; bfloat16 a une plage dynamique plus large
Conteneur redémarré au milieu de la tâche	Définissez HF_HOME vers un stockage persistant ; les téléchargements HF partiels reprennent automatiquement