SkyReels-V3

Generiere 24-fps-Video mit SkyReels-V3, Kunluns auf Wan2.1 basierendem offenem Videomodell, auf Clore.ai-GPUs.

SkyReels-V3 ist ein Open-Source-Videoerzeugungsmodell von Kunlun (SkyWork AI), das auf der Wan2.1-Videoarchitektur aufbaut. Es erzeugt flüssige 24-fps-Clips mit Text-zu-Video- (T2V) und Bild-zu-Video-Funktionen (I2V). Das Modell übernimmt die starke Bewegungs-Kohärenz und zeitliche Konsistenz von Wan2.1 und ergänzt sie um SkyWorks Trainingsverfeinerungen für bessere visuelle Qualität und genauere Einhaltung der Prompts.

SkyReels-V3 ausführen auf Clore.ai ermöglicht dir den Zugriff auf die benötigten 24 GB VRAM, ohne Hardware zu kaufen — miete eine RTX 4090 für ein paar Dollar und leg los.

Hauptfunktionen

• 24-fps-Ausgabe — sofort eine flüssige Bildrate in Sendequalität.

• Text-zu-Video — erzeugt Clips aus Beschreibungen in natürlicher Sprache mit starker Prompt-Treue.

• Bild-zu-Video — animiere ein Referenzbild mit steuerbarer Kamerabewegung und Bewegung des Motivs.

• Auf Wan2.1 aufgebaut — übernimmt die bewährte zeitliche Aufmerksamkeit und Bewegungsmodellierung der Wan-Architektur.

• Mehrere Auflösungen — unterstützt die Generierung in 480p und 720p, je nach VRAM-Budget.

• Offene Gewichte — unter einer offenen Lizenz für Forschung und kommerzielle Nutzung verfügbar.

• Chinesisch + Englisch — zweisprachige Prompt-Unterstützung durch den Wan2.1-Textencoder.

Anforderungen

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

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

Schnellstart

# Kernabhängigkeiten installieren
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install diffusers transformers accelerate sentencepiece
pip install imageio[ffmpeg]

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

Anwendungsbeispiele

Text-zu-Video

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 durch einen Bambuswald im Morgennebel geht, "
    "Sonnenlicht, das durch die hohen Halme fällt, cineastische Komposition, "
    "langsame, bewusste Bewegung"
)

video_frames = pipe(
    prompt=prompt,
    negative_prompt="unscharf, niedrige Qualität, Wasserzeichen, statisch",
    num_frames=97,               # ~4 Sek. 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

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="Die Kamera fährt langsam in die Szene hinein, 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)

Schnelle Vorschau in niedrigerer Auflösung

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 Iterationen
frames = pipe(
    prompt="Ozeanwellen, die gegen Felsen schlagen, dramatische Gischt, 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. Verwende Wan-Pipeline-Klassen — SkyReels-V3 basiert architektonisch auf Wan2.1, daher verwendet es WanPipeline / WanImageToVideoPipeline aus diffusers.

2. Starte mit 480p — arbeite zunächst bei niedrigerer Auflösung an den Prompts und erzeuge dann die finalen Clips in 720p, sobald du mit der Komposition zufrieden bist.

3. CPU-Offloading — enable_model_cpu_offload() wird auf 24-GB-Karten für 720p-Generierung empfohlen, um OOM zu vermeiden.

4. Persistenter Speicher — setzen Sie HF_HOME=/workspace/hf_cache auf einem persistenten Volume von Clore.ai; das Modell wiegt ~15–20 GB.

5. nativ 24 fps — ä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 bei Bedarf Sprachen 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 obligatorisch — führe die Generierung immer in einer tmux Session auf Clore.ai aus, damit SSH-Trennungen überstanden werden.

Fehlerbehebung

Problem	Fix
OutOfMemoryError bei 720p	Aktiviere pipe.enable_model_cpu_offload(); auf 480p reduzieren, falls weiterhin OOM
Modell auf HuggingFace nicht gefunden	Prüfe den exakten Repo-Namen auf der HF-Seite von SkyworkAI — es könnte unter einem anderen Variantennamen gelistet sein
Ruckelige oder flackernde Bewegung	Erhöhen Sie num_inference_steps auf 40; verringere guidance_scale auf 4.0
Langsame Generierung	~1–3 Min. pro 4-Sek.-Clip auf einer RTX 4090 sind für 720p normal; 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	Persistenten Speicher einhängen und setzen HF_HOME Umgebungsvariable