diffusers/main/fr/api/models/wan_animate_transformer_3d.md

WanAnimateTransformer3DModel

Un modèle Diffusion Transformer pour des données vidéo 3D a été introduit dans Wan Animate par l'équipe Alibaba Wan.

Le modèle peut être chargé à l'aide du fragment de code suivant.

from diffusers import WanAnimateTransformer3DModel

transformer = WanAnimateTransformer3DModel.from_pretrained("Wan-AI/Wan2.2-Animate-14B-Diffusers", subfolder="transformer", dtype=torch.bfloat16)

WanAnimateTransformer3DModel[[diffusers.WanAnimateTransformer3DModel]]

diffusers.WanAnimateTransformer3DModel[[diffusers.WanAnimateTransformer3DModel]]

diffusers.WanAnimateTransformer3DModel(patch_size: tuple[int] = (1, 2, 2), num_attention_heads: int = 40, attention_head_dim: int = 128, in_channels: int | None = 36, latent_channels: int | None = 16, out_channels: int | None = 16, text_dim: int = 4096, freq_dim: int = 256, ffn_dim: int = 13824, num_layers: int = 40, cross_attn_norm: bool = True, qk_norm: str | None = 'rms_norm_across_heads', eps: float = 1e-06, image_dim: int | None = 1280, added_kv_proj_dim: int | None = None, rope_max_seq_len: int = 1024, pos_embed_seq_len: int | None = None, motion_encoder_channel_sizes: dict[str, int] | None = None, motion_encoder_size: int = 512, motion_style_dim: int = 512, motion_dim: int = 20, motion_encoder_dim: int = 512, face_encoder_hidden_dim: int = 1024, face_encoder_num_heads: int = 4, inject_face_latents_blocks: int = 5, motion_encoder_batch_size: int = 8)

Source

Paramètres :

patch_size (tuple[int], par défaut (1, 2, 2)) : dimensions des patches 3D pour l'intégration vidéo (t_patch, h_patch, w_patch).

num_attention_heads (int, par défaut 40) : Longueur fixe pour les embeddings de texte.

attention_head_dim (int, par défaut 128) : Le nombre de canaux dans chaque tête.

in_channels (int, par défaut 16) : Le nombre de canaux dans l'entrée.

out_channels (int, par défaut 16) : Le nombre de canaux dans la sortie.

text_dim (int, par défaut 512) : Dimension d'entrée pour les embeddings de texte.

freq_dim (int, par défaut 256) : Dimension pour les embeddings temporels sinusoïdaux.

ffn_dim (int, par défaut 13824) : Dimension intermédiaire du réseau feed-forward.

num_layers (int, par défaut 40) : Le nombre de blocs de transformeurs à utiliser.

window_size (tuple[int], par défaut (-1, -1)) : Taille de la fenêtre pour l'attention locale (-1 indique une attention globale).

cross_attn_norm (bool, par défaut True) : Active la normalisation de l'attention croisée.

qk_norm (bool, par défaut True) : Active la normalisation des requêtes/clés.

eps (float, par défaut 1e-6) : Valeur d'épsilon pour les couches de normalisation.

image_dim (int, facultatif, valeur par défaut 1280) : Le nombre de canaux à utiliser pour l'intégration d'image. Si None, aucune projection n'est utilisée.

added_kv_proj_dim (int, facultatif, par défaut 5120) : Le nombre de canaux à utiliser pour les projections de clé et de valeur ajoutées. Si None, aucune projection n'est utilisée.

Un modèle Transformer pour des données de type vidéo utilisé dans le modèle WanAnimate.

forward[[diffusers.WanAnimateTransformer3DModel.forward]]

forward(hidden_states: Tensor, timestep: LongTensor, encoder_hidden_states: Tensor, encoder_hidden_states_image: typing.Optional[torch.Tensor] = None, pose_hidden_states: typing.Optional[torch.Tensor] = None, face_pixel_values: typing.Optional[torch.Tensor] = None, motion_encode_batch_size: int | None = None, return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None)

Source

Paramètres :

hidden_states (torch.Tensor de forme (B, 2C + 4, T + 1, H, W)) : Latents vidéo bruités en entrée de forme (B, 2C + 4, T + 1, H, W), où B est la taille du lot, C est le nombre de canaux latents (16 pour Wan VAE), T est le nombre de trames latentes dans un segment d’inférence, H est la hauteur latente et W est la largeur latente.

timestep : (torch.LongTensor) : l'étape temporelle actuelle dans la boucle de débruitage.

encoder_hidden_states (torch.Tensor) : Embeddings de texte issus de l'encodeur de texte (umT5 pour Wan Animate).

encoder_hidden_states_image (torch.Tensor) : caractéristiques visuelles CLIP de l'image de référence (personnage).

pose_hidden_states (torch.Tensor de forme (B, C, T, H, W)) : Latents de la vidéo de pose. TODO : description

face_pixel_values (torch.Tensor de forme (B, C', S, H', W')) : Vidéo du visage dans l'espace des pixels (et non dans l'espace latent). Typiquement, C' = 3 et H' et W' sont la hauteur/la largeur de la vidéo du visage en pixels. Ici, S est la longueur du segment d'inférence, généralement fixée à 77.

motion_encode_batch_size (int, facultatif) : La taille du lot pour l'encodage par lots de la vidéo faciale via l'encodeur de mouvement. Par défaut, elle est définie sur self.config.motion_encoder_batch_size si elle n'est pas spécifiée.

return_dict (bool, facultatif, par défaut True) : Indique s'il faut renvoyer la sortie sous forme de dictionnaire ou de tuple.

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

Retourne : ~models.transformer_2d.Transformer2DModelOutput ou tuple

Si return_dict est True, un ~models.transformer_2d.Transformer2DModelOutput dont le sample est le latent vidéo débruité est renvoyé, sinon un simple tuple dont le premier élément est ce tenseur est renvoyé.

Passage avant du modèle transformer Wan2.2-Animate.

Transformer2DModelOutput[[diffusers.models.modeling_outputs.Transformer2DModelOutput]]

diffusers.models.modeling_outputs.Transformer2DModelOutput[[diffusers.models.modeling_outputs.Transformer2DModelOutput]]

diffusers.models.modeling_outputs.Transformer2DModelOutput(sample: torch.Tensor)

Source

Paramètres :

sample (torch.Tensor de forme (batch_size, num_channels, height, width) ou (batch size, num_vector_embeds - 1, num_latent_pixels) si Transformer2DModel est discret) : Les états cachés en sortie, conditionnés par l'entrée encoder_hidden_states. Si discret, renvoie les distributions de probabilité pour les pixels latents non bruités.

La sortie de Transformer2DModel.