Wan 2.2 en local : vidéo IA sur votre carte - temps, VRAM, tests

👁 133 lectures

Wan 2.2 est un modèle vidéo gratuit d’Alibaba que vous pouvez exécuter sur votre propre ordinateur et utiliser commercialement. Le 26 septembre 2026, nous avons généré quatre clips de 5 secondes en 720p sur une carte RTX 4090, dans ComfyUI, avec la version la plus petite TI2V 5B. Un clip prenait environ 4 minutes à la carte. Ci-dessous, les quatre clips sans retouches, avec le temps, la consommation de mémoire et les erreurs visibles à l’œil nu.

Les montants en EUR sont des conversions indicatives des prix publiés en USD, calculées au taux de référence de la BCE du 2026-10-12 : 1 EUR = 1.1181 USD. Il ne s’agit pas de tarifs locaux confirmés ni de montants finaux toutes taxes comprises. Le fournisseur et la banque peuvent appliquer d’autres taux ou frais. ECB.

Qu’est-ce que Wan 2.2 et quelle version fonctionne en local

Wan 2.2 est une famille de modèles vidéo ouverts de l’équipe Wan-AI d’Alibaba, publiée sous licence Apache 2.0. Les variantes plus grandes (14 milliards de paramètres) nécessitent beaucoup plus de mémoire qu’une carte graphique grand public typique. La version TI2V 5B a 5 milliards de paramètres et génère de la vidéo à partir de texte ou d’une image de départ. Elle peut être exécutée sur une seule carte grand public. Nous avons utilisé les fichiers préparés par l’équipe ComfyUI :

• modèle wan2.2_ti2v_5B_fp16.safetensors - 10,0 GB,
• encodeur texte umt5_xxl_fp8_e4m3fn_scaled.safetensors - 6,7 GB,
• VAE wan2.2_vae.safetensors - 1,4 GB.

Les fichiers vont dans les dossiers models/diffusion_models, models/text_encoders et models/vae de ComfyUI. Pour installer ComfyUI lui-même, consultez notre guide ComfyUI de zéro.

Paramètres et mesures

Chaque clip : 1280×704, 121 images à 24 im./s (5,04 s), 20 étapes, CFG 5, sampler uni_pc, décalage 8. Ce sont les paramètres du template officiel ComfyUI pour Wan 2.2 5B. Carte : RTX 4090 24 GB, Windows 11, ComfyUI 0.37.

Le premier clip d’une série prend plus de deux fois plus de temps, car le modèle se charge du disque vers la mémoire. Les suivants prennent environ 4 minutes. Le pic de mémoire inclut environ 3,4 GB occupés précédemment par le système et le navigateur, donc Wan lui-même nécessitait environ 20 GB. Sur les cartes avec 12-16 GB, ComfyUI déplacera une partie du modèle vers la RAM système. Cela fonctionne, mais la génération prendra plus de temps. Nous ne l’avons pas mesuré.

Clips : ce qui a fonctionné et ce qui n’a pas fonctionné

1. Café versé dans une tasse

2. Tramway varsovien sous la pluie

3. Lama dans un pré de montagne

4. Animation 2D : travail de nuit et chat

Le schéma est clair : moins il y a de mouvement et de physique, mieux c’est. Les plans « sur trépied » avec mouvement en arrière-plan (pluie, tramway, feuilles) sont convaincants. Les actions précises, comme verser un liquide ou un geste spécifique d’animal, le modèle les simplifie ou les déforme.

Wan 2.2 en local ou générateur cloud

Les prix des générateurs cloud changent chaque semaine. Une comparaison à jour se trouve dans le hub générateurs vidéo IA. Notre avis : Wan 2.2 5B en local est rentable quand vous avez besoin de dizaines de plans de travail, d’arrière-plans ou de matériel de montage, et non d’un seul clip spectaculaire.

Script prêt à l’emploi : clip à partir d’un seul prompt

Les fichiers du modèle seront téléchargés par le script d’installation du guide ComfyUI avec l’option -Modeles wan. Pour la génération elle-même, nous avons préparé un script qui envoie le prompt à ComfyUI, attend les images et les assemble en MP4 via ffmpeg. Vous indiquez la durée en secondes, et le script la convertit automatiquement en nombre d’images au format requis par Wan (4n+1). Nous l’avons testé le 26.09.2026 sur un court clip test : 2 secondes en 640×352, 49 images, fichier MP4 final.

• Télécharger : generuj-wideo.py (6 KB) ou les 5 scripts dans un fichier ZIP (15 KB).
• Clip 5 s 720p : python generuj-wideo.py "a yellow tram passing a rainy street at dusk, static camera"
• Aperçu plus rapide : --sekundy 3 --szer 960 --wys 544 --kroki 12. Pour le MP4, ffmpeg est nécessaire (winget install Gyan.FFmpeg), sans lui vous obtiendrez des images PNG.

Avant d’exécuter un script trouvé sur Internet, lisez-le. Il s’exécute avec vos privilèges. C’est pourquoi le code complet est ci-dessous, sans raccourcissement, avec des commentaires en polonais. Les scripts sont sous licence MIT : vous pouvez les modifier et les utiliser également en entreprise.

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

Voir aussi : Wan AI : toutes les versions, prix et nos tests avec vidéos · Wan 3.0 contre Wan 2.2 sur les mêmes prompts

Mon service Jantaris propose 30 modèles vidéo sur un seul solde prépayé en USD - par exemple Kling 3.0 dès $0.09625 la seconde (720p) et Veo 3.1 Lite à $0.177 le clip de 8 s ; une génération ratée coûte $0. Tous les prix : le guide Jantaris.

Questions fréquentes

Quelle carte graphique est nécessaire pour Wan 2.2 ?

Dans notre test, Wan 2.2 TI2V 5B a occupé environ 20 GB de mémoire sur une RTX 4090 pour une vidéo 1280×704. Sur les cartes avec 12-16 GB, il fonctionne plus lentement, avec une partie du modèle en RAM système. Les variantes plus grandes 14B nécessitent beaucoup plus de mémoire.

Combien de temps faut-il pour générer une vidéo avec Wan 2.2 ?

Environ 4 minutes pour un clip de 5 secondes en 720p (121 images, 20 étapes) sur RTX 4090, une fois le modèle chargé. La génération du premier clip après le démarrage a pris 574 s, car il fallait charger 18 GB de fichiers depuis le disque.

Wan 2.2 est-il gratuit et peut-on l’utiliser commercialement ?

Oui. Les poids sont sur Hugging Face sous licence Apache 2.0, qui autorise l’usage commercial. Vous ne payez que l’électricité, environ 0,0179 EUR (0,02 USD) par clip.

Wan 2.2 génère-t-il de la vidéo avec son ?

Non. La version 5B génère uniquement l’image. Le son doit être ajouté au montage.

// lire la suiteGPT-6.1 Terra : prix de l’API et coût de mes testsBenchmarksSeedVR2 : passer une vidéo de 480p à 1080p en localBenchmarksNouveaux modèles sur fal.ai en octobre 2026 : 18 testsBenchmarks