# Modelo Transformer SD3

O modelo Transformer introduzido no [Stable Diffusion 3](https://hf.co/papers/2403.03206). Sua novidade reside no bloco de transformer MMDiT.

## SD3Transformer2DModel[[diffusers.SD3Transformer2DModel]]

#### diffusers.SD3Transformer2DModel[[diffusers.SD3Transformer2DModel]]

```python
diffusers.SD3Transformer2DModel(sample_size: int = 128, patch_size: int = 2, in_channels: int = 16, num_layers: int = 18, attention_head_dim: int = 64, num_attention_heads: int = 18, joint_attention_dim: int = 4096, caption_projection_dim: int = 1152, pooled_projection_dim: int = 2048, out_channels: int = 16, pos_embed_max_size: int = 96, dual_attention_layers: tuple = (), qk_norm: str | None = None)
```

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

**Parâmetros:**

sample_size (`int`, padrão `128`) : A largura/altura dos latentes. Isso é fixo durante o treinamento, pois é usado para aprender um número de embeddings de posição.

patch_size (`int`, padrão `2`) : Tamanho do patch para dividir os dados de entrada em pequenos patches.

in_channels (`int`, padrão `16`) : O número de canais latentes na entrada.

num_layers (`int`, padrão `18`) : O número de blocos de transformadores a serem usados.

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

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

joint_attention_dim (`int`, padrão `4096`) : A dimensão de incorporação a ser usada para a atenção conjunta de texto e imagem.

caption_projection_dim (`int`, padrão `1152`) : A dimensão de incorporação das incorporações de legenda.

pooled_projection_dim (`int`, padrão `2048`) : A dimensão de incorporação das projeções de texto agrupadas.

out_channels (`int`, padrão `16`) : O número de canais latentes na saída.

pos_embed_max_size (`int`, padrão `96`) : A altura/largura máxima latente dos embeddings posicionais.

dual_attention_layers (`tuple[int, ...]`, padrão `()`) : O número de blocos de transformador de fluxo duplo a serem usados.

qk_norm (`str`, *opcional*, padrão `None`) : A normalização a ser usada para a consulta e a chave na camada de atenção. Se `None`, nenhuma normalização é usada.

O modelo Transformer introduzido no [Stable Diffusion 3](https://huggingface.co/papers/2403.03206).

#### enable_forward_chunking[[diffusers.SD3Transformer2DModel.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/transformer_sd3.py#L175)

**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.SD3Transformer2DModel.forward]]

```python
forward(hidden_states: Tensor, encoder_hidden_states: Tensor = None, pooled_projections: Tensor = None, timestep: LongTensor = None, block_controlnet_hidden_states: list = None, joint_attention_kwargs: dict[str, typing.Any] | None = None, return_dict: bool = True, skip_layers: list[int] | None = None)
```

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

**Parâmetros:**

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

encoder_hidden_states (`torch.Tensor` de forma `(batch size, sequence_len, embed_dims)`) : Embeddings condicionais (embeddings calculados a partir das condições de entrada, como prompts) a serem usados.

pooled_projections (`torch.Tensor` de forma `(batch_size, projection_dim)`) : Embebimentos projetados a partir dos embebimentos das condições de entrada.

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

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

joint_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).

return_dict (`bool`, *opcional*, padrão `True`) : Indica se deve retornar um `~models.transformer_2d.Transformer2DModelOutput` em vez de uma tupla simples.

skip_layers (`list` de `int`, *opcional*) : Uma lista de índices de camadas para ignorar durante a passagem para frente.

**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 [SD3Transformer2DModel](/docs/diffusers/main/pt/api/models/sd3_transformer2d#diffusers.SD3Transformer2DModel).

#### fuse_qkv_projections[[diffusers.SD3Transformer2DModel.fuse_qkv_projections]]

```python
fuse_qkv_projections()
```

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

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.

#### unfuse_qkv_projections[[diffusers.SD3Transformer2DModel.unfuse_qkv_projections]]

```python
unfuse_qkv_projections()
```

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

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

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