Wan 2.2 in locale: test su RTX 4090, tempi, VRAM e video

👁 118 letture

Wan 2.2 è un modello video gratuito di Alibaba che puoi eseguire sul tuo computer e usare commercialmente. Il 26 settembre 2026 abbiamo generato quattro clip da 5 secondi a 720p su una RTX 4090, in ComfyUI, nella versione più piccola TI2V 5B. Ogni clip ha richiesto circa 4 minuti alla scheda. Di seguito trovi tutti e quattro i clip senza modifiche, con tempi, consumo di memoria ed errori visibili a occhio nudo.

Gli importi in EUR sono conversioni indicative dei prezzi pubblicati in USD, calcolate al cambio di riferimento BCE del 2026-10-12: 1 EUR = 1.1181 USD. Non sono prezzi locali confermati né importi finali comprensivi di imposte. Il fornitore e la banca possono applicare altri cambi o commissioni. ECB.

Cos’è Wan 2.2 e quale versione funziona in locale

Wan 2.2 è una famiglia di modelli video open source del team Wan-AI di Alibaba, rilasciati con licenza Apache 2.0. Le varianti più grandi (14 miliardi di parametri) richiedono molta più memoria di quella disponibile su una tipica scheda da gaming. La versione TI2V 5B ha 5 miliardi di parametri e genera video sia da testo che da immagine iniziale. Può essere eseguita su una singola scheda di questo tipo. Abbiamo usato i file pronti preparati dal team ComfyUI:

• modello wan2.2_ti2v_5B_fp16.safetensors - 10,0 GB,
• encoder di testo umt5_xxl_fp8_e4m3fn_scaled.safetensors - 6,7 GB,
• VAE wan2.2_vae.safetensors - 1,4 GB.

I file vanno nelle cartelle models/diffusion_models, models/text_encoders e models/vae in ComfyUI. Come installare ComfyUI è descritto nella guida ComfyUI da zero.

Impostazioni e misurazioni

Ogni clip: 1280×704, 121 frame a 24 fps (5,04 s), 20 step, CFG 5, sampler uni_pc, shift 8. Sono le impostazioni del template ufficiale ComfyUI per Wan 2.2 5B. Scheda: RTX 4090 24 GB, Windows 11, ComfyUI 0.37.

Il primo clip di una serie richiede più del doppio del tempo perché il modello viene caricato dal disco in memoria. I successivi richiedono circa 4 minuti. Il picco di memoria include circa 3,4 GB già occupati da sistema e browser, quindi Wan da solo ha richiesto circa 20 GB. Su schede con 12-16 GB ComfyUI sposterà parte del modello nella RAM. Funziona, ma la generazione richiederà più tempo. Non l’abbiamo misurato.

Clip: cosa ha funzionato e cosa no

1. Caffè versato in una tazza

2. Tram sotto la pioggia

3. Lama su un prato di montagna

4. Animazione 2D: lavoro notturno e gatto

Il pattern è chiaro: meno movimento e fisica, meglio è. Le inquadrature “da cavalletto” con movimento sullo sfondo (pioggia, tram, foglie) risultano convincenti. Azioni precise come versare liquidi o gesti specifici di animali vengono semplificati o distorti dal modello.

Wan 2.2 in locale o generatore cloud

I prezzi dei generatori cloud cambiano ogni settimana. Il confronto aggiornato è nell’hub generatori video AI. La nostra opinione: Wan 2.2 5B in locale conviene quando hai bisogno di decine di inquadrature di lavoro, sfondi o materiale per il montaggio, non di un singolo clip d’effetto.

Script pronto: clip da un singolo prompt

I file del modello verranno scaricati dallo script di installazione della guida ComfyUI con l’opzione -Modelli wan. Per la generazione vera e propria abbiamo preparato uno script che invia il prompt a ComfyUI, attende i frame e li compone in MP4 tramite ffmpeg. La durata la specifichi in secondi e lo script la converte automaticamente nel numero di frame nel formato richiesto da Wan (4n+1). L’abbiamo testato il 26.09.2026 su un clip breve: 2 secondi a 640×352, 49 frame, file MP4 pronto.

• Scarica: generuj-wideo.py (6 KB) oppure tutti e 5 gli script in un unico file ZIP (15 KB).
• Clip 5 s 720p: python generuj-wideo.py "a yellow tram passing a rainy street at dusk, static camera"
• Anteprima più veloce: --sekundy 3 --szer 960 --wys 544 --kroki 12. Per l’MP4 serve ffmpeg (winget install Gyan.FFmpeg), senza otterrai frame PNG.

Prima di eseguire qualsiasi script da internet, leggilo. Viene eseguito con i tuoi permessi. Per questo motivo sotto c’è il codice completo, senza abbreviazioni, con commenti in polacco (lo script è stato testato in polacco). Gli script sono sotto licenza MIT: puoi modificarli e usarli anche in azienda.

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

Vedi anche: Wan AI: tutte le versioni, prezzi e i nostri test con i video · Wan 3.0 contro Wan 2.2 con gli stessi prompt

Domande frequenti

Quale scheda grafica serve per Wan 2.2?

Nel nostro test Wan 2.2 TI2V 5B ha occupato circa 20 GB di memoria della RTX 4090 con video 1280×704. Su schede con 12-16 GB funziona più lentamente, con parte del modello nella RAM. Le varianti più grandi 14B richiedono molta più memoria.

Quanto tempo serve per generare un video con Wan 2.2?

Circa 4 minuti per un clip da 5 secondi a 720p (121 frame, 20 step) su RTX 4090, quando il modello è già caricato. La generazione del primo clip dopo l’avvio ha richiesto 574 s perché includeva il caricamento di 18 GB di file dal disco.

Wan 2.2 è gratuito e si può usare commercialmente?

Sì. I pesi sono su Hugging Face con licenza Apache 2.0, che permette l’uso commerciale. Paghi solo la corrente, circa 2 centesimi per clip.

Wan 2.2 genera video con audio?

No. La versione 5B genera solo immagini. L’audio va aggiunto in fase di montaggio.

// continua a leggereHiggsfield: come usarlo per pubblicità, video e contenuti socialMagazineModello AI locale o API: costi reali con RTX 4090 e confrontoMagazineWan 3.0 vs Wan 2.2: stesso prompt, 8 video a confrontoMagazine