OpenSora

Generieren Sie Videos mit OpenSora, der Open-Source-Alternative zu Sora

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

Erzeuge Videos mit OpenSora, der Open-Source Sora-Alternative, auf CLORE.AI GPUs.

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

Warum OpenSora?

• Open Source - Volle Apache 2.0 Lizenz

• Von Sora inspiriert - DiT-Architektur wie OpenAIs Sora

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

• Lange Videos - Erzeuge bis zu 16 Sekunden

• Aktive Entwicklung - Regelmäßige Updates und Verbesserungen

Modellvarianten

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

Schnelle Bereitstellung auf CLORE.AI

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-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, die mit Wollknäuel spielt" \
    --num-frames 51 \
    --resolution 480p \
    --save-dir ./outputs

Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen:

1. Gehen Sie zur Meine Bestellungen Seite

2. Klicken Sie auf Ihre Bestellung

3. Finden Sie die http_pub URL (z. B., abc123.clorecloud.net)

Verwenden Sie https://IHRE_HTTP_PUB_URL anstelle von localhost in den Beispielen unten.

Hardware-Anforderungen

Modellversion	Minimale GPU	Empfohlen	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

Aus Quelle

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

Verwendung von pip

pip install opensora

Grundlegende Verwendung

Kommandozeile

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

# Hohe Qualität
python scripts/inference.py \
    --prompt "Ein majestätischer Adler, der durch Wolken schwebt" \
    --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 erzeugen
prompt = "Eine Rakete, die in den Weltraum startet, dramatische Beleuchtung, cinematic"

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)

Erweiterte Generierung

Mit negativen Prompts

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

Lange Videos

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

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

Hohe Auflösung

# 720p-Generierung (erfordert 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

Kinematografisch

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

Natur

prompts = [
    "Aurora borealis, die über verschneiten Bergen tanzt, Zeitraffer",
    "Makroaufnahme eines Schmetterlings, der aus dem Kokon schlüpft",
    "Ozeanwellen, die bei Sonnenuntergang auf vulkanische Felsen treffen",
    "Nebel, der bei Sonnenaufgang durch einen uralten Wald zieht"
]

Abstrakt

prompts = [
    "Bunte Farbtropfen, die ins Wasser fallen, Zeitlupe",
    "Fraktale, die sich entwickeln und verwandeln, 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="Prompt", lines=2),
        gr.Textbox(label="Negativer Prompt", value="verschwommen, niedrige Qualität"),
        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="Auflösung"),
        gr.Number(value=-1, label="Seed")
    ],
    outputs=gr.Video(label="Generiertes Video"),
    title="OpenSora - Text zu Video",
    description="Erzeuge 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-Erzeugung

import os

prompts = [
    "Ein Phönix, der aus den Flammen aufsteigt",
    "Regen, der nachts auf Straßen in der Stadt fällt",
    "Zeitraffer von Blumen, die blühen",
    "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

Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

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

Preise variieren. Prüfen Sie CLORE.AI Marketplace auf aktuelle Preise.

Fehlerbehebung

Kein Speicher mehr

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

• Für Vorschauen niedrigere Auflösung verwenden

• Stelle sicher, dass die GPU genutzt wird (prüfe nvidia-smi)

Schlechte Qualität

• Erhöhe die Schritte auf 75-100

• Verwende beschreibendere Prompts

• Füge negative Prompts für Artefakte hinzu

• Probiere unterschiedliche Guidance-Werte (5-10)

Video-Artefakte

• Niedrigere Guidance-Skala

• Erhöhe Inferenzschritte

• Verwende zeitliche Glättung

• Nachbearbeitung mit Video-Stabilisierung

OpenSora vs Andere

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

Verwende OpenSora wenn:

• Längere Videogenerierung benötigt wird

• Du die volle Apache 2.0 Lizenz möchtest

• Du an einer Sora-ähnlichen Architektur interessiert bist

• Du aktive Community-Unterstützung brauchst

Open-Sora-Plan Alternative

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 "Dein Prompt hier" \
    --output video.mp4

Nächste Schritte

• Hunyuan Video - Hochwertiges T2V

• Wan2.1 Video - Schnelle Generierung

• Stable Video Diffusion - Bildanimation

• RIFE-Interpolation - Frame-Interpolation