OpenSora

Générez des vidéos avec OpenSora, l'alternative Sora open-source

Des alternatives plus récentes disponibles ! FramePack génère des vidéos avec seulement 6 Go de VRAM, Wan2.1 offre une qualité supérieure, et LTX-2 ajoute la génération audio native.

Générez des vidéos avec OpenSora, l'alternative Sora open-source, sur les GPU CLORE.AI.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Pourquoi OpenSora ?

• Open source - Licence Apache 2.0 complète

• Inspiré par Sora - Architecture DiT comme Sora d'OpenAI

• Scalable - Plusieurs tailles de modèle et résolutions

• Vidéos longues - Générer jusqu'à 16 secondes

• Développement actif - Mises à jour et améliorations régulières

Variantes de modèle

Modèle	Résolution	Durée	VRAM	Qualité
OpenSora 1.2	720p	16s	24 Go	Excellent
OpenSora 1.1	480p	8s	16Go	Bon
OpenSora 1.0	256p	4s	8 Go	Basique
Open-Sora-Plan	512p	10s	20Go	Excellent

Déploiement rapide sur CLORE.AI

Image Docker :

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

Ports :

22/tcp
7860/http

Commande :

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

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Aller à la Mes commandes page

2. Cliquez sur votre commande

3. Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Exigences matérielles

Version du modèle	GPU minimum	Recommandé	Optimal
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

Installation

Depuis la source

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

# Installer les dépendances
pip install -e .

# Télécharger les poids du modèle
python scripts/download_weights.py --version 1.2

Utilisation de pip

pip install opensora

Utilisation de base

Ligne de commande

# Génération simple
python scripts/inference.py \
    --prompt "A beautiful sunset over the ocean, cinematic" \
    --num-frames 51 \
    --resolution 480p \
    --save-dir ./outputs

# Haute qualité
python scripts/inference.py \
    --prompt "A majestic eagle soaring through clouds" \
    --num-frames 102 \
    --resolution 720p \
    --num-sampling-steps 100 \
    --save-dir ./outputs

API Python

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

# Charger le modèle
model = OpenSoraModel.from_pretrained("hpcaitech/OpenSora-v1.2")
model.to("cuda")

# Générer une vidéo
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
)

# Enregistrer
export_to_video(video, "rocket.mp4", fps=24)

Génération avancée

Avec prompts négatifs

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
)

Vidéos longues

# Générer 16 secondes à 24fps
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)

Haute résolution

# Génération 720p (exige plus de 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
)

Exemples de prompts

Cinématique

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

Nature

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

Abstrait

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

Options de configuration

Préréglages de résolution

resolutions = {
    "256p": (256, 455),
    "360p": (360, 640),
    "480p": (480, 854),
    "720p": (720, 1280),
    "1080p": (1080, 1920)  # High VRAM required
}

Paramètres de qualité

# Aperçu rapide
config_fast = {
    "num_frames": 25,
    "num_inference_steps": 25,
    "guidance_scale": 5.0
}

# Équilibré
config_balanced = {
    "num_frames": 51,
    "num_inference_steps": 50,
    "guidance_scale": 7.0
}

# Qualité maximale
config_quality = {
    "num_frames": 102,
    "num_inference_steps": 100,
    "guidance_scale": 7.5
}

Interface 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="flou, basse qualité"),
        gr.Slider(25, 200, value=51, step=1, label="Frames"),
        gr.Slider(20, 150, value=50, step=5, label="Steps"),
        gr.Slider(3, 15, value=7, step=0.5, label="Guidance"),
        gr.Dropdown(["480p", "720p"], value="480p", label="Resolution"),
        gr.Number(value=-1, label="Graine")
    ],
    outputs=gr.Video(label="Vidéo générée"),
    title="OpenSora - Text to Video",
    description="Generate videos using OpenSora. Running on CLORE.AI."
)

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

Optimisation de la mémoire

# Activer les optimisations mémoire
model.enable_model_cpu_offload()
model.enable_vae_tiling()

# Pour une VRAM très faible
model.enable_sequential_cpu_offload()

# Utiliser une précision inférieure
model = OpenSoraModel.from_pretrained(
    "hpcaitech/OpenSora-v1.2",
    torch_dtype=torch.float16
)

Génération par lot

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"Génération {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)

    # Libérer la mémoire entre les générations
    torch.cuda.empty_cache()

Performances

Résolution	Images	Pas	GPU	Temps
480p	51	50	RTX 4090	~3 min
480p	51	50	A100 40GB	~2 min
720p	51	50	A100 40GB	~5 min
720p	102	100	A100 80GB	~15 min

Estimation des coûts

Tarifs typiques du marketplace CLORE.AI :

GPU	Tarif horaire	~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)

Les prix varient. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Dépannage

Mémoire insuffisante

# Utiliser une résolution plus petite
python scripts/inference.py --resolution 360p --num-frames 25

# Activer le déchargement vers le CPU
python scripts/inference.py --cpu-offload

# Réduire la taille du lot
python scripts/inference.py --batch-size 1

Génération lente

• Réduire num_inference_steps (30-50 often enough)

• Utiliser une résolution plus basse pour les aperçus

• Assurez-vous que le GPU est utilisé (vérifiez nvidia-smi)

Mauvaise qualité

• Augmenter les étapes à 75-100

• Utiliser des prompts plus descriptifs

• Ajouter des prompts négatifs pour les artefacts

• Essayer différentes valeurs de guidance (5-10)

Artefacts vidéo

• Réduire l'échelle de guidance

• Augmenter les étapes d'inférence

• Utiliser un lissage temporel

• Post-traiter avec stabilisation vidéo

OpenSora vs Autres

Fonction	OpenSora 1.2	Hunyuan	Wan2.1	SVD
Architecture	DiT	DiT	DiT	U-Net
Durée maximale	16s	5s	5s	4s
Résolution maximale	720p	720p	720p	576p
Qualité	Excellent	Excellent	Excellent	Bon
Vitesse	Moyen	Lent	Rapide	Rapide
Licence	Apache 2.0	Ouvrir	Apache 2.0	Ouvrir

Utiliser OpenSora lorsque :

• Besoin de générer des vidéos plus longues

• Souhaite la licence complète Apache 2.0

• Intéressé par une architecture de type Sora

• Besoin d'un support communautaire actif

Alternative Open-Sora-Plan

Une autre option open-source :

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

Prochaines étapes

• Hunyuan Video - T2V de haute qualité

• Wan2.1 Video - Génération rapide

• Stable Video Diffusion - Animation d'image

• Interpolation RIFE - Interpolation d'images