> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/videogenerierung/opensora.md).

# OpenSora

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

{% hint style="info" %}
**Neuere Alternativen verfügbar!** [**FramePack**](/guides/guides_v2-de/videogenerierung/framepack.md) erstellt Videos mit nur 6 GB VRAM, [**Wan2.1**](/guides/guides_v2-de/videogenerierung/wan-video.md) bietet überlegene Qualität und [**LTX-2**](/guides/guides_v2-de/videogenerierung/ltx-video-2.md) fügt native Audioerzeugung hinzu.
{% endhint %}

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

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

## 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:**

```bash
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

```bash
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

```bash
pip install opensora
```

## Grundlegende Verwendung

### Kommandozeile

```bash
# 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

```python
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

```python
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

```python
# 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

```python
# 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

```python
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

```python
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

```python
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

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

### Qualitätseinstellungen

```python
# 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

```python
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

```python
# 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

```python
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*](https://clore.ai/marketplace) *für aktuelle Preise.*

## Fehlerbehebung

### Speicher erschöpft

```bash
# 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:

```bash
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](/guides/guides_v2-de/videogenerierung/hunyuan-video.md) - Hochwertige T2V
* [Wan2.1 Video](/guides/guides_v2-de/videogenerierung/wan-video.md) - Schnelle Generierung
* [Stable Video Diffusion](/guides/guides_v2-de/videogenerierung/stable-video-diffusion.md) - Bildanimation
* [RIFE-Interpolation](/guides/guides_v2-de/videoverarbeitung/rife-interpolation.md) - Frame-Interpolation


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/videogenerierung/opensora.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.