# HunyuanDiT2DModel

Um modelo Diffusion Transformer para dados 2D do [Hunyuan-DiT](https://github.com/Tencent/HunyuanDiT).

## HunyuanDiT2DModel[[diffusers.HunyuanDiT2DModel]]

#### diffusers.HunyuanDiT2DModel[[diffusers.HunyuanDiT2DModel]]

```python
diffusers.HunyuanDiT2DModel(num_attention_heads: int = 16, attention_head_dim: int = 88, in_channels: int | None = None, patch_size: int | None = None, activation_fn: str = 'gelu-approximate', sample_size = 32, hidden_size = 1152, num_layers: int = 28, mlp_ratio: float = 4.0, learn_sigma: bool = True, cross_attention_dim: int = 1024, norm_type: str = 'layer_norm', cross_attention_dim_t5: int = 2048, pooled_projection_dim: int = 1024, text_len: int = 77, text_len_t5: int = 256, use_style_cond_and_image_meta_size: bool = True)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/hunyuan_transformer_2d.py#L201)

**Parâmetros:**

num_attention_heads (`int`, *opcional*, padrão 16) : O número de cabeças a serem usadas para a atenção multi-cabeça.

attention_head_dim (`int`, *opcional*, padrão 88) : O número de canais em cada head.

in_channels (`int`, *opcional*) : O número de canais na entrada e na saída (especifique se a entrada é **contínua**).

patch_size (`int`, *opcional*) : O tamanho do patch a ser usado para a entrada.

activation_fn (`str`, *opcional*, padrão `"geglu"`) : Função de ativação a ser usada no feed-forward.

sample_size (`int`, *opcional*) : A largura das imagens latentes. Isso é fixo durante o treinamento, pois é usado para aprender um número de embeddings de posição.

dropout (`float`, *opcional*, padrão 0.0) : A probabilidade de dropout a ser utilizada.

cross_attention_dim (`int`, *opcional*) : O número de dimensões no embedding de texto do clipe.

hidden_size (`int`, *opcional*) : O tamanho da camada oculta nas camadas de incorporação de condicionamento.

num_layers (`int`, *opcional*, padrão 1) : O número de blocos de Transformer a serem usados.

mlp_ratio (`float`, *opcional*, padrão 4.0) : A proporção do tamanho da camada oculta em relação ao tamanho da entrada.

learn_sigma (`bool`, *opcional*, padrão `True`) : Se deve prever a variância.

cross_attention_dim_t5 (`int`, *opcional*) : O número de dimensões no embedding de texto t5.

pooled_projection_dim (`int`, *opcional*) : O tamanho da projeção agregada.

text_len (`int`, *opcional*) : O comprimento do embedding do texto do clipe.

text_len_t5 (`int`, *opcional*) : O comprimento da incorporação de texto do T5.

use_style_cond_and_image_meta_size (`bool`,  *opcional*) : Se deve ou não usar a condição de estilo e o tamanho meta da imagem. True para versão <=1.1, False para versão >= 1.2

HunYuanDiT: modelo de difusão com um backbone de Transformer.

Herde ModelMixin e ConfigMixin para ser compatível com o sampler StableDiffusionPipeline do diffusers.

#### enable_forward_chunking[[diffusers.HunyuanDiT2DModel.enable_forward_chunking]]

```python
enable_forward_chunking(chunk_size: int | None = None, dim: int = 0)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/hunyuan_transformer_2d.py#L476)

**Parâmetros:**

chunk_size (`int`, *opcional*) : O tamanho do bloco das camadas feed-forward. Se não for especificado, a camada feed-forward será executada individualmente sobre cada tensor com dim=`dim`.

dim (`int`, *opcional*, padrão `0`) : A dimensão sobre a qual o cálculo feed-forward deve ser dividido em blocos. Escolha entre dim=0 (lote) ou dim=1 (comprimento da sequência).

Define o processador de atenção para usar [feed forward chunking](https://huggingface.co/blog/reformer#2-chunked-feed-forward-layers).

#### forward[[diffusers.HunyuanDiT2DModel.forward]]

```python
forward(hidden_states, timestep, encoder_hidden_states = None, text_embedding_mask = None, encoder_hidden_states_t5 = None, text_embedding_mask_t5 = None, image_meta_size = None, style = None, image_rotary_emb = None, controlnet_block_samples = None, return_dict = True)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/hunyuan_transformer_2d.py#L357)

**Parâmetros:**

hidden_states (`torch.Tensor` de forma `(batch size, dim, height, width)`) : O tensor de entrada.

timestep ( `torch.LongTensor`, *opcional*) : Usado para indicar o passo de desruidamento.

encoder_hidden_states ( `torch.Tensor` de forma `(batch size, sequence len, embed dims)`, *opcional*) : Embebimentos condicionais para a camada de atenção cruzada. Esta é a saída de `BertModel`.

text_embedding_mask : torch.Tensor Uma máscara de atenção de forma `(batch, key_tokens)` é aplicada a `encoder_hidden_states`. Este é o resultado de `BertModel`.

encoder_hidden_states_t5 ( `torch.Tensor` de forma `(batch size, sequence len, embed dims)`, *opcional*) : Embebimentos condicionais para a camada de atenção cruzada. Esta é a saída do T5 Text Encoder.

text_embedding_mask_t5 : torch.Tensor Uma máscara de atenção de forma `(batch, key_tokens)` é aplicada a `encoder_hidden_states`. Este é o output do T5 Text Encoder.

image_meta_size (torch.Tensor) : incorporações condicionais que indicam os tamanhos das imagens

style : torch.Tensor: incorporamento condicional que indica o estilo

image_rotary_emb (`torch.Tensor`) : Os embeddings rotacionais de imagem a serem aplicados nos tensores de consulta e chave durante o cálculo da atenção.

controlnet_block_samples (`list` de `torch.Tensor`, *opcional*) : Uma lista de tensores que, se especificada, é adicionada aos resíduos dos blocos de transformer.

return_dict : bool Se deve retornar um dicionário.

**Retorna:**

Se `return_dict` for True, um `~models.transformer_2d.Transformer2DModelOutput` é retornado; caso contrário, uma `tuple` onde o primeiro elemento é o tensor da amostra.

O método forward do [HunyuanDiT2DModel](/docs/diffusers/main/pt/api/models/hunyuan_transformer2d#diffusers.HunyuanDiT2DModel).

#### fuse_qkv_projections[[diffusers.HunyuanDiT2DModel.fuse_qkv_projections]]

```python
fuse_qkv_projections()
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/hunyuan_transformer_2d.py#L320)

Ativa as projeções QKV fundidas. Para os módulos de autoatenção, todas as matrizes de projeção (ou seja, query, key, value) são fundidas. Para os módulos de atenção cruzada, as matrizes de projeção de key e value são fundidas.

> [!WARNING] > Esta API é 🧪 experimental.

#### set_default_attn_processor[[diffusers.HunyuanDiT2DModel.set_default_attn_processor]]

```python
set_default_attn_processor()
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/hunyuan_transformer_2d.py#L351)

Desativa os processadores de atenção personalizados e define a implementação padrão de atenção.

#### unfuse_qkv_projections[[diffusers.HunyuanDiT2DModel.unfuse_qkv_projections]]

```python
unfuse_qkv_projections()
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/hunyuan_transformer_2d.py#L342)

Desativa a projeção QKV fundida, se estiver habilitada.

> [!WARNING] > Esta API é 🧪 experimental.