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

# LTX-Video-Echtzeitgenerierung

Generiere 5-Sekunden-Videos schneller als in Echtzeit mit Lightricks' LTX-Video auf Clore.ai-GPUs.

LTX-Video von Lightricks ist das schnellste verfügbare Open-Source-Modell zur Videogenerierung. Auf einer RTX 4090 erzeugt es einen 5-Sekunden-Clip mit 768×512 in ungefähr 4 Sekunden — schneller als die Wiedergabe in Echtzeit. Das Modell unterstützt sowohl Text-zu-Video-(T2V)- als auch Bild-zu-Video-(I2V)-Workflows über native `diffusers` Integration über `LTXPipeline` und `LTXImageToVideoPipeline`.

Das Mieten einer GPU auf [Clore.ai](https://clore.ai/) gibt Ihnen sofortigen Zugriff auf die Hardware, die LTX-Video benötigt, ohne Vorabinvestition und mit stundenweiser Abrechnung.

## Hauptfunktionen

* **Schneller als Echtzeit** — 5-Sekunden-Video in \~4 Sekunden auf einer RTX 4090 erzeugt.
* **Text-zu-Video** — erzeugen Sie Clips aus natürlichen Sprachbeschreibungen.
* **Bild-zu-Video** — animiert ein statisches Referenzbild mit Bewegung und Kamerasteuerung.
* **Leichte Architektur** — Video-DiT mit 2B Parametern und einem kompakten latenten Raum.
* **Native Diffusers** — `LTXPipeline` und `LTXImageToVideoPipeline` in `diffusers >= 0.32`.
* **Offene Gewichte** — Apache-2.0-Lizenz; vollständig kommerzielle Nutzung erlaubt.
* **Zeitliches VAE** — 1:192-Kompressionsverhältnis über Raum und Zeit; effiziente Decodierung.

## 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.8+   | 12.8+      |
| diffusers  | 0.32+   | aktuellste |

**Clore.ai-GPU-Empfehlung:** Ein **RTX 4090** (24 GB, $0.14–0.42/Std.) ist ideal für maximalen Durchsatz. Ein **RTX 3090** (24 GB, $0.07–0.21/Std.) läuft immer noch schneller als viele konkurrierende Modelle und das zu einem Bruchteil der Kosten.

## Schnellstart

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

## Anwendungsbeispiele

### 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 hindurchzischen, Licht der goldenen Stunde "
    "das an der Wasseroberfläche gebrochen wird"
)

video_frames = pipe(
    prompt=prompt,
    negative_prompt="unscharf, 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("coral_reef.mp4 gespeichert")
```

### 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="Die Kamera schwenkt langsam nach rechts, die Lichter der Stadt flackern in der Dämmerung an",
    negative_prompt="statisch, unscharf",
    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)
```

### Skript zur Batch-Generierung

```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 sonnenbeschienenen Fensterbank streckt, Staubpartikel schweben in der Luft",
    "Luftaufnahme von Wellen, die auf schwarzen Vulkansand brechen",
    "Zeitraffer von Sturmwolken, 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. **Geschwindigkeitsbenchmark** — auf einer RTX 4090 erzeugt LTX-Video 121 Frames in \~4 Sekunden; verwenden Sie dies als Plausibilitätsprüfung, dass Ihre gemietete Hardware korrekt funktioniert.
2. **bf16-Präzision** — der Checkpoint ist in bf16 trainiert; wechseln Sie nicht zu fp16, sonst riskieren Sie eine Verschlechterung der Qualität.
3. **Gewichte cachen** — setzen Sie `HF_HOME=/workspace/hf_cache` auf einem persistenten Volume. Das Modell ist \~6 GB groß; bei jedem Containerstart erneut herunterzuladen verschwendet Zeit.
4. **Prompt-Engineering** — LTX-Video reagiert gut auf Filmsprache: „Drohnenaufnahme“, „Zeitlupe“, „goldene Stunde“, „Tracking-Shot“. Seien Sie präzise bei der Kamerabewegung.
5. **Über Nacht in Serie** — LTX-Video ist schnell genug, um Hunderte von Clips pro Stunde auf einer 4090 zu erzeugen. Stellen Sie Prompts aus einer Datei in eine Warteschlange und lassen Sie es laufen.
6. **SSH + tmux** — führen Sie die Generierung immer innerhalb einer `tmux` Sitzung aus, damit getrennte Verbindungen lange Batch-Jobs nicht unterbrechen.
7. **VRAM überwachen** — `watch -n1 nvidia-smi` in einem zweiten Terminal, um sicherzustellen, dass Sie nicht auf Swap zugreifen.

## Fehlerbehebung

| Problem                               | Fix                                                                                                         |
| ------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError`                    | Reduziere `num_frames` auf 81 oder `Breite`/`Höhe` auf 512×320                                              |
| Modell nicht in diffusers gefunden    | Aktualisieren: `pip install -U diffusers` — LTXPipeline erfordert diffusers ≥ 0.32                          |
| Schwarze oder statische Ausgabe       | Stellen Sie sicher, dass Sie ein `negative_prompt`; erhöhen Sie `guidance_scale` auf 8–9                    |
| `ImportError: imageio`                | `pip install imageio[ffmpeg]` — ffmpeg-Backend für den MP4-Export erforderlich                              |
| Langsame erste Inferenz               | Beim ersten Lauf werden CUDA-Kerne kompiliert und Gewichte heruntergeladen; nachfolgende Läufe sind schnell |
| Farbbänderungsartefakte               | Verwende `torch.bfloat16` (nicht float16); bfloat16 hat einen größeren Dynamikbereich                       |
| Container mitten im Job neu gestartet | Setze `HF_HOME` auf persistentem Speicher; unvollständige HF-Downloads werden automatisch fortgesetzt       |


---

# 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-de/videogenerierung/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.