OpenSora

OpenSora, ओपन-सोर्स Sora विकल्प के साथ वीडियो जेनरेट करें

नए विकल्प उपलब्ध! FramePack सिर्फ 6GB VRAM के साथ वीडियो उत्पन्न करता है, Wan2.1 श्रेष्ठ गुणवत्ता प्रदान करता है, और LTX-2 देशी ऑडियो जेनरेशन जोड़ता है।

CLORE.AI GPUs पर OpenSora, ओपन-सोर्स Sora विकल्प का उपयोग करके वीडियो जनरेट करें।

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

OpenSora क्यों?

• ओपन सोर्स - पूर्ण Apache 2.0 लाइसेंस

• Sora-प्रेरित - OpenAI के Sora की तरह DiT आर्किटेक्चर

• स्केलेबल - कई मॉडल आकार और रिज़ॉल्यूशन

• लंबे वीडियो - 16 सेकंड तक जेनरेट करें

• सक्रिय विकास - नियमित अपडेट और सुधार

मॉडल वेरिएंट

मॉडल	रिज़ॉल्यूशन	अवधि	VRAM	गुणवत्ता
OpenSora 1.2	720p	16s	24GB	उत्कृष्ट
OpenSora 1.1	480p	8s	16GB	अच्छा
OpenSora 1.0	256p	4s	8GB	बेसिक
Open-Sora-Plan	512p	10s	20GB	बहुत अच्छा

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

Docker इमेज:

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

पोर्ट:

22/tcp
7860/http

कमांड:

git clone https://github.com/hpcaitech/Open-Sora && \
cd Open-Sora && \
pip install -e . && \
pip install gradio && \
python scripts/inference.py \
    --prompt "A cat playing with yarn" \
    --num-frames 51 \
    --resolution 480p \
    --save-dir ./outputs

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

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

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

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

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

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

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

मॉडल संस्करण	न्यूनतम GPU	अनुशंसित	सर्वोत्तम
OpenSora 1.0	RTX 3070 8GB	RTX 3090 24GB	RTX 4090
OpenSora 1.1	RTX 3090 16GB	RTX 4090 24GB	A100 40GB
OpenSora 1.2	RTX 4090 24GB	A100 40GB	A100 80GB

इंस्टॉलेशन

स्रोत से

git clone https://github.com/hpcaitech/Open-Sora
cd Open-Sora

# निर्भरताएँ इंस्टॉल करें
pip install -e .

# मॉडल वेट्स डाउनलोड करें
python scripts/download_weights.py --version 1.2

pip का उपयोग

pip install opensora

मूल उपयोग

कमांड लाइन

# सरल जनरेशन
python scripts/inference.py \
    --prompt "A beautiful sunset over the ocean, cinematic" \
    --num-frames 51 \
    --resolution 480p \
    --save-dir ./outputs

# उच्च गुणवत्ता
python scripts/inference.py \
    --prompt "A majestic eagle soaring through clouds" \
    --num-frames 102 \
    --resolution 720p \
    --num-sampling-steps 100 \
    --save-dir ./outputs

Python API

import torch
from opensora.models import OpenSoraModel
from opensora.utils import export_to_video

# मॉडल लोड करें
model = OpenSoraModel.from_pretrained("hpcaitech/OpenSora-v1.2")
model.to("cuda")

# वीडियो जनरेट करें
prompt = "A rocket launching into space, dramatic lighting, cinematic"

video = model.generate(
    prompt=prompt,
    num_frames=51,
    height=480,
    width=854,
    num_inference_steps=50,
    guidance_scale=7.0
)

# सहेजें
export_to_video(video, "rocket.mp4", fps=24)

उन्नत जेनरेशन

निगेटिव प्रॉम्प्ट के साथ

video = model.generate(
    prompt="Professional photography of a tiger in the wild",
    negative_prompt="blurry, low quality, distorted, artifacts",
    num_frames=51,
    num_inference_steps=75,
    guidance_scale=7.5
)

लंबे वीडियो

# 24fps पर 16 सेकंड जेनरेट करें
video = model.generate(
    prompt="Time-lapse of flowers blooming in a garden",
    num_frames=384,  # 16 seconds at 24fps
    height=480,
    width=854,
    num_inference_steps=100
)

export_to_video(video, "timelapse.mp4", fps=24)

उच्च रिज़ॉल्यूशन

# 720p जेनरेशन (अधिक VRAM की आवश्यकता)
video = model.generate(
    prompt="Aerial view of a city at night with lights",
    num_frames=51,
    height=720,
    width=1280,
    num_inference_steps=75
)

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

सिनेमैटिक

prompts = [
    "Cinematic shot of a samurai drawing his sword, dramatic lighting, 4K",
    "Epic wide shot of a castle on a cliff during a storm",
    "Slow motion of water droplets falling into a still pond",
    "Tracking shot through a neon-lit cyberpunk alley at night"
]

प्रकृति

prompts = [
    "Aurora borealis dancing over snowy mountains, time-lapse",
    "Macro shot of a butterfly emerging from cocoon",
    "Ocean waves crashing on volcanic rocks at sunset",
    "Fog rolling through an ancient forest at dawn"
]

Abstract

prompts = [
    "Colorful paint drops falling into water, slow motion",
    "Fractals evolving and transforming, psychedelic colors",
    "Liquid metal morphing into different shapes"
]

कॉन्फ़िगरेशन विकल्प

रिज़ॉल्यूशन प्रीसेट

resolutions = {
    "256p": (256, 455),
    "360p": (360, 640),
    "480p": (480, 854),
    "720p": (720, 1280),
    "1080p": (1080, 1920)  # उच्च VRAM आवश्यक
}

गुणवत्ता सेटिंग्स

# तेज प्रीव्यू
config_fast = {
    "num_frames": 25,
    "num_inference_steps": 25,
    "guidance_scale": 5.0
}

# संतुलित
config_balanced = {
    "num_frames": 51,
    "num_inference_steps": 50,
    "guidance_scale": 7.0
}

# अधिकतम गुणवत्ता
config_quality = {
    "num_frames": 102,
    "num_inference_steps": 100,
    "guidance_scale": 7.5
}

Gradio इंटरफ़ेस

import gradio as gr
import torch
from opensora.models import OpenSoraModel
from opensora.utils import export_to_video
import tempfile

model = OpenSoraModel.from_pretrained("hpcaitech/OpenSora-v1.2")
model.to("cuda")

def generate_video(prompt, negative_prompt, frames, steps, guidance, resolution, seed):
    res_map = {"480p": (480, 854), "720p": (720, 1280)}
    height, width = res_map.get(resolution, (480, 854))

    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    video = model.generate(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_frames=frames,
        height=height,
        width=width,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    )

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        export_to_video(video, f.name, fps=24)
        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(25, 200, value=51, step=1, label="फ्रेम्स"),
        gr.Slider(20, 150, value=50, step=5, label="स्टेप्स"),
        gr.Slider(3, 15, value=7, step=0.5, label="गाइडेंस"),
        gr.Dropdown(["480p", "720p"], value="480p", label="रिज़ॉल्यूशन"),
        gr.Number(value=-1, label="Seed")
    ],
    outputs=gr.Video(label="Generated Video"),
    title="OpenSora - टेक्स्ट से वीडियो",
    description="OpenSora का उपयोग करके वीडियो जेनरेट करें। CLORE.AI पर चल रहा है."
)

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

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

# मेमोरी अनुकूलन सक्षम करें
model.enable_model_cpu_offload()
model.enable_vae_tiling()

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

# निम्न प्रिसीजन का उपयोग करें
model = OpenSoraModel.from_pretrained(
    "hpcaitech/OpenSora-v1.2",
    torch_dtype=torch.float16
)

बैच जनरेशन

import os

prompts = [
    "A phoenix rising from flames",
    "Rain falling on city streets at night",
    "Flowers blooming time-lapse",
    "Northern lights over mountains"
]

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]}...")

    video = model.generate(
        prompt=prompt,
        num_frames=51,
        num_inference_steps=50
    )

    export_to_video(video, f"{output_dir}/video_{i:03d}.mp4", fps=24)

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

प्रदर्शन

रिज़ॉल्यूशन	फ्रेम्स	स्टेप्स	GPU	समय
480p	51	50	RTX 4090	~3 min
480p	51	50	A100 40GB	~2 मिनट
720p	51	50	A100 40GB	~5 मिनट
720p	102	100	A100 80GB	~15 min

लागत अनुमान

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

GPU	घंटात्मक दर	~51 frame 480p videos/hour
RTX 4090 24GB	~$0.10	~15-20
A100 40GB	~$0.17	~25-30
A100 80GB	~$0.25	~35 (can do 720p)

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

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

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

# छोटी रिज़ॉल्यूशन का उपयोग करें
python scripts/inference.py --resolution 360p --num-frames 25

# CPU ऑफलोड सक्षम करें
python scripts/inference.py --cpu-offload

# बैच साइज घटाएँ
python scripts/inference.py --batch-size 1

धीमा जनरेशन

• घटाएँ num_inference_steps (30-50 often enough)

• प्रिव्यू के लिए निम्न रिज़ॉल्यूशन का उपयोग करें

• सुनिश्चित करें कि GPU उपयोग में है (जांचें nvidia-smi)

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

• स्टेप्स को 75-100 तक बढ़ाएँ

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

• आर्टिफैक्ट्स के लिए निगेटिव प्रॉम्प्ट जोड़ें

• विभिन्न गाइडेंस स्केल आज़माएँ (5-10)

वीडियो आर्टिफैक्ट्स

• गाइडेंस स्केल कम करें

• इन्फरेंस स्टेप्स बढ़ाएँ

• टेम्पोरल स्मूथिंग का उपयोग करें

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

OpenSora बनाम अन्य

फ़ीचर	OpenSora 1.2	Hunyuan	Wan2.1	SVD
आर्किटेक्चर	DiT	DiT	DiT	U-Net
अधिकतम अवधि	16s	5s	5s	4s
अधिकतम रिज़ॉल्यूशन	720p	720p	720p	576p
गुणवत्ता	बहुत अच्छा	उत्कृष्ट	उत्कृष्ट	अच्छा
स्पीड	मध्यम	धीमा	तेज़	तेज़
लाइसेंस	Apache 2.0	खोलें	Apache 2.0	खोलें

OpenSora का उपयोग करें जब:

• लंबा वीडियो जनरेशन चाहिए

• पूर्ण Apache 2.0 लाइसेंस चाहते हैं

• Sora-जैसी आर्किटेक्चर में रुचि हो

• सक्रिय समुदाय समर्थन चाहिए

Open-Sora-Plan विकल्प

एक और ओपन-सोर्स विकल्प:

git clone https://github.com/PKU-YuanGroup/Open-Sora-Plan
cd Open-Sora-Plan
pip install -e .

python scripts/inference.py \
    --prompt "Your prompt here" \
    --output video.mp4

अगले कदम

• Hunyuan Video - उच्च गुणवत्ता T2V

• Wan2.1 Video - तेज़ जेनरेशन

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

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