# AnyFlowTransformer3DModel

El Transformer 3D bidireccional utilizado por [`AnyFlowPipeline`](../pipelines/anyflow#diffusers.AnyFlowPipeline). Es el backbone Wan2.1 de la v0.35.1 con un cambio estructural: el incrustador de paso temporal se reemplaza por ``AnyFlowDualTimestepTextImageEmbedding``, de modo que cada llamada de propagación hacia adelante se condiciona tanto al paso temporal de origen ``t`` como al paso temporal de destino ``r``. Esta es la incrustación necesaria para aprender el mapa de flujo $\Phi_{r\leftarrow t}$ introducido en [AnyFlow](https://huggingface.co/papers/2605.13724). Consulte la página de [`AnyFlowPipeline`](../pipelines/anyflow) para obtener el artículo, los autores y los puntos de control publicados.

Para la generación autoregresiva por bloques (FAR causal), use [`AnyFlowFARTransformer3DModel`](anyflow_far_transformer3d) en su lugar.

```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')
```

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

**Parámetros:**

patch_size (*Tuple[int]*, por defecto *(1, 2, 2)*) : dimensiones del parche 3D para la incrustación de video (t_patch, h_patch, w_patch).

num_attention_heads (*int*, por defecto *40*) : Número de cabezas de atención.

attention_head_dim (*int*, por defecto *128*) : El número de canales en cada cabeza.

in_channels (*int*, por defecto *16*) : El número de canales en el latente de entrada.

out_channels (*int*, por defecto *16*) : El número de canales en el latente de salida.

text_dim (*int*, por defecto *4096*) : Dimensión de entrada para las incrustaciones de texto (UMT5).

freq_dim (*int*, por defecto *256*) : Dimensión para las incrustaciones sinusoidales de tiempo.

ffn_dim (*int*, por defecto *13824*) : Dimensión intermedia en la red feed-forward.

num_layers (*int*, por defecto *40*) : Número de bloques de transformer.

cross_attn_norm (*bool*, por defecto *True*) : Habilita la normalización de la atención cruzada.

eps (*float*, por defecto *1e-6*) : Epsilon para las capas de normalización.

image_dim (*Optional[int]*, *opcional*, valor predeterminado *None*) : Dimensión del incrustado de imagen para el condicionamiento I2V (*1280* para el modelo original Wan2.1-I2V).

rope_max_seq_len (*int*, por defecto *1024*) : Longitud máxima de secuencia utilizada para precalcular las frecuencias de posición rotativa.

gate_value (*float*, por defecto *0.25*) : Puerta de mezcla entre las incrustaciones de paso de tiempo de origen y de paso de tiempo delta (el parámetro \\(g\\) del artículo de AnyFlow, fijado en 0.25 en la destilación de la etapa 1).

deltatime_type (*str*, por defecto *'r'*) : Ya sea `"r"` (delta es el paso de tiempo objetivo) o `"t-r"` (delta es el intervalo absoluto).

Transformador 3D bidireccional para el muestreo de mapas de flujo de AnyFlow.

La arquitectura es el backbone v0.35.1 Wan2.1 3D DiT con un cambio estructural: el timestep embedder se reemplaza por `AnyFlowDualTimestepTextImageEmbedding` para que cada llamada forward condicione tanto en el timestep de origen `t` como en el timestep de destino `r`. Esta es la embedding necesaria para aprender el flow map \\(\Phi_{r\leftarrow t}\\) introducido en [AnyFlow](https://huggingface.co/papers/2605.13724).

Para la generación autoregresiva por bloques (FAR causal), use `AnyFlowFARTransformer3DModel` en su lugar; esa variante añade el bloque de máscara causal FAR y un patch embedding de marco comprimido sobre el mismo 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)
```

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

**Parámetros:**

hidden_states (*torch.Tensor* de forma *(batch_size, num_frames, num_channels, height, width)*) : Latentes de video de entrada.

timestep (*torch.Tensor*) : Paso temporal *t* del mapa de flujo de origen (más ruidoso).

r_timestep (*torch.Tensor*) : Paso de tiempo *r* del mapa de flujo objetivo (más limpio); define el destino del paso del mapa de flujo.

encoder_hidden_states (*torch.Tensor* de forma *(batch_size, sequence_len, embed_dims)*) : Embeddings de condicionamiento de texto.

encoder_hidden_states_image (*torch.Tensor*, *opcional*) : Embeddings de condicionamiento de imagen; se concatenan antes de los tokens de texto cuando se proporcionan.

attention_kwargs (*dict*, *opcional*) : Kwargs reenviados al *AttentionProcessor* tal como se definen bajo *self.processor* en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

return_dict (*bool*, *opcional*, valor predeterminado *True*) : Si se debe devolver un [*~models.transformer_2d.Transformer2DModelOutput*] en lugar de una tupla simple.

**Devuelve:**

[*~models.transformer_2d.Transformer2DModelOutput*] si *return_dict* es True, en caso contrario una *tuple* cuyo primer elemento es el tensor de velocidad predicho.

Paso de propagación hacia adelante del mapa de flujo bidireccional. `hidden_states` se organiza como `(B, F, C, H, W)` (latentes por cuadro). La entrada se divide en parches con el `patch_embedding` estándar (kernel = stride = `patch_size`) y se desruidifica mediante autoatención bidireccional global sobre la secuencia plana de tokens resultante.