LTX-Video Echtzeit-Generierung

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

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

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

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

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

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