# LTX-2 (audio + vidéo)

LTX-2 (janvier 2026) est le modèle vidéo de nouvelle génération de Lightricks et le premier modèle à poids ouverts à produire **audio synchronisé avec la vidéo** en un seul passage avant. À 19 milliards de paramètres, il génère des séquences avec effets sonores foley, audio d'ambiance et parole synchronisée sur les lèvres sans nécessiter de modèle audio séparé. L'architecture s'appuie sur l'avantage de vitesse de LTX-Video original tout en élargissant considérablement les capacités.

Louer un GPU sur [Clore.ai](https://clore.ai/) est la manière la plus pratique d'exécuter un modèle de 19 milliards de paramètres — pas besoin d'acheter un GPU à 2 000 $, il suffit de lancer une machine et de commencer à générer.

## Principales caractéristiques

* **Génération audio native** — effets foley, ambiance environnementale et dialogues synchronisés sur les lèvres produits conjointement avec les images vidéo.
* **19 milliards de paramètres** — un backbone transformer significativement plus grand que celui de LTX-Video v1, offrant des détails plus nets et un mouvement plus cohérent.
* **Texte en vidéo + Image en vidéo** — les deux modalités sont prises en charge avec sortie audio.
* **Jusqu'à 720p** — sortie de plus haute fidélité que le modèle v1.
* **Espace latent audio-visuel conjoint** — un VAE unifié encode à la fois la vidéo et l'audio, les maintenant alignés temporellement.
* **Poids ouverts** — publié sous une licence permissive pour une utilisation commerciale.
* **Intégration Diffusers** — compatible avec l'écosystème Hugging Face `intégration` ecosystème.

## Exigences

| Composant   | Minimum                   | Recommandé |
| ----------- | ------------------------- | ---------- |
| VRAM GPU    | 16 Go (avec déchargement) | 24+ Go     |
| RAM système | 32 Go                     | 64 Go      |
| Disque      | 50 Go                     | 80 Go      |
| Python      | 3.10+                     | 3.11       |
| CUDA        | 12.1+                     | 12.4       |
| intégration | 0.33+                     | dernière   |

**Recommandation GPU Clore.ai :** Un **RTX 4090** (24 Go, \~0,5–2 $/jour) est le minimum pour une génération 720p confortable avec audio. Pour des charges par lot ou des itérations plus rapides, filtrez pour **dual-4090** ou **A6000** (48 Go) les annonces sur la marketplace Clore.ai.

## Démarrage rapide

```bash
# Installer les dépendances
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124
pip install diffusers transformers accelerate sentencepiece
pip install imageio[ffmpeg] soundfile scipy

# Vérifier le GPU
python -c "import torch; print(torch.cuda.get_device_name(0), torch.cuda.get_device_properties(0).total_mem // 1024**3, 'GB')"
```

## Exemples d'utilisation

### Texte en vidéo avec audio

```python
import torch
from diffusers import LTXPipeline
from diffusers.utils import export_to_video
import soundfile as sf

# Charger LTX-2 (assurez-vous d'avoir le bon ID de modèle lors de la sortie)
pipe = LTXPipeline.from_pretrained(
    "Lightricks/LTX-Video-2",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = (
    "Un forgeron martelant du métal incandescent sur une enclume, des étincelles qui volent, "
    "cliquetis rythmique du marteau sur l'acier, bruit d'atelier ambiant"
)

output = pipe(
    prompt=prompt,
    negative_prompt="silencieux, flou, basse qualité",
    num_frames=121,
    width=1280,
    height=720,
    num_inference_steps=40,
    guidance_scale=7.0,
    generator=torch.Generator("cuda").manual_seed(42),
)

# Exporter les images vidéo
export_to_video(output.frames[0], "blacksmith.mp4", fps=24)

# Exporter l'audio si disponible
if hasattr(output, "audio") and output.audio is not None:
    sf.write("blacksmith_audio.wav", output.audio, samplerate=16000)
    print("Audio enregistré séparément — muxer avec ffmpeg :")
    print("  ffmpeg -i blacksmith.mp4 -i blacksmith_audio.wav -c:v copy -c:a aac output.mp4")

print("Fait : blacksmith.mp4")
```

### Image en vidéo avec audio synchronisé sur les lèvres

```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-2",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Image de portrait pour la synchronisation labiale
image = Image.open("portrait.png").resize((720, 1280))

output = pipe(
    prompt="Une personne disant 'Bienvenue dans le futur de la vidéo IA' avec une énonciation claire, fond neutre",
    image=image,
    num_frames=121,
    num_inference_steps=40,
    guidance_scale=7.0,
)

export_to_video(output.frames[0], "talking_head.mp4", fps=24)
```

### Scène d'ambiance avec foley

```python
import torch
from diffusers import LTXPipeline
from diffusers.utils import export_to_video

pipe = LTXPipeline.from_pretrained(
    "Lightricks/LTX-Video-2", torch_dtype=torch.bfloat16
).to("cuda")

# Prompt riche en audio — décrire les sons explicitement
prompt = (
    "Pluie tombant sur un toit en tôle dans un village tropical, "
    "tonnerre grondant au loin, oiseaux chantant brièvement entre les roulements, "
    "gouttes formant des flaques sur un chemin de terre"
)

output = pipe(
    prompt=prompt,
    num_frames=121,
    width=1280,
    height=720,
    num_inference_steps=40,
    guidance_scale=6.5,
)

export_to_video(output.frames[0], "rain_scene.mp4", fps=24)
```

## Conseils pour les utilisateurs de Clore.ai

1. **Décrire les sons explicitement** — la branche audio de LTX-2 répond aux indications audio dans le prompt. "Feu qui crépite", "pas sur du gravier", "murmure d'une foule" produisent de meilleurs foley que des descriptions vagues.
2. **Le déchargement CPU est essentiel** — à 19 milliards de paramètres, le modèle a besoin de `enable_model_cpu_offload()` sur des cartes 24 Go. Prévoyez 64 Go de RAM système.
3. **Stockage persistant** — le checkpoint du modèle fait \~40 Go. Montez un volume persistant Clore.ai et définissez `HF_HOME` pour éviter de retélécharger à chaque redémarrage du conteneur.
4. **Muxer audio + vidéo** — si le pipeline produit l'audio séparément, combinez avec : `ffmpeg -i video.mp4 -i audio.wav -c:v copy -c:a aac final.mp4`.
5. **bf16 uniquement** — le modèle 19B a été entraîné en bf16 ; le fp16 provoquera des instabilités numériques.
6. **Batch dans tmux** — exécutez toujours à l'intérieur de `tmux` sur les locations Clore.ai pour survivre aux déconnexions SSH.
7. **Vérifier l'ID du modèle** — comme LTX-2 vient d'être publié (janv. 2026), vérifiez l'ID exact du modèle HuggingFace sur le [page HF de Lightricks](https://huggingface.co/Lightricks) avant d'exécuter.

## Dépannage

| Problème                          | Corriger                                                                                                                                    |
| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError`                | Activez `pipe.enable_model_cpu_offload()`; assurez ≥64 Go de RAM système                                                                    |
| Pas d'audio dans la sortie        | La génération audio peut nécessiter un indicateur explicite ou des diffusers mis à jour ; consultez la fiche du modèle pour la dernière API |
| Désynchronisation audio/vidéo     | Remuxer avec ffmpeg : `ffmpeg -i video.mp4 -i audio.wav -c:v copy -c:a aac -shortest out.mp4`                                               |
| Génération très lente             | Le modèle 19B est gourmand en calcul ; \~2–4 min par clip de 5 s sur RTX 4090 est attendu                                                   |
| Sorties NaN                       | Utilisez `torch.bfloat16` — le fp16 n'est pas pris en charge à cette échelle de modèle                                                      |
| Erreur d'espace disque            | Le modèle fait \~40 Go ; assurez ≥80 Go d'espace disque libre avant de télécharger                                                          |
| `ModuleNotFoundError : soundfile` | `pip install soundfile` — nécessaire pour l'export WAV audio                                                                                |