> 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-de/video-generierung/ltx-video.md).

# LTX-Video Echtzeit-Generierung

LTX-Video von Lightricks ist das schnellste Open-Source-Videoerzeugungsmodell. Auf einer RTX 4090 erzeugt es einen 5‑Sekunden-Clip in 768×512 in etwa 4 Sekunden — schneller als Echtzeitwiedergabe. Das Modell unterstützt sowohl Text-zu-Video- (T2V) als auch Bild-zu-Video- (I2V) Workflows durch native `diffusers` Integration über `LTXPipeline` und `LTXImageToVideoPipeline`.

Eine GPU mieten auf [Clore.ai](https://clore.ai/) gibt Ihnen sofortigen Zugriff auf die Hardware, die LTX-Video benötigt, ohne Vorabinvestition und mit Abrechnung pro Stunde.

## Hauptmerkmale

* **Schneller als Echtzeit** — 5‑Sekunden-Video in \~4 Sekunden auf einer RTX 4090 erzeugt.
* **Text-zu-Video** — erzeugt Clips aus natürlichsprachlichen Beschreibungen.
* **Bild-zu-Video** — animiert ein statisches Referenzbild mit Bewegung und Kamerasteuerung.
* **Leichte Architektur** — 2‑Milliarden-Parameter Video DiT mit einem kompakten latenten Raum.
* **Native diffusers** — `LTXPipeline` und `LTXImageToVideoPipeline` in `diffusers >= 0.32`.
* **Offene Gewichte** — Apache‑2.0 Lizenz; vollständige kommerzielle Nutzung erlaubt.
* **Temporales VAE** — 1:192 Kompressionsverhältnis über Raum und Zeit; effizientes Decoding.

## Anforderungen

| Komponente | Minimum | Empfohlen |
| ---------- | ------- | --------- |
| GPU-VRAM   | 16 GB   | 24 GB     |
| System-RAM | 16 GB   | 32 GB     |
| Festplatte | 15 GB   | 30 GB     |
| Python     | 3.10+   | 3.11      |
| CUDA       | 12.1+   | 12.4      |
| diffusers  | 0.32+   | neueste   |

**Clore.ai GPU-Empfehlung:** Ein **RTX 4090** (24 GB, \~0,5–2 $/Tag) ist ideal für maximalen Durchsatz. Ein **RTX 3090** (24 GB, \~0,3–1 $/Tag) läuft immer noch schneller als viele konkurrierende Modelle zu einem Bruchteil der Kosten.

## Schnellstart

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

## Beispielanwendungen

### Text-zu-Video

```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 = (
    "Eine Drohnenaufnahme, die über ein türkisfarbenes Korallenriff gleitet, "
    "Schwärme tropischer Fische, die darunter hervorschießen, goldenes Licht "
    "das sich durch die Wasseroberfläche bricht"
)

video_frames = pipe(
    prompt=prompt,
    negative_prompt="verschwommen, niedrige Qualität, verzerrt",
    num_frames=121,               # ~5 Sek. bei 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("Saved coral_reef.mp4")
```

### Bild-zu-Video

```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="Kamera schwenkt langsam nach rechts, Stadtlichter gehen bei Dämmerung an",
    negative_prompt="statisch, verschwommen",
    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)
```

### Batch-Generierungsskript

```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 = [
    "Eine Katze, die sich auf einer sonnendurchfluteten Fensterbank streckt, Staubpartikel schweben",
    "Luftaufnahme von Wellen, die auf schwarzem Vulkan­sand brechen",
    "Zeitraffer von Gewitterwolken, die über eine Prärie ziehen",
]

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)}] Fertig")
```

## Tipps für Clore.ai-Nutzer

1. **Geschwindigkeits-Benchmark** — auf einer RTX 4090 erzeugt LTX-Video 121 Frames in \~4 Sekunden; verwenden Sie dies als Plausibilitätsprüfung, dass Ihre Anmietung korrekt arbeitet.
2. **bf16 Präzision** — der Checkpoint wurde in bf16 trainiert; wechseln Sie nicht zu fp16, sonst riskieren Sie Qualitätsverschlechterung.
3. **Gewichte cachen** — setze `HF_HOME=/workspace/hf_cache` auf einem persistenten Volume. Das Modell ist \~6 GB; erneutes Herunterladen bei jedem Containerstart verschwendet Zeit.
4. **Prompt-Engineering** — LTX-Video reagiert gut auf kinoreife Sprache: "Drohnenaufnahme", "Zeitlupe", "goldene Stunde", "Tracking-Shot". Seien Sie spezifisch bezüglich Kamerabewegung.
5. **Batch über Nacht** — LTX-Video ist schnell genug, um auf einer 4090 Hunderte von Clips pro Stunde zu erzeugen. Reichen Sie Prompts aus einer Datei ein und lassen Sie es laufen.
6. **SSH + tmux** — führen Sie die Generierung immer innerhalb einer `tmux` Sitzung aus, damit unterbrochene Verbindungen lange Batch-Jobs nicht beenden.
7. **VRAM überwachen** — `watch -n1 nvidia-smi` in einem zweiten Terminal, um sicherzustellen, dass Sie nicht auf Swap stoßen.

## Fehlerbehebung

| Problem                                     | Behebe                                                                                           |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `OutOfMemoryError`                          | Reduziere `num_frames` auf 81 oder `Breite`/`Höhe` auf 512×320                                   |
| Modell in diffusers nicht gefunden          | Aktualisieren: `pip install -U diffusers` — LTXPipeline erfordert diffusers ≥ 0.32               |
| Schwarzes oder statisches Ergebnis          | Stellen Sie sicher, dass Sie ein `negative_prompt`; erhöhen Sie `guidance_scale` auf 8–9         |
| `ImportError: imageio`                      | `pip install imageio[ffmpeg]` — ffmpeg-Backend benötigt für MP4-Export                           |
| Langsame erste Inferenz                     | Der erste Lauf kompiliert CUDA-Kerne und lädt Gewichte herunter; nachfolgende Läufe sind schnell |
| Farbbanding-Artefakte                       | Verwenden Sie `torch.bfloat16` (nicht float16); bfloat16 hat einen größeren Dynamikbereich       |
| Container wurde mitten im Job neu gestartet | Setze `HF_HOME` auf persistente Speicherung; partielle HF-Downloads setzen automatisch fort      |


---

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

```
GET https://docs.clore.ai/guides/guides_v2-de/video-generierung/ltx-video.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.