# OpenSora

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

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

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

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

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

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

### Verwendung von pip

```bash
pip install opensora
```

## Grundlegende Verwendung

### Kommandozeile

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

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

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

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

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

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

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

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

```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="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

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

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

## Fehlerbehebung

### Kein Speicher mehr

```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)
* 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:

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