Wan 2.2 lokalnie: wideo z AI na własnej karcie - czas, VRAM, próbki

👁 116 przeczytań

Wan 2.2 to darmowy model wideo od Alibaby, który można uruchomić na własnym komputerze i używać komercyjnie. 26 września 2026 roku wygenerowałem nim cztery 5-sekundowe klipy 720p na karcie RTX 4090, w ComfyUI, w najmniejszej wersji TI2V 5B. Jeden klip zajmował karcie około 4 minut. Poniżej wszystkie cztery klipy bez poprawek, z czasem, zużyciem pamięci i błędami, które widać gołym okiem.

Co to jest Wan 2.2 i która wersja działa w domu

Wan 2.2 to rodzina otwartych modeli wideo zespołu Wan-AI z Alibaby, udostępniona na licencji Apache 2.0. Większe warianty (14 mld parametrów) potrzebują znacznie więcej pamięci niż ma typowa karta dla graczy. Wersja TI2V 5B ma 5 mld parametrów i robi wideo zarówno z tekstu, jak i z obrazka startowego. Ją da się uruchomić na jednej karcie dla graczy. Użyłem gotowych plików przygotowanych przez zespół ComfyUI:

• model wan2.2_ti2v_5B_fp16.safetensors - 10,0 GB,
• koder tekstu umt5_xxl_fp8_e4m3fn_scaled.safetensors - 6,7 GB,
• VAE wan2.2_vae.safetensors - 1,4 GB.

Pliki trafiają do folderów models/diffusion_models, models/text_encoders i models/vae w ComfyUI. Jak postawić samo ComfyUI, opisuję w poradniku ComfyUI od zera.

Ustawienia i pomiary

Każdy klip: 1280×704, 121 klatek przy 24 kl./s (5,04 s), 20 kroków, CFG 5, sampler uni_pc, przesunięcie 8. To ustawienia z oficjalnego szablonu ComfyUI dla Wan 2.2 5B. Karta: RTX 4090 24 GB, Windows 11, ComfyUI 0.37.

Pierwszy klip w serii trwa ponad dwa razy dłużej, bo model wczytuje się z dysku do pamięci. Kolejne to około 4 minuty. Szczyt pamięci obejmuje około 3,4 GB zajętych wcześniej przez system i przeglądarkę, więc sam Wan potrzebował około 20 GB. Na kartach z 12-16 GB ComfyUI przeniesie część modelu do pamięci RAM. To działa, ale generowanie potrwa dłużej. Nie mierzyłem tego.

Klipy: co wyszło, a co nie

1. Kawa nalewana do filiżanki

2. Warszawski tramwaj w deszczu

3. Lama na górskiej łące

4. Animacja 2D: praca nocą i kot

Wzór jest wyraźny: im mniej ruchu i fizyki, tym lepiej. Ujęcia „ze statywu” z ruchem w tle (deszcz, tramwaj, liście) wychodzą przekonująco. Precyzyjne czynności, jak nalewanie płynu czy konkretny gest zwierzęcia, model upraszcza albo przekręca.

Wan 2.2 lokalnie czy generator w chmurze

Ceny generatorów w chmurze zmieniają się co tydzień. Aktualne porównanie jest w hubie generatory wideo AI. To moja opinia: Wan 2.2 5B lokalnie opłaca się, gdy potrzebujesz dziesiątek ujęć roboczych, tła albo materiału do montażu, a nie jednego efektownego klipu.

Gotowy skrypt: klip z jednego polecenia

Pliki modelu pobierze skrypt instalacyjny z poradnika ComfyUI z opcją -Modele wan. Do samego generowania przygotowałem skrypt, który wysyła polecenie do ComfyUI, czeka na klatki i składa je w MP4 przez ffmpeg. Długość podajesz w sekundach, a skrypt sam przelicza ją na liczbę klatek w formacie, którego wymaga Wan (4n+1). Sprawdziłem go 26.09.2026 na krótkim klipie testowym: 2 sekundy w 640×352, 49 klatek, gotowy plik MP4.

• Pobierz: generuj-wideo.py (6 KB) albo wszystkie 5 skryptów w jednym pliku ZIP (15 KB).
• Klip 5 s 720p: python generuj-wideo.py "a yellow tram passing a rainy street at dusk, static camera"
• Szybszy podgląd: --sekundy 3 --szer 960 --wys 544 --kroki 12. Do MP4 potrzebny jest ffmpeg (winget install Gyan.FFmpeg), bez niego dostaniesz klatki PNG.

Zanim uruchomisz jakikolwiek skrypt z internetu, przeczytaj go. Działa z twoimi uprawnieniami. Dlatego poniżej jest pełny kod, bez skracania, z komentarzami po polsku. Skrypty są na licencji MIT: możesz je zmieniać i używać także w firmie.

"""
generuj-wideo.py - klip z Wan 2.2 TI2V 5B przez lokalne ComfyUI (promptowy.com/wan-2-2/)
Autor: Piotr Olszewski, promptowy.com. 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()

Najczęstsze pytania

Jaka karta graficzna jest potrzebna do Wan 2.2?

W moim teście Wan 2.2 TI2V 5B zajął około 20 GB pamięci RTX 4090 przy wideo 1280×704. Na kartach z 12-16 GB działa wolniej, z częścią modelu w pamięci RAM. Większe warianty 14B wymagają dużo więcej pamięci.

Ile trwa wygenerowanie filmu w Wan 2.2?

Około 4 minut na 5-sekundowy klip 720p (121 klatek, 20 kroków) na RTX 4090, gdy model jest już wczytany. Pierwszy klip po starcie trwał 574 s, bo doszło wczytanie 18 GB plików z dysku.

Czy Wan 2.2 jest darmowy i czy można go używać komercyjnie?

Tak. Wagi są na Hugging Face na licencji Apache 2.0, która pozwala na użytek komercyjny. Płacisz tylko za prąd, około 2 groszy za klip.

Czy Wan 2.2 robi wideo z dźwiękiem?

Nie. Wersja 5B generuje sam obraz. Dźwięk trzeba dodać w montażu.