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

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 une intégration native `intégration` intégration via `LTXPipeline` et `LTXImageToVideoPipeline`.

Louer un GPU sur [Clore.ai](https://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.

## Principales caractéristiques

* **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 contrôle du mouvement et de la caméra.
* **Architecture légère** — DiT vidéo de 2 milliards 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 pleinement autorisée.
* **VAE temporel** — ratio de compression 1:192 à travers 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.1+   | 12.4       |
| intégration | 0.32+   | dernière   |

**Recommandation GPU Clore.ai :** Un **RTX 4090** (24 Go, \~0,5–2 $/jour) est idéal pour un débit maximal. Un **RTX 3090** (24 Go, \~0,3–1 $/jour) fonctionne toujours plus rapidement que de nombreux modèles concurrents pour une fraction du coût.

## Démarrage rapide

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

## Exemples d'utilisation

### Texte vers Vidéo

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

video_frames = pipe(
    prompt=prompt,
    negative_prompt="flou, basse qualité, déformé",
    num_frames=121,               # ~5 sec à 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("Saved coral_reef.mp4")
```

### Image vers Vidéo

```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 caméra panoramique se déplace lentement 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 lot

```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 chat s'étirant sur un rebord de fenêtre baigné de soleil, des poussières en suspension",
    "Vue aérienne de vagues s'écrasant sur du sable volcanique noir",
    "Timelapse de nuages d'orage roulant sur 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 ceci comme vérification que votre location fonctionne correctement.
2. **Précision bf16** — le point de contrôle est entraîné en bf16 ; ne passez pas en fp16 sous peine de dégrader 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échargement à chaque démarrage de conteneur fait perdre du temps.
4. **Ingénierie de prompts** — LTX-Video répond bien au langage cinématographique : "plan drone", "ralenti", "heure dorée", "plan de suivi". Soyez précis sur le mouvement de la caméra.
5. **Traitement par 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 à l'intérieur d'une `tmux` session afin que des connexions interrompues n'interrompent pas les longs travaux par lot.
7. **Surveiller la VRAM** — `watch -n1 nvidia-smi` dans un second terminal pour vous assurer que vous n'atteignez pas la swap.

## Dépannage

| Problème                             | Corriger                                                                                                       |
| ------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError`                   | Réduire `num_frames` à 81 ou `largeur`/`hauteur` à 512×320                                                     |
| Modèle introuvable dans diffusers    | Mise à jour : `pip install -U diffusers` — LTXPipeline requiert 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 |
| Artefacts de banding de couleur      | Utilisez `torch.bfloat16` (pas float16) ; le bfloat16 a une plage dynamique plus large                         |
| Conteneur redémarré en plein travail | Définir `HF_HOME` vers un stockage persistant ; les téléchargements HF partiels reprennent automatiquement     |