CubeComposer 4K 360° वीडियो

CubeComposer (CVPR 2026) एक स्पैटियो-टेम्पोरल ऑटोरिग्रेसिव डिफ्यूज़न मॉडल है जो उत्पन्न करता है मूल 4K 360° पैनोरामिक वीडियो मानक परिप्रेक्ष्य वीडियो इनपुट से। Wan वीडियो फाउंडेशन मॉडल पर निर्मित, 11,832 उच्च-रिज़ॉल्यूशन क्लिप्स पर प्रशिक्षित। यह पहला ओपन मॉडल है जो मूल 4K 360° जनरेशन में सक्षम है — जिससे उपभोक्ता GPU हार्डवेयर पर VR कंटेंट निर्माण, वर्चुअल टूर और इमर्सिव मीडिया संभव होता है।

यह क्यों महत्वपूर्ण है

360° वीडियो के लिए पारंपरिक रूप से विशेष कैप्चर रिग्स (कई कैमरे, स्टिचिंग सॉफ़्टवेयर, महंगी पोस्ट-प्रोसेसिंग) की आवश्यकता होती रही है। CubeComposer इसे बदल देता है:

इनपुट: कोई भी मानक कैमरा वीडियो (सिंगल-लेंस, फ़ोन कैमरा, डैशकैम)
आउटपुट: मूल 4K 360° इक्विरेक्टैंगुलर वीडियो
विधि: पैनोरामा को क्यूबमैप फ़ेस में विभाजित करता है, और स्थानिक संगति के साथ प्रत्येक फ़ेस को ऑटोरिग्रेसिव तरीके से जनरेट करता है
गुणवत्ता: पिछले स्टिचिंग और आउटपेंटिंग तरीकों की तुलना में काफी बेहतर प्रदर्शन करता है

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

कॉन्फ़िग

VRAM

रिज़ॉल्यूशन

गति

RTX 4090 24GB

24GB

4K 360° (30 फ़्रेम)

~8 मिनट/क्लिप

RTX 5090 32GB

32GB

4K 360° (60 फ़्रेम)

~6 मिनट/क्लिप

2× RTX 4090

48GB

4K 360° (120 फ़्रेम)

~9 मिनट/क्लिप

A100 80GB

80GB

4K 360° (240 फ़्रेम)

~12 मिनट/क्लिप

न्यूनतम: RTX 4090 24GB (या समकक्ष 24GB+ VRAM GPU)

Clore.ai पर: RTX 4090 से ~$1.20/घं. स्पॉट — 2 मिनट की क्लिप की लागत लगभग ~$0.40 होती है।

इंस्टॉलेशन

# रिपॉज़िटरी क्लोन करें
git clone https://github.com/TencentARC/CubeComposer
cd cubecomposer

# निर्भरताएँ इंस्टॉल करें (Python 3.10+, CUDA 12.1+)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
pip install -r requirements.txt

# मॉडल वेट्स डाउनलोड करें (~18GB)
python scripts/download_weights.py --model cubecomposer-4k-v1

Docker (Clore.ai के लिए अनुशंसित)

# कोई आधिकारिक Docker इमेज नहीं है — स्रोत से इंस्टॉल करें:
git clone https://github.com/TencentARC/CubeComposer /workspace/CubeComposer
cd /workspace/CubeComposer
pip install -r requirements.txt
python app.py --share --listen 0.0.0.0 --port 7860

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

CLI: परिप्रेक्ष्य वीडियो → 4K 360°

# बुनियादी उपयोग: इनपुट परिप्रेक्ष्य वीडियो, आउटपुट 4K इक्विरेक्टैंगुलर
python generate_360.py \
  --input /workspace/input_video.mp4 \
  --output /workspace/output_360.mp4 \
  --resolution 4096x2048 \
  --frames 30 \
  --fps 30

# उच्च गुणवत्ता: अधिक स्टेप्स, लंबी क्लिप
python generate_360.py \
  --input /workspace/walk_through_park.mp4 \
  --output /workspace/park_360_4k.mp4 \
  --resolution 4096x2048 \
  --frames 60 \
  --num_inference_steps 50 \
  --guidance_scale 7.5 \
  --fps 30

Python API

from cubecomposer import CubeComposerPipeline
import torch

# पाइपलाइन लोड करें
pipe = CubeComposerPipeline.from_pretrained(
    "cubecomposer/cubecomposer-4k-v1",
    torch_dtype=torch.bfloat16
).to("cuda")

# परिप्रेक्ष्य इनपुट से 360° वीडियो जनरेट करें
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),  # 4K इक्विरेक्टैंगुलर
    num_inference_steps=50,
    guidance_scale=7.5,
    cubemap_size=1024  # प्रत्येक क्यूबमैप फ़ेस का आकार
)

# मानक इक्विरेक्टैंगुलर MP4 के रूप में सहेजें
output.save("output_360.mp4", fps=30)
print(f"4K 360° वीडियो जनरेट किया गया: output_360.mp4")

Gradio WebUI

import gradio as gr
from cubecomposer import CubeComposerPipeline
import torch

pipe = CubeComposerPipeline.from_pretrained(
    "cubecomposer/cubecomposer-4k-v1",
    torch_dtype=torch.bfloat16
).to("cuda")

def generate_360(video, frames, steps):
    output = pipe(
        input_video_path=video,
        num_frames=int(frames),
        resolution=(4096, 2048),
        num_inference_steps=int(steps)
    )
    output.save("/tmp/output_360.mp4", fps=30)
    return "/tmp/output_360.mp4"

demo = gr.Interface(
    fn=generate_360,
    inputs=[
        gr.Video(label="इनपुट परिप्रेक्ष्य वीडियो"),
        gr.Slider(10, 120, value=30, label="फ़्रेमों की संख्या"),
        gr.Slider(20, 80, value=50, label="इन्फ़रेंस स्टेप्स (गुणवत्ता)")
    ],
    outputs=gr.Video(label="4K 360° आउटपुट"),
    title="CubeComposer — 4K 360° वीडियो जनरेशन",
    description="कोई भी परिप्रेक्ष्य वीडियो अपलोड करें → मूल 4K 360° पैनोरामिक वीडियो प्राप्त करें"
)

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

Clore.ai पर डिप्लॉय करें: चरण-दर-चरण

1. एक RTX 4090 किराए पर लें

पर जाएँ clore.ai/marketplace
फ़िल्टर: GPU with 24GB+ VRAM (RTX 4090 अनुशंसित)
स्पॉट कीमत: उपलब्धता के अनुसार ~$1.20–2.50/घं.
चुनें Custom Docker या Ubuntu इमेज

2. SSH के माध्यम से सेटअप करें

# अपने Clore सर्वर से कनेक्ट करें
ssh root@<server-ip>

# एक-लाइनर सेटअप
git clone https://github.com/TencentARC/CubeComposer && \
  cd cubecomposer && \
  pip install -r requirements.txt && \
  python scripts/download_weights.py && \
  python app.py --port 7860 --host 0.0.0.0

3. UI एक्सेस करें

खोलें http://<server-ip>:7860 अपने ब्राउज़र में Gradio इंटरफ़ेस का उपयोग करने के लिए।

वर्कफ़्लो: फ़ोन वीडियो → VR-रेडी 4K 360°

# चरण 1: फ़ोन वीडियो सर्वर पर अपलोड करें
scp ~/my_video.mp4 root@<server-ip>:/workspace/

# चरण 2: 4K 360° संस्करण जनरेट करें
ssh root@<server-ip> "cd cubecomposer && python generate_360.py \
  --input /workspace/my_video.mp4 \
  --output /workspace/my_video_360_4k.mp4 \
  --resolution 4096x2048 --frames 60"

# चरण 3: YouTube/VR हेडसेट्स के लिए 360° मेटाडेटा जोड़ें
ffmpeg -i my_video_360_4k.mp4 \
  -c copy \
  -metadata:s:v:0 spherical=equirectangular \
  my_video_360_4k_vr.mp4

# चरण 4: परिणाम डाउनलोड करें
scp root@<server-ip>:/workspace/my_video_360_4k_vr.mp4 ~/

Spectrum इंटीग्रेशन: Wan2.1 पर 4.79× स्पीडअप

यह Spectrum accelerator (CVPR 2026) — Chebyshev बहुपदों का उपयोग करने वाला एक training-free spectral diffusion feature forecaster — CubeComposer के अंतर्निहित Wan2.1 base पर महत्वपूर्ण स्पीडअप के लिए लागू किया जा सकता है:

from cubecomposer import CubeComposerPipeline
from spectrum_accelerator import SpectrumAccelerator
import torch

pipe = CubeComposerPipeline.from_pretrained(
    "cubecomposer/cubecomposer-4k-v1",
    torch_dtype=torch.bfloat16
).to("cuda")

# गुणवत्ता में कोई कमी के बिना 4.79× स्पीडअप के लिए Spectrum लागू करें
accelerator = SpectrumAccelerator(pipe.unet, order=8)  # Chebyshev order
pipe.unet = accelerator

# अब मूल गति के लगभग 4.79× पर जनरेट करता है
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),
    num_inference_steps=50  # लगभग 240 स्टेप्स के बराबर गुणवत्ता
)
output.save("output_fast_360.mp4")

गुणवत्ता सुझाव

इनपुट वीडियो की गुणवत्ता मायने रखती है — उच्च रिज़ॉल्यूशन इनपुट = बेहतर 360° आउटपुट
स्थिर फुटेज — हैंडहेल्ड शेक क्यूबमैप फ़ेसों के बीच संगति कम करता है
अच्छी रोशनी — अत्यधिक कॉन्ट्रास्ट से बचें (ओवरएक्सपोज़्ड आकाश + अँधेरा इंटीरियर)
लंबी क्लिप्स — 30+ फ़्रेम बेहतर समयगत संगति देते हैं
फ़ेस रिज़ॉल्यूशन — --cubemap_size 1024 सबसे उपयुक्त है (महत्वपूर्ण कार्य के लिए 2048, लेकिन VRAM 4× अधिक लगता है)

उपयोग के मामले

VR कंटेंट निर्माण — किसी भी फुटेज को Meta Quest, Apple Vision Pro के लिए कन्वर्ट करें
वर्चुअल प्रॉपर्टी टूर — वॉकथ्रू वीडियो को 360° टूर में बदलें
यात्रा कंटेंट — इमर्सिव यात्रा अनुभव साझा करें
आर्किटेक्चर विज़ुअलाइज़ेशन — 360° इंटीरियर/एक्सटीरियर वॉकथ्रू
इवेंट दस्तावेज़ीकरण — इवेंट रिकॉर्डिंग्स को इमर्सिव रिप्ले में बदलें
गेमिंग एसेट्स — 360° पर्यावरण संदर्भ जनरेट करें

प्रोडक्शन वर्कफ़्लो के लिए लागत अनुमान

कार्य

Clore.ai लागत

5-सेकंड क्लिप (30 फ़्रेम, 4K)

~$0.30 (RTX 4090 स्पॉट)

10-सेकंड क्लिप (60 फ़्रेम, 4K)

~$0.50

30-सेकंड क्लिप (180 फ़्रेम, 4K)

~$1.20

बैच: 100 क्लिप्स (प्रत्येक 5 सेकंड)

~$30