OpenSora

Generiere Videos mit OpenSora, der Open-Source-Sora-Alternative

Neuere Alternativen verfügbar! FramePack erstellt Videos mit nur 6 GB VRAM, Wan2.1 bietet überlegene Qualität und LTX-2 fügt native Audioerzeugung hinzu.

Erstellen Sie Videos mit OpenSora, der Open-Source-Alternative zu Sora, auf CLORE.AI-GPUs.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Warum OpenSora?

• Open Source - Vollständige Apache-2.0-Lizenz

• Von Sora inspiriert - DiT-Architektur wie bei OpenAIs Sora

• Skalierbar - Mehrere Modellgrößen und Auflösungen

• Lange Videos - Erzeugt bis zu 16 Sekunden

• Aktive Entwicklung - Regelmäßige Updates und Verbesserungen

Modellvarianten

Modell	Auflösung	Dauer	VRAM	Qualität
OpenSora 1.2	720p	16 s	24 GB	Hervorragend
OpenSora 1.1	480p	8 s	16 GB	Gut
OpenSora 1.0	256p	4 s	8 GB	Einfach
Open-Sora-Plan	512p	10 s	20 GB	Großartig

Schnellbereitstellung auf CLORE.AI

Docker-Image:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Ports:

22/tcp
7860/http

Befehl:

git clone https://github.com/hpcaitech/Open-Sora && \\
cd Open-Sora && \\
pip install -e . && \
pip install gradio && \\
python scripts/inference.py \\
    --prompt "Eine Katze spielt mit Wollfaden" \\
    --num-frames 51 \\
    --resolution 480p \\
    --save-dir ./outputs

Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

1. Gehe zu Meine Bestellungen Seite

2. Klicke auf deine Bestellung

3. Finde die http_pub URL (z. B. abc123.clorecloud.net)

Verwende https://YOUR_HTTP_PUB_URL anstelle von localhost in den folgenden Beispielen.

Hardware-Anforderungen

Modellversion	Minimale GPU	Empfohlen	Optimal
OpenSora 1.0	RTX 3070 8GB	RTX 3090 24 GB	RTX 4090
OpenSora 1.1	RTX 3090 16GB	RTX 4090 24GB	A100 40GB
OpenSora 1.2	RTX 4090 24GB	A100 40GB	A100 80GB

Installation

Aus dem Quellcode

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

# Abhängigkeiten installieren
pip install -e .

# Modellgewichte herunterladen
python scripts/download_weights.py --version 1.2

Mit pip

pip install opensora

Grundlegende Verwendung

Kommandozeile

# Einfache Generierung
python scripts/inference.py \\
    --prompt "Ein wunderschöner Sonnenuntergang über dem Ozean, filmisch" \\
    --num-frames 51 \\
    --resolution 480p \\
    --save-dir ./outputs

# Hohe Qualität
python scripts/inference.py \\
    --prompt "Ein majestätischer Adler, der durch die Wolken gleitet" \\
    --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

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

# Video generieren
prompt = "Eine Rakete startet ins All, dramatische Beleuchtung, filmisch"

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

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

Fortgeschrittene Generierung

Mit negativen Prompts

video = model.generate(
    prompt="Professionelle Fotografie eines Tigers in freier Wildbahn",
    negative_prompt="unscharf, geringe Qualität, verzerrt, Artefakte",
    num_frames=51,
    num_inference_steps=75,
    guidance_scale=7.5
)

Lange Videos

# 16 Sekunden bei 24 fps generieren
video = model.generate(
    prompt="Zeitraffer von Blumen, die in einem Garten blühen",
    num_frames=384,  # 16 Sekunden bei 24 fps
    height=480,
    width=854,
    num_inference_steps=100
)

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

Hohe Auflösung

# 720p-Generierung (benötigt mehr VRAM)
video = model.generate(
    prompt="Luftaufnahme einer Stadt bei Nacht mit Lichtern",
    num_frames=51,
    height=720,
    width=1280,
    num_inference_steps=75
)

Prompt-Beispiele

Filmisch

prompts = [
    "Filmische Aufnahme eines Samurai, der sein Schwert zieht, dramatische Beleuchtung, 4K",
    "Epische Weitwinkelaufnahme einer Burg auf einer Klippe während eines Sturms",
    "Zeitlupe von Wassertropfen, die in einen stillen Teich fallen",
    "Tracking-Aufnahme durch eine neonbeleuchtete Cyberpunk-Gasse bei Nacht"
]

Natur

prompts = [
    "Nordlichter tanzen über verschneiten Bergen, Zeitraffer",
    "Makroaufnahme eines Schmetterlings, der aus einem Kokon schlüpft",
    "Ozeanwellen, die bei Sonnenuntergang gegen vulkanische Felsen schlagen",
    "Nebel, der im Morgengrauen durch einen alten Wald zieht"
]

Abstrakt

prompts = [
    "Bunte Farbkleckse, die in Wasser fallen, Zeitlupe",
    "Fraktale, die sich entwickeln und verändern, psychedelische Farben",
    "Flüssiges Metall, das sich in verschiedene Formen verwandelt"
]

Konfigurationsoptionen

Auflösungsvoreinstellungen

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

Qualitätseinstellungen

# Schnelle Vorschau
config_fast = {
    "num_frames": 25,
    "num_inference_steps": 25,
    "guidance_scale": 5.0
}

# Ausgewogen
config_balanced = {
    "num_frames": 51,
    "num_inference_steps": 50,
    "guidance_scale": 7.0
}

# Maximale Qualität
config_quality = {
    "num_frames": 102,
    "num_inference_steps": 100,
    "guidance_scale": 7.5
}

Gradio-Oberfläche

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="Eingabeaufforderung", lines=2),
        gr.Textbox(label="Negativer Prompt", value="unscharf, niedrige Qualität"),
        gr.Slider(25, 200, value=51, step=1, label="Bilder"),
        gr.Slider(20, 150, value=50, step=5, label="Schritte"),
        gr.Slider(3, 15, value=7, step=0.5, label="Leitstärke"),
        gr.Dropdown(["480p", "720p"], value="480p", label="Auflösung"),
        gr.Number(value=-1, label="Seed")
    ],
    outputs=gr.Video(label="Generiertes Video"),
    title="OpenSora - Text zu Video",
    description="Erstellen Sie Videos mit OpenSora. Läuft auf CLORE.AI."
)

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

Speicheroptimierung

# Speicheroptimierungen aktivieren
model.enable_model_cpu_offload()
model.enable_vae_tiling()

# Für sehr wenig VRAM
model.enable_sequential_cpu_offload()

# Niedrigere Präzision verwenden
model = OpenSoraModel.from_pretrained(
    "hpcaitech/OpenSora-v1.2",
    torch_dtype=torch.float16
)

Batch-Generierung

import os

prompts = [
    "Ein Phönix, der aus Flammen aufsteigt",
    "Regen, der nachts auf Stadtstraßen fällt",
    "Zeitraffer von blühenden Blumen",
    "Nordlichter über Bergen"
]

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

for i, prompt in enumerate(prompts):
    print(f"Generiere {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)

    # Speicher zwischen den Generierungen freigeben
    torch.cuda.empty_cache()

Leistung

Auflösung	Frames	Schritte	GPU	Zeit
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.

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise:

GPU	Stundensatz	~51 Videos im 480p-Format pro Stunde
RTX 4090 24GB	~$0.10	~15-20
A100 40GB	~$0.17	~25-30
A100 80GB	~$0.25	~35 (kann 720p)

Preise variieren. Prüfen Sie CLORE.AI-Marktplatz für aktuelle Preise.

Fehlerbehebung

Speicher erschöpft

# Kleinere Auflösung verwenden
python scripts/inference.py --resolution 360p --num-frames 25

# CPU-Offload aktivieren
python scripts/inference.py --cpu-offload

# Batch-Größe reduzieren
python scripts/inference.py --batch-size 1

Langsame Generierung

• Reduziere num_inference_steps (30-50 oft ausreichend)

• Verwenden Sie für Vorschauen eine niedrigere Auflösung

• Stellen Sie sicher, dass die GPU genutzt wird (prüfen Sie nvidia-smi)

Schlechte Qualität

• Erhöhen Sie die Schritte auf 75-100

• Verwenden Sie aussagekräftigere Prompts

• Fügen Sie negative Prompts für Artefakte hinzu

• Probieren Sie verschiedene Guidance-Skalen (5-10) aus

Video-Artefakte

• Guidance-Skala senken

• Inferenzschritte erhöhen

• Verwenden Sie temporale Glättung

• Nachbearbeitung mit Videostabilisierung

OpenSora im Vergleich zu anderen

Funktion	OpenSora 1.2	Hunyuan	Wan2.1	SVD
Architektur	DiT	DiT	DiT	U-Net
Maximale Dauer	16 s	5 s	5 s	4 s
Maximale Auflösung	720p	720p	720p	576p
Qualität	Großartig	Hervorragend	Hervorragend	Gut
Geschwindigkeit	Mittel	Langsam	Schnell	Schnell
Lizenz	Apache 2.0	Öffnen	Apache 2.0	Öffnen

Verwenden Sie OpenSora, wenn:

• Längere Videogenerierung benötigen

• Eine vollständige Apache-2.0-Lizenz wünschen

• An einer Sora-ähnlichen Architektur interessiert sind

• Aktive Unterstützung durch die Community benötigen

Alternative zu Open-Sora-Plan

Eine weitere Open-Source-Option:

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

python scripts/inference.py \\
    --prompt "Ihr Prompt hier" \\
    --output video.mp4

Nächste Schritte

• Hunyuan Video - Hochwertige T2V

• Wan2.1 Video - Schnelle Generierung

• Stable Video Diffusion - Bildanimation

• RIFE-Interpolation - Frame-Interpolation