LTX-Video रीयल-टाइम जनरेशन

Clore.ai GPUs पर Lightricks के LTX-Video के साथ वास्तविक-समय से तेज़ 5-सेकंड वीडियो जेनरेट करें।

LTX-Video by Lightricks सबसे तेज़ ओपन-सोर्स वीडियो जनरेशन मॉडल है। एक RTX 4090 पर यह लगभग 4 सेकंड में 5-सेकंड का 768×512 क्लिप उत्पन्न करता है — वास्तविक-समय प्लेबैक से तेज। मॉडल टेक्स्ट-टू-वीडियो (T2V) और इमेज-टू-वीडियो (I2V) वर्कफ़्लो दोनों के लिए नेटिव के माध्यम से समर्थन करता है diffusers इंटीग्रेशन द्वारा LTXPipeline और LTXImageToVideoPipeline.

GPU किराए पर लेना Clore.ai आपको LTX-Video को आवश्यक हार्डवेयर का तात्कालिक एक्सेस देता है, बिना अग्रिम निवेश और प्रति-घंटा बिलिंग के।

प्रमुख विशेषताएँ

• वास्तविक-समय से तेज — RTX 4090 पर ~4 सेकंड में 5-सेकंड वीडियो जनरेट किया गया।

• टेक्स्ट-टू-वीडियो — प्राकृतिक भाषा विवरणों से क्लिप उत्पन्न करें।

• इमेज-टू-वीडियो — एक स्थिर संदर्भ छवि को गति और कैमरा नियंत्रण के साथ एनिमेट करें।

• हल्का आर्किटेक्चर — कॉम्पैक्ट लेटेंट स्पेस के साथ 2B पैरामीटर वीडियो DiT।

• नेटिव diffusers — LTXPipeline और LTXImageToVideoPipeline में diffusers >= 0.32.

• ओपन वेट्स — Apache-2.0 लाइसेंस; पूर्ण वाणिज्यिक उपयोग की अनुमति है।

• टेम्पोरल VAE — स्थान और समय में 1:192 संपीड़न अनुपात; कुशल डिकोडिंग।

आवश्यकताएँ

घटक	न्यूनतम	अनुशंसित
GPU VRAM	16 GB	24 GB
सिस्टम RAM	16 GB	32 GB
डिस्क	15 GB	30 GB
Python	3.10+	3.11
CUDA	12.1+	12.4
diffusers	0.32+	नवीनतम

Clore.ai GPU सिफारिश: एक RTX 4090 (24 GB, ~$0.5–2/दिन) अधिकतम थ्रूपुट के लिए आदर्श है। एक RTX 3090 (24 GB, ~$0.3–1/दिन) तब भी कई प्रतिस्पर्धी मॉडलों की तुलना में बहुत कम लागत पर तेज़ चलता है।

त्वरित प्रारम्भ

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

उपयोग के उदाहरण

टेक्स्ट-टू-वीडियो

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 = (
    "एक फ़्लेमेंटीन कोरल रीफ के ऊपर से ग्लाइड करते हुए एक ड्रोन शॉट,"
    "नीचे तैरते उष्णकटिबंधीय मछलियों के झुंड, सुनहरी घड़ी की रोशनी "
    "पानी की सतह के माध्यम से-विकिरणित"
)

video_frames = pipe(
    prompt=prompt,
    negative_prompt="blurry, low quality, distorted",
    num_frames=121,               # ~5 सेकंड पर 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")

इमेज-टू-वीडियो

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="कैमरा धीरे-धीरे दायाँ पैन करता है, शहर की रोशनी सांध्याकाल में जल उठती हैं",
    negative_prompt="स्टैटिक, धुंधला",
    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)

बैच जनरेशन स्क्रिप्ट

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 = [
    "सूर्यप्रकाश वाली खिड़की पर खिंचते हुए एक बिल्ली, धूल कण तैरते हुए",
    "काले ज्वालामुखीय बालू पर लहरों के टकराने का हवाई दृश्य",
    "एक प्रेरी पर तूफानी बादलों के लंगेन का टाइम-लैप्स",
]

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)}] पूरा")

Clore.ai उपयोगकर्ताओं के लिए सुझाव

1. स्पीड बेंचमार्क — RTX 4090 पर, LTX-Video ~4 सेकंड में 121 फ्रेम जनरेट करता है; इसे एक सत्यापन के रूप में उपयोग करें कि आपकी रेंटल सही तरीके से प्रदर्शन कर रही है।

2. bf16 प्रिसिशन — चेकपॉइंट bf16 में प्रशिक्षित है; fp16 पर स्विच न करें अन्यथा आप गुणवत्ता में गिरावट का जोखिम उठाएंगे।

3. वेट्स को कैश करें — सेट करें HF_HOME=/workspace/hf_cache एक परसिस्टेंट वॉल्यूम पर। मॉडल ~6 GB है; हर कंटेनर स्टार्ट पर फिर से डाउनलोड करना समय बर्बाद करता है।

4. प्रॉम्प्ट इंजीनियरिंग — LTX-Video सिनेमाई भाषा पर अच्छी प्रतिक्रिया देता है: "drone shot", "slow motion", "golden hour", "tracking shot"। कैमरा मूवमेंट के बारे में विशिष्ट रहें।

5. रात भर बैच — LTX-Video एक 4090 पर प्रति घंटे सैकड़ों क्लिप जनरेट करने के लिए तेज़ है। प्रॉम्प्ट्स को फ़ाइल से कतारबद्ध करें और इसे चलने दें।

6. SSH + tmux — हमेशा जनरेशन को एक tmux सेशन के अंदर चलाएं ताकि कटती कनेक्शन्स लंबे बैच जॉब्स को बाधित न करें।

7. VRAM पर निगरानी रखें — watch -n1 nvidia-smi दूसरे टर्मिनल में यह सुनिश्चित करने के लिए कि आप स्वैप पर नहीं पहुँच रहे हैं।

समस्याओं का निवारण

समस्या	समाधान
OutOfMemoryError	घटाएँ num_frames को 81 या चौड़ाई/ऊँचाई को 512×320 करें
मॉडल diffusers में नहीं मिला	अपग्रेड: pip install -U diffusers — LTXPipeline को diffusers ≥ 0.32 की आवश्यकता है
काला या स्थिर आउटपुट	सुनिश्चित करें कि आप एक negative_prompt; बढ़ाएँ guidance_scale को 8–9 तक
ImportError: imageio	pip install imageio[ffmpeg] — MP4 एक्सपोर्ट के लिए ffmpeg बैकएंड आवश्यक है
पहली इनफेरेंस धीमी	पहला रन CUDA कर्नेल कम्पाइल करता है और वेट डाउनलोड करता है; बाद के रन तेज़ होते हैं
रंग बैंडिंग आर्टिफैक्ट्स	उपयोग करें torch.bfloat16 (float16 नहीं); bfloat16 की डायनेमिक रेंज व्यापक है
कंटेनर मिड-जॉब में रिस्टार्ट हुआ	सेट करें HF_HOME परसिस्टेंट स्टोरेज पर; आंशिक HF डाउनलोड स्वतः फिर से सुरु हो जाते हैं