# # Bajo licencia Apache License, versión 2.0 (la "Licencia"); # no puede usar este archivo excepto en cumplimiento de la Licencia. # Puede obtener una copia de la Licencia en # # http://www.apache.org/licenses/LICENSE-2.0 # # A menos que la ley aplicable lo exija o se haya acordado por escrito, el software # distribuido bajo la Licencia se distribuye en una base "TAL CUAL", # SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sea expresa o implícita. # Consulte la Licencia para el lenguaje específico que rige los permisos y # limitaciones de la Licencia. --> # Wan [Wan-2.1](https://huggingface.co/papers/2503.20314) del equipo Wan. *Este informe presenta Wan, una suite integral y abierta de modelos de base para video diseñada para ampliar los límites de la generación de video. Basada en el paradigma principal de transformadores de difusión, Wan logra avances significativos en las capacidades generativas mediante una serie de innovaciones, que incluyen nuestro nuevo VAE, estrategias de preentrenamiento escalables, curación de datos a gran escala y métricas de evaluación automatizadas. Estas contribuciones mejoran colectivamente el rendimiento y la versatilidad del modelo. Específicamente, Wan se caracteriza por cuatro funciones clave: Rendimiento líder: El modelo de 14B de Wan, entrenado en un vasto conjunto de datos que comprende miles de millones de imágenes y videos, demuestra las leyes de escalado de la generación de video con respecto tanto al tamaño de los datos como al del modelo. Supera consistentemente a los modelos de código abierto existentes y a las soluciones comerciales de última generación en múltiples benchmarks internos y externos, demostrando una superioridad de rendimiento clara y significativa. Integralidad: Wan ofrece dos modelos capaces, es decir, de 1.3B y 14B parámetros, para la eficiencia y la efectividad, respectivamente. También cubre múltiples aplicaciones de nivel inferior, incluyendo la generación de video a partir de imágenes, la edición de video guiada por instrucciones y la generación de video personal, abarcando hasta ocho tareas. Eficiencia de grado de consumo: El modelo de 1.3B demuestra una eficiencia de recursos excepcional, requiriendo solo 8.19 GB de VRAM, lo que lo hace compatible con una amplia gama de GPUs de grado de consumo. Apertura: Ponemos en código abierto toda la serie de Wan, incluido el código fuente y todos los modelos, con el objetivo de fomentar el crecimiento de la comunidad de generación de video. Esta apertura busca ampliar significativamente las posibilidades creativas de la producción de video en la industria y proporcionar a la academia modelos de base de video de alta calidad. Todo el código y los modelos están disponibles en [esta URL https](https://github.com/Wan-Video/Wan2.1).* Puedes encontrar todos los puntos de control originales de Wan2.1 bajo la organización [Wan-AI](https://huggingface.co/Wan-AI). Los siguientes modelos de Wan son compatibles con 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] > Haz clic en los modelos Wan en la barra lateral derecha para ver más ejemplos de generación de video. ### Generación de texto a video El siguiente ejemplo demuestra cómo generar un video a partir de texto optimizado para la memoria o la velocidad de inferencia. Consulte la guía [Reduce memory usage](../../optimization/memory) para obtener más detalles sobre las diversas técnicas de ahorro de memoria. El modelo de texto a video Wan2.1 a continuación requiere ~13GB 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) es lento la primera vez, pero las llamadas posteriores al pipeline son más rápidas. [Caching](../../optimization/cache) también puede acelerar la inferencia al almacenar y reutilizar salidas intermedias. ```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) ``` ### Generación de video a partir de los primeros y últimos fotogramas El siguiente ejemplo demuestra cómo usar el pipeline de imagen a video para generar un video utilizando una descripción de texto, un fotograma inicial y un fotograma final. ```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) ``` ### Generación controlable de cualquier cosa a video Wan VACE admite diversas técnicas de generación que logran una generación de video controlable. Algunas de las capacidades incluyen: - Control a Video (Profundidad, Pose, Boceto, Flujo, Escala de grises, Garabato, Diseño, Caja delimitadora, etc.). Biblioteca recomendada para preprocesar videos y obtener videos de control: [huggingface/controlnet_aux]() - Imagen/Video a Video (primer fotograma, último fotograma, clip inicial, clip final, clips aleatorios) - Inpainting y Outpainting - Sujeto al video (caras, objetos, personajes, etc.) - Composición a video (referencia cualquier cosa, anima cualquier cosa, intercambia cualquier cosa, expande cualquier cosa, mueve cualquier cosa, etc.) Los fragmentos de código disponibles en [esta](https://github.com/huggingface/diffusers/pull/11582) solicitud de extracción (pull request) demuestran algunos ejemplos de cómo se pueden generar videos con señales de controlabilidad. La regla general a tener en cuenta al preparar las entradas para el pipeline de VACE es que las imágenes de entrada, o los fotogramas de un video que se desee utilizar para el condicionamiento, deben tener una máscara correspondiente de color negro. La máscara negra indica que el modelo no generará nuevo contenido para esa área, y solo utilizará esas partes para condicionar el proceso de generación. Para las partes o fotogramas que el modelo debe generar, la máscara debe ser de color blanco. ### Wan-Animate: Animación y reemplazo de personajes unificados con replicación integral [Wan-Animate](https://huggingface.co/papers/2509.14055) del equipo Wan. *Presentamos Wan-Animate, un marco unificado para la animación y el reemplazo de personajes. Dada una imagen de un personaje y un video de referencia, Wan-Animate puede animar al personaje replicando con precisión las expresiones y los movimientos del personaje en el video para generar videos de personajes de alta fidelidad. Alternativamente, puede integrar el personaje animado en el video de referencia para reemplazar al personaje original, replicando la iluminación y el tono de color de la escena para lograr una integración ambiental sin costuras. Wan-Animate se basa en el modelo Wan. Para adaptarlo a tareas de animación de personajes, empleamos un paradigma de entrada modificado para diferenciar entre las condiciones de referencia y las regiones para la generación. Este diseño unifica múltiples tareas en una representación simbólica común. Utilizamos señales de esqueleto alineadas espacialmente para replicar el movimiento corporal y características faciales implícitas extraídas de las imágenes de origen para reencarnar las expresiones, lo que permite la generación de videos de personajes con alta controlabilidad y expresividad. Además, para mejorar la integración ambiental durante el reemplazo de personajes, desarrollamos un Relighting LoRA auxiliar. Este módulo preserva la consistencia de la apariencia del personaje mientras aplica la iluminación y el tono de color ambientales apropiados. Los resultados experimentales demuestran que Wan-Animate alcanza un rendimiento líder en su categoría. Nos comprometemos a publicar en código abierto los pesos del modelo y su código fuente.* La página del proyecto: https://humanaigc.github.io/wan-animate Este modelo fue aportado principalmente por [M. Tolga Cangöz](https://github.com/tolgacangoz). #### Uso El pipeline Wan-Animate admite dos modos de operación: 1. **Modo de animación** (predeterminado): Anima una imagen de un personaje basándose en el movimiento y la expresión de los videos de referencia 2. **Modo de reemplazo**: Reemplaza un personaje en un video de fondo con un nuevo personaje, preservando la escena ##### Prerrequisitos Antes de usar el pipeline, debe preprocesar su video de referencia para extraer: - **Video de pose**: Contiene puntos clave esqueléticos que representan el movimiento corporal - **Video facial**: Contiene representaciones de rasgos faciales para el control de la expresión Para el modo de reemplazo, también necesitas: - **Video de fondo**: El video original que contiene la escena - **Máscara de video**: una máscara que indica dónde generar contenido (blanco) frente a dónde conservar el original (negro) > [!NOTE] > No se deben usar videos sin procesar para entradas como `pose_video`, ya que el pipeline espera que estén preprocesados para extraer la información adecuada. Los scripts de preprocesamiento para preparar estas entradas están disponibles en el [repositorio original de Wan-Animate](https://github.com/Wan-Video/Wan2.2?tab=readme-ov-file#1-preprocessing). La integración de estos pasos de preprocesamiento en Diffusers está prevista para una versión futura. El siguiente ejemplo demuestra cómo usar el 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) ``` #### Parámetros clave - **mode**: Elija entre `"animate"` (predeterminado) o `"replace"` - **prev_segment_conditioning_frames**: Número de fotogramas para la guía temporal (se recomienda 1 o 5). Usar 5 proporciona una mejor consistencia temporal, pero requiere más memoria - **guidance_scale**: Controla qué tan de cerca sigue la salida el prompt de texto. Valores más altos (5-7) producen resultados más alineados con el prompt. Para Wan-Animate, CFG está deshabilitado por defecto (`guidance_scale=1.0`), pero se puede habilitar para soportar prompts negativos y un control más fino sobre las expresiones faciales. (Tenga en cuenta que CFG solo apuntará al prompt de texto y al condicionamiento facial.) ## Notas - Wan2.1 admite LoRAs con [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.WanLoraLoaderMixin.load_lora_weights). Mostrar código de ejemplo ```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/es/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel) y [AutoencoderKLWan](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan) admiten la carga desde archivos individuales con [from_single_file()](/docs/diffusers/v0.43.0/es/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file). Mostrar código de ejemplo ```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 ) ``` - Establezca el dtype de [AutoencoderKLWan](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan) en `torch.float32` para obtener una mejor calidad de decodificación. - El número de fotogramas por segundo (fps) o `k` debe calcularse mediante `4 * k + 1`. - Pruebe valores de `shift` más bajos (`2.0` a `5.0`) para videos de menor resolución y valores de `shift` más altos (`7.0` a `12.0`) para imágenes de mayor resolución. - Wan 2.1 y 2.2 admiten el uso de [LightX2V LoRAs](https://huggingface.co/Kijai/WanVideo_comfy/tree/main/Lightx2v) para acelerar la inferencia. Su uso en Wan 2.2 es ligeramente más complejo. Consulta [este fragmento de código](https://github.com/huggingface/diffusers/pull/12040#issuecomment-3144185272) para obtener más información. - Wan 2.2 tiene dos denoisers. Por defecto, los LoRAs solo se cargan en el primer denoiser. Se puede establecer `load_into_transformer_2=True` para cargar los LoRAs en el segundo denoiser. Consulte los ejemplos [este](https://github.com/huggingface/diffusers/pull/12074#issue-3292620048) y [este](https://github.com/huggingface/diffusers/pull/12074#issuecomment-3155896144) para obtener más información. ## 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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan.py#L96) **Parámetros:** tokenizer (`T5Tokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente 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), concretamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). transformer ([WanTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel)) : Transformer condicional para desruidar los latentes de entrada. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes. transformer_2 ([WanTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel), *opcional*) : Transformer condicional para desruidar los latentes de entrada durante la etapa de bajo ruido. Si se proporciona, habilita la desruidación en dos etapas, donde `transformer` gestiona las etapas de alto ruido y `transformer_2` gestiona las etapas de bajo ruido. Si no se proporciona, solo se utiliza `transformer`. boundary_ratio (`float`, *opcional*, valor predeterminado `None`) : Proporción de los pasos de tiempo totales que se utiliza como límite para cambiar entre transformadores en el desruido de dos etapas. El paso de tiempo límite real se calcula como `boundary_ratio * num_train_timesteps`. Cuando se proporciona, `transformer` maneja los pasos de tiempo >= boundary_timestep y `transformer_2` maneja los pasos de tiempo < boundary_timestep. Si es `None`, solo se utiliza `transformer` para todo el proceso de desruido. Pipeline para la generación de texto a video usando Wan. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). #### __call__[[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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan.py#L382) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, pase `prompt_embeds` en su lugar. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts a evitar durante la generación de imágenes. Si no se define, pase `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (`guidance_scale` < `1`). height (`int`, por defecto `480`) : La altura en píxeles de la imagen generada. width (`int`, por defecto `832`) : El ancho en píxeles de la imagen generada. num_frames (`int`, por defecto `81`) : El número de fotogramas en el video generado. num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. guidance_scale (`float`, por defecto `5.0`) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. guidance_scale_2 (`float`, *opcional*, valor predeterminado `None`) : Escala de guía para el transformer de la etapa de bajo ruido (`transformer_2`). Si `None` y el `boundary_ratio` de la pipeline no es None, utiliza el mismo valor que `guidance_scale`. Solo se utiliza cuando `transformer_2` y el `boundary_ratio` de la pipeline no son None. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan a partir del argumento de entrada `negative_prompt`. output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`. return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un `WanPipelineOutput` en lugar de una tupla simple. attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. max_sequence_length (`int`, por defecto `512`) : La longitud máxima de la secuencia del codificador de texto. Si el prompt es más largo que esto, se truncará. Si el prompt es más corto, se rellenará hasta esta longitud. **Devuelve:** `~WanPipelineOutput` o `tuple` Si `return_dict` es `True`, se devuelve `WanPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw). La función de llamada para el pipeline de generación. Ejemplos: ```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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan.py#L200) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. device : (`torch.device`, *opcional*): dispositivo de torch dtype : (`torch.dtype`, *opcional*): dtype de torch Codifica el prompt en estados ocultos del codificador de texto. ## 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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_i2v.py#L127) **Parámetros:** tokenizer (`T5Tokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente 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), concretamente 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), concretamente 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/es/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel)) : Transformer condicional para desruidar los latentes de entrada. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes. transformer_2 ([WanTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel), *opcional*) : Transformer condicional para desruidar los latentes de entrada durante la etapa de bajo ruido. En la desruidado de dos etapas, `transformer` gestiona las etapas de alto ruido y `transformer_2` gestiona las etapas de bajo ruido. Si no se proporciona, solo se utiliza `transformer`. boundary_ratio (`float`, *opcional*, valor predeterminado `None`) : Proporción de los pasos de tiempo totales que se utiliza como límite para cambiar entre transformadores en el desruido de dos etapas. El paso de tiempo límite real se calcula como `boundary_ratio * num_train_timesteps`. Cuando se proporciona, `transformer` maneja los pasos de tiempo >= boundary_timestep y `transformer_2` maneja los pasos de tiempo < boundary_timestep. Si es `None`, solo se utiliza `transformer` para todo el proceso de desruido. Pipeline para la generación de video a partir de imágenes usando Wan. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). #### __call__[[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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_i2v.py#L510) **Parámetros:** image (`PipelineImageInput`) : La imagen de entrada para condicionar la generación. Debe ser una imagen, una lista de imágenes o un `torch.Tensor`. last_image (`torch.Tensor`, *opcional*) : Último fotograma opcional para condicionar el video generado. Cuando se proporciona, el modelo interpola entre `image` (primer fotograma) y `last_image` (último fotograma). prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). height (`int`, por defecto `480`) : La altura del video generado. width (`int`, por defecto `832`) : El ancho del video generado. num_frames (`int`, por defecto `81`) : El número de fotogramas en el video generado. num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. guidance_scale (`float`, por defecto `5.0`) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. guidance_scale_2 (`float`, *opcional*, valor predeterminado `None`) : Escala de guía para el transformer de la etapa de bajo ruido (`transformer_2`). Si `None` y el `boundary_ratio` de la pipeline no es None, utiliza el mismo valor que `guidance_scale`. Solo se utiliza cuando `transformer_2` y el `boundary_ratio` de la pipeline no son None. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, los embeddings de texto se generan a partir del argumento de entrada `negative_prompt`. image_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de imagen pregeneradas. Se pueden usar para ajustar fácilmente las entradas de imagen (ponderación). Si no se proporcionan, las incrustaciones de imagen se generan a partir del argumento de entrada `image`. output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`. return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un `WanPipelineOutput` en lugar de una tupla simple. attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. max_sequence_length (`int`, por defecto `512`) : La longitud máxima de la secuencia del codificador de texto. Si el prompt es más largo que esto, se truncará. Si el prompt es más corto, se rellenará hasta esta longitud. **Devuelve:** `~WanPipelineOutput` o `tuple` Si `return_dict` es `True`, se devuelve `WanPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw). La función de llamada para el pipeline de generación. Ejemplos: ```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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_i2v.py#L254) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. device : (`torch.device`, *opcional*): dispositivo de torch dtype : (`torch.dtype`, *opcional*): dtype de torch Codifica el prompt en estados ocultos del codificador de texto. ## 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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_vace.py#L141) **Parámetros:** tokenizer (`T5Tokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente 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), concretamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados. transformer (`WanVACETransformer3DModel`, *opcional*) : Transformer condicional para desruidar los latentes de entrada durante la etapa de ruido alto. En el desruido de dos etapas, `transformer` gestiona las etapas de ruido alto y `transformer_2` gestiona las etapas de ruido bajo. Debe proporcionarse al menos uno de `transformer` o `transformer_2`. transformer_2 (`WanVACETransformer3DModel`, *opcional*) : Transformer condicional para desruidar los latentes de entrada durante la etapa de bajo ruido. En la desruidado de dos etapas, `transformer` gestiona las etapas de alto ruido y `transformer_2` gestiona las etapas de bajo ruido. Debe proporcionarse al menos uno de `transformer` o `transformer_2`. boundary_ratio (`float`, *opcional*, valor predeterminado `None`) : Proporción de los pasos de tiempo totales que se utiliza como límite para cambiar entre transformadores en el desruido de dos etapas. El paso de tiempo límite real se calcula como `boundary_ratio * num_train_timesteps`. Cuando se proporciona, `transformer` maneja los pasos de tiempo >= boundary_timestep y `transformer_2` maneja los pasos de tiempo < boundary_timestep. Si es `None`, solo se utiliza el transformador disponible para todo el proceso de desruido. Pipeline para generación controlable usando Wan. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). #### __call__[[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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_vace.py#L690) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). video (`list[PIL.Image.Image]`, *opcional*) : El video o videos de entrada que se usarán como punto de partida para la generación. El video debe ser una lista de imágenes PIL, un array de numpy o un tensor de torch. Actualmente, el pipeline solo admite la generación de un video a la vez. mask (`list[PIL.Image.Image]`, *opcional*) : La máscara de entrada define qué regiones del video se usarán como condición y cuáles se generarán. Las áreas negras en la máscara indican regiones de condicionamiento, mientras que las áreas blancas indican regiones para la generación. La máscara debe ser una lista de imágenes PIL, un array de numpy o un tensor de torch. Actualmente, se admite la generación de un solo video a la vez. reference_images (`list[PIL.Image.Image]`, *opcional*) : Una lista de una o más imágenes de referencia como condicionamiento adicional para la generación. Por ejemplo, si intentas hacer inpainting de un video para cambiar el personaje, puedes pasar aquí imágenes de referencia del nuevo personaje. Consulta los [ejemplos](https://github.com/huggingface/diffusers/pull/11582) de Diffusers y la [guía de usuario](https://github.com/ali-vilab/VACE/blob/0897c6d055d7d9ea9e191dce763006664d9780f8/UserGuide.md) original para obtener la lista completa de tareas y casos de uso admitidos. conditioning_scale (`float`, `list[float]`, `torch.Tensor`, por defecto `1.0`) : La escala de condicionamiento que se aplicará al añadir el flujo latente de condicionamiento de control al flujo latente de desruido en cada capa de control del modelo. Si se proporciona un float, se aplicará de forma uniforme a todas las capas. Si se proporciona una lista o un tensor, debe tener la misma longitud que el número de capas de control del modelo (`len(transformer.config.vace_layers)`). height (`int`, por defecto `480`) : La altura en píxeles de la imagen generada. width (`int`, por defecto `832`) : El ancho en píxeles de la imagen generada. num_frames (`int`, por defecto `81`) : El número de fotogramas en el video generado. num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. guidance_scale (`float`, por defecto `5.0`) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. guidance_scale_2 (`float`, *opcional*, valor predeterminado `None`) : Escala de guía para el transformer de la etapa de bajo ruido (`transformer_2`). Si `None` y el `boundary_ratio` de la pipeline no es None, utiliza el mismo valor que `guidance_scale`. Solo se utiliza cuando `transformer_2` y el `boundary_ratio` de la pipeline no son None. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan a partir del argumento de entrada `negative_prompt`. output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`. return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un `WanPipelineOutput` en lugar de una tupla simple. attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. max_sequence_length (`int`, por defecto `512`) : La longitud máxima de la secuencia del codificador de texto. Si el prompt es más largo que esto, se truncará. Si el prompt es más corto, se rellenará hasta esta longitud. **Devuelve:** `~WanPipelineOutput` o `tuple` Si `return_dict` es `True`, se devuelve `WanPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw). La función de llamada para el pipeline de generación. Ejemplos: ```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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_vace.py#L247) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. device : (`torch.device`, *opcional*): dispositivo de torch dtype : (`torch.dtype`, *opcional*): dtype de torch Codifica el prompt en estados ocultos del codificador de texto. ## WanVideoToVideoPipeline[[diffusers.WanVideoToVideoPipeline]] #### diffusers.WanVideoToVideoPipeline[[diffusers.WanVideoToVideoPipeline]] ```python diffusers.WanVideoToVideoPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, transformer: WanTransformer3DModel, vae: AutoencoderKLWan, scheduler: FlowMatchEulerDiscreteScheduler) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_video2video.py#L174) **Parámetros:** tokenizer (`T5Tokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente 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), concretamente la variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). transformer ([WanTransformer3DModel](/docs/diffusers/v0.43.0/es/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel)) : Transformer condicional para desruidar los latentes de entrada. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes. Pipeline para la generación de video a video usando Wan. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). #### __call__[[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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_video2video.py#L481) **Parámetros:** video (`list[PIL.Image.Image]`) : El video de entrada utilizado como punto de partida para la generación de video a video. El video debe proporcionarse como una lista de imágenes PIL, un array de numpy o un tensor de torch. prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). height (`int`, por defecto `480`) : La altura en píxeles de la imagen generada. width (`int`, por defecto `832`) : El ancho en píxeles de la imagen generada. num_inference_steps (`int`, por defecto `50`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. timesteps (`list[int]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente. guidance_scale (`float`, por defecto `5.0`) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se habilita estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. strength (`float`, por defecto `0.8`) : Una mayor intensidad produce más diferencias entre la imagen original y el video generado. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, `negative_prompt_embeds` se generan a partir del argumento de entrada `negative_prompt`. output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`. return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un `WanPipelineOutput` en lugar de una tupla simple. attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. max_sequence_length (`int`, por defecto `512`) : La longitud máxima de la secuencia del codificador de texto. Si el prompt es más largo que esto, se truncará. Si el prompt es más corto, se rellenará hasta esta longitud. **Devuelve:** `~WanPipelineOutput` o `tuple` Si `return_dict` es `True`, se devuelve `WanPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw). La función de llamada para el pipeline de generación. Ejemplos: ```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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_video2video.py#L265) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. device : (`torch.device`, *opcional*): dispositivo de torch dtype : (`torch.dtype`, *opcional*): dtype de torch Codifica el prompt en estados ocultos del codificador de texto. ## 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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L150) **Parámetros:** tokenizer (`T5Tokenizer`) : Tokenizador de [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), específicamente 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), concretamente 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), concretamente 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/es/api/models/wan_animate_transformer_3d#diffusers.WanAnimateTransformer3DModel)) : Transformer condicional para desruidar los latentes de entrada. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/es/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/es/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Autoencoder Variacional (VAE) para codificar y decodificar videos hacia y desde representaciones latentes. image_processor (`CLIPImageProcessor`) : Procesador de imágenes para preprocesar imágenes antes de codificarlas. Pipeline para la animación y el reemplazo unificados de personajes usando Wan-Animate. WanAnimatePipeline toma como entrada una imagen de un personaje, un video de poses y un video de rostro, y genera un video en dos modos: 1. **Modo de animación**: El modelo genera un video de la imagen del personaje que imita el movimiento humano de los videos de pose y rostro de entrada. El personaje se anima en función de los controles de movimiento proporcionados, creando un nuevo video animado del personaje. 2. **Modo de reemplazo**: El modelo reemplaza un personaje en un video de fondo con la imagen de personaje proporcionada, utilizando los videos de pose y rostro para el control del movimiento. Este modo requiere las entradas adicionales `background_video` y `mask_video`. El video de máscara debe tener regiones negras donde se debe preservar el contenido original y regiones blancas donde se debe generar el nuevo personaje. Este modelo hereda de [DiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos implementados en todas las tuberías (descarga, guardado, ejecución en un dispositivo específico, etc.). El pipeline también hereda los siguientes métodos de carga: - [load_lora_weights()](/docs/diffusers/v0.43.0/es/api/loaders/lora#diffusers.loaders.WanLoraLoaderMixin.load_lora_weights) para cargar los pesos de LoRA #### __call__[[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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L763) **Parámetros:** image (`PipelineImageInput`) : La imagen de caracteres de entrada para condicionar la generación. Debe ser una imagen, una lista de imágenes o un `torch.Tensor`. pose_video (`list[PIL.Image.Image]`) : El video de poses de entrada para condicionar la generación. Debe ser una lista de imágenes PIL. face_video (`list[PIL.Image.Image]`) : El video de rostro de entrada para condicionar la generación. Debe ser una lista de imágenes PIL. background_video (`list[PIL.Image.Image]`, *opcional*) : Cuando el modo es `"replace"`, el video de fondo de entrada para condicionar la generación. Debe ser una lista de imágenes PIL. mask_video (`list[PIL.Image.Image]`, *opcional*) : Cuando el modo es `"replace"`, el video de máscara de entrada para condicionar la generación. Debe ser una lista de imágenes PIL. prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar. negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). mode (`str`, por defecto `"animation"`) : El modo de la generación. Elija entre `"animate"` y `"replace"`. prev_segment_conditioning_frames (`int`, por defecto `1`) : El número de fotogramas del segmento de video anterior que se usarán para la guía temporal. Se recomienda que sea 1 o 5. En general, debe ser 4N + 1, donde N es un entero no negativo. motion_encode_batch_size (`int`, *opcional*) : El tamaño de lote para la codificación por lotes del video facial mediante el codificador de movimiento. Esto permite equilibrar la velocidad de inferencia con un menor uso de memoria estableciendo un tamaño de lote más pequeño. Si no se establece, el valor predeterminado será `self.transformer.config.motion_encoder_batch_size`. height (`int`, por defecto `720`) : La altura del video generado. width (`int`, por defecto `1280`) : El ancho del video generado. segment_frame_length (`int`, por defecto `77`) : El número de fotogramas en cada segmento de video generado. El total de fotogramas del video generado será igual al número de fotogramas de `pose_video`; generaremos el video en segmentos hasta alcanzar esta longitud. En general, debe ser 4N + 1, donde N es un entero no negativo. num_inference_steps (`int`, por defecto `20`) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. guidance_scale (`float`, por defecto `1.0`) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se activa estableciendo `guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen. Por defecto, CFG no se utiliza en la inferencia de Wan Animate. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación. generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporciona, se genera un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado. prompt_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de texto pregeneradas. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, las incrustaciones de texto se generan a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto (ponderación del prompt). Si no se proporcionan, los embeddings de texto se generan a partir del argumento de entrada `negative_prompt`. image_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de imagen pregeneradas. Se pueden usar para ajustar fácilmente las entradas de imagen (ponderación). Si no se proporcionan, las incrustaciones de imagen se generan a partir del argumento de entrada `image`. output_type (`str`, *opcional*, por defecto `"np"`) : El formato de salida de la imagen generada. Elija entre `PIL.Image` o `np.array`. return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un `WanPipelineOutput` en lugar de una tupla simple. attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opcional*) : una función o una subclase de `PipelineCallback` o `MultiPipelineCallbacks` que se llama al final de cada paso de denoising durante la inferencia, con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`List`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline. max_sequence_length (`int`, por defecto `512`) : La longitud máxima de la secuencia del codificador de texto. Si el prompt es más largo que esto, se truncará. Si el prompt es más corto, se rellenará hasta esta longitud. **Devuelve:** `~WanPipelineOutput` o `tuple` Si `return_dict` es `True`, se devuelve `WanPipelineOutput`; en caso contrario, se devuelve una `tuple` cuyo primer elemento es una lista con las imágenes generadas y cuyo segundo elemento es una lista de `bool` que indica si la imagen generada correspondiente contiene contenido "not-safe-for-work" (nsfw). La función de llamada para el pipeline de generación. Ejemplos: ```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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L291) **Parámetros:** prompt (`str` o `list[str]`, *opcional*) : prompt a codificar negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`). do_classifier_free_guidance (`bool`, *opcional*, por defecto `True`) : Si se debe usar o no la guía libre de clasificador. num_videos_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de videos que deben generarse por indicación. Dispositivo de torch en el que colocar las incrustaciones resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`. device : (`torch.device`, *opcional*): dispositivo de torch dtype : (`torch.dtype`, *opcional*): dtype de torch Codifica el prompt en estados ocultos del codificador de texto. #### pad_video_frames[[diffusers.WanAnimatePipeline.pad_video_frames]] ```python pad_video_frames(frames: list[typing.Any], num_target_frames: int) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L718) Rellena un video con forma de matriz `frames` hasta `num_target_frames` utilizando una estrategia similar a "reflect". Se asume que la dimensión de los fotogramas es la primera dimensión. En el caso 1D, podemos visualizar esta estrategia de la siguiente manera: 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) ``` [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_output.py#L9) **Parámetros:** frames (`torch.Tensor`, `np.ndarray` o list[list[PIL.Image.Image]]) : lista de salidas de video - Puede ser una lista anidada de longitud `batch_size,` donde cada sublista contiene secuencias de imágenes PIL desruidas de longitud `num_frames.` También puede ser un array de NumPy o un tensor de Torch de forma `(batch_size, num_frames, channels, height, width)`. Clase de salida para las tuberías de Wan.