# SkyReels-V3

SkyReels-V3 Kunlun (SkyWork AI) का एक ओपन‑सोर्स वीडियो जनरेशन मॉडल है जो Wan2.1 वीडियो आर्किटेक्चर पर निर्मित है। यह टेक्स्ट‑टू‑वीडियो (T2V) और इमेज‑टू‑वीडियो (I2V) दोनों क्षमताओं के साथ स्मूद 24 fps क्लिप जेनरेट करता है। मॉडल Wan2.1 की मजबूत मोशन समन्वय और अस्थायी सुसंगति को विरासत में लेता है और बेहतर विज़ुअल गुणवत्ता और प्रॉम्प्ट पालन के लिए SkyWork के प्रशिक्षण परिष्कार जोड़ता है।

SkyReels-V3 को चलाना [Clore.ai](https://clore.ai/) आपको आवश्यक 24 GB VRAM बिना हार्डवेयर खरीदे एक्सेस करने देता है — RTX 4090 कुछ डॉलर पर किराये पर लें और जनरेशन शुरू करें।

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

* **24 fps आउटपुट** — बॉक्स से बाहर स्मूद, ब्रॉडकास्ट‑क्वालिटी फ्रेम रेट।
* **टेक्स्ट-टू-वीडियो** — प्राकृतिक भाषा विवरणों से क्लिप जेनरेट करें और प्रॉम्प्ट का अच्छी तरह पालन करें।
* **इमेज-टू-वीडियो** — संदर्भ छवि को नियंत्रित कैमरा मूवमेंट और विषय की गति के साथ एनिमेट करें।
* **Wan2.1 पर निर्मित** — Wan आर्किटेक्चर की सिद्ध अस्थायी अटेंशन और मोशन मॉडलिंग को विरासत में लेता है।
* **मल्टी‑रिज़ॉल्यूशन** — VRAM बजट के अनुसार 480p और 720p पर जेनरेशन का समर्थन करता है।
* **ओपन वेट्स** — शोध और वाणिज्यिक उपयोग के लिए ओपन लाइसेंस के तहत उपलब्ध।
* **चीनी + अंग्रेजी** — Wan2.1 टेक्स्ट एन्कोडर से द्विभाषी प्रॉम्प्ट समर्थन।

## आवश्यकताएँ

| घटक        | न्यूनतम                   | अनुशंसित |
| ---------- | ------------------------- | -------- |
| GPU VRAM   | 16 GB (ऑफलोड के साथ 480p) | 24 GB    |
| सिस्टम RAM | 32 GB                     | 64 GB    |
| डिस्क      | 25 GB                     | 50 GB    |
| Python     | 3.10+                     | 3.11     |
| CUDA       | 12.1+                     | 12.4     |

**Clore.ai GPU सिफारिश:** एक **RTX 4090** (24 GB, \~$0.5–2/दिन) मीठा स्थान है — पूर्ण प्रिसिजन पर 720p जेनरेशन के लिए पर्याप्त VRAM। एक **RTX 3090** (24 GB, \~$0.3–1/दिन) 480p के लिए काम करता है और मार्केटप्लेस पर प्रति‑क्लिप सर्वश्रेष्ठ मूल्य‑प्रति‑क्लिप अनुपात पेश करता है।

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

```bash
# मुख्य निर्भरताएँ इंस्टॉल करें
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
pip install diffusers transformers accelerate sentencepiece
pip install imageio[ffmpeg]

# GPU सत्यापित करें
python -c "import torch; print(torch.cuda.get_device_name(0))"
```

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

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

```python
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

# SkyReels-V3 Wan2.1 पाइपलाइन आर्किटेक्चर का उपयोग करता है
pipe = WanPipeline.from_pretrained(
    "SkyworkAI/SkyReels-V3-T2V",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = (
    "बांस के जंगल में सुबह की धुंध में चल रहा एक सामुराई, "
    "लंबे तनों के बीच से छनकर आती धूप, सिनेमैटिक कंपोज़िशन, "
    "धीरा और परिमार्जित गति"
)

video_frames = pipe(
    prompt=prompt,
    negative_prompt="ब्लरी, कम गुणवत्ता, वॉटरमार्क, स्टैटिक",
    num_frames=97,               # ~24 fps पर ~4 सेकंड
    width=1280,
    height=720,
    num_inference_steps=30,
    guidance_scale=5.0,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]

export_to_video(video_frames, "samurai_forest.mp4", fps=24)
print("samurai_forest.mp4 सहेजा गया")
```

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

```python
import torch
from PIL import Image
from diffusers import WanImageToVideoPipeline
from diffusers.utils import export_to_video

pipe = WanImageToVideoPipeline.from_pretrained(
    "SkyworkAI/SkyReels-V3-I2V",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

image = Image.open("landscape.png").resize((1280, 720))

video_frames = pipe(
    prompt="कैमरा धीरे‑धीरे सीन के अंदर की ओर आगे बढ़ता है, बादल ऊपर से बह रहे हैं",
    image=image,
    negative_prompt="स्टैटिक, झिलमिलाना, ब्लरी",
    num_frames=97,
    num_inference_steps=30,
    guidance_scale=5.0,
).frames[0]

export_to_video(video_frames, "landscape_anim.mp4", fps=24)
```

### निम्न‑रिज़ॉल्यूशन तेज़ प्रीव्यू

```python
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained(
    "SkyworkAI/SkyReels-V3-T2V", torch_dtype=torch.bfloat16
).to("cuda")

# तेज़ इटरेशन के लिए 480p
frames = pipe(
    prompt="पत्थरों पर टकराते महासागर की लहरें, नाटकीय स्प्रे, सूर्यास्त",
    num_frames=49,
    width=854,
    height=480,
    num_inference_steps=20,
    guidance_scale=5.0,
).frames[0]

export_to_video(frames, "waves_preview.mp4", fps=24)
```

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

1. **Wan पाइपलाइन क्लासेस का उपयोग करें** — SkyReels-V3 आर्किटेक्चरल रूप से Wan2.1 पर आधारित है, इसलिए यह उपयोग करता है `WanPipeline` / `WanImageToVideoPipeline` diffusers से।
2. **480p से शुरू करें** — पहले निचली रिज़ॉल्यूशन पर प्रॉम्प्ट के साथ इटरेट करें, फिर कंपोज़िशन से संतुष्ट होने पर अंतिम क्लिप 720p पर जेनरेट करें।
3. **CPU ऑफलोडिंग** — `enable_model_cpu_offload()` 720p जेनरेशन के लिए 24 GB कार्ड पर OOM से बचने के लिए अनुशंसित है।
4. **स्थायी स्टोरेज** — सेट करें `HF_HOME=/workspace/hf_cache` Clore.ai पर एक पर्सिस्टेंट वॉल्यूम पर; मॉडल का वजन \~15–20 GB है।
5. **24 fps नेटिव** — एक्सपोर्ट fps मत बदलें; मॉडल की अस्थायी अटेंशन 24 fps आउटपुट के लिए प्रशिक्षित थी।
6. **द्विभाषी प्रॉम्प्ट** — Wan2.1 टेक्स्ट एन्कोडर अंग्रेजी और चीनी दोनों संभालता है; यदि आवश्यक हो तो आप भाषाओं को मिश्रित कर सकते हैं।
7. **Guidance स्केल** — 4.0–6.0 सबसे अच्छा काम करता है। अधिक मान (>8) ओवरसैचुरेशन पैदा कर सकते हैं।
8. **tmux अनिवार्य है** — जेनरेशन हमेशा एक `tmux` Clore.ai पर सेशन में चलाएं ताकि SSH डिस्कनेक्ट्स से बचा जा सके।

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

| समस्या                                       | समाधान                                                                                                                           |
| -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` 720p पर                   | सक्षम करें `pipe.enable_model_cpu_offload()`; यदि अभी भी OOM है तो 480p पर घटाएँ                                                 |
| मॉडल HuggingFace पर नहीं मिला                | सटीक रिपो नाम की जांच करें [SkyworkAI HF पेज](https://huggingface.co/SkyworkAI) — यह किसी वैरिएंट नाम के तहत सूचीबद्ध हो सकता है |
| कंपकंपी या झिलमिलाती गति                     | बढ़ाएँ `num_inference_steps` को 40 तक; घटाएँ `guidance_scale` को 4.0 तक                                                          |
| धीमी जनरेशन                                  | RTX 4090 पर 720p के लिए \~4‑सेकंड क्लिप पर \~1–3 मिनट सामान्य है; 480p लगभग 2× तेज़ है                                           |
| रंग परिवर्तन / ओवरसैचुरेशन                   | कम करें `guidance_scale` को 4.0–5.0 तक                                                                                           |
| `ImportError: imageio`                       | `pip install imageio[ffmpeg]`                                                                                                    |
| रीस्टार्ट पर वेट्स फिर से डाउनलोड हो रहे हैं | पर्सिस्टेंट स्टोरेज माउंट करें और सेट करें `HF_HOME` पर्यावरण परिवर्तनीय                                                         |