# # Licenciado sob a Apache License, Versão 2.0 (a "Licença"); # você não pode usar este arquivo, exceto em conformidade com a Licença. # Você pode obter uma cópia da Licença em # # http://www.apache.org/licenses/LICENSE-2.0 # # A menos que exigido pela lei aplicável ou acordado por escrito, o software # distribuído sob a Licença é distribuído em uma base "COMO ESTÁ", # SEM GARANTIAS OU CONDIÇÕES DE QUALQUER TIPO, expressas ou implícitas. # Consulte a Licença para o idioma específico que rege as permissões e # limitações sob a Licença. --> # Wan [Wan-2.1](https://huggingface.co/papers/2503.20314) da equipe Wan. *Este relatório apresenta o Wan, um conjunto abrangente e aberto de modelos de fundação para vídeo, projetado para expandir os limites da geração de vídeo. Construído sobre o paradigma mainstream de difusão com transformadores, o Wan alcança avanços significativos em capacidades generativas por meio de uma série de inovações, incluindo nosso novo VAE, estratégias de pré-treino escaláveis, curadoria de dados em larga escala e métricas de avaliação automatizadas. Essas contribuições, em conjunto, aprimoram o desempenho e a versatilidade do modelo. Especificamente, o Wan é caracterizado por quatro recursos principais: Desempenho de ponta: O modelo de 14B do Wan, treinado em um vasto conjunto de dados composto por bilhões de imagens e vídeos, demonstra as leis de escala da geração de vídeo em relação tanto ao tamanho dos dados quanto ao do modelo. Ele supera consistentemente os modelos open-source existentes, bem como as soluções comerciais de última geração, em múltiplos benchmarks internos e externos, demonstrando uma superioridade de desempenho clara e significativa. Abrangência: O Wan oferece dois modelos capazes, ou seja, 1,3B e 14B de parâmetros, para eficiência e eficácia, respectivamente. Ele também abrange múltiplas aplicações downstream, incluindo image-to-video, edição de vídeo guiada por instruções e geração de vídeo pessoal, abrangendo até oito tarefas. Eficiência de nível consumidor: O modelo de 1,3B demonstra uma eficiência de recursos excepcional, exigindo apenas 8,19 GB de VRAM, o que o torna compatível com uma ampla variedade de GPUs de nível consumidor. Abertura: Abrimos o código-fonte de toda a série do Wan, incluindo o código-fonte e todos os modelos, com o objetivo de fomentar o crescimento da comunidade de geração de vídeo. Essa abertura busca expandir significativamente as possibilidades criativas da produção de vídeo na indústria e fornecer à academia modelos de fundação para vídeo de alta qualidade. Todo o código e os modelos estão disponíveis em [este URL https](https://github.com/Wan-Video/Wan2.1).* Você pode encontrar todos os checkpoints originais do Wan2.1 sob a organização [Wan-AI](https://huggingface.co/Wan-AI). Os seguintes modelos Wan são suportados no 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] > Clique nos modelos Wan na barra lateral à direita para mais exemplos de geração de vídeo. ### Geração de Texto para Vídeo O exemplo abaixo demonstra como gerar um vídeo a partir de texto otimizado para memória ou velocidade de inferência. Consulte o guia [Reduzir o uso de memória](../../optimization/memory) para mais detalhes sobre as diversas técnicas de economia de memória. O modelo de texto para vídeo Wan2.1 abaixo requer ~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) é lento na primeira vez, mas as chamadas subsequentes ao pipeline são mais rápidas. [Caching](../../optimization/cache) também pode acelerar a inferência ao armazenar e reutilizar saídas intermediárias. ```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) ``` ### Geração de Vídeo a Partir do Primeiro e Último Quadro O exemplo abaixo demonstra como usar o pipeline de imagem para vídeo para gerar um vídeo usando uma descrição de texto, um quadro inicial e um quadro 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) ``` ### Geração controlável de vídeo a partir de qualquer entrada O Wan VACE suporta diversas técnicas de geração que alcançam a geração de vídeo controlável. Algumas das capacidades incluem: - Controle para Vídeo (Profundidade, Pose, Esboço, Fluxo, Escala de Cinza, Rabisco, Layout, Caixa Delimitadora, etc.). Biblioteca recomendada para pré-processar vídeos e obter vídeos de controle: [huggingface/controlnet_aux]() - Imagem/Vídeo para Vídeo (primeiro quadro, último quadro, clipe inicial, clipe final, clipes aleatórios) - Inpainting e Outpainting - Sujeito ao Vídeo (rostos, objetos, personagens, etc.) - Composição para Vídeo (referencie qualquer coisa, anime qualquer coisa, troque qualquer coisa, expanda qualquer coisa, mova qualquer coisa, etc.) Os trechos de código disponíveis neste [pull request](https://github.com/huggingface/diffusers/pull/11582) demonstram alguns exemplos de como vídeos podem ser gerados com sinais de controlabilidade. A regra geral a ser lembrada ao preparar as entradas para o pipeline VACE é que as imagens de entrada, ou os quadros de um vídeo que você deseja usar para condicionamento, devem ter uma máscara correspondente que seja preta. A máscara preta indica que o modelo não gerará novo conteúdo para aquela área e usará apenas essas partes para condicionar o processo de geração. Para as partes/quadros que devem ser gerados pelo modelo, a máscara deve ser branca. ### Wan-Animate: Animação e substituição de personagens unificadas com replicação holística [Wan-Animate](https://huggingface.co/papers/2509.14055) da equipe Wan. *Apresentamos o Wan-Animate, um framework unificado para animação e substituição de personagens. Dada uma imagem de um personagem e um vídeo de referência, o Wan-Animate pode animar o personagem replicando com precisão as expressões e os movimentos do personagem no vídeo para gerar vídeos de personagens de alta fidelidade. Alternativamente, ele pode integrar o personagem animado no vídeo de referência para substituir o personagem original, replicando a iluminação e o tom de cor da cena para alcançar uma integração ambiental sem emendas. O Wan-Animate é construído sobre o modelo Wan. Para adaptá-lo a tarefas de animação de personagens, empregamos um paradigma de entrada modificado para diferenciar entre condições de referência e regiões para geração. Esse design unifica múltiplas tarefas em uma representação simbólica comum. Usamos sinais de esqueleto alinhados espacialmente para replicar o movimento corporal e recursos faciais implícitos extraídos de imagens de origem para reencenar expressões, permitindo a geração de vídeos de personagens com alta controlabilidade e expressividade. Além disso, para aprimorar a integração ambiental durante a substituição de personagens, desenvolvemos um Relighting LoRA auxiliar. Este módulo preserva a consistência da aparência do personagem enquanto aplica a iluminação e o tom de cor ambientais apropriados. Os resultados experimentais demonstram que o Wan-Animate alcança desempenho state-of-the-art. Estamos comprometidos em disponibilizar os pesos do modelo e seu código-fonte em código aberto.* A página do projeto: https://humanaigc.github.io/wan-animate Este modelo foi contribuído principalmente por [M. Tolga Cangöz](https://github.com/tolgacangoz). #### Uso O pipeline Wan-Animate suporta dois modos de operação: 1. **Modo de animação** (padrão): Anima uma imagem de personagem com base no movimento e na expressão de vídeos de referência 2. **Modo de substituição**: substitui um personagem em um vídeo de fundo por um novo personagem, preservando a cena ##### Pré-requisitos Antes de usar o pipeline, você precisa pré-processar seu vídeo de referência para extrair: - **Vídeo de pose**: Contém pontos-chave esqueléticos representando o movimento do corpo - **Vídeo facial**: Contém representações de características faciais para controle de expressão Para o modo de substituição, você precisa adicionalmente de: - **Vídeo de fundo**: O vídeo original contendo a cena - **Vídeo de máscara**: Uma máscara que indica onde gerar conteúdo (branco) versus preservar o original (preto) > [!NOTE] > Vídeos brutos não devem ser usados para entradas como `pose_video`, que o pipeline espera que sejam pré-processados para extrair as informações adequadas. Scripts de pré-processamento para preparar essas entradas estão disponíveis no [repositório original do Wan-Animate](https://github.com/Wan-Video/Wan2.2?tab=readme-ov-file#1-preprocessing). A integração dessas etapas de pré-processamento no Diffusers está planejada para uma versão futura. O exemplo abaixo demonstra como usar o 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 Principais - **mode**: Escolha entre `"animate"` (padrão) ou `"replace"` - **prev_segment_conditioning_frames**: Número de quadros para orientação temporal (recomenda-se 1 ou 5). Usar 5 fornece melhor consistência temporal, mas requer mais memória - **guidance_scale**: Controla o quão de perto a saída segue o prompt de texto. Valores mais altos (5-7) produzem resultados mais alinhados com o prompt. Para o Wan-Animate, o CFG é desativado por padrão (`guidance_scale=1.0`), mas pode ser ativado para suportar prompts negativos e um controle mais fino sobre as expressões faciais. (Observe que o CFG atuará apenas sobre o prompt de texto e o condicionamento facial.) ## Observações - O Wan2.1 suporta LoRAs com [load_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.WanLoraLoaderMixin.load_lora_weights). Exibir código de exemplo ```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/pt/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel) e [AutoencoderKLWan](/docs/diffusers/v0.43.0/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan) suportam carregamento a partir de arquivos únicos com [from_single_file()](/docs/diffusers/v0.43.0/pt/api/loaders/single_file#diffusers.loaders.FromSingleFileMixin.from_single_file). Exibir código de exemplo ```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 ) ``` - Defina o dtype do [AutoencoderKLWan](/docs/diffusers/v0.43.0/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan) como `torch.float32` para uma melhor qualidade de decodificação. - O número de quadros por segundo (fps) ou `k` deve ser calculado por `4 * k + 1`. - Tente valores de `shift` mais baixos (`2.0` a `5.0`) para vídeos de menor resolução e valores de `shift` mais altos (`7.0` a `12.0`) para imagens de maior resolução. - Wan 2.1 e 2.2 suportam o uso de [LightX2V LoRAs](https://huggingface.co/Kijai/WanVideo_comfy/tree/main/Lightx2v) para acelerar a inferência. O uso deles no Wan 2.2 é ligeiramente mais complexo. Consulte [este trecho de código](https://github.com/huggingface/diffusers/pull/12040#issuecomment-3144185272) para saber mais. - O Wan 2.2 possui dois denoisers. Por padrão, os LoRAs são carregados apenas no primeiro denoiser. É possível definir `load_into_transformer_2=True` para carregar os LoRAs no segundo denoiser. Consulte os exemplos [este](https://github.com/huggingface/diffusers/pull/12074#issue-3292620048) e [este](https://github.com/huggingface/diffusers/pull/12074#issuecomment-3155896144) para saber mais. ## 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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan.py#L96) **Parâmetros:** tokenizer (`T5Tokenizer`) : Tokenizer do [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), especificamente a 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), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). transformer ([WanTransformer3DModel](/docs/diffusers/v0.43.0/pt/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel)) : Transformer condicional para desruidar os latentes de entrada. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes. transformer_2 ([WanTransformer3DModel](/docs/diffusers/v0.43.0/pt/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel), *opcional*) : Transformer condicional para desruidar os latentes de entrada durante a etapa de baixo ruído. Se fornecido, habilita a desruidagem em duas etapas, na qual `transformer` trata as etapas de alto ruído e `transformer_2` trata as etapas de baixo ruído. Se não for fornecido, apenas `transformer` é utilizado. boundary_ratio (`float`, *opcional*, padrão `None`) : Proporção dos timesteps totais a ser usada como limite para alternar entre os transformers no desruidamento em duas etapas. O timestep de limite real é calculado como `boundary_ratio * num_train_timesteps`. Quando fornecido, `transformer` trata timesteps >= boundary_timestep e `transformer_2` trata timesteps < boundary_timestep. Se `None`, apenas `transformer` é usado para todo o processo de desruidamento. Pipeline para geração de texto para vídeo usando Wan. Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um 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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan.py#L382) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, passe `prompt_embeds` em vez disso. negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts a evitar durante a geração de imagem. Se não definido, passe `negative_prompt_embeds` em vez disso. Ignorado quando não está usando orientação (`guidance_scale` < `1`). height (`int`, padrão `480`) : A altura em pixels da imagem gerada. width (`int`, padrão `832`) : A largura em pixels da imagem gerada. num_frames (`int`, padrão `81`) : O número de quadros no vídeo gerado. num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. guidance_scale (`float`, padrão `5.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. guidance_scale_2 (`float`, *opcional*, padrão `None`) : Escala de orientação para o transformer do estágio de baixo ruído (`transformer_2`). Se `None` e o `boundary_ratio` do pipeline não for None, usa o mesmo valor de `guidance_scale`. Usado apenas quando `transformer_2` e o `boundary_ratio` do pipeline não forem None. num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido. prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidos, `negative_prompt_embeds` são gerados a partir do argumento de entrada `negative_prompt`. output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `WanPipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [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*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline. max_sequence_length (`int`, padrão `512`) : O comprimento máximo da sequência do codificador de texto. Se o prompt for mais longo que isso, ele será truncado. Se o prompt for mais curto, ele será preenchido até esse comprimento. **Retorna:** `~WanPipelineOutput` ou `tuple` Se `return_dict` for `True`, `WanPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw). A função de chamada do pipeline para geração. Exemplos: ```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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan.py#L200) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance. num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`. device : (`torch.device`, *opcional*): dispositivo torch dtype : (`torch.dtype`, *opcional*): dtype do torch Codifica o prompt em estados ocultos do 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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_i2v.py#L127) **Parâmetros:** tokenizer (`T5Tokenizer`) : Tokenizer do [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), especificamente a 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), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). image_encoder (`CLIPVisionModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPVisionModel), especificamente a 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/pt/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel)) : Transformer condicional para desruidar os latentes de entrada. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes. transformer_2 ([WanTransformer3DModel](/docs/diffusers/v0.43.0/pt/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel), *opcional*) : Transformer condicional para desruidar os latentes de entrada durante a etapa de baixo ruído. Na dessonificação em duas etapas, `transformer` trata as etapas de alto ruído e `transformer_2` trata as etapas de baixo ruído. Se não for fornecido, apenas `transformer` é usado. boundary_ratio (`float`, *opcional*, padrão `None`) : Proporção dos timesteps totais a ser usada como limite para alternar entre os transformers no desruidamento em duas etapas. O timestep de limite real é calculado como `boundary_ratio * num_train_timesteps`. Quando fornecido, `transformer` trata timesteps >= boundary_timestep e `transformer_2` trata timesteps < boundary_timestep. Se `None`, apenas `transformer` é usado para todo o processo de desruidamento. Pipeline para geração de vídeo a partir de imagem usando Wan. Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um 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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_i2v.py#L510) **Parâmetros:** image (`PipelineImageInput`) : A imagem de entrada para condicionar a geração. Deve ser uma imagem, uma lista de imagens ou um `torch.Tensor`. last_image (`torch.Tensor`, *opcional*) : Último quadro opcional para condicionar o vídeo gerado. Quando fornecido, o modelo interpola entre `image` (primeiro quadro) e `last_image` (último quadro). prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). height (`int`, padrão `480`) : A altura do vídeo gerado. width (`int`, padrão `832`) : A largura do vídeo gerado. num_frames (`int`, padrão `81`) : O número de quadros no vídeo gerado. num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. guidance_scale (`float`, padrão `5.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. guidance_scale_2 (`float`, *opcional*, padrão `None`) : Escala de orientação para o transformer do estágio de baixo ruído (`transformer_2`). Se `None` e o `boundary_ratio` do pipeline não for None, usa o mesmo valor de `guidance_scale`. Usado apenas quando `transformer_2` e o `boundary_ratio` do pipeline não forem None. num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido. prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `negative_prompt`. image_embeds (`torch.Tensor`, *opcional*) : Embebimentos de imagem pré-gerados. Pode ser usado para ajustar facilmente as entradas de imagem (ponderação). Se não for fornecido, os embebimentos de imagem são gerados a partir do argumento de entrada `image`. output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `WanPipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [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*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline. max_sequence_length (`int`, padrão `512`) : O comprimento máximo da sequência do codificador de texto. Se o prompt for mais longo que isso, ele será truncado. Se o prompt for mais curto, ele será preenchido até esse comprimento. **Retorna:** `~WanPipelineOutput` ou `tuple` Se `return_dict` for `True`, `WanPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw). A função de chamada do pipeline para geração. Exemplos: ```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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_i2v.py#L254) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance. num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`. device : (`torch.device`, *opcional*): dispositivo torch dtype : (`torch.dtype`, *opcional*): dtype do torch Codifica o prompt em estados ocultos do 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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_vace.py#L141) **Parâmetros:** tokenizer (`T5Tokenizer`) : Tokenizer do [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), especificamente a 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), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. transformer (`WanVACETransformer3DModel`, *opcional*) : Transformer condicional para desruidar os latentes de entrada durante a etapa de alto ruído. Na dessonificação em duas etapas, `transformer` trata as etapas de alto ruído e `transformer_2` trata as etapas de baixo ruído. Pelo menos um de `transformer` ou `transformer_2` deve ser fornecido. transformer_2 (`WanVACETransformer3DModel`, *opcional*) : Transformer condicional para desruidar os latentes de entrada durante a etapa de baixo ruído. Na dessonificação em duas etapas, `transformer` trata as etapas de alto ruído e `transformer_2` trata as etapas de baixo ruído. Pelo menos um de `transformer` ou `transformer_2` deve ser fornecido. boundary_ratio (`float`, *opcional*, padrão `None`) : Proporção dos timesteps totais a ser usada como limite para alternar entre os transformers no desruidamento em duas etapas. O timestep de limite real é calculado como `boundary_ratio * num_train_timesteps`. Quando fornecido, `transformer` trata timesteps >= boundary_timestep e `transformer_2` trata timesteps < boundary_timestep. Se `None`, apenas o transformer disponível é usado para todo o processo de desruidamento. Pipeline para geração controlável usando Wan. Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um 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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_vace.py#L690) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). video (`list[PIL.Image.Image]`, *opcional*) : O vídeo de entrada ou os vídeos de entrada a serem usados como ponto de partida para a geração. O vídeo deve ser uma lista de imagens PIL, um array numpy ou um tensor torch. Atualmente, o pipeline suporta apenas a geração de um vídeo por vez. mask (`list[PIL.Image.Image]`, *opcional*) : A máscara de entrada define quais regiões do vídeo devem ser usadas como condição e quais devem ser geradas. As áreas pretas na máscara indicam regiões de condicionamento, enquanto as áreas brancas indicam regiões para geração. A máscara deve ser uma lista de imagens PIL, um array numpy ou um tensor torch. Atualmente, suporta a geração de um único vídeo por vez. reference_images (`list[PIL.Image.Image]`, *opcional*) : Uma lista com uma ou mais imagens de referência como condicionamento extra para a geração. Por exemplo, se você estiver tentando fazer inpainting de um vídeo para alterar o personagem, pode passar imagens de referência do novo personagem aqui. Consulte os [exemplos](https://github.com/huggingface/diffusers/pull/11582) do Diffusers e o [guia do usuário](https://github.com/ali-vilab/VACE/blob/0897c6d055d7d9ea9e191dce763006664d9780f8/UserGuide.md) original para a lista completa de tarefas e casos de uso suportados. conditioning_scale (`float`, `list[float]`, `torch.Tensor`, padrão `1.0`) : A escala de condicionamento a ser aplicada ao adicionar o stream latente de condicionamento de controle ao stream latente de desruidificação em cada camada de controle do modelo. Se um float for fornecido, ele será aplicado uniformemente a todas as camadas. Se uma lista ou tensor for fornecido, ele deve ter o mesmo comprimento que o número de camadas de controle no modelo (`len(transformer.config.vace_layers)`). height (`int`, padrão `480`) : A altura em pixels da imagem gerada. width (`int`, padrão `832`) : A largura em pixels da imagem gerada. num_frames (`int`, padrão `81`) : O número de quadros no vídeo gerado. num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. guidance_scale (`float`, padrão `5.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. guidance_scale_2 (`float`, *opcional*, padrão `None`) : Escala de orientação para o transformer do estágio de baixo ruído (`transformer_2`). Se `None` e o `boundary_ratio` do pipeline não for None, usa o mesmo valor de `guidance_scale`. Usado apenas quando `transformer_2` e o `boundary_ratio` do pipeline não forem None. num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido. prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidos, `negative_prompt_embeds` são gerados a partir do argumento de entrada `negative_prompt`. output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `WanPipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [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*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline. max_sequence_length (`int`, padrão `512`) : O comprimento máximo da sequência do codificador de texto. Se o prompt for mais longo que isso, ele será truncado. Se o prompt for mais curto, ele será preenchido até esse comprimento. **Retorna:** `~WanPipelineOutput` ou `tuple` Se `return_dict` for `True`, `WanPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw). A função de chamada do pipeline para geração. Exemplos: ```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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_vace.py#L247) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance. num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`. device : (`torch.device`, *opcional*): dispositivo torch dtype : (`torch.dtype`, *opcional*): dtype do torch Codifica o prompt em estados ocultos do codificador de texto. ## WanVideoToVideoPipeline[[diffusers.WanVideoToVideoPipeline]] #### diffusers.WanVideoToVideoPipeline[[diffusers.WanVideoToVideoPipeline]] ```python diffusers.WanVideoToVideoPipeline(tokenizer: AutoTokenizer, text_encoder: UMT5EncoderModel, transformer: WanTransformer3DModel, vae: AutoencoderKLWan, scheduler: FlowMatchEulerDiscreteScheduler) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_video2video.py#L174) **Parâmetros:** tokenizer (`T5Tokenizer`) : Tokenizer do [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), especificamente a 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), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). transformer ([WanTransformer3DModel](/docs/diffusers/v0.43.0/pt/api/models/wan_transformer_3d#diffusers.WanTransformer3DModel)) : Transformer condicional para desruidar os latentes de entrada. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes. Pipeline para geração de vídeo-para-vídeo usando Wan. Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um 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) ``` [Fonte](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]`) : O vídeo de entrada usado como ponto de partida para a geração de vídeo-para-vídeo. O vídeo deve ser fornecido como uma lista de imagens PIL, um array numpy ou um tensor torch. prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). height (`int`, padrão `480`) : A altura em pixels da imagem gerada. width (`int`, padrão `832`) : A largura em pixels da imagem gerada. num_inference_steps (`int`, padrão `50`) : O número de etapas de remoção de ruído. Mais etapas de remoção de ruído geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. timesteps (`list[int]`, *opcional*) : Passos de tempo personalizados para usar no processo de remoção de ruído com agendadores que suportam um argumento `timesteps` em seu método `set_timesteps`. Se não definido, o comportamento padrão quando `num_inference_steps` é passado será usado. Deve estar em ordem decrescente. guidance_scale (`float`, padrão `5.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. strength (`float`, padrão `0.8`) : Uma intensidade maior resulta em mais diferenças entre a imagem original e o vídeo gerado. num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido. prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidos, `negative_prompt_embeds` são gerados a partir do argumento de entrada `negative_prompt`. output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `WanPipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [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*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`list`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline. max_sequence_length (`int`, padrão `512`) : O comprimento máximo da sequência do codificador de texto. Se o prompt for mais longo que isso, ele será truncado. Se o prompt for mais curto, ele será preenchido até esse comprimento. **Retorna:** `~WanPipelineOutput` ou `tuple` Se `return_dict` for `True`, `WanPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw). A função de chamada do pipeline para geração. Exemplos: ```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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_video2video.py#L265) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance. num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`. device : (`torch.device`, *opcional*): dispositivo torch dtype : (`torch.dtype`, *opcional*): dtype do torch Codifica o prompt em estados ocultos do 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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L150) **Parâmetros:** tokenizer (`T5Tokenizer`) : Tokenizer do [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5Tokenizer), especificamente a 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), especificamente a variante [google/umt5-xxl](https://huggingface.co/google/umt5-xxl). image_encoder (`CLIPVisionModel`) : [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPVisionModel), especificamente a 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/pt/api/models/wan_animate_transformer_3d#diffusers.WanAnimateTransformer3DModel)) : Transformer condicional para desruidar os latentes de entrada. scheduler ([UniPCMultistepScheduler](/docs/diffusers/v0.43.0/pt/api/schedulers/unipc#diffusers.UniPCMultistepScheduler)) : Um agendador a ser usado em combinação com `transformer` para desruidar os latentes da imagem codificada. vae ([AutoencoderKLWan](/docs/diffusers/v0.43.0/pt/api/models/autoencoder_kl_wan#diffusers.AutoencoderKLWan)) : Modelo de Variational Auto-Encoder (VAE) para codificar e decodificar vídeos para e a partir de representações latentes. image_processor (`CLIPImageProcessor`) : Processador de imagens para pré-processamento de imagens antes da codificação. Pipeline para animação e substituição unificadas de personagens usando Wan-Animate. WanAnimatePipeline recebe uma imagem de personagem, um vídeo de pose e um vídeo de rosto como entrada e gera um vídeo em dois modos: 1. **Modo de animação**: O modelo gera um vídeo da imagem do personagem que imita o movimento humano nos vídeos de pose e rosto de entrada. O personagem é animado com base nos controles de movimento fornecidos, criando um novo vídeo animado do personagem. 2. **Modo de substituição**: O modelo substitui um personagem em um vídeo de fundo pela imagem de personagem fornecida, utilizando os vídeos de pose e rosto para controle de movimento. Este modo requer as entradas adicionais `background_video` e `mask_video`. O vídeo de máscara deve ter regiões pretas onde o conteúdo original deve ser preservado e regiões brancas onde o novo personagem deve ser gerado. Este modelo herda de [DiffusionPipeline](/docs/diffusers/v0.43.0/pt/api/pipelines/overview#diffusers.DiffusionPipeline). Consulte a documentação da superclasse para os métodos genéricos implementados para todos os pipelines (download, salvamento, execução em um dispositivo específico, etc.). O pipeline também herda os seguintes métodos de carregamento: - [load_lora_weights()](/docs/diffusers/v0.43.0/pt/api/loaders/lora#diffusers.loaders.WanLoraLoaderMixin.load_lora_weights) para carregar os pesos do 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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L763) **Parâmetros:** image (`PipelineImageInput`) : A imagem de caractere de entrada para condicionar a geração. Deve ser uma imagem, uma lista de imagens ou um `torch.Tensor`. pose_video (`list[PIL.Image.Image]`) : O vídeo de pose de entrada para condicionar a geração. Deve ser uma lista de imagens PIL. face_video (`list[PIL.Image.Image]`) : O vídeo facial de entrada para condicionar a geração. Deve ser uma lista de imagens PIL. background_video (`list[PIL.Image.Image]`, *opcional*) : Quando o modo é `"replace"`, o vídeo de fundo de entrada para condicionar a geração. Deve ser uma lista de imagens PIL. mask_video (`list[PIL.Image.Image]`, *opcional*) : Quando o modo é `"replace"`, o vídeo de máscara de entrada para condicionar a geração. Deve ser uma lista de imagens PIL. prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts para orientar a geração da imagem. Se não definido, é necessário passar `prompt_embeds` em vez disso. negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). mode (`str`, padrão `"animation"`) : O modo de geração. Escolha entre `"animate"` e `"replace"`. prev_segment_conditioning_frames (`int`, padrão `1`) : O número de quadros do segmento de vídeo anterior a serem usados para orientação temporal. Recomendado ser 1 ou 5. Em geral, deve ser 4N + 1, onde N é um inteiro não negativo. motion_encode_batch_size (`int`, *opcional*) : O tamanho do lote para a codificação em lote do vídeo facial por meio do codificador de movimento. Isso permite equilibrar a velocidade de inferência com um menor uso de memória definindo um tamanho de lote menor. Se não for definido, o valor padrão será `self.transformer.config.motion_encoder_batch_size`. height (`int`, padrão `720`) : A altura do vídeo gerado. width (`int`, padrão `1280`) : A largura do vídeo gerado. segment_frame_length (`int`, padrão `77`) : O número de quadros em cada segmento de vídeo gerado. O total de quadros do vídeo gerado será igual ao número de quadros em `pose_video`; geraremos o vídeo em segmentos até atingirmos esse comprimento. Em geral, deve ser 4N + 1, onde N é um inteiro não negativo. num_inference_steps (`int`, padrão `20`) : O número de etapas de desruido. Mais etapas de desruido geralmente resultam em uma imagem de maior qualidade, em detrimento de uma inferência mais lenta. guidance_scale (`float`, padrão `1.0`) : Escala de orientação definida em [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` é definido como `w` da equação 2. do [Imagen Paper](https://huggingface.co/papers/2205.11487). A escala de orientação é ativada ao definir `guidance_scale > 1`. Uma escala de orientação maior incentiva a geração de imagens que estão intimamente ligadas ao `prompt` de texto, geralmente em detrimento de uma menor qualidade de imagem. Por padrão, o CFG não é usado na inferência do Wan Animate. num_videos_per_prompt (`int`, *opcional*, padrão 1) : O número de imagens a serem geradas por prompt. generator (`torch.Generator` ou `list[torch.Generator]`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a geração determinística. latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pré-gerados, amostrados de uma distribuição gaussiana, a serem usados como entradas para a geração de imagens. Pode ser usado para ajustar a mesma geração com diferentes prompts. Se não for fornecido, um tensor de latentes é gerado por amostragem usando o `generator` aleatório fornecido. prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Incorporações de texto pré-geradas. Podem ser usadas para ajustar facilmente as entradas de texto (ponderação do prompt). Se não forem fornecidas, as incorporações de texto são geradas a partir do argumento de entrada `negative_prompt`. image_embeds (`torch.Tensor`, *opcional*) : Embebimentos de imagem pré-gerados. Pode ser usado para ajustar facilmente as entradas de imagem (ponderação). Se não for fornecido, os embebimentos de imagem são gerados a partir do argumento de entrada `image`. output_type (`str`, *opcional*, padrão `"np"`) : O formato de saída da imagem gerada. Escolha entre `PIL.Image` ou `np.array`. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `WanPipelineOutput` em vez de uma tupla simples. attention_kwargs (`dict`, *opcional*) : Um dicionário de kwargs que, se especificado, é passado para o `AttentionProcessor` conforme definido em `self.processor` em [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*) : Uma função ou uma subclasse de `PipelineCallback` ou `MultiPipelineCallbacks` que é chamada no final de cada etapa de remoção de ruído durante a inferência, com os seguintes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá uma lista de todos os tensores, conforme especificado por `callback_on_step_end_tensor_inputs`. callback_on_step_end_tensor_inputs (`List`, *opcional*) : A lista de entradas de tensor para a função `callback_on_step_end`. Os tensores especificados na lista serão passados como argumento `callback_kwargs`. Você só poderá incluir variáveis listadas no atributo `._callback_tensor_inputs` da sua classe de pipeline. max_sequence_length (`int`, padrão `512`) : O comprimento máximo da sequência do codificador de texto. Se o prompt for mais longo que isso, ele será truncado. Se o prompt for mais curto, ele será preenchido até esse comprimento. **Retorna:** `~WanPipelineOutput` ou `tuple` Se `return_dict` for `True`, `WanPipelineOutput` é retornado; caso contrário, uma `tuple` é retornada, em que o primeiro elemento é uma lista com as imagens geradas e o segundo elemento é uma lista de `bool`s indicando se a imagem gerada correspondente contém conteúdo "not-safe-for-work" (nsfw). A função de chamada do pipeline para geração. Exemplos: ```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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L291) **Parâmetros:** prompt (`str` ou `list[str]`, *opcional*) : prompt a ser codificado negative_prompt (`str` ou `list[str]`, *opcional*) : O prompt ou os prompts que não devem orientar a geração da imagem. Se não definido, é necessário passar `negative_prompt_embeds` em vez disso. Ignorado quando não se usa orientação (ou seja, ignorado se `guidance_scale` for menor que `1`). do_classifier_free_guidance (`bool`, *opcional*, padrão `True`) : Se deve ou não usar classifier free guidance. num_videos_per_prompt (`int`, *opcional*, padrão 1) : Número de vídeos que devem ser gerados por prompt. Dispositivo torch para colocar os embeddings resultantes prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, os embeddings de texto serão gerados a partir do argumento de entrada `prompt`. negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pré-gerados. Podem ser usados para ajustar facilmente as entradas de texto, *por exemplo*, ponderação de prompts. Se não forem fornecidos, negative_prompt_embeds será gerado a partir do argumento de entrada `negative_prompt`. device : (`torch.device`, *opcional*): dispositivo torch dtype : (`torch.dtype`, *opcional*): dtype do torch Codifica o prompt em estados ocultos do codificador de texto. #### pad_video_frames[[diffusers.WanAnimatePipeline.pad_video_frames]] ```python pad_video_frames(frames: list[typing.Any], num_target_frames: int) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_wan_animate.py#L718) Preenche um vídeo em formato de array `frames` até `num_target_frames` usando uma estratégia semelhante a "reflect". A dimensão dos quadros é assumida como a primeira dimensão. No caso 1D, podemos visualizar essa estratégia da seguinte forma: 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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/wan/pipeline_output.py#L9) **Parâmetros:** frames (`torch.Tensor`, `np.ndarray` ou list[list[PIL.Image.Image]]) : lista de saídas de vídeo - Pode ser uma lista aninhada de comprimento `batch_size,` em que cada sublista contém sequências de imagens PIL desruidas de comprimento `num_frames.` Também pode ser um array NumPy ou um tensor Torch de forma `(batch_size, num_frames, channels, height, width)`. Classe de saída para pipelines do Wan.