Wan2.1 Video

Generieren Sie Videos mit Alibabas Wan2.1-Modell auf Clore.ai GPUs

Erzeugen Sie hochwertige Videos mit Alibabas Wan2.1 Text-zu-Video- und Bild-zu-Video-Modellen auf CLORE.AI-GPUs.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marketplace.

Warum Wan2.1?

• Hohe Qualität - State-of-the-art Videoerzeugung

• Mehrere Modi - Text-zu-Video, Bild-zu-Video

• Verschiedene Größen - 1,3B bis 14B Parameter

• Lange Videos - Bis zu 81 Bilder

• Offene Gewichte - Apache-2.0-Lizenz

Modellvarianten

Modell	Parameter	VRAM	Auflösung	Frames
Wan2.1-T2V-1.3B	1,3B	8GB	480p	81
Wan2.1-T2V-14B	14B	24GB	720p	81
Wan2.1-I2V-14B	14B	24GB	720p	81

Schnelle Bereitstellung auf CLORE.AI

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel

Ports:

22/tcp
7860/http

Befehl:

pip install diffusers transformers accelerate gradio && \
python -c "
import gradio as gr
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained('alibaba-pai/Wan2.1-T2V-1.3B', torch_dtype=torch.float16)
pipe.to('cuda')
pipe.enable_model_cpu_offload()

def generate(prompt, steps, frames, seed):
    generator = torch.Generator('cuda').manual_seed(seed) if seed > 0 else None
    output = pipe(prompt, num_frames=frames, num_inference_steps=steps, generator=generator)
    export_to_video(output.frames[0], 'output.mp4', fps=16)
    return 'output.mp4'

gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label='Prompt'),
        gr.Slider(20, 100, value=50, label='Steps'),
        gr.Slider(16, 81, value=49, step=8, label='Frames'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Video(),
    title='Wan2.1 - Text to Video'
).launch(server_name='0.0.0.0', server_port=7860)
"

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

Modell	Minimale GPU	Empfohlen	Optimal
1,3B T2V	RTX 3070 8GB	RTX 3090 24GB	RTX 4090
14B T2V	RTX 4090 24GB	A100 40GB	A100 80GB
14B I2V	RTX 4090 24GB	A100 40GB	A100 80GB

Installation

pip install diffusers transformers accelerate torch

Text-zu-Video

Grundlegende Nutzung (1,3B)

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

pipe = WanPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-T2V-1.3B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = "Eine Katze spielt mit einem Ball in einem sonnigen Garten"

output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "cat_video.mp4", fps=16)

Hohe Qualität (14B)

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

pipe = WanPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-T2V-14B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

prompt = "Kinematische Aufnahme eines Drachen, der bei Sonnenuntergang über Berge fliegt, 4K, detailliert"

output = pipe(
    prompt=prompt,
    negative_prompt="verschwommen, niedrige Qualität, verzerrt",
    num_frames=81,
    height=720,
    width=1280,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "dragon.mp4", fps=24)

Bild-zu-Video

Ein Bild animieren

import torch
from diffusers import WanI2VPipeline
from diffusers.utils import load_image, export_to_video

pipe = WanI2VPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-I2V-14B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Lade Eingabebild
image = load_image("input.jpg")

prompt = "Die Person auf dem Bild beginnt, nach vorne zu gehen"

output = pipe(
    prompt=prompt,
    image=image,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "animated.mp4", fps=16)

Bild-zu-Video mit Wan2.1-I2V-14B

Wan2.1-I2V-14B animiert ein statisches Bild und verwendet dazu einen Textprompt, um die Bewegung zu steuern. Erfordert 24GB VRAM (RTX 4090 oder A100 40GB empfohlen).

Modelldetails

Eigenschaft	Wert
Modell-ID	Wan-AI/Wan2.1-I2V-14B-480P
Parameter	14 Milliarden
Benötigter VRAM	24GB
Maximale Auflösung	480p (854×480) oder 720p (1280×720)
Maximale Frames	81
Lizenz	Apache 2.0

Hardware-Anforderungen

GPU	VRAM	Status
RTX 4090	24GB	✅ Empfohlen
RTX 3090	24GB	✅ Unterstützt
A100 40GB	40GB	✅ Optimal
A100 80GB	80GB	✅ Beste Qualität
RTX 3080	10GB	❌ Unzureichend

Schnelles CLI-Skript

Speichern als generate_i2v.py und ausführen:

python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P --image input.jpg --prompt "camera slowly zooms out"

generate_i2v.py — vollständiges Skript

#!/usr/bin/env python3
"""
Wan2.1 Bild-zu-Video CLI-Skript.
Verwendung: python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P \
           --image input.jpg --prompt "camera slowly zooms out"
"""

import argparse
import os
import sys
import torch
from diffusers import WanImageToVideoPipeline
from diffusers.utils import load_image, export_to_video
from PIL import Image


def parse_args():
    parser = argparse.ArgumentParser(description="Wan2.1 Image-to-Video Generator")
    parser.add_argument(
        "--model",
        type=str,
        default="Wan-AI/Wan2.1-I2V-14B-480P",
        help="Modell-ID von Hugging Face (Standard: Wan-AI/Wan2.1-I2V-14B-480P)",
    )
    parser.add_argument(
        "--image",
        type=str,
        required=True,
        help="Pfad zum Eingabebild (JPEG oder PNG)",
    )
    parser.add_argument(
        "--prompt",
        type=str,
        required=True,
        help='Text-Prompt, der die gewünschte Bewegung beschreibt (z. B. "camera slowly zooms out")',
    )
    parser.add_argument(
        "--negative-prompt",
        type=str,
        default="verschwommen, niedrige Qualität, verzerrt, ruckartige Bewegung, Artefakte",
        help="Negativer Prompt, um unerwünschte Artefakte zu vermeiden",
    )
    parser.add_argument(
        "--frames",
        type=int,
        default=49,
        help="Anzahl der zu erzeugenden Videoframes (Standard: 49, max: 81)",
    )
    parser.add_argument(
        "--steps",
        type=int,
        default=50,
        help="Anzahl der Diffusionsschritte (Standard: 50)",
    )
    parser.add_argument(
        "--guidance",
        type=float,
        default=7.0,
        help="Classifier-free Guidance Scale (Standard: 7.0)",
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=-1,
        help="Zufalls-Seed für Reproduzierbarkeit (-1 = zufällig)",
    )
    parser.add_argument(
        "--fps",
        type=int,
        default=16,
        help="Ausgabevideo-FPS (Standard: 16)",
    )
    parser.add_argument(
        "--output",
        type=str,
        default="output_i2v.mp4",
        help="Pfad der Ausgabevideodatei (Standard: output_i2v.mp4)",
    )
    parser.add_argument(
        "--height",
        type=int,
        default=480,
        help="Ausgabevideo-Höhe in Pixel (Standard: 480)",
    )
    parser.add_argument(
        "--width",
        type=int,
        default=854,
        help="Ausgabevideo-Breite in Pixel (Standard: 854)",
    )
    parser.add_argument(
        "--cpu-offload",
        action="store_true",
        default=True,
        help="Aktiviere Modell-CPU-Offload, um VRAM zu sparen (Standard: True)",
    )
    parser.add_argument(
        "--vae-tiling",
        action="store_true",
        default=False,
        help="Aktiviere VAE-Tiling für hochauflösende Ausgaben",
    )
    return parser.parse_args()


def load_and_resize_image(image_path: str, width: int, height: int) -> Image.Image:
    """Lädt Bild vom Pfad und skaliert auf die Zielgröße."""
    if not os.path.exists(image_path):
        print(f"[ERROR] Image not found: {image_path}", file=sys.stderr)
        sys.exit(1)

    img = Image.open(image_path).convert("RGB")
    original_size = img.size
    img = img.resize((width, height), Image.LANCZOS)
    print(f"[INFO] Loaded image: {image_path} ({original_size[0]}x{original_size[1]}) → resized to {width}x{height}")
    return img


def load_pipeline(model_id: str, cpu_offload: bool, vae_tiling: bool):
    """Lädt die Wan I2V-Pipeline mit Speicheroptimierungen."""
    print(f"[INFO] Loading model: {model_id}")
    print(f"[INFO] CUDA available: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        vram_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
        print(f"[INFO] GPU: {torch.cuda.get_device_name(0)} ({vram_gb:.1f} GB VRAM)")
        if vram_gb < 23:
            print("[WARN] Weniger als 24GB VRAM erkannt — aktivieren Sie --cpu-offload oder verwenden Sie das 1,3B-Modell")

    pipe = WanImageToVideoPipeline.from_pretrained(
        model_id,
        torch_dtype=torch.float16,
    )

    if cpu_offload:
        print("[INFO] Aktivierung des Modell-CPU-Offloads")
        pipe.enable_model_cpu_offload()
    else:
        pipe.to("cuda")

    if vae_tiling:
        print("[INFO] Aktivierung von VAE-Tiling für Hochauflösungs-Generierung")
        pipe.enable_vae_tiling()

    return pipe


def generate_video(pipe, args) -> None:
    """Führt die I2V-Pipeline aus und speichert das Ausgabevideo."""
    image = load_and_resize_image(args.image, args.width, args.height)

    generator = None
    if args.seed >= 0:
        generator = torch.Generator("cuda").manual_seed(args.seed)
        print(f"[INFO] Using seed: {args.seed}")
    else:
        print("[INFO] Using random seed")

    print(f"[INFO] Generating {args.frames} frames at {args.width}x{args.height}")
    print(f"[INFO] Steps: {args.steps} | Guidance: {args.guidance} | FPS: {args.fps}")
    print(f"[INFO] Prompt: {args.prompt}")

    output = pipe(
        prompt=args.prompt,
        negative_prompt=args.negative_prompt,
        image=image,
        num_frames=args.frames,
        height=args.height,
        width=args.width,
        num_inference_steps=args.steps,
        guidance_scale=args.guidance,
        generator=generator,
    )

    export_to_video(output.frames[0], args.output, fps=args.fps)
    print(f"[INFO] Video saved to: {os.path.abspath(args.output)}")
    duration = args.frames / args.fps
    print(f"[INFO] Duration: {duration:.1f}s at {args.fps}fps ({args.frames} frames)")


def main():
    args = parse_args()

    if not torch.cuda.is_available():
        print("[ERROR] CUDA GPU nicht gefunden. Wan2.1-I2V-14B benötigt eine CUDA-fähige GPU.", file=sys.stderr)
        sys.exit(1)

    pipe = load_pipeline(args.model, args.cpu_offload, args.vae_tiling)
    generate_video(pipe, args)
    print("[DONE] Bild-zu-Video-Erzeugung abgeschlossen!")


if __name__ == "__main__":
    main()

Erweiterte I2V-Pipeline (Python-API)

import torch
from diffusers import WanImageToVideoPipeline
from diffusers.utils import load_image, export_to_video
from PIL import Image

# ── Pipeline laden ──────────────────────────────────────────────────────────────
pipe = WanImageToVideoPipeline.from_pretrained(
    "Wan-AI/Wan2.1-I2V-14B-480P",
    torch_dtype=torch.float16,
)
pipe.enable_model_cpu_offload()   # hält den VRAM unter 24GB
pipe.enable_vae_tiling()          # optional: hilft für 720p

# ── Eingabebild laden & vorbereiten ───────────────────────────────────────────────
image = load_image("input.jpg").resize((854, 480))

# ── Generieren ───────────────────────────────────────────────────────────────────
prompt = "camera slowly zooms out, revealing the full landscape"
negative_prompt = "verschwommen, niedrige Qualität, verzerrt, flackern, Artefakte"

generator = torch.Generator("cuda").manual_seed(42)

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=image,
    num_frames=49,          # ~3 Sekunden bei 16fps
    height=480,
    width=854,
    num_inference_steps=50,
    guidance_scale=7.5,
    generator=generator,
)

export_to_video(output.frames[0], "i2v_output.mp4", fps=16)
print("Gespeichert: i2v_output.mp4")

I2V Prompt-Tipps

Ziel	Prompt-Beispiel
Kamerabewegung	"camera slowly zooms out from the subject"
Parallaxeeffekt	"subtile Parallaxbewegung, Änderung der Schärfentiefe"
Charakteranimation	"die Figur dreht den Kopf und lächelt"
Naturanimation	"Blätter rascheln in einer sanften Brise, Licht verschiebt sich"
Abstrakte Bewegung	"Farben wirbeln und verschmelzen, fließende Bewegung"

Speichertipps für I2V (24GB-GPUs)

# Auf 24GB-GPUs obligatorisch
pipe.enable_model_cpu_offload()

# Optional: reduziert den Spitzen-VRAM um ~10%
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# Zwischen Durchläufen bereinigen
import gc
gc.collect()
torch.cuda.empty_cache()

Prompt-Beispiele

Natur & Landschaften

prompts = [
    "Zeitraffer von Wolken, die sich über Berggipfel bewegen, dramatische Beleuchtung",
    "Ozeanwellen, die gegen Felsen schlagen, Zeitlupe, filmisch",
    "Nordlichter, die am Nachthimmel tanzen, lebendige Farben",
    "Wald im Herbst mit fallenden Blättern, friedliche Atmosphäre"
]

Tiere & Charaktere

prompts = [
    "Ein Golden Retriever, der durch ein Blumenfeld rennt",
    "Ein Schmetterling, der aus seinem Kokon schlüpft, Makroaufnahme",
    "Samurai-Krieger, der sein Schwert zieht, dramatische Beleuchtung",
    "Roboter, der durch futuristische Stadtstraßen läuft"
]

Abstrakt & Künstlerisch

prompts = [
    "Bunte Farbe, die sich im Wasser wirbelt, abstrakte Kunst",
    "Geometrische Formen, die sich verwandeln und morphen, Neonfarben",
    "Tintentröpfchen, die sich in Milch ausbreiten, Makrofotografie"
]

Erweiterte Einstellungen

Qualität vs. Geschwindigkeit

# Schnelle Vorschau
output = pipe(
    prompt=prompt,
    num_frames=17,
    num_inference_steps=25,
    guidance_scale=5.0
)

# Ausgewogen
output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

# Maximale Qualität
output = pipe(
    prompt=prompt,
    num_frames=81,
    num_inference_steps=100,
    guidance_scale=7.5
)

Auflösungsoptionen

# 480p (1,3B-Modell)
output = pipe(prompt, height=480, width=854, num_frames=49)

# 720p (14B-Modell)
output = pipe(prompt, height=720, width=1280, num_frames=49)

# 1080p (14B-Modell, hoher VRAM)
output = pipe(prompt, height=1080, width=1920, num_frames=33)

Batch-Erzeugung

import os
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompts = [
    "Ein Raketenstart ins All",
    "Fische, die im Korallenriff schwimmen",
    "Regen, der nachts auf einer Stadtstraße fällt"
]

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]}...")

    output = pipe(
        prompt=prompt,
        num_frames=49,
        num_inference_steps=50
    )

    export_to_video(output.frames[0], f"{output_dir}/video_{i:03d}.mp4", fps=16)
    torch.cuda.empty_cache()

Gradio-Oberfläche

import gradio as gr
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video
import tempfile

pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

def generate_video(prompt, negative_prompt, frames, steps, guidance, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    output = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_frames=frames,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    )

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        export_to_video(output.frames[0], f.name, fps=16)
        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(17, 81, value=49, step=8, label="Frames"),
        gr.Slider(20, 100, value=50, step=5, label="Steps"),
        gr.Slider(3, 12, value=7, step=0.5, label="Guidance"),
        gr.Number(value=-1, label="Seed")
    ],
    outputs=gr.Video(label="Generiertes Video"),
    title="Wan2.1 - Text to Video Generation",
    description="Erzeugen Sie Videos aus Text-Prompts. Läuft auf CLORE.AI."
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Speicheroptimierung

# Aktivieren Sie alle Optimierungen
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# Für sehr wenig VRAM
pipe.enable_sequential_cpu_offload()

# Cache zwischen Generierungen leeren
torch.cuda.empty_cache()

Leistung

Modell	Auflösung	Frames	GPU	Zeit
1,3B	480p	49	RTX 4090	~2 min
1,3B	480p	49	A100 40GB	~1,5 min
14B	720p	49	A100 40GB	~5 Min
14B	720p	81	A100 80GB	~8 Min.

Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

GPU	Stundensatz	~49-Frame-Videos/Stunde
RTX 3090 24GB	~$0.06	~20 (1,3B)
RTX 4090 24GB	~$0.10	~30 (1,3B)
A100 40GB	~$0.17	~40 (1,3B) / ~12 (14B)
A100 80GB	~$0.25	~8 (14B hochauflösend)

Preise variieren. Prüfen Sie CLORE.AI Marketplace auf aktuelle Preise.

Fehlerbehebung

Kein Speicher mehr

# Kleineres Modell verwenden
pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B")

# Aktivieren Sie alle Optimierungen
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Frames reduzieren
output = pipe(prompt, num_frames=17)

# Auflösung reduzieren
output = pipe(prompt, height=480, width=854)

Schlechte Qualität

• Erhöhen Sie die Schritte (75-100)

• Schreiben Sie detailliertere Prompts

• Verwenden Sie negative Prompts

• Probieren Sie das 14B-Modell für bessere Qualität

Video zu kurz

• Erhöhen Sie num_frames (max. 81)

• Verwenden Sie RIFE-Interpolation für Frame-Interpolation

• Ketten Sie mehrere Generierungen

Artefakte/Flackern

• Erhöhen Sie den Guidance-Scale

• Verwenden Sie einen festen Seed für Konsistenz

• Nachbearbeitung mit Video-Stabilisierung

Wan2.1 vs. Andere

Funktion	Wan2.1	Hunyuan	SVD	CogVideoX
Qualität	Ausgezeichnet	Ausgezeichnet	Gut	Großartig
Geschwindigkeit	Schnell	Mittel	Schnell	Langsam
Maximale Frames	81	129	25	49
Auflösung	720p	720p	576p	720p
I2V-Unterstützung	Ja	Ja	Ja	Ja
Lizenz	Apache 2.0	Öffnen	Öffnen	Öffnen

Verwenden Sie Wan2.1 wenn:

• Offene-Source-Videoerzeugung benötigt wird

• Schnelle Erzeugungsgeschwindigkeit gewünscht ist

• Apache-2.0-Lizenz erforderlich

• Ausgewogenes Verhältnis von Qualität/Geschwindigkeit benötigt wird

Nächste Schritte

• Hunyuan Video - Alternative T2V

• OpenSora - Alternative zu Open Sora

• Stable Video Diffusion - Bildanimation

• RIFE-Interpolation - Frame-Interpolation