Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /main /fr /api /models /anyflow_transformer3d.md

mishig

8 days ago

preview code

download

raw

6.36 kB

# AnyFlowTransformer3DModel

Le Transformer 3D bidirectionnel utilisé par [`AnyFlowPipeline`](../pipelines/anyflow#diffusers.AnyFlowPipeline). Il s’agit du backbone Wan2.1 v0.35.1 avec une modification structurelle : l’embedder de timestep est remplacé par ``AnyFlowDualTimestepTextImageEmbedding``, de sorte que chaque appel forward conditionne sur le timestep source ``t`` et le timestep cible ``r``. C’est l’embedding nécessaire pour apprendre la carte de flux $\Phi_{r\leftarrow t}$ introduite dans [AnyFlow](https://huggingface.co/papers/2605.13724). Consultez la page [`AnyFlowPipeline`](../pipelines/anyflow) pour le papier, les auteurs et les checkpoints publiés.

Pour la génération autorégressive par morceaux (FAR causal), utilisez plutôt [`AnyFlowFARTransformer3DModel`](anyflow_far_transformer3d).

```python
from diffusers import AnyFlowTransformer3DModel
# Bidirectional AnyFlow checkpoint (T2V):
transformer = AnyFlowTransformer3DModel.from_pretrained(
    "nvidia/AnyFlow-Wan2.1-T2V-1.3B-Diffusers", subfolder="transformer"
)
```

## AnyFlowTransformer3DModel[[diffusers.AnyFlowTransformer3DModel]]

#### diffusers.AnyFlowTransformer3DModel[[diffusers.AnyFlowTransformer3DModel]]

```python
diffusers.AnyFlowTransformer3DModel(patch_size: typing.Tuple[int] = (1, 2, 2), num_attention_heads: int = 40, attention_head_dim: int = 128, in_channels: int = 16, out_channels: int = 16, text_dim: int = 4096, freq_dim: int = 256, ffn_dim: int = 13824, num_layers: int = 40, cross_attn_norm: bool = True, eps: float = 1e-06, image_dim: typing.Optional[int] = None, rope_max_seq_len: int = 1024, gate_value: float = 0.25, deltatime_type: str = 'r')
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_anyflow.py#L507)

**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*) : Nombre de têtes d'attention.

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 le latent d'entrée.
out_channels (*int*, par défaut *16*) : Le nombre de canaux dans le latent de sortie.

text_dim (*int*, par défaut *4096*) : Dimension d'entrée pour les embeddings de texte (UMT5).
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*) : Nombre de blocs transformer.

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

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

image_dim (*Optional[int]*, *facultatif*, par défaut *None*) : Dimension de l'embedding d'image pour le conditionnement I2V (*1280* pour le modèle original Wan2.1-I2V).
rope_max_seq_len (*int*, par défaut *1024*) : Longueur maximale de séquence utilisée pour précalculer les fréquences de position rotative.

gate_value (*float*, par défaut *0.25*) : Porte de mélange entre les embeddings de pas source et de pas delta (le paramètre \\(g\\) du papier AnyFlow, fixé à 0.25 dans la distillation de l'étape 1).
deltatime_type (*str*, par défaut *'r'*) : Soit `"r"` (delta est l'étape temporelle cible) soit `"t-r"` (delta est l'intervalle absolu).

Transformeur 3D bidirectionnel pour l'échantillonnage de la carte de flux d'AnyFlow.

L’architecture est le socle 3D DiT de Wan2.1 v0.35.1 avec une modification structurelle : l’encodeur de pas de temps est remplacé par `AnyFlowDualTimestepTextImageEmbedding` afin que chaque appel avant conditionne sur le pas de temps source `t` et le pas de temps cible `r`. Il s’agit de l’encodage nécessaire pour apprendre la carte de flux \\(\Phi_&amp;lcub;r\leftarrow t}\\) introduite dans [AnyFlow](https://huggingface.co/papers/2605.13724).
Pour la génération autorégressive par morceaux (FAR causal), utilisez `AnyFlowFARTransformer3DModel` à la place ; cette variante ajoute le masque de bloc causal FAR et un patch embedding de trame compressée sur le même backbone.
#### forward[[diffusers.AnyFlowTransformer3DModel.forward]]
```python
forward(hidden_states: Tensor, timestep: Tensor, r_timestep: Tensor, encoder_hidden_states: Tensor, encoder_hidden_states_image: typing.Optional[torch.Tensor] = None, attention_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None, return_dict: bool = True)
```
[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_anyflow.py#L626)
**Paramètres :**
hidden_states (*torch.Tensor* de forme *(batch_size, num_frames, num_channels, height, width)*) : Latents vidéo en entrée.
timestep (*torch.Tensor*) : Pas de temps *t* de la carte de flux source (plus bruitée).
r_timestep (*torch.Tensor*) : Pas de temps *r* de la carte de flux cible (plus propre) ; définit la destination de l'étape de la carte de flux.
encoder_hidden_states (*torch.Tensor* de forme *(batch_size, sequence_len, embed_dims)*) : Embeddings de conditionnement textuel.
encoder_hidden_states_image (*torch.Tensor*, *facultatif*) : Embeddings de conditionnement par image ; concaténés avant les jetons de texte lorsqu'ils sont fournis.
attention_kwargs (*dict*, *facultatif*) : Arguments nommés transmis à *AttentionProcessor* tels que définis sous *self.processor* dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
return_dict (*bool*, *facultatif*, par défaut *True*) : Indique s'il faut retourner un [*~models.transformer_2d.Transformer2DModelOutput*] plutôt qu'un simple tuple.
**Retourne :**
[*~models.transformer_2d.Transformer2DModelOutput*] si *return_dict* est True, sinon un *tuple* dont le premier élément est le tenseur de vitesse prédit.
Passage avant de la carte de flux bidirectionnelle. `hidden_states` est organisé en `(B, F, C, H, W)` (latents par image). L’entrée est patchifiée avec le `patch_embedding` standard (noyau = pas = `patch_size`) et débruitée par une auto-attention bidirectionnelle globale sur la séquence plate de jetons résultante.

Xet Storage Details

Size:: 6.36 kB
Xet hash:: 244088315ddca59165f6d32f31bd0782448cc9dc3c776cb11785dd0b7a09a51d

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	# AnyFlowTransformer3DModel

	Le Transformer 3D bidirectionnel utilisé par [`AnyFlowPipeline`](../pipelines/anyflow#diffusers.AnyFlowPipeline). Il s’agit du backbone Wan2.1 v0.35.1 avec une modification structurelle : l’embedder de timestep est remplacé par ``AnyFlowDualTimestepTextImageEmbedding``, de sorte que chaque appel forward conditionne sur le timestep source ``t`` et le timestep cible ``r``. C’est l’embedding nécessaire pour apprendre la carte de flux $\Phi_{r\leftarrow t}$ introduite dans [AnyFlow](https://huggingface.co/papers/2605.13724). Consultez la page [`AnyFlowPipeline`](../pipelines/anyflow) pour le papier, les auteurs et les checkpoints publiés.

	Pour la génération autorégressive par morceaux (FAR causal), utilisez plutôt [`AnyFlowFARTransformer3DModel`](anyflow_far_transformer3d).

	```python
	from diffusers import AnyFlowTransformer3DModel

	# Bidirectional AnyFlow checkpoint (T2V):
	transformer = AnyFlowTransformer3DModel.from_pretrained(
	"nvidia/AnyFlow-Wan2.1-T2V-1.3B-Diffusers", subfolder="transformer"
	)
	```

	## AnyFlowTransformer3DModel[[diffusers.AnyFlowTransformer3DModel]]

	#### diffusers.AnyFlowTransformer3DModel[[diffusers.AnyFlowTransformer3DModel]]

	```python
	diffusers.AnyFlowTransformer3DModel(patch_size: typing.Tuple[int] = (1, 2, 2), num_attention_heads: int = 40, attention_head_dim: int = 128, in_channels: int = 16, out_channels: int = 16, text_dim: int = 4096, freq_dim: int = 256, ffn_dim: int = 13824, num_layers: int = 40, cross_attn_norm: bool = True, eps: float = 1e-06, image_dim: typing.Optional[int] = None, rope_max_seq_len: int = 1024, gate_value: float = 0.25, deltatime_type: str = 'r')
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_anyflow.py#L507)

	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) : Nombre de têtes d'attention.

	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 le latent d'entrée.

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

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

	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) : Nombre de blocs transformer.

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

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

	image_dim (Optional[int], facultatif, par défaut None) : Dimension de l'embedding d'image pour le conditionnement I2V (1280 pour le modèle original Wan2.1-I2V).

	rope_max_seq_len (int, par défaut 1024) : Longueur maximale de séquence utilisée pour précalculer les fréquences de position rotative.

	gate_value (float, par défaut 0.25) : Porte de mélange entre les embeddings de pas source et de pas delta (le paramètre \\(g\\) du papier AnyFlow, fixé à 0.25 dans la distillation de l'étape 1).

	deltatime_type (str, par défaut 'r') : Soit `"r"` (delta est l'étape temporelle cible) soit `"t-r"` (delta est l'intervalle absolu).

	Transformeur 3D bidirectionnel pour l'échantillonnage de la carte de flux d'AnyFlow.

	L’architecture est le socle 3D DiT de Wan2.1 v0.35.1 avec une modification structurelle : l’encodeur de pas de temps est remplacé par `AnyFlowDualTimestepTextImageEmbedding` afin que chaque appel avant conditionne sur le pas de temps source `t` et le pas de temps cible `r`. Il s’agit de l’encodage nécessaire pour apprendre la carte de flux \\(\Phi_&lcub;r\leftarrow t}\\) introduite dans [AnyFlow](https://huggingface.co/papers/2605.13724).

	Pour la génération autorégressive par morceaux (FAR causal), utilisez `AnyFlowFARTransformer3DModel` à la place ; cette variante ajoute le masque de bloc causal FAR et un patch embedding de trame compressée sur le même backbone.

	#### forward[[diffusers.AnyFlowTransformer3DModel.forward]]

	```python
	forward(hidden_states: Tensor, timestep: Tensor, r_timestep: Tensor, encoder_hidden_states: Tensor, encoder_hidden_states_image: typing.Optional[torch.Tensor] = None, attention_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None, return_dict: bool = True)
	```

	[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_anyflow.py#L626)

	Paramètres :

	hidden_states (torch.Tensor de forme (batch_size, num_frames, num_channels, height, width)) : Latents vidéo en entrée.

	timestep (torch.Tensor) : Pas de temps t de la carte de flux source (plus bruitée).

	r_timestep (torch.Tensor) : Pas de temps r de la carte de flux cible (plus propre) ; définit la destination de l'étape de la carte de flux.

	encoder_hidden_states (torch.Tensor de forme (batch_size, sequence_len, embed_dims)) : Embeddings de conditionnement textuel.

	encoder_hidden_states_image (torch.Tensor, facultatif) : Embeddings de conditionnement par image ; concaténés avant les jetons de texte lorsqu'ils sont fournis.

	attention_kwargs (dict, facultatif) : Arguments nommés transmis à AttentionProcessor tels que définis sous self.processor dans [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

	return_dict (bool, facultatif, par défaut True) : Indique s'il faut retourner un [~models.transformer_2d.Transformer2DModelOutput] plutôt qu'un simple tuple.

	Retourne :

	[~models.transformer_2d.Transformer2DModelOutput] si return_dict est True, sinon un tuple dont le premier élément est le tenseur de vitesse prédit.

	Passage avant de la carte de flux bidirectionnelle. `hidden_states` est organisé en `(B, F, C, H, W)` (latents par image). L’entrée est patchifiée avec le `patch_embedding` standard (noyau = pas = `patch_size`) et débruitée par une auto-attention bidirectionnelle globale sur la séquence plate de jetons résultante.