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