# HunyuanDiT2DModel

Model Diffusion Transformer untuk data 2D dari [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)
```

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

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

patch_size (`int`, *opsional*) : Ukuran patch yang digunakan untuk input.

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

sample_size (`int`, *opsional*) : Lebar dari gambar laten. Ini tetap selama pelatihan karena digunakan untuk mempelajari sejumlah posisi embedding.

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

cross_attention_dim (`int`, *opsional*) : Jumlah dimensi pada embedding teks klip.

hidden_size (`int`, *opsional*) : Ukuran lapisan tersembunyi pada lapisan embedding kondisional.

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

mlp_ratio (`float`, *opsional*, default 4.0) : Rasio ukuran lapisan tersembunyi terhadap ukuran input.

learn_sigma (`bool`, *opsional*, defaultnya `True`) : Apakah akan memprediksi varians.

cross_attention_dim_t5 (`int`, *opsional*) : Jumlah dimensi dalam t5 text embedding.

pooled_projection_dim (`int`, *opsional*) : Ukuran dari proyeksi yang dipooling.

text_len (`int`, *opsional*) : Panjang dari embedding teks klip.

text_len_t5 (`int`, *opsional*) : Panjang dari embedding teks T5.

use_style_cond_and_image_meta_size (`bool`,  *opsional*) : Apakah akan menggunakan kondisi gaya dan ukuran meta gambar. True untuk versi <=1.1, False untuk versi >= 1.2

HunYuanDiT: Model difusi dengan tulang punggung Transformer.

Warisi ModelMixin dan ConfigMixin agar kompatibel dengan sampler StableDiffusionPipeline dari diffusers.

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

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

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

**Parameter:**

chunk_size (`int`, *opsional*) : Ukuran chunk dari lapisan feed-forward. Jika tidak ditentukan, lapisan feed-forward akan dijalankan secara individual untuk setiap tensor dengan dim=`dim`.

dim (`int`, *opsional*, defaultnya `0`) : Dimensi di mana komputasi feed-forward harus di-chunk. Pilih antara dim=0 (batch) atau dim=1 (panjang sekuens).

Menetapkan prosesor perhatian untuk menggunakan [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)
```

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

**Parameter:**

hidden_states (`torch.Tensor` dengan bentuk `(batch size, dim, height, width)`) : Tensor input.

timestep ( `torch.LongTensor`, *opsional*) : Digunakan untuk menunjukkan langkah denoising.

encoder_hidden_states ( `torch.Tensor` dengan bentuk `(batch size, sequence len, embed dims)`, *opsional*) : Embedding kondisional untuk lapisan cross attention. Ini adalah output dari `BertModel`.

text_embedding_mask : torch.Tensor Mask perhatian dengan bentuk `(batch, key_tokens)` diterapkan pada `encoder_hidden_states`. Ini adalah keluaran dari `BertModel`.

encoder_hidden_states_t5 ( `torch.Tensor` dengan bentuk `(batch size, sequence len, embed dims)`, *opsional*) : Embedding kondisional untuk lapisan cross attention. Ini adalah output dari T5 Text Encoder.

text_embedding_mask_t5 : torch.Tensor Mask perhatian dengan bentuk `(batch, key_tokens)` diterapkan pada `encoder_hidden_states`. Ini adalah keluaran dari T5 Text Encoder.

image_meta_size (torch.Tensor) : embedding kondisional yang menunjukkan ukuran gambar

style : torch.Tensor: Embedding kondisional yang menunjukkan gaya

image_rotary_emb (`torch.Tensor`) : Embedding rotasi gambar yang diterapkan pada tensor query dan key selama perhitungan perhatian.

controlnet_block_samples (`list` dari `torch.Tensor`, *opsional*) : Daftar tensor yang, jika ditentukan, akan ditambahkan ke residual blok transformer.

return_dict : bool Apakah akan mengembalikan kamus.

**Mengembalikan:**

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

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

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

```python
fuse_qkv_projections()
```

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

Mengaktifkan proyeksi QKV yang digabungkan. Untuk modul self-attention, semua matriks proyeksi (yaitu, query, key, value) digabungkan. Untuk modul cross-attention, matriks proyeksi key dan value digabungkan.

> [!WARNING] > API ini 🧪 eksperimental.

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

```python
set_default_attn_processor()
```

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

Menonaktifkan prosesor perhatian kustom dan mengatur implementasi perhatian default.

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

```python
unfuse_qkv_projections()
```

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

Menonaktifkan proyeksi QKV yang digabungkan jika diaktifkan.

> [!WARNING] > API ini 🧪 eksperimental.