Wan 2.2 lokal: KI-Video auf eigener Grafikkarte - Test RTX 4090

👁 118 Aufrufe

Wan 2.2 ist ein kostenloses Video-Modell von Alibaba, das Sie auf dem eigenen Computer ausführen und kommerziell nutzen können. Am 26. September 2026 haben wir damit vier 5-Sekunden-Clips in 720p auf einer RTX 4090 generiert, in ComfyUI, mit der kleinsten Version TI2V 5B. Ein Clip benötigte etwa 4 Minuten. Im Folgenden alle vier Clips ohne Nachbearbeitung, mit Zeit, Speicherverbrauch und Fehlern, die mit bloßem Auge sichtbar sind.

Was ist Wan 2.2 und welche Version läuft zu Hause

Wan 2.2 ist eine Familie offener Video-Modelle des Wan-AI-Teams von Alibaba, veröffentlicht unter Apache-2.0-Lizenz. Größere Varianten (14 Mrd. Parameter) benötigen deutlich mehr Speicher als eine typische Gaming-Grafikkarte hat. Die Version TI2V 5B hat 5 Mrd. Parameter und erstellt Videos sowohl aus Text als auch aus einem Startbild. Sie lässt sich auf einer solchen Karte ausführen. Wir haben die fertigen Dateien verwendet, die vom ComfyUI-Team bereitgestellt wurden:

• Modell wan2.2_ti2v_5B_fp16.safetensors - 10,0 GB,
• Text-Encoder umt5_xxl_fp8_e4m3fn_scaled.safetensors - 6,7 GB,
• VAE wan2.2_vae.safetensors - 1,4 GB.

Die Dateien kommen in die Ordner models/diffusion_models, models/text_encoders und models/vae in ComfyUI. Wie Sie ComfyUI selbst aufsetzen, beschreiben wir im Leitfaden ComfyUI von Grund auf.

Einstellungen und Messwerte

Jeder Clip: 1280×704, 121 Frames bei 24 fps (5,04 s), 20 Steps, CFG 5, Sampler uni_pc, Shift 8. Das sind die Einstellungen aus dem offiziellen ComfyUI-Template für Wan 2.2 5B. Karte: RTX 4090 24 GB, Windows 11, ComfyUI 0.37.

Der erste Clip einer Serie dauert über doppelt so lang, weil das Modell von der Festplatte in den Speicher geladen wird. Folgende dauern etwa 4 Minuten. Die VRAM-Spitze umfasst etwa 3,4 GB, die zuvor von System und Browser belegt waren, das Modell selbst benötigte also etwa 20 GB. Bei Karten mit 12-16 GB verschiebt ComfyUI einen Teil des Modells in den RAM. Das funktioniert, aber die Generierung dauert länger. Wir haben das nicht gemessen.

Clips: Was funktioniert und was nicht

1. Kaffee wird in Tasse gegossen

2. Warschauer Straßenbahn im Regen

3. Lama auf Bergwiese

4. 2D-Animation: Nachtarbeit und Katze

Das Muster ist deutlich: Je weniger Bewegung und Physik, desto besser. Aufnahmen „vom Stativ“ mit Bewegung im Hintergrund (Regen, Straßenbahn, Blätter) wirken überzeugend. Präzise Handlungen wie das Eingießen von Flüssigkeit oder eine konkrete Geste eines Tieres vereinfacht oder verdreht das Modell.

Wan 2.2 lokal oder Cloud-Generator

Die Preise der Cloud-Generatoren ändern sich wöchentlich. Einen aktuellen Vergleich finden Sie im Hub KI-Video-Generatoren. Unsere Meinung: Wan 2.2 5B lokal lohnt sich, wenn Sie Dutzende Arbeitsaufnahmen, Hintergründe oder Schnittmaterial brauchen, nicht einen einzigen effektvollen Clip.

Fertiges Skript: Clip aus einem Prompt

Die Modelldateien lädt das Installationsskript aus dem Leitfaden ComfyUI mit der Option -Modele wan. Für die Generierung selbst haben wir ein Skript vorbereitet, das den Prompt an ComfyUI sendet, auf die Frames wartet und sie per ffmpeg zu MP4 zusammenfügt. Die Länge geben Sie in Sekunden an, das Skript rechnet sie automatisch in die Frame-Anzahl im Format um, das Wan verlangt (4n+1). Wir haben es am 26.09.2026 an einem kurzen Testclip geprüft: 2 Sekunden in 640×352, 49 Frames, fertige MP4-Datei.

• Download: generuj-wideo.py (6 KB) oder alle 5 Skripte in einer ZIP-Datei (15 KB).
• Clip 5 s 720p: python generuj-wideo.py "a yellow tram passing a rainy street at dusk, static camera"
• Schnellere Vorschau: --sekundy 3 --szer 960 --wys 544 --kroki 12. Für MP4 wird ffmpeg benötigt (winget install Gyan.FFmpeg), ohne erhalten Sie PNG-Frames.

Bevor Sie irgendein Skript aus dem Internet ausführen, lesen Sie es. Es läuft mit Ihren Berechtigungen. Deshalb folgt unten der vollständige Code, ohne Kürzung, mit Kommentaren auf Polnisch (wir haben den Test auf Polnisch durchgeführt). Die Skripte stehen unter MIT-Lizenz: Sie können sie ändern und auch geschäftlich nutzen.

"""
generuj-wideo.py - klip z Wan 2.2 TI2V 5B przez lokalne ComfyUI (wissnox.de/wan-2-2/)
Autor: Piotr Olszewski, wissnox.de. Licencja skryptu: MIT. Sprawdzone 26.09.2026: ComfyUI 0.37, RTX 4090.

Wymaga: działającego ComfyUI (http://127.0.0.1:8188) z plikami Wan 2.2 5B
(instaluj-comfyui.ps1 -Modele wan) oraz ffmpeg w PATH do złożenia MP4 (winget install Gyan.FFmpeg).
Bez ffmpeg zostają same klatki PNG. Tylko biblioteka standardowa Pythona 3.9+.

Przykłady:
  python generuj-wideo.py "a yellow tram passing a rainy street at dusk, static camera, realistic"
  python generuj-wideo.py "flat 2D animation of a cat walking across a desk" --sekundy 3 --szer 960 --wys 544

Na RTX 4090: 5 s w 1280x704 to ok. 4 minuty (pierwszy klip dłużej - wczytanie 18 GB z dysku).
Model najlepiej radzi sobie ze statyczną kamerą i ruchem w tle, słabo z precyzyjną fizyką (nalewanie, gesty).
"""
import argparse, json, os, random, shutil, subprocess, sys, tempfile, time, urllib.parse, urllib.request, uuid

FPS = 24
NEG = "blurry, distorted, low quality, jitter, watermark, text, subtitles, static image, deformed hands, extra limbs"


def graf(polecenie, szer, wys, klatki, kroki, seed, prefiks):
    # odpowiednik oficjalnego szablonu ComfyUI „Wan 2.2 5B text to video"
    return {
        "1": {"class_type": "UNETLoader", "inputs": {"unet_name": "wan2.2_ti2v_5B_fp16.safetensors", "weight_dtype": "default"}},
        "2": {"class_type": "CLIPLoader", "inputs": {"clip_name": "umt5_xxl_fp8_e4m3fn_scaled.safetensors", "type": "wan", "device": "default"}},
        "3": {"class_type": "VAELoader", "inputs": {"vae_name": "wan2.2_vae.safetensors"}},
        "4": {"class_type": "CLIPTextEncode", "inputs": {"clip": ["2", 0], "text": polecenie}},
        "5": {"class_type": "CLIPTextEncode", "inputs": {"clip": ["2", 0], "text": NEG}},
        "6": {"class_type": "ModelSamplingSD3", "inputs": {"model": ["1", 0], "shift": 8.0}},
        "7": {"class_type": "Wan22ImageToVideoLatent", "inputs": {"vae": ["3", 0], "width": szer, "height": wys, "length": klatki, "batch_size": 1}},
        "8": {"class_type": "KSampler", "inputs": {"model": ["6", 0], "seed": seed, "steps": kroki, "cfg": 5.0, "sampler_name": "uni_pc", "scheduler": "simple",
                                                    "positive": ["4", 0], "negative": ["5", 0], "latent_image": ["7", 0], "denoise": 1.0}},
        "9": {"class_type": "VAEDecode", "inputs": {"samples": ["8", 0], "vae": ["3", 0]}},
        "10": {"class_type": "SaveImage", "inputs": {"images": ["9", 0], "filename_prefix": prefiks}},
    }


def api(serwer, sciezka, dane=None):
    req = urllib.request.Request(serwer + sciezka, data=json.dumps(dane).encode() if dane is not None else None,
                                 headers={"Content-Type": "application/json"})
    return json.load(urllib.request.urlopen(req, timeout=60))


def main():
    a = argparse.ArgumentParser(description="Klip wideo z Wan 2.2 5B przez lokalne ComfyUI")
    a.add_argument("polecenie", help="opis ujęcia (najlepiej po angielsku, z opisem kamery)")
    a.add_argument("--sekundy", type=float, default=5.0, help="długość klipu (domyślnie 5 s)")
    a.add_argument("--szer", type=int, default=1280); a.add_argument("--wys", type=int, default=704)
    a.add_argument("--kroki", type=int, default=20)
    a.add_argument("--seed", type=int, default=None)
    a.add_argument("--serwer", default="http://127.0.0.1:8188")
    a.add_argument("--wyjscie", default="wideo")
    x = a.parse_args()
    if x.szer % 32 or x.wys % 32:
        a.error("szerokość i wysokość muszą być wielokrotnością 32 (np. 1280x704, 960x544)")
    klatki = int(round(x.sekundy * FPS / 4)) * 4 + 1          # Wan wymaga długości 4n+1
    try:
        api(x.serwer, "/system_stats")
    except Exception as e:
        sys.exit(f"Nie mogę połączyć się z ComfyUI pod {x.serwer} ({e}). Uruchom start-comfyui.bat.")
    seed = x.seed if x.seed is not None else random.randint(1, 2**31)
    prefiks = f"wan_{uuid.uuid4().hex[:8]}"
    print(f"Generuję {klatki} klatek ({klatki / FPS:.1f} s) w {x.szer}x{x.wys}, ziarno {seed}...")
    t0 = time.time()
    pid = api(x.serwer, "/prompt", {"prompt": graf(x.polecenie, x.szer, x.wys, klatki, x.kroki, seed, prefiks), "client_id": str(uuid.uuid4())})["prompt_id"]
    while True:
        h = api(x.serwer, f"/history/{pid}")
        if pid in h:
            break
        print(f"r  trwa... {time.time() - t0:.0f} s", end="", flush=True)
        time.sleep(2)
    print()
    wynik = h[pid]
    if wynik.get("status", {}).get("status_str") != "success":
        sys.exit("Błąd ComfyUI: " + json.dumps(wynik.get("status", {}), ensure_ascii=False)[:600])
    imgs = sorted([o for v in wynik["outputs"].values() for o in v.get("images", [])], key=lambda o: o["filename"])
    os.makedirs(x.wyjscie, exist_ok=True)
    tmp = tempfile.mkdtemp(prefix="wan_")
    for i, img in enumerate(imgs):
        q = urllib.parse.urlencode({"filename": img["filename"], "subfolder": img.get("subfolder", ""), "type": img.get("type", "output")})
        with urllib.request.urlopen(f"{x.serwer}/view?{q}", timeout=60) as r, open(os.path.join(tmp, f"{i:04d}.png"), "wb") as f:
            shutil.copyfileobj(r, f)
    czas = time.time() - t0
    nazwa = os.path.join(x.wyjscie, f"wan_{time.strftime('%Y%m%d_%H%M%S')}_{seed}")
    if shutil.which("ffmpeg"):
        subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-framerate", str(FPS), "-i", os.path.join(tmp, "%04d.png"),
                        "-c:v", "libx264", "-crf", "20", "-pix_fmt", "yuv420p", "-movflags", "+faststart", nazwa + ".mp4"], check=True)
        shutil.rmtree(tmp, ignore_errors=True)
        print(f"Gotowe: {nazwa}.mp4 ({len(imgs)} klatek, {czas:.0f} s)")
    else:
        shutil.move(tmp, nazwa + "_klatki")
        print(f"Gotowe: klatki PNG w {nazwa}_klatki ({czas:.0f} s). Zainstaluj ffmpeg, żeby dostać MP4.")


if __name__ == "__main__":
    main()

Siehe auch: Wan AI: alle Versionen, Preise und unsere Tests mit Videos · Wan 3.0 gegen Wan 2.2 mit denselben Prompts

Häufig gestellte Fragen

Welche Grafikkarte braucht man für Wan 2.2?

In unserem Test belegte Wan 2.2 TI2V 5B etwa 20 GB Speicher der RTX 4090 bei Video 1280×704. Auf Karten mit 12-16 GB läuft es langsamer, mit einem Teil des Modells im RAM. Größere Varianten 14B benötigen deutlich mehr Speicher.

Wie lange dauert die Generierung eines Videos in Wan 2.2?

Etwa 4 Minuten für einen 5-Sekunden-Clip in 720p (121 Frames, 20 Steps) auf RTX 4090, wenn das Modell bereits geladen ist. Die Generierung des ersten Clips nach dem Start dauerte 574 s, weil das Laden von 18 GB Dateien von der Festplatte hinzukam.

Ist Wan 2.2 kostenlos und kann man es kommerziell nutzen?

Ja. Die Weights sind auf Hugging Face unter Apache-2.0-Lizenz verfügbar, die kommerzielle Nutzung erlaubt. Sie zahlen nur für Strom, etwa 2 Cent pro Clip.

Erstellt Wan 2.2 Videos mit Ton?

Nein. Die 5B-Version generiert nur Bild. Ton muss im Schnitt hinzugefügt werden.

// weiterlesenEine Grafikkarte per WLAN ist das überflüssigste Gadget des JahresTechnikWarum mich der Comeback-Erfolg des Ryzen 5800X3D an meine eigene Aufruestmuedigkeit erinnertTechnikEigene Punktzahl oder Rang: Was wirklich über unsere Zufriedenheit entscheidetGeist