Wan2.1 Video

Clore.ai GPUs पर Alibaba के Wan2.1 मॉडल के साथ वीडियो जेनरेट करें

CLORE.AI GPUs पर Alibaba के Wan2.1 टेक्स्ट-टू-वीडियो और इमेज-टू-वीडियो मॉडल से उच्च-गुणवत्ता वाले वीडियो जनरेट करें।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

क्यों Wan2.1?

• उच्च गुणवत्ता - उन्नत वीडियो जनरेशन

• कई मोड - टेक्स्ट-टू-वीडियो, इमेज-टू-वीडियो

• विभिन्न आकार - 1.3B से 14B पैरामीटर

• लंबे वीडियो - अधिकतम 81 फ्रेम तक

• ओपन वेट्स - Apache 2.0 लाइसेंस

मॉडल वेरिएंट

मॉडल	पैरामीटर	VRAM	रिज़ॉल्यूशन	फ्रेम्स
Wan2.1-T2V-1.3B	1.3B	8GB	480p	81
Wan2.1-T2V-14B	14B	24GB	720p	81
Wan2.1-I2V-14B	14B	24GB	720p	81

CLORE.AI पर त्वरित डिप्लॉय

Docker इमेज:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

पोर्ट:

22/tcp
7860/http

कमांड:

pip install diffusers transformers accelerate gradio && \
python -c "
import gradio as gr
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained('alibaba-pai/Wan2.1-T2V-1.3B', torch_dtype=torch.float16)
pipe.to('cuda')
pipe.enable_model_cpu_offload()

def generate(prompt, steps, frames, seed):
    generator = torch.Generator('cuda').manual_seed(seed) if seed > 0 else None
    output = pipe(prompt, num_frames=frames, num_inference_steps=steps, generator=generator)
    export_to_video(output.frames[0], 'output.mp4', fps=16)
    return 'output.mp4'

gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label='Prompt'),
        gr.Slider(20, 100, value=50, label='Steps'),
        gr.Slider(16, 81, value=49, step=8, label='Frames'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Video(),
    title='Wan2.1 - Text to Video'
).launch(server_name='0.0.0.0', server_port=7860)
"

अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना खोजें http_pub URL में मेरे ऑर्डर:

1. जाएँ मेरे ऑर्डर पृष्ठ

2. अपने ऑर्डर पर क्लिक करें

3. खोजें http_pub URL (उदा., abc123.clorecloud.net)

उपयोग करें https://YOUR_HTTP_PUB_URL की बजाय localhost नीचे दिए उदाहरणों में।

हार्डवेयर आवश्यकताएँ

मॉडल	न्यूनतम GPU	अनुशंसित	सर्वोत्तम
1.3B T2V	RTX 3070 8GB	RTX 3090 24GB	RTX 4090
14B T2V	RTX 4090 24GB	A100 40GB	A100 80GB
14B I2V	RTX 4090 24GB	A100 40GB	A100 80GB

इंस्टॉलेशन

pip install diffusers transformers accelerate torch

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

बुनियादी उपयोग (1.3B)

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

pipe = WanPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-T2V-1.3B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = "A cat playing with a ball in a sunny garden"

output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "cat_video.mp4", fps=16)

उच्च गुणवत्ता (14B)

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

pipe = WanPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-T2V-14B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

prompt = "Cinematic shot of a dragon flying over mountains at sunset, 4K, detailed"

output = pipe(
    prompt=prompt,
    negative_prompt="blurry, low quality, distorted",
    num_frames=81,
    height=720,
    width=1280,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "dragon.mp4", fps=24)

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

एक इमेज को एनिमेट करें

import torch
from diffusers import WanI2VPipeline
from diffusers.utils import load_image, export_to_video

pipe = WanI2VPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-I2V-14B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Load input image
image = load_image("input.jpg")

prompt = "The person in the image starts walking forward"

output = pipe(
    prompt=prompt,
    image=image,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "animated.mp4", fps=16)

Wan2.1-I2V-14B के साथ इमेज-टू-वीडियो

Wan2.1-I2V-14B स्थिर छवि को टेक्स्ट प्रॉम्प्ट के निर्देश से मूवमेंट के साथ एनिमेट करता है। आवश्यक है 24GB VRAM (RTX 4090 या A100 40GB की सिफारिश की जाती है).

मॉडल विवरण

संपत्ति	मान
मॉडल आईडी	Wan-AI/Wan2.1-I2V-14B-480P
पैरामीटर	14 बिलियन
आवश्यक VRAM	24GB
अधिकतम रिज़ॉल्यूशन	480p (854×480) या 720p (1280×720)
अधिकतम फ्रेम्स	81
लाइसेंस	Apache 2.0

हार्डवेयर आवश्यकताएँ

GPU	VRAM	स्थिति
RTX 4090	24GB	✅ अनुशंसित
RTX 3090	24GB	✅ समर्थित
A100 40GB	40GB	✅ इष्टतम
A100 80GB	80GB	✅ सर्वोत्तम गुणवत्ता
RTX 3080	10GB	❌ अपर्याप्त

त्वरित CLI स्क्रिप्ट

इसे के रूप में सहेजें generate_i2v.py और चलाएँ:

python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P --image input.jpg --prompt "camera slowly zooms out"

generate_i2v.py — पूर्ण स्क्रिप्ट

#!/usr/bin/env python3
"""
Wan2.1 इमेज-टू-वीडियो CLI स्क्रिप्ट।
उपयोग: python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P \
           --image input.jpg --prompt "camera slowly zooms out"
"""

import argparse
import os
पूर्ण कार्यशील उदाहरण
import torch
from diffusers import WanImageToVideoPipeline
from diffusers.utils import load_image, export_to_video
from PIL import Image


def parse_args():
    parser = argparse.ArgumentParser(description="Wan2.1 Image-to-Video Generator")
    parser.add_argument(
        "--model",
        type=str,
        default="Wan-AI/Wan2.1-I2V-14B-480P",
        help="Model ID from Hugging Face (default: Wan-AI/Wan2.1-I2V-14B-480P)",
    )
    parser.add_argument(
        "--image",
        type=str,
        required=True,
        help="Path to input image (JPEG or PNG)",
    )
    parser.add_argument(
        "--prompt",
        type=str,
        required=True,
        help='Text prompt describing the desired motion (e.g. "camera slowly zooms out")',
    )
    parser.add_argument(
        "--negative-prompt",
        type=str,
        default="blurry, low quality, distorted, jerky motion, artifacts",
        help="Negative prompt to avoid unwanted artifacts",
    )
    parser.add_argument(
        "--frames",
        type=int,
        default=49,
        help="Number of video frames to generate (default: 49, max: 81)",
    )
    parser.add_argument(
        "--steps",
        type=int,
        default=50,
        help="Number of diffusion steps (default: 50)",
    )
    parser.add_argument(
        "--guidance",
        type=float,
        default=7.0,
        help="Classifier-free guidance scale (default: 7.0)",
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=-1,
        help="Random seed for reproducibility (-1 = random)",
    )
    parser.add_argument(
        "--fps",
        type=int,
        default=16,
        help="Output video FPS (default: 16)",
    )
    parser.add_argument(
        "--output",
        type=str,
        default="output_i2v.mp4",
        help="Output video file path (default: output_i2v.mp4)",
    )
    parser.add_argument(
        "--height",
        type=int,
        default=480,
        help="Output video height in pixels (default: 480)",
    )
    parser.add_argument(
        "--width",
        type=int,
        default=854,
        help="Output video width in pixels (default: 854)",
    )
    parser.add_argument(
        "--cpu-offload",
        action="store_true",
        default=True,
        help="Enable model CPU offloading to save VRAM (default: True)",
    )
    parser.add_argument(
        "--vae-tiling",
        action="store_true",
        default=False,
        help="Enable VAE tiling for high-resolution outputs",
    )
    return parser.parse_args()


def load_and_resize_image(image_path: str, width: int, height: int) -> Image.Image:
    """Load image from path and resize to target dimensions."""
    if not os.path.exists(image_path):
        print(f"[ERROR] Image not found: {image_path}", file=sys.stderr)
        sys.exit(1)

    img = Image.open(image_path).convert("RGB")
    original_size = img.size
    img = img.resize((width, height), Image.LANCZOS)
    print(f"[INFO] Loaded image: {image_path} ({original_size[0]}x{original_size[1]}) → resized to {width}x{height}")
    return img


def load_pipeline(model_id: str, cpu_offload: bool, vae_tiling: bool):
    """Load the Wan I2V pipeline with memory optimizations."""
    print(f"[INFO] Loading model: {model_id}")
    print(f"[INFO] CUDA available: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        vram_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
        print(f"[INFO] GPU: {torch.cuda.get_device_name(0)} ({vram_gb:.1f} GB VRAM)")
        if vram_gb < 23:
            print("[WARN] Less than 24GB VRAM detected — enable --cpu-offload or use the 1.3B model")

    pipe = WanImageToVideoPipeline.from_pretrained(
        model_id,
        torch_dtype=torch.float16,
    )

    if cpu_offload:
        print("[INFO] Enabling model CPU offload")
        pipe.enable_model_cpu_offload()
    else:
        pipe.to("cuda")

    if vae_tiling:
        print("[INFO] Enabling VAE tiling for high-res generation")
        pipe.enable_vae_tiling()

    return pipe


def generate_video(pipe, args) -> None:
    """Run the I2V pipeline and save the output video."""
    image = load_and_resize_image(args.image, args.width, args.height)

    generator = None
    if args.seed >= 0:
        generator = torch.Generator("cuda").manual_seed(args.seed)
        print(f"[INFO] Using seed: {args.seed}")
    else:
        print("[INFO] Using random seed")

    print(f"[INFO] Generating {args.frames} frames at {args.width}x{args.height}")
    print(f"[INFO] Steps: {args.steps} | Guidance: {args.guidance} | FPS: {args.fps}")
    print(f"[INFO] Prompt: {args.prompt}")

    output = pipe(
        prompt=args.prompt,
        negative_prompt=args.negative_prompt,
        image=image,
        num_frames=args.frames,
        height=args.height,
        width=args.width,
        num_inference_steps=args.steps,
        guidance_scale=args.guidance,
        generator=generator,
    )

    export_to_video(output.frames[0], args.output, fps=args.fps)
    print(f"[INFO] Video saved to: {os.path.abspath(args.output)}")
    duration = args.frames / args.fps
    print(f"[INFO] Duration: {duration:.1f}s at {args.fps}fps ({args.frames} frames)")


def main():
    args = parse_args()

    if not torch.cuda.is_available():
        print("[ERROR] CUDA GPU not found. Wan2.1-I2V-14B requires a CUDA-capable GPU.", file=sys.stderr)
        sys.exit(1)

    pipe = load_pipeline(args.model, args.cpu_offload, args.vae_tiling)
    generate_video(pipe, args)
    print("[DONE] Image-to-video generation complete!")


if __name__ == "__main__":
    main()

उन्नत I2V पाइपलाइन (Python API)

import torch
from diffusers import WanImageToVideoPipeline
from diffusers.utils import load_image, export_to_video
from PIL import Image

# ── पाइपलाइन लोड करें ──────────────────────────────────────────────────────────────
pipe = WanImageToVideoPipeline.from_pretrained(
    "Wan-AI/Wan2.1-I2V-14B-480P",
    torch_dtype=torch.float16,
)
pipe.enable_model_cpu_offload()   # VRAM को 24GB से कम रखने में मदद करता है
pipe.enable_vae_tiling()          # वैकल्पिक: 720p के लिए सहायक

# ── इनपुट इमेज लोड और तैयार करें ─────────────────────────────────────────────────
image = load_image("input.jpg").resize((854, 480))

# ── जनरेट करें ───────────────────────────────────────────────────────────────────
prompt = "camera slowly zooms out, revealing the full landscape"
negative_prompt = "blurry, low quality, distorted, flickering, artifacts"

generator = torch.Generator("cuda").manual_seed(42)

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=image,
    num_frames=49,          # ~3 सेकंड 16fps पर
    height=480,
    width=854,
    num_inference_steps=50,
    guidance_scale=7.5,
    generator=generator,
)

export_to_video(output.frames[0], "i2v_output.mp4", fps=16)
print("Saved: i2v_output.mp4")

I2V प्रॉम्प्ट टिप्स

लक्ष्य	प्रॉम्प्ट उदाहरण
कैमरा मूवमेंट	"camera slowly zooms out from the subject"
पैरालैक्स इफ़ेक्ट	"subtle parallax motion, depth of field shift"
किरदार एनिमेशन	"the figure turns their head and smiles"
प्रकृति एनिमेशन	"leaves rustle in a gentle breeze, light shifts"
अमूर्त मूवमेंट	"colors swirl and blend, fluid motion"

I2V के लिए मेमोरी टिप्स (24GB GPUs)

# 24GB GPUs पर अनिवार्य
pipe.enable_model_cpu_offload()

# वैकल्पिक: पीक VRAM ~10% कम करता है
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# रन के बीच साफ़ करें
import gc
gc.collect()
torch.cuda.empty_cache()

प्रॉम्प्ट उदाहरण

प्रकृति और परिदृश्य

prompts = [
    "Time-lapse of clouds moving over mountain peaks, dramatic lighting",
    "Ocean waves crashing on rocks, slow motion, cinematic",
    "Northern lights dancing in the night sky, vibrant colors",
    "Forest in autumn with leaves falling, peaceful atmosphere"
]

जानवर और किरदार

prompts = [
    "A golden retriever running through a field of flowers",
    "A butterfly emerging from its cocoon, macro shot",
    "Samurai warrior drawing sword, dramatic lighting",
    "Robot walking through futuristic city streets"
]

Abstract & Artistic

prompts = [
    "Colorful paint swirling in water, abstract art",
    "Geometric shapes transforming and morphing, neon colors",
    "Ink drops spreading in milk, macro photography"
]

उन्नत सेटिंग्स

गुणवत्ता बनाम गति

# तेज प्रीव्यू
output = pipe(
    prompt=prompt,
    num_frames=17,
    num_inference_steps=25,
    guidance_scale=5.0
)

# संतुलित
output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

# अधिकतम गुणवत्ता
output = pipe(
    prompt=prompt,
    num_frames=81,
    num_inference_steps=100,
    guidance_scale=7.5
)

रिज़ॉल्यूशन विकल्प

# 480p (1.3B मॉडल)
output = pipe(prompt, height=480, width=854, num_frames=49)

# 720p (14B मॉडल)
output = pipe(prompt, height=720, width=1280, num_frames=49)

# 1080p (14B मॉडल, उच्च VRAM)
output = pipe(prompt, height=1080, width=1920, num_frames=33)

बैच जनरेशन

import os
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompts = [
    "A rocket launching into space",
    "Fish swimming in coral reef",
    "Rain falling on a city street at night"
]

output_dir = "./videos"
os.makedirs(output_dir, exist_ok=True)

for i, prompt in enumerate(prompts):
    print(f"Generating {i+1}/{len(prompts)}: {prompt[:40]}...")

    output = pipe(
        prompt=prompt,
        num_frames=49,
        num_inference_steps=50
    )

    export_to_video(output.frames[0], f"{output_dir}/video_{i:03d}.mp4", fps=16)
    torch.cuda.empty_cache()

Gradio इंटरफ़ेस

import gradio as gr
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video
import tempfile

pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

def generate_video(prompt, negative_prompt, frames, steps, guidance, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    output = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_frames=frames,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    )

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        export_to_video(output.frames[0], f.name, fps=16)
        return f.name

demo = gr.Interface(
    fn=generate_video,
    inputs=[
        gr.Textbox(label="Prompt", lines=2),
        gr.Textbox(label="Negative Prompt", value="blurry, low quality"),
        gr.Slider(17, 81, value=49, step=8, label="Frames"),
        gr.Slider(20, 100, value=50, step=5, label="Steps"),
        gr.Slider(3, 12, value=7, step=0.5, label="Guidance"),
        gr.Number(value=-1, label="Seed")
    ],
    outputs=gr.Video(label="Generated Video"),
    title="Wan2.1 - Text to Video Generation",
    description="टेक्स्ट प्रॉम्प्ट से वीडियो जनरेट करें। CLORE.AI पर चल रहा है."
)

demo.launch(server_name="0.0.0.0", server_port=7860)

मेमोरी अनुकूलन

# सभी ऑप्टिमाइज़ेशन सक्षम करें
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# बहुत कम VRAM के लिए
pipe.enable_sequential_cpu_offload()

# जेनरेशन के बीच कैश साफ़ करें
torch.cuda.empty_cache()

प्रदर्शन

मॉडल	रिज़ॉल्यूशन	फ्रेम्स	GPU	समय
1.3B	480p	49	RTX 4090	~2 मिनट
1.3B	480p	49	A100 40GB	~1.5 मिनट
14B	720p	49	A100 40GB	~5 मिनट
14B	720p	81	A100 80GB	~8 मिनट

लागत अनुमान

सामान्य CLORE.AI मार्केटप्लेस दरें:

GPU	घंटात्मक दर	~49 फ्रेम वीडियो/घंटा
RTX 3090 24GB	~$0.06	~20 (1.3B)
RTX 4090 24GB	~$0.10	~30 (1.3B)
A100 40GB	~$0.17	~40 (1.3B) / ~12 (14B)
A100 80GB	~$0.25	~8 (14B उच्च-रिज़ॉल्यूशन)

कीमतें भिन्न होती हैं। जाँच करें CLORE.AI मार्केटप्लेस वर्तमान दरों के लिए।

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

आउट ऑफ़ मेमोरी

# छोटे मॉडल का उपयोग करें
pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B")

# सभी ऑप्टिमाइज़ेशन सक्षम करें
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# फ्रेम्स घटाएं
output = pipe(prompt, num_frames=17)

# रिज़ॉल्यूशन घटाएँ
output = pipe(prompt, height=480, width=854)

खराब गुणवत्ता

• स्टेप्स बढ़ाएँ (75-100)

• और अधिक विस्तृत प्रॉम्प्ट लिखें

• नेगेटिव प्रॉम्प्ट का उपयोग करें

• बेहतर गुणवत्ता के लिए 14B मॉडल आज़माएँ

वीडियो बहुत छोटा है

• बढ़ाएँ num_frames (अधिकतम 81)

• फ्रेम इंटरपोलिशन के लिए RIFE इंटरपोलेशन का उपयोग करें

• कई जेनरेशन चेन करें

आर्टिफैक्ट्स/फ्लिकरिंग

• guidance scale बढ़ाएँ

• सुसंगतता के लिए फिक्स्ड सीड उपयोग करें

• वीडियो स्थिरीकरण से पोस्ट-प्रोसेस करें

Wan2.1 बनाम अन्य

फ़ीचर	Wan2.1	Hunyuan	SVD	CogVideoX
गुणवत्ता	उत्कृष्ट	उत्कृष्ट	अच्छा	बहुत अच्छा
स्पीड	तेज़	मध्यम	तेज़	धीमा
अधिकतम फ्रेम्स	81	129	25	49
रिज़ॉल्यूशन	720p	720p	576p	720p
I2V समर्थन	हां	हां	हां	हां
लाइसेंस	Apache 2.0	खोलें	खोलें	खोलें

कब Wan2.1 का उपयोग करें:

• ओपन-सोर्स वीडियो जनरेशन चाहिए

• तेज़ जनरेशन स्पीड चाहिये

• Apache 2.0 लाइसेंस आवश्यक है

• संतुलित गुणवत्ता/गति चाहिए

अगले कदम

• Hunyuan Video - वैकल्पिक T2V

• OpenSora - Open Sora विकल्प

• Stable Video Diffusion - इमेज एनिमेशन

• RIFE इंटरपोलेशन - फ्रेम इंटरपोलेशन