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

👁 238 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. Da się ją uruchomić na jednej takiej karcie. 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.

Porównanie wszystkich generatorów: generator wideo AI - ranking 10/2026, ceny i test po polsku · po polsku, bez abonamentu: ZWID (mój serwis)

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 powstaje 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.

Najprościej: Hangar

Wan 2.2 TI2V 5B jest w katalogu Hangara. To moje narzędzie: darmowy menedżer lokalnych modeli obrazu, wideo i muzyki na Windows, bez konta, z ComfyUI pod spodem. Zestaw to te same trzy pliki co wyżej, razem 18,1 GB (model fp16 10,0 GB, enkoder umT5 fp8 6,74 GB, VAE 1,41 GB). Lżejszego wariantu katalog na razie nie ma, więc na karcie 12-16 GB ComfyUI przeniesie część wag do RAM i będzie wolniej. Licencja Apache 2.0, klipy wolno wykorzystywać komercyjnie, także w UE.

1. Pobierz instalator (14 MB) ze strony Hangara. Nie jest jeszcze podpisany cyfrowo, więc Windows SmartScreen pokaże ostrzeżenie: kliknij „Więcej informacji”, a potem „Uruchom mimo to”.
2. Hangar wykrywa kartę (Nvidia z CUDA, od 8 GB VRAM, najlepiej 12 GB i więcej) i pokazuje, czy model się zmieści.
3. Wybierz Wan 2.2 TI2V 5B. Hangar pobiera pliki z Hugging Face i sprawdza ich sumy sha256.
4. Wpisz opis sceny po angielsku, ustaw długość w sekundach i kliknij generuj.

W teście Hangara na RTX 4090 (17 października 2026) klip 2 s w 1280×704 powstał w 105 s razem z ładowaniem modelu. Instalator i opis: Hangar.

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

Zobacz też: Wan AI: wszystkie wersje, ceny i moje testy z filmami · Wan 3.0 kontra Wan 2.2 na tych samych poleceniach

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. Generowanie pierwszego klipu po starcie trwało 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.

// czytaj dalejPinterest robi własnego chatbota zakupowego. I nie chce go nikomu sprzedawaćNewsyAI w HR trafia pod lupę. Automatyzacja rekrutacji musi umieć wyjaśnić własne decyzjePremiumEuropa kłóci się o własne prawo AI. Po 12 godzinach rozmów nie ma porozumieniaPremium