Wan2.1 Video

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

Erstellen 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 gemietet wurden über CLORE.AI-Marktplatz.

Warum Wan2.1?

• Hohe Qualität - Videogenerierung auf dem neuesten Stand der Technik

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

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

• Lange Videos - Bis zu 81 Frames

• Offene Gewichte - Apache-2.0-Lizenz

Modellvarianten

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

Schnellbereitstellung auf CLORE.AI

Docker-Image:

pytorch/pytorch:2.11.0-cuda12.8-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='Eingabeaufforderung'),
        gr.Slider(20, 100, value=50, label='Schritte'),
        gr.Slider(16, 81, value=49, step=8, label='Frames'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Video(),
    title='Wan2.1 - Text zu Video'
).launch(server_name='0.0.0.0', server_port=7860)
"

Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

1. Gehe zu Meine Bestellungen Seite

2. Klicke auf deine Bestellung

3. Finde die http_pub URL (z. B. abc123.clorecloud.net)

Verwende https://YOUR_HTTP_PUB_URL anstelle von localhost in den folgenden Beispielen.

Hardware-Anforderungen

Modell	Minimale GPU	Empfohlen	Optimal
1.3B T2V	RTX 3070 8GB	RTX 3090 24 GB	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, detailreich"

output = pipe(
    prompt=prompt,
    negative_prompt="unscharf, 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

Animiere ein Bild

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()

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

prompt = "Die Person im 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 mithilfe eines Text-Prompts zur Steuerung der Bewegung. Erfordert 24 GB VRAM (RTX 4090 oder A100 40GB empfohlen).

Modelldetails

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

Hardware-Anforderungen

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

Schnelles CLI-Skript

Speichern unter generate_i2v.py und ausführen:

python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P --image input.jpg --prompt "Die Kamera zoomt langsam heraus"

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 "Die Kamera zoomt langsam heraus"
"""

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-Bild-zu-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. "Die Kamera zoomt langsam heraus")',
    )
    parser.add_argument(
        "--negative-prompt",
        type=str,
        default="unscharf, 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 Video-Frames (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-Skala (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="FPS des Ausgabevideos (Standard: 16)",
    )
    parser.add_argument(
        "--output",
        type=str,
        default="output_i2v.mp4",
        help="Dateipfad für das Ausgabevideo (Standard: output_i2v.mp4)",
    )
    parser.add_argument(
        "--height",
        type=int,
        default=480,
        help="Höhe des Ausgabevideos in Pixeln (Standard: 480)",
    )
    parser.add_argument(
        "--width",
        type=int,
        default=854,
        help="Breite des Ausgabevideos in Pixeln (Standard: 854)",
    )
    parser.add_argument(
        "--cpu-offload",
        action="store_true",
        default=True,
        help="CPU-Offloading des Modells aktivieren, um VRAM zu sparen (Standard: True)",
    )
    parser.add_argument(
        "--vae-tiling",
        action="store_true",
        default=False,
        help="VAE-Tiling für hochauflösende Ausgaben aktivieren",
    )
    return parser.parse_args()


def load_and_resize_image(image_path: str, width: int, height: int) -> Image.Image:
    """Bild aus Pfad laden und auf Zielabmessungen skalieren."""
    if not os.path.exists(image_path):
        print(f"[ERROR] Bild nicht gefunden: {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] Bild geladen: {image_path} ({original_size[0]}x{original_size[1]}) → auf {width}x{height} skaliert")
    return img


def load_pipeline(model_id: str, cpu_offload: bool, vae_tiling: bool):
    """Die Wan-I2V-Pipeline mit Speicheroptimierungen laden."""
    print(f"[INFO] Modell wird geladen: {model_id}")
    print(f"[INFO] CUDA verfügbar: {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 24 GB 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] CPU-Offload des Modells wird aktiviert")
        pipe.enable_model_cpu_offload()
    else:
        pipe.to("cuda")

    if vae_tiling:
        print("[INFO] VAE-Tiling für hochauflösende Generierung wird aktiviert")
        pipe.enable_vae_tiling()

    return pipe


def generate_video(pipe, args) -> None:
    """Die I2V-Pipeline ausführen und das Ausgabevideo speichern."""
    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] Verwendeter Seed: {args.seed}")
    else:
        print("[INFO] Zufälligen Seed verwenden")

    print(f"[INFO] Generiere {args.frames} Frames mit {args.width}x{args.height}")
    print(f"[INFO] Schritte: {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 gespeichert unter: {os.path.abspath(args.output)}")
    duration = args.frames / args.fps
    print(f"[INFO] Dauer: {duration:.1f}s bei {args.fps}fps ({args.frames} Frames)")


def main():
    args = parse_args()

    if not torch.cuda.is_available():
        print("[ERROR] Keine CUDA-GPU 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-Generierung 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 24 GB
pipe.enable_vae_tiling()          # optional: hilft bei 720p

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

# ── Generieren ───────────────────────────────────────────────────────────────────
prompt = "Die Kamera zoomt langsam heraus und zeigt die gesamte Landschaft"
negative_prompt = "unscharf, niedrige Qualität, verzerrt, flackernd, 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	"Die Kamera zoomt langsam vom Motiv weg"
Parallax-Effekt	"subtile Parallax-Bewegung, Tiefenschärfe-Verschiebung"
Charakteranimation	"die Figur dreht den Kopf und lächelt"
Naturanimation	"Blätter rascheln in einer sanften Brise, Licht verändert sich"
Abstrakte Bewegung	"Farben wirbeln und vermischen sich, flüssige Bewegung"

Speichertipps für I2V (24-GB-GPUs)

# Auf 24-GB-GPUs erforderlich
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 über Berggipfel ziehen, dramatische Beleuchtung",
    "Ozeanwellen, die gegen Felsen schlagen, Zeitlupe, filmisch",
    "Nordlichter tanzen am Nachthimmel, leuchtende 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 zieht das Schwert, dramatische Beleuchtung",
    "Roboter, der durch futuristische Stadtstraßen geht"
]

Abstrakt & Künstlerisch

prompts = [
    "Bunte Farbe, die in Wasser wirbelt, abstrakte Kunst",
    "Geometrische Formen, die sich verwandeln und morphieren, Neonfarben",
    "Tintentropfen, 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-Generierung

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 = [
    "Eine Rakete startet ins All",
    "Fische, die in einem Korallenriff schwimmen",
    "Regen, der nachts auf eine 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="Eingabeaufforderung", lines=2),
        gr.Textbox(label="Negativer Prompt", value="unscharf, niedrige Qualität"),
        gr.Slider(17, 81, value=49, step=8, label="Frames"),
        gr.Slider(20, 100, value=50, step=5, label="Schritte"),
        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 zu Video-Generierung",
    description="Videos aus Texteingaben generieren. Läuft auf CLORE.AI."
)

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

Speicheroptimierung

# Alle Optimierungen aktivieren
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.

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise:

GPU	Stundensatz	~49-Frame-Videos/Stunde
RTX 3090 24 GB	~$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-Marktplatz für aktuelle Preise.

Fehlerbehebung

Speicher erschöpft

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

# Alle Optimierungen aktivieren
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

• Schritte erhöhen (75-100)

• Formuliere detailliertere Prompts

• Verwende Negative Prompts

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

Video zu kurz

• Erhöhen Sie num_frames (max. 81)

• Verwende RIFE-Interpolation für die Frame-Interpolation

• Verknüpfe mehrere Generierungen

Artefakte/Flickern

• Erhöhe die Guidance-Skala

• Verwende einen festen Seed für Konsistenz

• Nachbearbeitung mit Videostabilisierung

Wan2.1 vs. andere

Funktion	Wan2.1	Hunyuan	SVD	CogVideoX
Qualität	Hervorragend	Hervorragend	Gut	Großartig
Geschwindigkeit	Schnell	Mittel	Schnell	Langsam
Max. 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

Verwende Wan2.1, wenn:

• Open-Source-Videogenerierung benötigt wird

• eine schnelle Generierungsgeschwindigkeit gewünscht ist

• Apache-2.0-Lizenz erforderlich

• ein ausgewogenes Verhältnis von Qualität und Geschwindigkeit benötigt wird

Nächste Schritte

• Hunyuan Video - Alternative T2V

• OpenSora - Open-Sora-Alternative

• Stable Video Diffusion - Bildanimation

• RIFE-Interpolation - Frame-Interpolation