# Transformer2DModel

Model Transformer untuk data seperti gambar dari [CompVis](https://huggingface.co/CompVis) yang didasarkan pada [Vision Transformer](https://huggingface.co/papers/2010.11929) yang diperkenalkan oleh Dosovitskiy et al. [Transformer2DModel](/docs/diffusers/v0.43.0/id/api/models/transformer2d#diffusers.Transformer2DModel) menerima input diskrit (kelas dari vektor embedding) atau kontinu (embedding aktual).

Ketika input bersifat **kontinu**:

1. Proyeksikan input dan ubah bentuknya menjadi `(batch_size, sequence_length, feature_dimension)`.
2. Terapkan blok Transformer dengan cara standar.
3. Bentuk ulang menjadi gambar.

Ketika input bersifat **diskrit**:

> [!TIP]
> Diasumsikan salah satu kelas input adalah piksel laten yang dimasker. Kelas yang diprediksi dari gambar tanpa derau tidak memuat prediksi untuk piksel yang dimasker karena gambar tanpa derau tidak dapat dimasker.

1. Konversi input (kelas piksel laten) menjadi embedding dan terapkan embedding posisional.
2. Terapkan blok Transformer dengan cara standar.
3. Memprediksi kelas dari gambar yang tidak berisik.

## Transformer2DModel[[diffusers.Transformer2DModel]]

#### diffusers.Transformer2DModel[[diffusers.Transformer2DModel]]

```python
diffusers.Transformer2DModel(num_attention_heads: int = 16, attention_head_dim: int = 88, in_channels: int | None = None, out_channels: int | None = None, num_layers: int = 1, dropout: float = 0.0, norm_num_groups: int = 32, cross_attention_dim: int | None = None, attention_bias: bool = False, sample_size: int | None = None, num_vector_embeds: int | None = None, patch_size: int | None = None, activation_fn: str = 'geglu', num_embeds_ada_norm: int | None = None, use_linear_projection: bool = False, only_cross_attention: bool = False, double_self_attention: bool = False, upcast_attention: bool = False, norm_type: str = 'layer_norm', norm_elementwise_affine: bool = True, norm_eps: float = 1e-05, attention_type: str = 'default', caption_channels: int = None, interpolation_scale: float = None, use_additional_conditions: bool | None = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/transformer_2d.py#L39)

**Parameter:**

num_attention_heads (`int`, *opsional*, default 16) : Jumlah head yang digunakan untuk multi-head attention.

attention_head_dim (`int`, *opsional*, defaultnya 88) : Jumlah channel di setiap head.

in_channels (`int`, *opsional*) : Jumlah saluran pada input dan output (dinyatakan jika input bersifat **kontinu**).

num_layers (`int`, *opsional*, default 1) : Jumlah lapisan blok Transformer yang akan digunakan.

dropout (`float`, *opsional*, default 0.0) : Probabilitas dropout yang akan digunakan.

cross_attention_dim (`int`, *opsional*) : Jumlah dimensi `encoder_hidden_states` yang akan digunakan.

sample_size (`int`, *opsional*) : Lebar dari gambar laten (dinyatakan jika input bersifat **diskrit**). Nilai ini tetap selama pelatihan karena digunakan untuk mempelajari sejumlah position embeddings.

num_vector_embeds (`int`, *opsional*) : Jumlah kelas dari vektor embedding piksel laten (tentukan jika input bersifat **diskrit**). Termasuk kelas untuk piksel laten yang dimasker.

activation_fn (`str`, *opsional*, defaultnya `"geglu"`) : Fungsi aktivasi yang digunakan dalam feed-forward.

num_embeds_ada_norm ( `int`, *opsional*) : Jumlah langkah difusi yang digunakan selama pelatihan. Sertakan jika setidaknya salah satu dari norm_layers adalah `AdaLayerNorm`. Nilai ini tetap selama pelatihan karena digunakan untuk mempelajari sejumlah embedding yang ditambahkan ke hidden states. Selama inferensi, Anda dapat melakukan denoising hingga, tetapi tidak lebih dari, `num_embeds_ada_norm` langkah.

attention_bias (`bool`, *opsional*) : Mengonfigurasi apakah perhatian pada `TransformerBlocks` harus memuat parameter bias.

Model Transformer 2D untuk data serupa gambar.

#### forward[[diffusers.Transformer2DModel.forward]]

```python
forward(hidden_states: Tensor, encoder_hidden_states: typing.Optional[torch.Tensor] = None, timestep: typing.Optional[torch.LongTensor] = None, added_cond_kwargs: dict[str, torch.Tensor] = None, class_labels: typing.Optional[torch.LongTensor] = None, cross_attention_kwargs: dict[str, typing.Any] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, return_dict: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/transformer_2d.py#L324)

**Parameter:**

hidden_states (`torch.LongTensor` dengan bentuk `(batch size, num latent pixels)` jika diskrit, `torch.Tensor` dengan bentuk `(batch size, channel, height, width)` jika kontinu) : Input `hidden_states`.

encoder_hidden_states ( `torch.Tensor` dengan bentuk `(batch size, sequence len, embed dims)`, *opsional*) : Embedding kondisional untuk lapisan cross attention. Jika tidak diberikan, cross-attention secara default menggunakan self-attention.

timestep ( `torch.LongTensor`, *opsional*) : Digunakan untuk menunjukkan langkah denoising. Timestep opsional yang diterapkan sebagai embedding di `AdaLayerNorm`.

class_labels ( `torch.LongTensor` dengan bentuk `(batch size, num classes)`, *opsional*) : Digunakan untuk menunjukkan kondisioning label kelas. Label kelas opsional yang akan diterapkan sebagai embedding di `AdaLayerZeroNorm`.

cross_attention_kwargs ( `dict[str, Any]`, *opsional*) : Sebuah kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor` seperti yang didefinisikan di bawah `self.processor` dalam [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

attention_mask ( `torch.Tensor`, *opsional*) : Mask perhatian dengan bentuk `(batch, key_tokens)` diterapkan pada `encoder_hidden_states`. Jika `1`, mask dipertahankan, sedangkan jika `0`, mask dibuang. Mask akan dikonversi menjadi bias, yang menambahkan nilai negatif besar ke skor perhatian yang sesuai dengan token "buang".

encoder_attention_mask ( `torch.Tensor`, *opsional*) : Mask cross-attention yang diterapkan pada `encoder_hidden_states`. Dua format didukung:  * Mask `(batch, sequence_length)` True = simpan, False = buang. * Bias `(batch, 1, sequence_length)` 0 = simpan, -10000 = buang.  Jika `ndim == 2`: akan diinterpretasikan sebagai mask, kemudian dikonversi menjadi bias yang konsisten dengan format di atas. Bias ini akan ditambahkan ke skor cross-attention.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [UNet2DConditionOutput](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) alih-alih tuple biasa.

**Mengembalikan:**

Jika `return_dict` bernilai True, sebuah `Transformer2DModelOutput` akan dikembalikan, selain itu sebuah `tuple` di mana elemen pertama adalah tensor sampel.

Metode forward dari [Transformer2DModel](/docs/diffusers/v0.43.0/id/api/models/transformer2d#diffusers.Transformer2DModel).

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

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_outputs.py#L21)

**Parameter:**

sample (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)` atau `(batch size, num_vector_embeds - 1, num_latent_pixels)` jika [Transformer2DModel](/docs/diffusers/v0.43.0/id/api/models/transformer2d#diffusers.Transformer2DModel) bersifat diskrit) : Output hidden states yang dikondisikan pada input `encoder_hidden_states`. Jika diskrit, mengembalikan distribusi probabilitas untuk piksel laten yang tidak berisik.

Output dari [Transformer2DModel](/docs/diffusers/v0.43.0/id/api/models/transformer2d#diffusers.Transformer2DModel).