CubeComposer 4K 360° Video

CubeComposer (CVPR 2026) est un modèle de diffusion autorégressif spatio-temporel qui génère une vidéo panoramique 360° 4K native à partir d’une vidéo standard en perspective. Construit sur le modèle de fondation vidéo Wan, entraîné sur 11 832 clips haute résolution. C’est le premier modèle ouvert capable de générer nativement du 360° en 4K — permettant la création de contenu VR, les visites virtuelles et les médias immersifs sur du matériel GPU grand public.

Pourquoi c’est important

La vidéo 360° a traditionnellement nécessité des dispositifs de capture spécialisés (plusieurs caméras, logiciels d’assemblage, post-traitement coûteux). CubeComposer change cela :

• Entrée: toute vidéo prise par une caméra standard (objectif unique, caméra de téléphone, dashcam)

• Sortie: vidéo équirectangulaire 4K 360° native

• Méthode: décompose les panoramas en faces de cubemap, génère chaque face de manière autorégressive avec cohérence spatiale

• Qualité: surpasse nettement les approches précédentes d’assemblage et d’outpainting

Configuration matérielle requise

Configuration	VRAM	Résolution	Vitesse
RTX 4090 24 Go	24GB	4K 360° (30 images)	~8 min/clip
RTX 5090 32 Go	32 Go	4K 360° (60 images)	~6 min/clip
2× RTX 4090	48GB	4K 360° (120 images)	~9 min/clip
A100 80 Go	80 Go	4K 360° (240 images)	~12 min/clip

Minimum: RTX 4090 24 Go (ou GPU équivalent avec 24 Go+ de VRAM)

Sur Clore.ai : RTX 4090 à partir de 0,14–0,42 $/h en spot — un clip de 2 minutes coûte environ 0,40 $.

Installation

# Cloner le dépôt
git clone https://github.com/TencentARC/CubeComposer
cd cubecomposer

# Installer les dépendances (Python 3.10+, CUDA 12.8+)
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
pip install -r requirements.txt

# Télécharger les poids du modèle (~18 Go)
python scripts/download_weights.py --model cubecomposer-4k-v1

Docker (recommandé pour Clore.ai)

# Pas d’image Docker officielle — installez depuis les sources :
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

Démarrage rapide

CLI : Vidéo en perspective → 4K 360°

# Utilisation de base : vidéo d’entrée en perspective, sortie équirectangulaire 4K
python generate_360.py \\
  --input /workspace/input_video.mp4 \\
  --output /workspace/output_360.mp4 \\
  --resolution 4096x2048 \\
  --frames 30 \\
  --fps 30

# Qualité supérieure : plus d’étapes, clip plus long
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

API Python

from cubecomposer import CubeComposerPipeline
import torch

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

# Générer une vidéo 360° à partir d’une entrée en perspective
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),  # 4K équirectangulaire
    num_inference_steps=50,
    guidance_scale=7.5,
    cubemap_size=1024  # taille de chaque face du cubemap
)

# Enregistrer au format MP4 équirectangulaire standard
output.save("output_360.mp4", fps=30)
print(f"Vidéo 4K 360° générée : output_360.mp4")

Interface Web Gradio

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="Vidéo d’entrée en perspective"),
        gr.Slider(10, 120, value=30, label="Nombre d’images"),
        gr.Slider(20, 80, value=50, label="Étapes d’inférence (qualité)")
    ],
    outputs=gr.Video(label="Sortie 4K 360°"),
    title="CubeComposer — génération de vidéo 4K 360°",
    description="Téléversez n’importe quelle vidéo en perspective → obtenez une vidéo panoramique 4K 360° native"
)

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

Déployer sur Clore.ai : étape par étape

1. Louez une RTX 4090

1. Accédez à clore.ai/marketplace

2. Filtre : GPU avec 24 Go+ de VRAM (RTX 4090 recommandée)

3. Prix spot : ~1,20–2,50 $/h selon la disponibilité

4. Sélectionnez Docker personnalisé ou Ubuntu image

2. Configuration via SSH

# Connectez-vous à votre serveur Clore
ssh root@<server-ip>

# Configuration en une seule ligne
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. Accédez à l’interface

Ouvrez http://<server-ip>:7860 dans votre navigateur pour utiliser l’interface Gradio.

Flux de travail : vidéo de téléphone → 4K 360° prête pour la VR

# Étape 1 : téléversez la vidéo du téléphone sur le serveur
scp ~/my_video.mp4 root@<server-ip>:/workspace/

# Étape 2 : générez la version 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"

# Étape 3 : ajoutez les métadonnées 360° pour YouTube/les casques VR
ffmpeg -i my_video_360_4k.mp4 \\
  -c copy \\
  -metadata:s:v:0 spherical=equirectangular \\
  my_video_360_4k_vr.mp4

# Étape 4 : téléchargez le résultat
scp root@<server-ip>:/workspace/my_video_360_4k_vr.mp4 ~/

Intégration Spectrum : accélération ×4,79 sur Wan2.1

Le Accélérateur Spectrum (CVPR 2026) — un prévisionneur spectral de caractéristiques de diffusion sans entraînement utilisant des polynômes de Tchebychev — peut être appliqué à la base Wan2.1 sous-jacente de CubeComposer pour des accélérations significatives :

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")

# Appliquez Spectrum pour une accélération ×4,79 sans perte de qualité
accelerator = SpectrumAccelerator(pipe.unet, order=8)  # ordre de Tchebychev
pipe.unet = accelerator

# Génère désormais à environ ×4,79 la vitesse d’origine
output = pipe(
    input_video_path="input.mp4",
    num_frames=30,
    resolution=(4096, 2048),
    num_inference_steps=50  # qualité effective d’environ 240 étapes
)
output.save("output_fast_360.mp4")

Conseils de qualité

1. La qualité de la vidéo d’entrée compte — une entrée à plus haute résolution = une meilleure sortie 360°

2. Images stables — les tremblements à main levée réduisent la cohérence entre les faces du cubemap

3. Bon éclairage — évitez les contrastes extrêmes (ciel surexposé + intérieur sombre)

4. Clips plus longs — 30 images ou plus offrent une meilleure cohérence temporelle

5. Résolution des faces — --cubemap_size 1024 est le juste milieu (2048 pour les travaux critiques, coûte 4× plus de VRAM)

Cas d’usage

• Création de contenu VR — convertissez n’importe quelle séquence pour Meta Quest, Apple Vision Pro

• Visites virtuelles de biens — transformez des vidéos de visite en tours 360°

• Contenu de voyage — partagez des expériences de voyage immersives

• Visualisation architecturale — visites intérieures/extérieures 360°

• Documentation d’événements — convertissez les enregistrements d’événements en rediffusions immersives

• Ressources pour le jeu vidéo — générez des références d’environnements 360°

Estimation des coûts pour le flux de production

Tâche	Coût Clore.ai
Clip de 5 secondes (30 images, 4K)	~0,30 $ (spot RTX 4090)
Clip de 10 secondes (60 images, 4K)	~$0.50
Clip de 30 secondes (180 images, 4K)	~$1.20
Lot : 100 clips (5 s chacun)	~$30

Guides associés

• Génération vidéo Wan2.1 — le modèle de fondation à la base de CubeComposer

• FramePack — génération efficace de longues vidéos (6 Go de VRAM !)

• Vidéo LTX-2 — génération vidéo latente rapide

• ComfyUI — flux de travail basé sur des nœuds pour la vidéo + l’image

• Interpolation vidéo RIFE — fluidifiez la vidéo générée

---

Dernière mise à jour : 16 mars 2026 | Article : arXiv:2603.04291 (CVPR 2026) | Basé sur le modèle de fondation Wan2.1