Wan 2.2 en local: vídeo con IA en tu tarjeta - tiempo, VRAM

👁 135 lecturas

Wan 2.2 es un modelo de vídeo gratuito de Alibaba que puedes ejecutar en tu propio ordenador y usar comercialmente. El 26 de septiembre de 2026 generamos con él cuatro clips de 5 segundos a 720p en una tarjeta RTX 4090, en ComfyUI, en la versión más pequeña TI2V 5B. Cada clip le llevó a la tarjeta unos 4 minutos. A continuación, los cuatro clips sin retoques, con el tiempo, el consumo de memoria y los errores que se ven a simple vista.

Las cantidades en EUR son conversiones orientativas de los precios publicados en USD, calculadas con el tipo de referencia del BCE del 2026-10-12: 1 EUR = 1.1181 USD. No son precios locales confirmados ni importes finales con impuestos. El proveedor y el banco pueden aplicar otros tipos o cargos. ECB.

Qué es Wan 2.2 y qué versión funciona en casa

Wan 2.2 es una familia de modelos de vídeo abiertos del equipo Wan-AI de Alibaba, publicada bajo licencia Apache 2.0. Las variantes más grandes (14 mil millones de parámetros) necesitan mucha más memoria de la que tiene una tarjeta típica para jugadores. La versión TI2V 5B tiene 5 mil millones de parámetros y hace vídeo tanto desde texto como desde una imagen inicial. Se puede ejecutar en una sola tarjeta de este tipo. Usamos los archivos preparados por el equipo de ComfyUI:

• modelo wan2.2_ti2v_5B_fp16.safetensors - 10,0 GB,
• codificador de texto umt5_xxl_fp8_e4m3fn_scaled.safetensors - 6,7 GB,
• VAE wan2.2_vae.safetensors - 1,4 GB.

Los archivos van a las carpetas models/diffusion_models, models/text_encoders y models/vae en ComfyUI. Cómo instalar ComfyUI lo explicamos en la guía ComfyUI desde cero.

Configuración y mediciones

Cada clip: 1280×704, 121 fotogramas a 24 fps (5,04 s), 20 pasos, CFG 5, sampler uni_pc, desplazamiento 8. Esta es la configuración de la plantilla oficial de ComfyUI para Wan 2.2 5B. Tarjeta: RTX 4090 24 GB, Windows 11, ComfyUI 0.37.

El primer clip de una serie tarda más del doble porque el modelo se carga del disco a la memoria. Los siguientes tardan unos 4 minutos. El pico de memoria incluye unos 3,4 GB ocupados previamente por el sistema y el navegador, así que Wan en sí necesitó unos 20 GB. En tarjetas con 12-16 GB, ComfyUI trasladará parte del modelo a la RAM. Funciona, pero la generación tardará más. No lo medimos.

Clips: qué salió bien y qué no

1. Café vertiéndose en una taza

2. Tranvía de Varsovia bajo la lluvia

3. Llama en un prado de montaña

4. Animación 2D: trabajo nocturno y gato

El patrón es claro: cuanto menos movimiento y física, mejor. Los planos «con trípode» con movimiento de fondo (lluvia, tranvía, hojas) salen convincentes. Las acciones precisas, como verter líquido o un gesto concreto de un animal, el modelo las simplifica o las distorsiona.

Wan 2.2 en local o generador en la nube

Los precios de los generadores en la nube cambian cada semana. La comparación actualizada está en el hub generadores de vídeo IA. Nuestra opinión: Wan 2.2 5B en local compensa cuando necesitas decenas de tomas de trabajo, fondos o material para montaje, no un solo clip impactante.

Script listo: clip desde un solo prompt

Los archivos del modelo los descargará el script de instalación de la guía ComfyUI con la opción -Modelos wan. Para la generación en sí preparamos un script que envía el prompt a ComfyUI, espera los fotogramas y los compone en MP4 mediante ffmpeg. La duración la indicas en segundos y el script la convierte automáticamente al número de fotogramas en el formato que requiere Wan (4n+1). Lo comprobamos el 26.09.2026 en un clip de prueba corto: 2 segundos a 640×352, 49 fotogramas, archivo MP4 listo.

• Descarga: generuj-wideo.py (6 KB) o los 5 scripts en un archivo ZIP (15 KB).
• Clip de 5 s a 720p: python generuj-wideo.py "a yellow tram passing a rainy street at dusk, static camera"
• Vista previa más rápida: --sekundy 3 --szer 960 --wys 544 --kroki 12. Para MP4 se necesita ffmpeg (winget install Gyan.FFmpeg), sin él obtendrás fotogramas PNG.

Antes de ejecutar cualquier script de internet, léelo. Se ejecuta con tus permisos. Por eso a continuación está el código completo, sin acortar, con comentarios en polaco. Los scripts están bajo licencia MIT: puedes modificarlos y usarlos también en la empresa.

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

Ver también: Wan AI: todas las versiones, precios y nuestras pruebas con vídeos · Wan 3.0 contra Wan 2.2 con los mismos prompts

Preguntas frecuentes

Qué tarjeta gráfica se necesita para Wan 2.2

En nuestra prueba, Wan 2.2 TI2V 5B ocupó unos 20 GB de memoria de la RTX 4090 con vídeo a 1280×704. En tarjetas con 12-16 GB funciona más lento, con parte del modelo en la RAM. Las variantes más grandes de 14B requieren mucha más memoria.

Cuánto tarda en generarse un vídeo en Wan 2.2

Unos 4 minutos por clip de 5 segundos a 720p (121 fotogramas, 20 pasos) en RTX 4090, cuando el modelo ya está cargado. La generación del primer clip tras el inicio tardó 574 s porque se añadió la carga de 18 GB de archivos del disco.

Es Wan 2.2 gratuito y se puede usar comercialmente

Sí. Los pesos están en Hugging Face bajo licencia Apache 2.0, que permite uso comercial. Solo pagas la electricidad, unos 0,008944 EUR (0,01 USD) por clip.

Wan 2.2 hace vídeo con audio

No. La versión 5B genera solo imagen. El audio hay que añadirlo en el montaje.

// sigue leyendoGPT-6 Cyber: benchmarks de la tarjeta del sistema y qué midenBenchmarksQwen-Image 2.1 Turbo: generación local en 4 s con una RTX 4090BenchmarksGemma 4 31B en local con RTX 4090: VRAM, velocidad y análisisBenchmarks