> 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/video-generierung/skyreels.md).

# SkyReels-V3

SkyReels-V3 ist ein Open-Source-Videogenerationsmodell von Kunlun (SkyWork AI), das auf der Wan2.1-Videearchitektur aufbaut. Es erzeugt flüssige 24-fps-Clips mit sowohl Text-zu-Video-(T2V)- als auch Bild-zu-Video-(I2V)-Fähigkeiten. Das Modell erbt Wan2.1s starke Bewegungs-Kohärenz und zeitliche Konsistenz und ergänzt diese um SkyWorks Trainingsverfeinerungen für verbesserte visuelle Qualität und bessere Einhaltung von Prompts.

SkyReels-V3 auszuführen auf [Clore.ai](https://clore.ai/) ermöglicht dir den Zugriff auf die benötigten 24 GB VRAM ohne eigenen Hardwarekauf — miete eine RTX 4090 für ein paar Dollar und beginne mit der Generierung.

## Hauptmerkmale

* **24 fps Ausgabe** — flüssige, sendetaugliche Bildrate direkt einsatzbereit.
* **Text-zu-Video** — generiere Clips aus natürlichsprachlichen Beschreibungen mit starker Prompt-Befolgung.
* **Bild-zu-Video** — animiere ein Referenzbild mit steuerbarer Kamerabewegung und Subjektbewegung.
* **Basierend auf Wan2.1** — übernimmt die erprobte zeitliche Aufmerksamkeit und Bewegungsmodellierung der Wan-Architektur.
* **Mehrere Auflösungen** — unterstützt Generierung in 480p und 720p je nach VRAM-Budget.
* **Offene Gewichte** — verfügbar unter einer offenen Lizenz für Forschungs- und kommerzielle Nutzung.
* **Chinesisch + Englisch** — zweisprachige Prompt-Unterstützung durch den Wan2.1-Textencoder.

## Anforderungen

| Komponente | Minimum                  | Empfohlen |
| ---------- | ------------------------ | --------- |
| GPU-VRAM   | 16 GB (480p mit Offload) | 24 GB     |
| System-RAM | 32 GB                    | 64 GB     |
| Festplatte | 25 GB                    | 50 GB     |
| Python     | 3.10+                    | 3.11      |
| CUDA       | 12.1+                    | 12.4      |

**Clore.ai GPU-Empfehlung:** Ein **RTX 4090** (24 GB, \~0,5–2 $/Tag) ist der Sweet Spot — genug VRAM für 720p-Generierung in voller Präzision. Ein **RTX 3090** (24 GB, \~0,3–1 $/Tag) funktioniert für 480p und bietet das beste Preis-pro-Clip-Verhältnis auf dem Marktplatz.

## Schnellstart

```bash
# Core-Abhängigkeiten installieren
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
pip install diffusers transformers accelerate sentencepiece
pip install imageio[ffmpeg]

# GPU überprüfen
python -c "import torch; print(torch.cuda.get_device_name(0))"
```

## Beispielanwendungen

### Text-zu-Video

```python
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

# SkyReels-V3 verwendet die Wan2.1-Pipeline-Architektur
pipe = WanPipeline.from_pretrained(
    "SkyworkAI/SkyReels-V3-T2V",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = (
    "Ein Samurai, der bei Morgennebel durch einen Bambuswald geht, "
    "Sonnenlicht, das durch die hohen Halme filtert, filmische Komposition, "
    "langsame, bedachte Bewegung"
)

video_frames = pipe(
    prompt=prompt,
    negative_prompt="unscharf, niedrige Qualität, Wasserzeichen, statisch",
    num_frames=97,               # ~4 Sekunden bei 24 fps
    width=1280,
    height=720,
    num_inference_steps=30,
    guidance_scale=5.0,
    generator=torch.Generator("cuda").manual_seed(42),
).frames[0]

export_to_video(video_frames, "samurai_forest.mp4", fps=24)
print("Samurai_forest.mp4 gespeichert")
```

### Bild-zu-Video

```python
import torch
from PIL import Image
from diffusers import WanImageToVideoPipeline
from diffusers.utils import export_to_video

pipe = WanImageToVideoPipeline.from_pretrained(
    "SkyworkAI/SkyReels-V3-I2V",
    torch_dtype=torch.bfloat16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

image = Image.open("landscape.png").resize((1280, 720))

video_frames = pipe(
    prompt="Kamera schiebt sich langsam in die Szene, Wolken ziehen darüber hinweg",
    image=image,
    negative_prompt="statisch, Zittern, unscharf",
    num_frames=97,
    num_inference_steps=30,
    guidance_scale=5.0,
).frames[0]

export_to_video(video_frames, "landscape_anim.mp4", fps=24)
```

### Niedrigere Auflösung — schnelle Vorschau

```python
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained(
    "SkyworkAI/SkyReels-V3-T2V", torch_dtype=torch.bfloat16
).to("cuda")

# 480p für schnelle Iteration
frames = pipe(
    prompt="Ozeanwellen, die gegen Felsen schlagen, dramatischer Spray, Sonnenuntergang",
    num_frames=49,
    width=854,
    height=480,
    num_inference_steps=20,
    guidance_scale=5.0,
).frames[0]

export_to_video(frames, "waves_preview.mp4", fps=24)
```

## Tipps für Clore.ai-Nutzer

1. **Wan-Pipeline-Klassen verwenden** — SkyReels-V3 basiert architektonisch auf Wan2.1, daher verwendet es `WanPipeline` / `WanImageToVideoPipeline` aus diffusers.
2. **Beginne bei 480p** — iteriere zuerst an Prompts in niedrigerer Auflösung und generiere dann finale Clips in 720p, sobald du mit der Komposition zufrieden bist.
3. **CPU-Offloading** — `enable_model_cpu_offload()` wird bei 24-GB-Karten für 720p-Generierung empfohlen, um OOM zu vermeiden.
4. **Persistenter Speicher** — setze `HF_HOME=/workspace/hf_cache` auf einem Clore.ai Persistent Volume; das Modell wiegt \~15–20 GB.
5. **24 fps nativ** — ändere die Export-fps nicht; die zeitliche Aufmerksamkeit des Modells wurde für 24-fps-Ausgabe trainiert.
6. **Zweisprachige Prompts** — der Wan2.1-Textencoder verarbeitet sowohl Englisch als auch Chinesisch; du kannst die Sprachen bei Bedarf mischen.
7. **Guidance-Scale** — 4.0–6.0 funktioniert am besten. Höhere Werte (>8) können zu Übersättigung führen.
8. **tmux ist Pflicht** — führe die Generierung immer in einer `tmux` Session auf Clore.ai aus, um SSH-Trennungen zu überleben.

## Fehlerbehebung

| Problem                                              | Behebe                                                                                                                                          |
| ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` bei 720p                          | Aktivieren Sie `pipe.enable_model_cpu_offload()`; reduziere auf 480p falls weiterhin OOM                                                        |
| Modell nicht auf HuggingFace gefunden                | Überprüfe den genauen Repo-Namen auf [SkyworkAI HF-Seite](https://huggingface.co/SkyworkAI) — es könnte unter einem Variantenamen gelistet sein |
| Ruckartige oder flackernde Bewegung                  | Erhöhen Sie `num_inference_steps` auf 40; reduziere `guidance_scale` auf 4.0                                                                    |
| Langsame Generierung                                 | \~1–3 Min pro 4-Sekunden-Clip auf einer RTX 4090 sind normal für 720p; 480p ist ungefähr 2× schneller                                           |
| Farbverschiebung / Übersättigung                     | Niedriger `guidance_scale` auf 4.0–5.0                                                                                                          |
| `ImportError: imageio`                               | `pip install imageio[ffmpeg]`                                                                                                                   |
| Gewichte werden beim Neustart erneut heruntergeladen | Hänge persistente Speicherung ein und setze `HF_HOME` Umgebungsvariable                                                                         |


---

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

```
GET https://docs.clore.ai/guides/guides_v2-de/video-generierung/skyreels.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.
