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

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

GPU किराए पर लेना [Clore.ai](https://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/दिन) तब भी कई प्रतिस्पर्धी मॉडलों की तुलना में बहुत कम लागत पर तेज़ चलता है।

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

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

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

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

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

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

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

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

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

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

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 डाउनलोड स्वतः फिर से सुरु हो जाते हैं |