hf-doc-build/doc / diffusers /main /fr /api /pipelines /wan.md

|

raw

105 kB

Sous licence Apache License, Version 2.0 (la « Licence ») ;

vous ne pouvez utiliser ce fichier que conformément à la Licence.

Vous pouvez obtenir un exemplaire de la Licence à

http://www.apache.org/licenses/LICENSE-2.0

Sauf exigence légale ou accord écrit

distribué sous la Licence est distribué sur une base « EN L'ÉTAT »,

SANS AUCUNE GARANTIE NI CONDITION, explicite ou implicite.

Voir la Licence pour le langage spécifique régissant les autorisations et

limitations under the License. -->

Wan

Wan-2.1 par l'équipe Wan.

Ce rapport présente Wan, une suite complète et ouverte de modèles de fondation pour la vidéo, conçue pour repousser les limites de la génération vidéo. Construite sur le paradigme principal du diffusion transformer, Wan obtient des avancées significatives en capacités génératives grâce à une série d'innovations, notamment notre VAE novateur, des stratégies de pré-entraînement évolutives, une curation de données à grande échelle et des métriques d'évaluation automatisées. Ces contributions améliorent collectivement les performances et la polyvalence du modèle. Plus précisément, Wan se caractérise par quatre fonctionnalités clés : Performance de pointe : Le modèle 14B de Wan, entraîné sur un vaste jeu de données composé de milliards d'images et de vidéos, démontre les lois d'échelle de la génération vidéo en fonction à la fois de la quantité de données et de la taille du modèle. Il surpasse systématiquement les modèles open source existants ainsi que les solutions commerciales de pointe sur de multiples benchmarks internes et externes, démontrant une supériorité de performance claire et significative. Exhaustivité : Wan propose deux modèles performants, à savoir 1,3B et 14B paramètres, pour l'efficacité et l'effectivité respectivement. Il couvre également plusieurs applications en aval, y compris l'image-à-vidéo, l'édition vidéo guidée par des instructions et la génération vidéo personnelle, englobant jusqu'à huit tâches. Efficacité de niveau grand public : Le modèle 1,3B démontre une efficacité des ressources exceptionnelle, nécessitant seulement 8,19 Go de VRAM, ce qui le rend compatible avec une large gamme de GPU de niveau grand public. Ouverture : Nous mettons en open source l'ensemble de la série Wan, y compris le code source et tous les modèles, dans le but de favoriser la croissance de la communauté de la génération vidéo. Cette ouverture vise à élargir considérablement les possibilités créatives de la production vidéo dans l'industrie et à fournir à l'académie des modèles de fondation vidéo de haute qualité. Tout le code et les modèles sont disponibles à cette URL https.

Vous pouvez trouver tous les points de contrôle originaux de Wan2.1 sous l'organisation Wan-AI.

Les modèles Wan suivants sont pris en charge dans Diffusers :

Cliquez sur les modèles Wan dans la barre latérale droite pour plus d’exemples de génération de vidéos.

Génération de texte en vidéo

L'exemple ci-dessous montre comment générer une vidéo à partir de texte, optimisée pour la mémoire ou la vitesse d'inférence.

Reportez-vous au guide Réduire l'utilisation de la mémoire pour plus de détails sur les différentes techniques d'économie de mémoire.

Le modèle de génération de vidéo à partir de texte Wan2.1 ci-dessous nécessite environ 13 Go de VRAM.

# pip install ftfy
import torch
import numpy as np
from diffusers import AutoModel, WanPipeline
from diffusers.quantizers import PipelineQuantizationConfig
from diffusers.hooks.group_offloading import apply_group_offloading
from diffusers.utils import export_to_video, load_image
from transformers import UMT5EncoderModel

text_encoder = UMT5EncoderModel.from_pretrained("Wan-AI/Wan2.1-T2V-14B-Diffusers", subfolder="text_encoder", dtype=torch.bfloat16)
vae = AutoModel.from_pretrained("Wan-AI/Wan2.1-T2V-14B-Diffusers", subfolder="vae", dtype=torch.float32)
transformer = AutoModel.from_pretrained("Wan-AI/Wan2.1-T2V-14B-Diffusers", subfolder="transformer", dtype=torch.bfloat16)

# group-offloading
onload_device = torch.device("cuda")
offload_device = torch.device("cpu")
apply_group_offloading(text_encoder,
    onload_device=onload_device,
    offload_device=offload_device,
    offload_type="block_level",
    num_blocks_per_group=4
)
transformer.enable_group_offload(
    onload_device=onload_device,
    offload_device=offload_device,
    offload_type="leaf_level",
    use_stream=True
)

pipeline = WanPipeline.from_pretrained(
    "Wan-AI/Wan2.1-T2V-14B-Diffusers",
    vae=vae,
    transformer=transformer,
    text_encoder=text_encoder,
    dtype=torch.bfloat16
)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

prompt = """
The camera rushes from far to near in a low-angle shot,
revealing a white ferret on a log. It plays, leaps into the water, and emerges, as the camera zooms in
for a close-up. Water splashes berry bushes nearby, while moss, snow, and leaves blanket the ground.
Birch trees and a light blue sky frame the scene, with ferns in the foreground. Side lighting casts dynamic
shadows and warm highlights. Medium composition, front view, low angle, with depth of field.
"""
negative_prompt = """
Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality,
low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured,
misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
"""

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_frames=81,
    guidance_scale=5.0,
).frames[0]
export_to_video(output, "output.mp4", fps=16)

Compilation est lente lors de la première exécution, mais les appels suivants au pipeline sont plus rapides. Le cache peut également accélérer l'inférence en stockant et en réutilisant les sorties intermédiaires.

# pip install ftfy
import torch
import numpy as np
from diffusers import AutoModel, WanPipeline
from diffusers.hooks.group_offloading import apply_group_offloading
from diffusers.utils import export_to_video, load_image
from transformers import UMT5EncoderModel

text_encoder = UMT5EncoderModel.from_pretrained("Wan-AI/Wan2.1-T2V-14B-Diffusers", subfolder="text_encoder", dtype=torch.bfloat16)
vae = AutoModel.from_pretrained("Wan-AI/Wan2.1-T2V-14B-Diffusers", subfolder="vae", dtype=torch.float32)
transformer = AutoModel.from_pretrained("Wan-AI/Wan2.1-T2V-14B-Diffusers", subfolder="transformer", dtype=torch.bfloat16)

pipeline = WanPipeline.from_pretrained(
    "Wan-AI/Wan2.1-T2V-14B-Diffusers",
    vae=vae,
    transformer=transformer,
    text_encoder=text_encoder,
    dtype=torch.bfloat16
)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

# torch.compile
pipeline.transformer.to(memory_format=torch.channels_last)
pipeline.transformer = torch.compile(
    pipeline.transformer, mode="max-autotune", fullgraph=True
)

prompt = """
The camera rushes from far to near in a low-angle shot,
revealing a white ferret on a log. It plays, leaps into the water, and emerges, as the camera zooms in
for a close-up. Water splashes berry bushes nearby, while moss, snow, and leaves blanket the ground.
Birch trees and a light blue sky frame the scene, with ferns in the foreground. Side lighting casts dynamic
shadows and warm highlights. Medium composition, front view, low angle, with depth of field.
"""
negative_prompt = """
Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality,
low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured,
misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
"""

output = pipeline(
    prompt=prompt,
    negative_prompt=negative_prompt,
    num_frames=81,
    guidance_scale=5.0,
).frames[0]
export_to_video(output, "output.mp4", fps=16)

Génération de vidéo à partir de la première et de la dernière image

L'exemple ci-dessous montre comment utiliser le pipeline image-verso-vidéo pour générer une vidéo à partir d'une description textuelle, d'une image de départ et d'une image de fin.

import numpy as np
import torch
import torchvision.transforms.functional as TF
from diffusers import AutoencoderKLWan, WanImageToVideoPipeline
from diffusers.utils import export_to_video, load_image
from transformers import CLIPVisionModel

model_id = "Wan-AI/Wan2.1-FLF2V-14B-720P-diffusers"
image_encoder = CLIPVisionModel.from_pretrained(model_id, subfolder="image_encoder", dtype=torch.float32)
vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", dtype=torch.float32)
pipe = WanImageToVideoPipeline.from_pretrained(
    model_id, vae=vae, image_encoder=image_encoder, dtype=torch.bfloat16
)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

first_frame = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_first_frame.png")
last_frame = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/flf2v_input_last_frame.png")

def aspect_ratio_resize(image, pipe, max_area=720 * 1280):
    aspect_ratio = image.height / image.width
    mod_value = pipe.vae_scale_factor_spatial * pipe.transformer.config.patch_size[1]
    height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
    width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
    image = image.resize((width, height))
    return image, height, width

def center_crop_resize(image, height, width):
    # Calculate resize ratio to match first frame dimensions
    resize_ratio = max(width / image.width, height / image.height)

    # Resize the image
    width = round(image.width * resize_ratio)
    height = round(image.height * resize_ratio)
    size = [width, height]
    image = TF.center_crop(image, size)

    return image, height, width

first_frame, height, width = aspect_ratio_resize(first_frame, pipe)
if last_frame.size != first_frame.size:
    last_frame, _, _ = center_crop_resize(last_frame, height, width)

prompt = "CG animation style, a small blue bird takes off from the ground, flapping its wings. The bird's feathers are delicate, with a unique pattern on its chest. The background shows a blue sky with white clouds under bright sunshine. The camera follows the bird upward, capturing its flight and the vastness of the sky from a close-up, low-angle perspective."

output = pipe(
    image=first_frame, last_image=last_frame, prompt=prompt, height=height, width=width, guidance_scale=5.5
).frames[0]
export_to_video(output, "output.mp4", fps=16)

Génération contrôlable de n'importe quel type vers vidéo

Wan VACE prend en charge diverses techniques de génération permettant une génération de vidéos contrôlable. Parmi les fonctionnalités incluses :

Contrôle vidéo à vidéo (profondeur, pose, esquisse, flux, niveaux de gris, gribouillis, mise en page, boîte de contour, etc.). Bibliothèque recommandée pour prétraiter les vidéos afin d’obtenir des vidéos de contrôle : huggingface/controlnet_aux
Image/vidéo vers vidéo (première image, dernière image, clip de départ, clip de fin, clips aléatoires)
Inpainting et Outpainting
Sujet de la vidéo (visages, objets, personnages, etc.)
Composition vers vidéo (référencer n'importe quoi, animer n'importe quoi, échanger n'importe quoi, étendre n'importe quoi, déplacer n'importe quoi, etc.)

Les extraits de code disponibles dans cette pull request illustrent quelques exemples de la manière dont des vidéos peuvent être générées à l'aide de signaux de contrôlabilité.

La règle générale à garder en tête lors de la préparation des entrées pour le pipeline VACE est que les images d’entrée, ou les frames d’une vidéo que vous souhaitez utiliser pour le conditionnement, doivent être accompagnées d’un masque correspondant, de couleur noire. Le masque noir indique que le modèle ne générera pas de nouveau contenu pour cette zone, et n’utilisera ces parties que pour conditionner le processus de génération. Pour les parties/frames qui doivent être générées par le modèle, le masque doit être de couleur blanche.

Wan-Animate : Animation et remplacement unifiés de personnages avec réplique holistique

Wan-Animate par l'équipe Wan.

Nous présentons Wan-Animate, un cadre unifié pour l'animation et le remplacement de personnages. À partir d'une image de personnage et d'une vidéo de référence, Wan-Animate peut animer le personnage en reproduisant avec précision les expressions et les mouvements du personnage dans la vidéo, afin de générer des vidéos de personnage haute fidélité. Alternativement, il peut intégrer le personnage animé dans la vidéo de référence pour remplacer le personnage d'origine, en reproduisant l'éclairage et la tonalité de couleur de la scène afin d'obtenir une intégration environnementale sans couture. Wan-Animate est construit sur le modèle Wan. Pour l'adapter aux tâches d'animation de personnage, nous utilisons un paradigme d'entrée modifié pour distinguer les conditions de référence des régions de génération. Cette conception unifie plusieurs tâches dans une représentation symbolique commune. Nous utilisons des signaux de squelette alignés spatialement pour reproduire le mouvement du corps et des caractéristiques faciales implicites extraites des images sources pour rejouer les expressions, permettant la génération de vidéos de personnage avec une grande contrôlabilité et expressivité. De plus, pour améliorer l'intégration environnementale lors du remplacement de personnage, nous développons un Relighting LoRA auxiliaire. Ce module préserve la cohérence de l'apparence du personnage tout en appliquant l'éclairage et la tonalité de couleur environnementaux appropriés. Les résultats expérimentaux démontrent que Wan-Animate atteint des performances de pointe. Nous nous engageons à open-sourcer les poids du modèle et son code source.

La page du projet : https://humanaigc.github.io/wan-animate

Ce modèle a été principalement contribué par M. Tolga Cangöz.

Utilisation

Le pipeline Wan-Animate prend en charge deux modes de fonctionnement :

Mode Animation (par défaut) : Anime une image de personnage en se basant sur le mouvement et l'expression issus de vidéos de référence
Mode de remplacement : Remplace un personnage dans une vidéo d'arrière-plan par un nouveau personnage tout en préservant la scène

Prérequis

Avant d'utiliser le pipeline, vous devez prétraiter votre vidéo de référence pour extraire :

Vidéo de pose : Contient des points clés squelettiques représentant le mouvement du corps
Vidéo du visage : Contient des représentations des traits du visage pour le contrôle des expressions

Pour le mode de remplacement, vous avez également besoin de :

Vidéo d'arrière-plan : La vidéo d'origine contenant la scène
Vidéo de masque : un masque indiquant où générer du contenu (blanc) par rapport à conserver l’original (noir)

Les vidéos brutes ne doivent pas être utilisées pour des entrées telles que pose_video, pour lesquelles le pipeline s’attend à ce qu’elles soient prétraitées afin d’extraire les informations appropriées. Des scripts de prétraitement pour préparer ces entrées sont disponibles dans le dépôt original Wan-Animate. L’intégration de ces étapes de prétraitement dans Diffusers est prévue pour une future version.

L'exemple ci-dessous montre comment utiliser le pipeline Wan-Animate :

import numpy as np
import torch
from diffusers import AutoencoderKLWan, WanAnimatePipeline
from diffusers.utils import export_to_video, load_image, load_video

model_id = "Wan-AI/Wan2.2-Animate-14B-Diffusers"
vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", dtype=torch.float32)
pipe = WanAnimatePipeline.from_pretrained(model_id, vae=vae, dtype=torch.bfloat16)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

# Load character image and preprocessed videos
image = load_image("path/to/character.jpg")
pose_video = load_video("path/to/pose_video.mp4")  # Preprocessed skeletal keypoints
face_video = load_video("path/to/face_video.mp4")  # Preprocessed facial features

# Resize image to match VAE constraints
def aspect_ratio_resize(image, pipe, max_area=720 * 1280):
    aspect_ratio = image.height / image.width
    mod_value = pipe.vae_scale_factor_spatial * pipe.transformer.config.patch_size[1]
    height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
    width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
    image = image.resize((width, height))
    return image, height, width

image, height, width = aspect_ratio_resize(image, pipe)

prompt = "A person dancing energetically in a studio with dynamic lighting and professional camera work"
negative_prompt = "blurry, low quality, distorted, deformed, static, poorly drawn"

# Generate animated video
output = pipe(
    image=image,
    pose_video=pose_video,
    face_video=face_video,
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=height,
    width=width,
    segment_frame_length=77,
    guidance_scale=1.0,
    mode="animate",  # Animation mode (default)
).frames[0]
export_to_video(output, "animated_character.mp4", fps=30)

import numpy as np
import torch
from diffusers import AutoencoderKLWan, WanAnimatePipeline
from diffusers.utils import export_to_video, load_image, load_video

model_id = "Wan-AI/Wan2.2-Animate-14B-Diffusers"
vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", dtype=torch.float32)
pipe = WanAnimatePipeline.from_pretrained(model_id, vae=vae, dtype=torch.bfloat16)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

# Load all required inputs for replacement mode
image = load_image("path/to/new_character.jpg")
pose_video = load_video("path/to/pose_video.mp4")  # Preprocessed skeletal keypoints
face_video = load_video("path/to/face_video.mp4")  # Preprocessed facial features
background_video = load_video("path/to/background_video.mp4")  # Original scene
mask_video = load_video("path/to/mask_video.mp4")  # Black: preserve, White: generate

# Resize image to match video dimensions
def aspect_ratio_resize(image, pipe, max_area=720 * 1280):
    aspect_ratio = image.height / image.width
    mod_value = pipe.vae_scale_factor_spatial * pipe.transformer.config.patch_size[1]
    height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
    width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
    image = image.resize((width, height))
    return image, height, width

image, height, width = aspect_ratio_resize(image, pipe)

prompt = "A person seamlessly integrated into the scene with consistent lighting and environment"
negative_prompt = "blurry, low quality, inconsistent lighting, floating, disconnected from scene"

# Replace character in background video
output = pipe(
    image=image,
    pose_video=pose_video,
    face_video=face_video,
    background_video=background_video,
    mask_video=mask_video,
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=height,
    width=width,
    segment_frame_lengths=77,
    guidance_scale=1.0,
    mode="replace",  # Replacement mode
).frames[0]
export_to_video(output, "character_replaced.mp4", fps=30)

import numpy as np
import torch
from diffusers import AutoencoderKLWan, WanAnimatePipeline
from diffusers.utils import export_to_video, load_image, load_video

model_id = "Wan-AI/Wan2.2-Animate-14B-Diffusers"
vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", dtype=torch.float32)
pipe = WanAnimatePipeline.from_pretrained(model_id, vae=vae, dtype=torch.bfloat16)
pipe.to("cuda")  # or "mps", "xpu", "cpu"

image = load_image("path/to/character.jpg")
pose_video = load_video("path/to/pose_video.mp4")
face_video = load_video("path/to/face_video.mp4")

def aspect_ratio_resize(image, pipe, max_area=720 * 1280):
    aspect_ratio = image.height / image.width
    mod_value = pipe.vae_scale_factor_spatial * pipe.transformer.config.patch_size[1]
    height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
    width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
    image = image.resize((width, height))
    return image, height, width

image, height, width = aspect_ratio_resize(image, pipe)

prompt = "A person dancing energetically in a studio"
negative_prompt = "blurry, low quality"

# Advanced: Use temporal guidance and custom callback
def callback_fn(pipe, step_index, timestep, callback_kwargs):
    # You can modify latents or other tensors here
    print(f"Step {step_index}, Timestep {timestep}")
    return callback_kwargs

output = pipe(
    image=image,
    pose_video=pose_video,
    face_video=face_video,
    prompt=prompt,
    negative_prompt=negative_prompt,
    height=height,
    width=width,
    segment_frame_length=77,
    num_inference_steps=50,
    guidance_scale=5.0,
    prev_segment_conditioning_frames=5,  # Use 5 frames for temporal guidance (1 or 5 recommended)
    callback_on_step_end=callback_fn,
    callback_on_step_end_tensor_inputs=["latents"],
).frames[0]
export_to_video(output, "animated_advanced.mp4", fps=30)

Paramètres clés

mode : Choisissez entre "animate" (par défaut) ou "replace"
prev_segment_conditioning_frames : Nombre de frames pour le guidage temporel (1 ou 5 recommandé). L'utilisation de 5 offre une meilleure cohérence temporelle mais nécessite plus de mémoire
guidance_scale : Contrôle dans quelle mesure la sortie suit le prompt texte. Des valeurs plus élevées (5-7) produisent des résultats plus alignés avec le prompt. Pour Wan-Animate, le CFG est désactivé par défaut (guidance_scale=1.0) mais peut être activé pour prendre en charge les prompts négatifs et un contrôle plus fin des expressions faciales. (Notez que le CFG ne ciblera que le prompt texte et le conditionnement du visage.)

Notes

Wan2.1 prend en charge les LoRA avec load_lora_weights().

Afficher un exemple de code

# pip install ftfy
import torch
from diffusers import AutoModel, WanPipeline
from diffusers.schedulers.scheduling_unipc_multistep import UniPCMultistepScheduler
from diffusers.utils import export_to_video

vae = AutoModel.from_pretrained(
    "Wan-AI/Wan2.1-T2V-1.3B-Diffusers", subfolder="vae", dtype=torch.float32
)
pipeline = WanPipeline.from_pretrained(
    "Wan-AI/Wan2.1-T2V-1.3B-Diffusers", vae=vae, dtype=torch.bfloat16
)
pipeline.scheduler = UniPCMultistepScheduler.from_config(
    pipeline.scheduler.config, flow_shift=5.0
)
pipeline.to("cuda")  # or "mps", "xpu", "cpu"

pipeline.load_lora_weights("benjamin-paine/steamboat-willie-1.3b", adapter_name="steamboat-willie")
pipeline.set_adapters("steamboat-willie")

pipeline.enable_model_cpu_offload()

# use "steamboat willie style" to trigger the LoRA
prompt = """
steamboat willie style, golden era animation, The camera rushes from far to near in a low-angle shot,
revealing a white ferret on a log. It plays, leaps into the water, and emerges, as the camera zooms in
for a close-up. Water splashes berry bushes nearby, while moss, snow, and leaves blanket the ground.
Birch trees and a light blue sky frame the scene, with ferns in the foreground. Side lighting casts dynamic
shadows and warm highlights. Medium composition, front view, low angle, with depth of field.
"""

output = pipeline(
    prompt=prompt,
    num_frames=81,
    guidance_scale=5.0,
).frames[0]
export_to_video(output, "output.mp4", fps=16)

WanTransformer3DModel et AutoencoderKLWan prennent en charge le chargement à partir de fichiers uniques via from_single_file().

Afficher un exemple de code

# pip install ftfy
import torch
from diffusers import WanPipeline, WanTransformer3DModel, AutoencoderKLWan

vae = AutoencoderKLWan.from_single_file(
    "https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/blob/main/split_files/vae/wan_2.1_vae.safetensors"
)
transformer = WanTransformer3DModel.from_single_file(
    "https://huggingface.co/Comfy-Org/Wan_2.1_ComfyUI_repackaged/blob/main/split_files/diffusion_models/wan2.1_t2v_1.3B_bf16.safetensors",
    dtype=torch.bfloat16
)
pipeline = WanPipeline.from_pretrained(
    "Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
    vae=vae,
    transformer=transformer,
    dtype=torch.bfloat16
)

Définissez le dtype de AutoencoderKLWan sur torch.float32 pour une meilleure qualité de décodage.
Le nombre d'images par seconde (fps) ou k doit être calculé par 4 * k + 1.
Essayez des valeurs de shift plus basses (2.0 à 5.0) pour les vidéos de faible résolution et des valeurs de shift plus élevées (7.0 à 12.0) pour les images de haute résolution.
Wan 2.1 et 2.2 prennent en charge l'utilisation de LightX2V LoRAs pour accélérer l'inférence. Leur utilisation sur Wan 2.2 est légèrement plus complexe. Consultez ce fragment de code pour en savoir plus.
Wan 2.2 dispose de deux débruiteurs. Par défaut, les LoRA ne sont chargés que dans le premier débruiteur. Il est possible de définir load_into_transformer_2=True pour charger les LoRA dans le second débruiteur. Consultez les exemples celui-ci et celui-là pour en savoir plus.

WanPipeline[[diffusers.WanPipeline]]

diffusers.WanPipeline[[diffusers.WanPipeline]]

diffusers.WanPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, vae: AutoencoderKLWan, scheduler: FlowMatchEulerDiscreteScheduler, transformer: diffusers.models.transformers.transformer_wan.WanTransformer3DModel | None = None, transformer_2: diffusers.models.transformers.transformer_wan.WanTransformer3DModel | None = None, boundary_ratio: float | None = None, expand_timesteps: bool = False)

Source

Paramètres :

tokenizer (T5Tokenizer) : Tokenizer de T5, plus précisément la variante google/umt5-xxl.

text_encoder (T5EncoderModel) : T5, plus précisément la variante google/umt5-xxl.

transformer (WanTransformer3DModel) : Transformer conditionnel pour le débruitage des latents d'entrée.

scheduler (UniPCMultistepScheduler) : un planificateur à utiliser en combinaison avec transformer pour débruyer les latents d'image encodés.

vae (AutoencoderKLWan) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos vers et depuis des représentations latentes.

transformer_2 (WanTransformer3DModel, facultatif) : Transformer conditionnel pour le débruitage des latents d’entrée pendant l’étape à faible bruit. S’il est fourni, il active un débruitage en deux étapes où transformer gère les étapes à fort bruit et transformer_2 gère les étapes à faible bruit. S’il n’est pas fourni, seul transformer est utilisé.

boundary_ratio (float, facultatif, valeur par défaut None) : Ratio des timesteps totaux à utiliser comme limite pour le passage entre les transformers dans le débruitage en deux étapes. Le timestep de limite effectif est calculé comme boundary_ratio * num_train_timesteps. S'il est fourni, transformer gère les timesteps >= boundary_timestep et transformer_2 gère les timesteps < boundary_timestep. Si None, seul transformer est utilisé pour l'ensemble du processus de débruitage.

Pipeline pour la génération de vidéos à partir de texte utilisant Wan.

Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, etc.).

appel[[diffusers.WanPipeline.call]]

__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 480, width: int = 832, num_frames: int = 81, num_inference_steps: int = 50, guidance_scale: float = 5.0, guidance_scale_2: float | None = None, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, output_type: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)

Source

Paramètres :

prompt (str ou list[str], facultatif) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, passez plutôt prompt_embeds.

negative_prompt (str ou list[str], facultatif) : Le prompt ou les prompts à éviter lors de la génération d’image. S’il n’est pas défini, passez plutôt negative_prompt_embeds. Ignoré lorsque le guidage n’est pas utilisé (guidance_scale < 1).

height (int, par défaut 480) : La hauteur en pixels de l'image générée.

width (int, par défaut 832) : La largeur en pixels de l'image générée.

num_frames (int, par défaut 81) : Le nombre de frames dans la vidéo générée.

num_inference_steps (int, par défaut 50) : Le nombre d'étapes de débruitage. Un plus grand nombre d'étapes de débruitage conduit généralement à une image de meilleure qualité, au prix d'une inférence plus lente.

guidance_scale (float, par défaut 5.0) : Échelle de guidage telle que définie dans Classifier-Free Diffusion Guidance. guidance_scale est défini comme w de l'équation 2. de Imagen Paper. L'échelle de guidage est activée en définissant guidance_scale > 1. Une échelle de guidage plus élevée encourage la génération d'images étroitement liées au prompt texte, généralement au détriment de la qualité de l'image.

guidance_scale_2 (float, facultatif, valeur par défaut None) : Échelle de guidage pour le transformer de la phase à faible bruit (transformer_2). Si None et que le boundary_ratio du pipeline n'est pas None, utilise la même valeur que guidance_scale. Utilisé uniquement lorsque transformer_2 et le boundary_ratio du pipeline ne sont pas None.

num_videos_per_prompt (int, facultatif, valeur par défaut 1) : Le nombre d'images à générer par invite.

generator (torch.Generator ou list[torch.Generator], facultatif) : Un torch.Generator pour rendre la génération déterministe.

latents (torch.Tensor, facultatif) : Latents bruités pré-générés, échantillonnés à partir d'une distribution gaussienne, à utiliser comme entrées pour la génération d'images. Peut être utilisé pour ajuster la même génération avec des prompts différents. S'il n'est pas fourni, un tenseur de latents est généré par échantillonnage à l'aide du generator aléatoire fourni.

prompt_embeds (torch.Tensor, facultatif) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, les incrustations de texte sont générées à partir de l'argument d'entrée prompt.

negative_prompt_embeds (torch.Tensor, facultatif) : Incrustations de texte négatif pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte (pondération des prompts). Si non fourni, negative_prompt_embeds sont générés à partir de l'argument d'entrée negative_prompt.

output_type (str, facultatif, par défaut "np") : Le format de sortie de l'image générée. Choisissez entre PIL.Image ou np.array.

return_dict (bool, facultatif, par défaut True) : Indique s'il faut retourner un WanPipelineOutput plutôt qu'un simple tuple.

attention_kwargs (dict, facultatif) : Un dictionnaire de kwargs qui, s'il est spécifié, est transmis à l'AttentionProcessor tel que défini sous self.processor dans diffusers.models.attention_processor.

callback_on_step_end (Callable, PipelineCallback, MultiPipelineCallbacks, facultatif) : une fonction ou une sous-classe de PipelineCallback ou MultiPipelineCallbacks qui est appelée à la fin de chaque étape de débruitage pendant l’inférence, avec les arguments suivants : callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict). callback_kwargs contiendra une liste de tous les tenseurs, tels que spécifiés par callback_on_step_end_tensor_inputs.

callback_on_step_end_tensor_inputs (list, facultatif) : La liste des entrées tensorielles pour la fonction callback_on_step_end. Les tenseurs spécifiés dans la liste seront passés en tant qu'argument callback_kwargs. Vous ne pourrez inclure que les variables listées dans l'attribut ._callback_tensor_inputs de votre classe de pipeline.

max_sequence_length (int, par défaut 512) : La longueur de séquence maximale du codeur de texte. Si le prompt est plus long que cela, il sera tronqué. S'il est plus court, il sera complété jusqu'à cette longueur.

Retourne : ~WanPipelineOutput ou tuple

Si return_dict est True, WanPipelineOutput est retourné, sinon un tuple est retourné dont le premier élément est une liste des images générées et le deuxième élément est une liste de bool indiquant si l'image générée correspondante contient du contenu « not-safe-for-work » (nsfw).

La fonction d'appel du pipeline pour la génération.

Exemples :

>>> import torch
>>> from diffusers.utils import export_to_video
>>> from diffusers import AutoencoderKLWan, WanPipeline
>>> from diffusers.schedulers.scheduling_unipc_multistep import UniPCMultistepScheduler

>>> # Available models: Wan-AI/Wan2.1-T2V-14B-Diffusers, Wan-AI/Wan2.1-T2V-1.3B-Diffusers
>>> model_id = "Wan-AI/Wan2.1-T2V-14B-Diffusers"
>>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32)
>>> pipe = WanPipeline.from_pretrained(model_id, vae=vae, torch_dtype=torch.bfloat16)
>>> flow_shift = 5.0  # 5.0 for 720P, 3.0 for 480P
>>> pipe.scheduler = UniPCMultistepScheduler.from_config(pipe.scheduler.config, flow_shift=flow_shift)
>>> pipe.to("cuda")

>>> prompt = "A cat and a dog baking a cake together in a kitchen. The cat is carefully measuring flour, while the dog is stirring the batter with a wooden spoon. The kitchen is cozy, with sunlight streaming through the window."
>>> negative_prompt = "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards"

>>> output = pipe(
...     prompt=prompt,
...     negative_prompt=negative_prompt,
...     height=720,
...     width=1280,
...     num_frames=81,
...     guidance_scale=5.0,
... ).frames[0]
>>> export_to_video(output, "output.mp4", fps=16)

encode_prompt[[diffusers.WanPipeline.encode_prompt]]

encode_prompt(prompt: str | list[str], negative_prompt: str | list[str] | None = None, do_classifier_free_guidance: bool = True, num_videos_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, max_sequence_length: int = 226, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None)

Source

Paramètres :

prompt (str ou list[str], facultatif) : invite à encoder

negative_prompt (str ou list[str], facultatif) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer negative_prompt_embeds à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si guidance_scale est inférieur à 1).

do_classifier_free_guidance (bool, facultatif, par défaut True) : Indique s'il faut utiliser le guidage sans classifieur ou non.

num_videos_per_prompt (int, facultatif, valeur par défaut 1) : Nombre de vidéos à générer par invite. Appareil torch sur lequel placer les embeddings résultants

prompt_embeds (torch.Tensor, facultatif) : Incrustations de texte pré-générées. Peut être utilisé pour ajuster facilement les entrées de texte, par ex. pondération des prompts. Si non fourni, les incrustations de texte seront générées à partir de l'argument d'entrée prompt.

negative_prompt_embeds (torch.Tensor, facultatif) : Embeddings de texte négatif pré-générés. Peut être utilisé pour ajuster facilement les entrées de texte, par exemple le pondération des prompts. S'il n'est pas fourni, negative_prompt_embeds sera généré à partir de l'argument d'entrée negative_prompt.

device : (torch.device, facultatif) : appareil torch

dtype : (torch.dtype, facultatif) : torch dtype

Encode le prompt dans les états cachés de l'encodeur de texte.

WanImageToVideoPipeline[[diffusers.WanImageToVideoPipeline]]

diffusers.WanImageToVideoPipeline[[diffusers.WanImageToVideoPipeline]]

diffusers.WanImageToVideoPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, vae: AutoencoderKLWan, scheduler: FlowMatchEulerDiscreteScheduler, image_processor: CLIPImageProcessorPil = None, image_encoder: CLIPVisionModel = None, transformer: WanTransformer3DModel = None, transformer_2: WanTransformer3DModel = None, boundary_ratio: float | None = None, expand_timesteps: bool = False)

Source

Paramètres :

tokenizer (T5Tokenizer) : Tokenizer de T5, plus précisément la variante google/umt5-xxl.

text_encoder (T5EncoderModel) : T5, plus précisément la variante google/umt5-xxl.

image_encoder (CLIPVisionModel) : CLIP, plus précisément la variante clip-vit-huge-patch14.

transformer (WanTransformer3DModel) : Transformer conditionnel pour le débruitage des latents d'entrée.

scheduler (UniPCMultistepScheduler) : un planificateur à utiliser en combinaison avec transformer pour débruyer les latents d'image encodés.

vae (AutoencoderKLWan) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos vers et depuis des représentations latentes.

transformer_2 (WanTransformer3DModel, facultatif) : Transformer conditionnel pour débruyer les latents d’entrée pendant l’étape à faible bruit. Dans le débruyage en deux étapes, transformer gère les étapes à fort bruit et transformer_2 gère les étapes à faible bruit. S’il n’est pas fourni, seul transformer est utilisé.

boundary_ratio (float, facultatif, valeur par défaut None) : Ratio des timesteps totaux à utiliser comme limite pour le passage entre les transformers dans le débruitage en deux étapes. Le timestep de limite effectif est calculé comme boundary_ratio * num_train_timesteps. S'il est fourni, transformer gère les timesteps >= boundary_timestep et transformer_2 gère les timesteps < boundary_timestep. Si None, seul transformer est utilisé pour l'ensemble du processus de débruitage.

Pipeline pour la génération de vidéos à partir d’images utilisant Wan.

Ce modèle hérite de DiffusionPipeline. Consultez la documentation de la classe parente pour les méthodes génériques implémentées pour tous les pipelines (téléchargement, sauvegarde, exécution sur un appareil particulier, etc.).

appel[[diffusers.WanImageToVideoPipeline.call]]

__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 480, width: int = 832, num_frames: int = 81, num_inference_steps: int = 50, guidance_scale: float = 5.0, guidance_scale_2: float | None = None, num_videos_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, image_embeds: typing.Optional[torch.Tensor] = None, last_image: typing.Optional[torch.Tensor] = None, output_type: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)

Source

Paramètres :

image (PipelineImageInput) : L'image d'entrée sur laquelle conditionner la génération. Doit être une image, une liste d'images ou un torch.Tensor.

last_image (torch.Tensor, optional) : Optional last frame to condition the generated video on. When provided, the model interpolates between image (first frame) and last_image (last frame).

prompt (str ou list[str], facultatif) : Le prompt ou les prompts pour guider la génération d’image. S’il n’est pas défini, il faut passer prompt_embeds à la place.

negative_prompt (str ou list[str], facultatif) : Le prompt ou les prompts à ne pas utiliser pour guider la génération d’image. S’il n’est pas défini, il faut passer negative_prompt_embeds à la place. Ignoré lorsque le guidage n’est pas utilisé (c’est-à-dire ignoré si guidance_scale est inférieur à 1).

height (int, par défaut 480) : La hauteur de la vidéo générée.

width (int, par défaut 832) : La largeur de la vidéo générée.