> 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-hi/video-generation/skyreels.md).

# SkyReels-V3

Clore.ai GPUs पर SkyReels-V3, Kunlun का Wan2.1-आधारित ओपन वीडियो मॉडल, के साथ 24fps वीडियो जनरेट करें।

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

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

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

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

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

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

**Clore.ai GPU अनुशंसा:** एक **RTX 4090** (24 GB, $0.14–0.42/घंटा) सबसे उपयुक्त विकल्प है — पूर्ण परिशुद्धता पर 720p जनरेशन के लिए पर्याप्त VRAM। एक **RTX 3090** (24 GB, $0.07–0.21/घंटा) 480p के लिए काम करता है और मार्केटप्लेस पर प्रति-क्लिप सर्वोत्तम मूल्य अनुपात देता है।

## त्वरित शुरुआत

```bash
# मुख्य निर्भरताएँ इंस्टॉल करें
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
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()` OOM से बचने के लिए 24 GB कार्ड्स पर 720p जनरेशन के लिए अनुशंसित है।
4. **स्थायी स्टोरेज** — सेट करें `HF_HOME=/workspace/hf_cache` Clore.ai पर्सिस्टेंट वॉल्यूम पर; मॉडल का आकार लगभग 15–20 GB है।
5. **मूल 24 fps** — एक्सपोर्ट fps न बदलें; मॉडल का temporal attention 24 fps आउटपुट के लिए प्रशिक्षित है।
6. **द्विभाषी प्रॉम्प्ट्स** — Wan2.1 टेक्स्ट एन्कोडर अंग्रेज़ी और चीनी दोनों को संभालता है; आवश्यकता होने पर आप भाषाएँ मिला सकते हैं।
7. **गाइडेंस स्केल** — 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 पर 4-सेकंड की क्लिप के लिए \~1–3 मिनट 720p पर सामान्य है; 480p लगभग 2× तेज है                                       |
| रंग परिवर्तन / अति-संतृप्ति                   | कम करें `guidance_scale` को 4.0–5.0 तक                                                                                       |
| `ImportError: imageio`                        | `pip install imageio[ffmpeg]`                                                                                                |
| रीस्टार्ट पर वेट्स फिर से डाउनलोड हो जाते हैं | पर्सिस्टेंट स्टोरेज माउंट करें और सेट करें `HF_HOME` environment variable                                                    |


---

# 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-hi/video-generation/skyreels.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.