# # 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](https://huggingface.co/papers/2503.20314) 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](https://github.com/Wan-Video/Wan2.1).* Vous pouvez trouver tous les points de contrôle originaux de Wan2.1 sous l'organisation [Wan-AI](https://huggingface.co/Wan-AI). Les modèles Wan suivants sont pris en charge dans Diffusers : - [Wan 2.1 T2V 1.3B](https://huggingface.co/Wan-AI/Wan2.1-T2V-1.3B-Diffusers) - [Wan 2.1 T2V 14B](https://huggingface.co/Wan-AI/Wan2.1-T2V-14B-Diffusers) - [Wan 2.1 I2V 14B - 480P](https://huggingface.co/Wan-AI/Wan2.1-I2V-14B-480P-Diffusers) - [Wan 2.1 I2V 14B - 720P](https://huggingface.co/Wan-AI/Wan2.1-I2V-14B-720P-Diffusers) - [Wan 2.1 FLF2V 14B - 720P](https://huggingface.co/Wan-AI/Wan2.1-FLF2V-14B-720P-diffusers) - [Wan 2.1 VACE 1.3B](https://huggingface.co/Wan-AI/Wan2.1-VACE-1.3B-diffusers) - [Wan 2.1 VACE 14B](https://huggingface.co/Wan-AI/Wan2.1-VACE-14B-diffusers) - [Wan 2.2 T2V 14B](https://huggingface.co/Wan-AI/Wan2.2-T2V-A14B-Diffusers) - [Wan 2.2 I2V 14B](https://huggingface.co/Wan-AI/Wan2.2-I2V-A14B-Diffusers) - [Wan 2.2 TI2V 5B](https://huggingface.co/Wan-AI/Wan2.2-TI2V-5B-Diffusers) - [Wan 2.2 Animate 14B](https://huggingface.co/Wan-AI/Wan2.2-Animate-14B-Diffusers) > [!TIP] > 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](../../optimization/memory) 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. ```py # 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](../../optimization/fp16#torchcompile) est lente lors de la première exécution, mais les appels suivants au pipeline sont plus rapides. Le [cache](../../optimization/cache) peut également accélérer l'inférence en stockant et en réutilisant les sorties intermédiaires. ```py # 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. ```python 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](https://github.com/huggingface/diffusers/pull/11582) 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](https://huggingface.co/papers/2509.14055) 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](https://github.com/tolgacangoz). #### Utilisation Le pipeline Wan-Animate prend en charge deux modes de fonctionnement : 1. **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 2. **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) > [!NOTE] > 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](https://github.com/Wan-Video/Wan2.2?tab=readme-ov-file#1-preprocessing). 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 : ```python 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) ``` ```python 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) ``` ```python 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()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.WanLoraLoaderMixin.load_lora_weights). Afficher un exemple de code ```py # 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](/docs/diffusers/v0.43.0/fr/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel) et [AutoencoderKLWan](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan) prennent en charge le chargement à partir de fichiers uniques via [from_single_file()](/docs/diffusers/v0.43.0/fr/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file). Afficher un exemple de code ```py # 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](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_wan#diffusers.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](https://huggingface.co/Kijai/WanVideo_comfy/tree/main/Lightx2v) pour accélérer l'inférence. Leur utilisation sur Wan 2.2 est légèrement plus complexe. Consultez [ce fragment de code](https://github.com/huggingface/diffusers/pull/12040#issuecomment-3144185272) 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](https://github.com/huggingface/diffusers/pull/12074#issue-3292620048) et [celui-là](https://github.com/huggingface/diffusers/pull/12074#issuecomment-3155896144) pour en savoir plus. ## WanPipeline[[diffusers.WanPipeline]] #### diffusers.WanPipeline[[diffusers.WanPipeline]] ```python 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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan.py#L96) **Paramètres :** tokenizer (`T5Tokenizer`) : Tokenizer de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). transformer ([WanTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel)) : Transformer conditionnel pour le débruitage des latents d'entrée. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_wan#diffusers.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](/docs/diffusers/v0.43.0/fr/api/models/wan_transformer_3d#diffusers.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](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.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__]] ```python __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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan.py#L382) **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](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). 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`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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 : ```python >>> 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]] ```python 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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan.py#L200) **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]] ```python 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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_i2v.py#L127) **Paramètres :** tokenizer (`T5Tokenizer`) : Tokenizer de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). image_encoder (`CLIPVisionModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPVisionModel), plus précisément la variante [clip-vit-huge-patch14](https://github.com/mlfoundations/open_clip/blob/main/docs/PRETRAINED.md#vit-h14-xlm-roberta-large). transformer ([WanTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel)) : Transformer conditionnel pour le débruitage des latents d'entrée. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_wan#diffusers.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](/docs/diffusers/v0.43.0/fr/api/models/wan_transformer_3d#diffusers.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](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.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__]] ```python __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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_i2v.py#L510) **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. 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](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). 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`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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 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 `negative_prompt`. image_embeds (`torch.Tensor`, *facultatif*) : Embeddings d’images pré-générés. Peut être utilisé pour ajuster facilement les entrées d’image (pondération). S’ils ne sont pas fournis, les embeddings d’images sont générés à partir de l’argument d’entrée `image`. 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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 : ```python >>> import torch >>> import numpy as np >>> from diffusers import AutoencoderKLWan, WanImageToVideoPipeline >>> from diffusers.utils import export_to_video, load_image >>> from transformers import CLIPVisionModel >>> # Available models: Wan-AI/Wan2.1-I2V-14B-480P-Diffusers, Wan-AI/Wan2.1-I2V-14B-720P-Diffusers >>> model_id = "Wan-AI/Wan2.1-I2V-14B-480P-Diffusers" >>> image_encoder = CLIPVisionModel.from_pretrained( ... model_id, subfolder="image_encoder", torch_dtype=torch.float32 ... ) >>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32) >>> pipe = WanImageToVideoPipeline.from_pretrained( ... model_id, vae=vae, image_encoder=image_encoder, torch_dtype=torch.bfloat16 ... ) >>> pipe.to("cuda") >>> image = load_image( ... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg" ... ) >>> max_area = 480 * 832 >>> 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)) >>> prompt = ( ... "An astronaut hatching from an egg, on the surface of the moon, the darkness and depth of space realised in " ... "the background. High quality, ultrarealistic detail and breath-taking movie-like camera shot." ... ) >>> 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( ... image=image, ... prompt=prompt, ... negative_prompt=negative_prompt, ... height=height, ... width=width, ... num_frames=81, ... guidance_scale=5.0, ... ).frames[0] >>> export_to_video(output, "output.mp4", fps=16) ``` #### encode_prompt[[diffusers.WanImageToVideoPipeline.encode_prompt]] ```python 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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_i2v.py#L254) **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. ## WanVACEPipeline[[diffusers.WanVACEPipeline]] #### diffusers.WanVACEPipeline[[diffusers.WanVACEPipeline]] ```python diffusers.WanVACEPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, vae: AutoencoderKLWan, scheduler: FlowMatchEulerDiscreteScheduler, transformer: WanVACETransformer3DModel = None, transformer_2: WanVACETransformer3DModel = None, boundary_ratio: float | None = None) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_vace.py#L141) **Paramètres :** tokenizer (`T5Tokenizer`) : Tokenizer de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos vers et depuis des représentations latentes. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés. transformer (`WanVACETransformer3DModel`, *facultatif*) : Transformer conditionnel pour débruyer les latents d’entrée pendant l’étape à bruit élevé. Dans le débruyage en deux étapes, `transformer` gère les étapes à bruit élevé et `transformer_2` gère les étapes à bruit faible. Au moins l’un des paramètres `transformer` ou `transformer_2` doit être fourni. transformer_2 (`WanVACETransformer3DModel`, *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. Au moins l’un des paramètres `transformer` ou `transformer_2` doit être fourni. 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 le transformer disponible est utilisé pour l'ensemble du processus de débruitage. Pipeline pour la génération contrôlable à l'aide de Wan. Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.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.WanVACEPipeline.__call__]] ```python __call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, video: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] | None = None, mask: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] | None = None, reference_images: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] | None = None, conditioning_scale: typing.Union[float, list[float], torch.Tensor] = 1.0, 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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_vace.py#L690) **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, 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`). video (`list[PIL.Image.Image]`, *facultatif*) : La vidéo ou les vidéos d'entrée à utiliser comme point de départ pour la génération. La vidéo doit être une liste d'images PIL, un tableau numpy ou un tenseur torch. Actuellement, le pipeline ne prend en charge la génération que d'une seule vidéo à la fois. mask (`list[PIL.Image.Image]`, *facultatif*) : Le masque d'entrée définit les régions de la vidéo sur lesquelles conditionner et celles à générer. Les zones noires du masque indiquent les régions de conditionnement, tandis que les zones blanches indiquent les régions de génération. Le masque doit être une liste d'images PIL, un tableau numpy ou un tenseur torch. Prend actuellement en charge la génération d'une seule vidéo à la fois. reference_images (`list[PIL.Image.Image]`, *facultatif*) : Une liste d'une ou plusieurs images de référence servant de conditionnement supplémentaire pour la génération. Par exemple, si vous souhaitez réparer une vidéo pour changer de personnage, vous pouvez transmettre ici des images de référence du nouveau personnage. Consultez les [exemples](https://github.com/huggingface/diffusers/pull/11582) de Diffusers et le [guide utilisateur](https://github.com/ali-vilab/VACE/blob/0897c6d055d7d9ea9e191dce763006664d9780f8/UserGuide.md) original pour la liste complète des tâches et cas d'utilisation pris en charge. conditioning_scale (`float`, `list[float]`, `torch.Tensor`, par défaut `1.0`) : L'échelle de conditionnement à appliquer lors de l'ajout du flux latent de conditionnement de contrôle au flux latent de débruitage dans chaque couche de contrôle du modèle. Si un float est fourni, il sera appliqué uniformément à toutes les couches. Si une liste ou un tenseur est fourni, il doit avoir la même longueur que le nombre de couches de contrôle du modèle (`len(transformer.config.vace_layers)`). 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](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). 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`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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 : ```python >>> import torch >>> import PIL.Image >>> from diffusers import AutoencoderKLWan, WanVACEPipeline >>> from diffusers.schedulers.scheduling_unipc_multistep import UniPCMultistepScheduler >>> from diffusers.utils import export_to_video, load_image def prepare_video_and_mask(first_img: PIL.Image.Image, last_img: PIL.Image.Image, height: int, width: int, num_frames: int): first_img = first_img.resize((width, height)) last_img = last_img.resize((width, height)) frames = [] frames.append(first_img) # Ideally, this should be 127.5 to match original code, but they perform computation on numpy arrays # whereas we are passing PIL images. If you choose to pass numpy arrays, you can set it to 127.5 to # match the original code. frames.extend([PIL.Image.new("RGB", (width, height), (128, 128, 128))] * (num_frames - 2)) frames.append(last_img) mask_black = PIL.Image.new("L", (width, height), 0) mask_white = PIL.Image.new("L", (width, height), 255) mask = [mask_black, *[mask_white] * (num_frames - 2), mask_black] return frames, mask >>> # Available checkpoints: Wan-AI/Wan2.1-VACE-1.3B-diffusers, Wan-AI/Wan2.1-VACE-14B-diffusers >>> model_id = "Wan-AI/Wan2.1-VACE-1.3B-diffusers" >>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32) >>> pipe = WanVACEPipeline.from_pretrained(model_id, vae=vae, torch_dtype=torch.bfloat16) >>> flow_shift = 3.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 = "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." >>> 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" >>> 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>>> " ... ) >>> height = 512 >>> width = 512 >>> num_frames = 81 >>> video, mask = prepare_video_and_mask(first_frame, last_frame, height, width, num_frames) >>> output = pipe( ... video=video, ... mask=mask, ... prompt=prompt, ... negative_prompt=negative_prompt, ... height=height, ... width=width, ... num_frames=num_frames, ... num_inference_steps=30, ... guidance_scale=5.0, ... generator=torch.Generator().manual_seed(42), ... ).frames[0] >>> export_to_video(output, "output.mp4", fps=16) ``` #### encode_prompt[[diffusers.WanVACEPipeline.encode_prompt]] ```python 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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_vace.py#L247) **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. ## WanVideoToVideoPipeline[[diffusers.WanVideoToVideoPipeline]] #### diffusers.WanVideoToVideoPipeline[[diffusers.WanVideoToVideoPipeline]] ```python diffusers.WanVideoToVideoPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, transformer: WanTransformer3DModel, vae: AutoencoderKLWan, scheduler: FlowMatchEulerDiscreteScheduler) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_video2video.py#L174) **Paramètres :** tokenizer (`T5Tokenizer`) : Tokenizer de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). transformer ([WanTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel)) : Transformer conditionnel pour le débruitage des latents d'entrée. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos vers et depuis des représentations latentes. Pipeline pour la génération vidéo-à-vidéo utilisant Wan. Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.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.WanVideoToVideoPipeline.__call__]] ```python __call__(video: list[PIL.Image.Image] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 480, width: int = 832, num_inference_steps: int = 50, timesteps: list[int] | None = None, guidance_scale: float = 5.0, strength: float = 0.8, 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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_video2video.py#L481) **Paramètres :** video (`list[PIL.Image.Image]`) : La vidéo d’entrée utilisée comme point de départ pour la génération vidéo-à-vidéo. La vidéo doit être fournie sous forme de liste d’images PIL, de tableau numpy ou de tenseur torch. 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 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_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. timesteps (`list[int]`, *facultatif*) : Étapes de temps personnalisées à utiliser pour le processus de débruitage avec les planificateurs qui prennent en charge un argument `timesteps` dans leur méthode `set_timesteps`. S'il n'est pas défini, le comportement par défaut lorsque `num_inference_steps` est passé sera utilisé. Doit être dans l'ordre décroissant. guidance_scale (`float`, par défaut `5.0`) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). 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. strength (`float`, par défaut `0.8`) : Une intensité plus élevée entraîne plus de différences entre l'image d'origine et la vidéo générée. 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`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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 : ```python >>> import torch >>> from diffusers.utils import export_to_video, load_video >>> from diffusers import AutoencoderKLWan, WanVideoToVideoPipeline >>> 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-1.3B-Diffusers" >>> vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32) >>> pipe = WanVideoToVideoPipeline.from_pretrained(model_id, vae=vae, torch_dtype=torch.bfloat16) >>> flow_shift = 3.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 robot standing on a mountain top. The sun is setting in the background" >>> 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" >>> video = load_video( ... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/hiker.mp4" ... ) >>> output = pipe( ... video=video, ... prompt=prompt, ... negative_prompt=negative_prompt, ... height=480, ... width=720, ... guidance_scale=5.0, ... strength=0.7, ... ).frames[0] >>> export_to_video(output, "output.mp4", fps=16) ``` #### encode_prompt[[diffusers.WanVideoToVideoPipeline.encode_prompt]] ```python 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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_video2video.py#L265) **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. ## WanAnimatePipeline[[diffusers.WanAnimatePipeline]] #### diffusers.WanAnimatePipeline[[diffusers.WanAnimatePipeline]] ```python diffusers.WanAnimatePipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, vae: AutoencoderKLWan, scheduler: UniPCMultistepScheduler, image_processor: CLIPImageProcessorPil, image_encoder: CLIPVisionModel, transformer: WanAnimateTransformer3DModel) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L150) **Paramètres :** tokenizer (`T5Tokenizer`) : Tokenizer de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). text_encoder (`T5EncoderModel`) : [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), plus précisément la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). image_encoder (`CLIPVisionModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPVisionModel), plus précisément la variante [clip-vit-huge-patch14](https://github.com/mlfoundations/open_clip/blob/main/docs/PRETRAINED.md#vit-h14-xlm-roberta-large). transformer ([WanAnimateTransformer3DModel](/docs/diffusers/v0.43.0/fr/api/models/wan_animate_transformer_3d#diffusers.WanAnimateTransformer3DModel)) : Transformer conditionné pour débruyer les latents d'entrée. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/fr/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : un planificateur à utiliser en combinaison avec `transformer` pour débruyer les latents d'image encodés. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : modèle Variational Auto-Encoder (VAE) permettant d’encoder et de décoder des vidéos vers et depuis des représentations latentes. image_processor (`CLIPImageProcessor`) : Processeur d'images pour la prétraitement des images avant encodage. Pipeline pour l'animation et le remplacement unifiés de personnages à l'aide de Wan-Animate. WanAnimatePipeline prend en entrée une image de personnage, une vidéo de pose et une vidéo de visage, et génère une vidéo dans deux modes : 1. **Mode animation** : le modèle génère une vidéo de l'image du personnage qui imite le mouvement humain des vidéos d'attitude et de visage en entrée. Le personnage est animé en fonction des contrôles de mouvement fournis, créant ainsi une nouvelle vidéo animée du personnage. 2. **Mode de remplacement** : le modèle remplace un personnage dans une vidéo d'arrière-plan par l'image de personnage fournie, en utilisant les vidéos de pose et de visage pour le contrôle du mouvement. Ce mode nécessite des entrées supplémentaires `background_video` et `mask_video`. La vidéo de masque doit contenir des zones noires là où le contenu d'origine doit être conservé et des zones blanches là où le nouveau personnage doit être généré. Ce modèle hérite de [DiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/overview#diffusers.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.). Le pipeline hérite également des méthodes de chargement suivantes : - [load_lora_weights()](/docs/diffusers/v0.43.0/fr/api/loaders/lora#diffusers.loaders.WanLoraLoaderMixin.load_lora_weights) pour charger les poids LoRA #### __appel__[[diffusers.WanAnimatePipeline.__call__]] ```python __call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], pose_video: list[PIL.Image.Image], face_video: list[PIL.Image.Image], background_video: list[PIL.Image.Image] | None = None, mask_video: list[PIL.Image.Image] | None = None, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, height: int = 720, width: int = 1280, segment_frame_length: int = 77, num_inference_steps: int = 20, mode: str = 'animate', prev_segment_conditioning_frames: int = 1, motion_encode_batch_size: int | None = None, guidance_scale: float = 1.0, 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, output_type: str | None = 'np', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int, NoneType], diffusers.callbacks.PipelineCallback | diffusers.callbacks.MultiPipelineCallbacks]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L763) **Paramètres :** image (`PipelineImageInput`) : L'image de caractères d'entrée sur laquelle conditionner la génération. Doit être une image, une liste d'images ou un `torch.Tensor`. pose_video (`list[PIL.Image.Image]`) : La vidéo de pose d'entrée pour conditionner la génération. Doit être une liste d'images PIL. face_video (`list[PIL.Image.Image]`) : La vidéo faciale d'entrée pour conditionner la génération. Doit être une liste d'images PIL. background_video (`list[PIL.Image.Image]`, *facultatif*) : lorsque le mode est `"replace"`, la vidéo d'arrière-plan d'entrée sur laquelle conditionner la génération. Doit être une liste d'images PIL. mask_video (`list[PIL.Image.Image]`, *facultatif*) : lorsque le mode est `"replace"`, la vidéo de masque d’entrée pour conditionner la génération. Doit être une liste d’images PIL. 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`). mode (`str`, par défaut `"animation"`) : Le mode de génération. Choisissez entre `"animate"` et `"replace"`. prev_segment_conditioning_frames (`int`, par défaut `1`) : Le nombre de frames du segment vidéo précédent à utiliser pour le guidage temporel. Il est recommandé de le définir à 1 ou 5. En général, il doit être égal à 4N + 1, où N est un entier non négatif. motion_encode_batch_size (`int`, *facultatif*) : La taille du lot pour l'encodage par lots de la vidéo faciale via l'encodeur de mouvement. Cela permet de compenser la vitesse d'inférence par une réduction de l'utilisation de la mémoire en définissant une taille de lot plus petite. Par défaut, la valeur est `self.transformer.config.motion_encoder_batch_size` si elle n'est pas définie. height (`int`, par défaut `720`) : La hauteur de la vidéo générée. width (`int`, par défaut `1280`) : La largeur de la vidéo générée. segment_frame_length (`int`, par défaut `77`) : Le nombre d'images dans chaque segment de vidéo généré. Le nombre total d'images de la vidéo générée sera égal au nombre d'images de `pose_video` ; la vidéo sera générée par segments jusqu'à atteindre cette longueur. En général, cette valeur doit être de la forme 4N + 1, où N est un entier non négatif. num_inference_steps (`int`, par défaut `20`) : 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 `1.0`) : Échelle de guidage telle que définie dans [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` est défini comme `w` de l'équation 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). 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. Par défaut, le CFG n'est pas utilisé lors de l'inférence de Wan Animate. 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`](https://pytorch.org/docs/stable/generated/torch.Generator.html) 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 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 `negative_prompt`. image_embeds (`torch.Tensor`, *facultatif*) : Embeddings d’images pré-générés. Peut être utilisé pour ajuster facilement les entrées d’image (pondération). S’ils ne sont pas fournis, les embeddings d’images sont générés à partir de l’argument d’entrée `image`. 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](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). 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 de tenseurs 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 : ```python >>> import torch >>> import numpy as np >>> from diffusers import WanAnimatePipeline >>> from diffusers.utils import export_to_video, load_image, load_video >>> model_id = "Wan-AI/Wan2.2-Animate-14B-Diffusers" >>> pipe = WanAnimatePipeline.from_pretrained(model_id, torch_dtype=torch.bfloat16) >>> # Optionally upcast the Wan VAE to FP32 >>> pipe.vae.to(torch.float32) >>> pipe.to("cuda") >>> # Load the reference character image >>> image = load_image( ... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg" ... ) >>> # Load pose and face videos (preprocessed from reference video) >>> # Note: Videos should be preprocessed to extract pose keypoints and face features >>> # Refer to the Wan-Animate preprocessing documentation for details >>> pose_video = load_video("path/to/pose_video.mp4") >>> face_video = load_video("path/to/face_video.mp4") >>> # CFG is generally not used for Wan Animate >>> prompt = ( ... "An astronaut hatching from an egg, on the surface of the moon, the darkness and depth of space realised in " ... "the background. High quality, ultrarealistic detail and breath-taking movie-like camera shot." ... ) >>> # Animation mode: Animate the character with the motion from pose/face videos >>> output = pipe( ... image=image, ... pose_video=pose_video, ... face_video=face_video, ... prompt=prompt, ... height=height, ... width=width, ... segment_frame_length=77, # Frame length of each inference segment ... guidance_scale=1.0, ... num_inference_steps=20, ... mode="animate", ... ).frames[0] >>> export_to_video(output, "output_animation.mp4", fps=30) >>> # Replacement mode: Replace a character in the background video >>> # Requires additional background_video and mask_video inputs >>> background_video = load_video("path/to/background_video.mp4") >>> mask_video = load_video("path/to/mask_video.mp4") # Black areas preserved, white areas generated >>> output = pipe( ... image=image, ... pose_video=pose_video, ... face_video=face_video, ... background_video=background_video, ... mask_video=mask_video, ... prompt=prompt, ... height=height, ... width=width, ... segment_frame_length=77, # Frame length of each inference segment ... guidance_scale=1.0, ... num_inference_steps=20, ... mode="replace", ... ).frames[0] >>> export_to_video(output, "output_replacement.mp4", fps=30) ``` #### encode_prompt[[diffusers.WanAnimatePipeline.encode_prompt]] ```python 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](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L291) **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. #### pad_video_frames[[diffusers.WanAnimatePipeline.pad_video_frames]] ```python pad_video_frames(frames: list[typing.Any], num_target_frames: int) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L718) Remplit un tableau de type vidéo `frames` jusqu'à `num_target_frames` en utilisant une stratégie de type « reflect ». La dimension des images est supposée être la première dimension. Dans le cas 1D, nous pouvons visualiser cette stratégie comme suit : pad_video_frames([1, 2, 3, 4, 5], 10) -> [1, 2, 3, 4, 5, 4, 3, 2, 1, 2] ## WanPipelineOutput[[diffusers.pipelines.wan.pipeline_output.WanPipelineOutput]] #### diffusers.pipelines.wan.pipeline_output.WanPipelineOutput[[diffusers.pipelines.wan.pipeline_output.WanPipelineOutput]] ```python diffusers.pipelines.wan.pipeline_output.WanPipelineOutput(frames: Tensor) ``` [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_output.py#L9) **Paramètres :** frames (`torch.Tensor`, `np.ndarray` ou list[list[PIL.Image.Image]]) : liste de sorties vidéo - Il peut s'agir d'une liste imbriquée de longueur `batch_size,` où chaque sous-liste contient des séquences d'images PIL débruitées de longueur `num_frames.` Il peut également s'agir d'un tableau NumPy ou d'un tenseur Torch de forme `(batch_size, num_frames, channels, height, width)`. Classe de sortie pour les pipelines Wan.