> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/generation-video/ltx-video.md).

# 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](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.

## 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

```bash
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

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

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

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-video/ltx-video.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.