# SanaTransformer2DModel

Model Diffusion Transformer untuk data 2D dari [SANA: Efficient High-Resolution Image Synthesis with Linear Diffusion Transformers](https://huggingface.co/papers/2410.10629) diperkenalkan oleh NVIDIA dan MIT HAN Lab, oleh Enze Xie, Junsong Chen, Junyu Chen, Han Cai, Haotian Tang, Yujun Lin, Zhekai Zhang, Muyang Li, Ligeng Zhu, Yao Lu, Song Han.

Abstrak dari makalah tersebut adalah:

*Kami memperkenalkan Sana, sebuah kerangka kerja teks-ke-gambar yang dapat menghasilkan gambar hingga resolusi 4096×4096 secara efisien. Sana dapat mensintesis gambar beresolusi tinggi dan berkualitas tinggi dengan keselarasan teks-gambar yang kuat pada kecepatan yang sangat cepat, dan dapat di-deploy pada GPU laptop. Desain intinya meliputi: (1) Autoencoder kompresi dalam: berbeda dengan AE tradisional yang hanya mengompresi gambar 8×, kami melatih AE yang dapat mengompresi gambar 32×, secara efektif mengurangi jumlah token laten. (2) Linear DiT: kami mengganti semua vanilla attention di DiT dengan linear attention, yang lebih efisien pada resolusi tinggi tanpa mengorbankan kualitas. (3) Text encoder hanya-decoder: kami mengganti T5 dengan LLM kecil modern hanya-decoder sebagai text encoder dan merancang instruksi manusia yang kompleks dengan in-context learning untuk meningkatkan keselarasan gambar-teks. (4) Pelatihan dan sampling yang efisien: kami mengusulkan Flow-DPM-Solver untuk mengurangi langkah sampling, dengan pelabelan dan seleksi caption yang efisien untuk mempercepat konvergensi. Akibatnya, Sana-0.6B sangat kompetitif dengan model difusi raksasa modern (misalnya Flux-12B), berukuran 20 kali lebih kecil dan 100+ kali lebih cepat dalam throughput yang diukur. Selain itu, Sana-0.6B dapat di-deploy pada GPU laptop 16GB, membutuhkan waktu kurang dari 1 detik untuk menghasilkan gambar beresolusi 1024×1024. Sana memungkinkan pembuatan konten dengan biaya rendah. Kode dan model akan dirilis secara publik.*

Model dapat dimuat dengan potongan kode berikut.

```python
from diffusers import SanaTransformer2DModel

transformer = SanaTransformer2DModel.from_pretrained("Efficient-Large-Model/Sana_1600M_1024px_BF16_diffusers", subfolder="transformer", dtype=torch.bfloat16)
```

## SanaTransformer2DModel[[diffusers.SanaTransformer2DModel]]

#### diffusers.SanaTransformer2DModel[[diffusers.SanaTransformer2DModel]]

```python
diffusers.SanaTransformer2DModel(in_channels: int = 32, out_channels: int | None = 32, num_attention_heads: int = 70, attention_head_dim: int = 32, num_layers: int = 20, num_cross_attention_heads: int | None = 20, cross_attention_head_dim: int | None = 112, cross_attention_dim: int | None = 2240, caption_channels: int = 2304, mlp_ratio: float = 2.5, dropout: float = 0.0, attention_bias: bool = False, sample_size: int = 32, patch_size: int = 1, norm_elementwise_affine: bool = False, norm_eps: float = 1e-06, interpolation_scale: int | None = None, guidance_embeds: bool = False, guidance_embeds_scale: float = 0.1, qk_norm: str | None = None, timestep_scale: float = 1.0)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/sana_transformer.py#L294)

**Parameter:**

in_channels (`int`, defaultnya `32`) : Jumlah channel pada input.

out_channels (`int`, *opsional*, defaultnya `32`) : Jumlah channel pada output.

num_attention_heads (`int`, defaultnya `70`) : Jumlah head yang digunakan untuk multi-head attention.

attention_head_dim (`int`, defaultnya `32`) : Jumlah channel di setiap head.

num_layers (`int`, defaultnya `20`) : Jumlah lapisan blok Transformer yang akan digunakan.

num_cross_attention_heads (`int`, *opsional*, defaultnya `20`) : Jumlah head yang digunakan untuk cross-attention.

cross_attention_head_dim (`int`, *opsional*, defaultnya `112`) : Jumlah channel di setiap head untuk cross-attention.

cross_attention_dim (`int`, *opsional*, defaultnya `2240`) : Jumlah channel pada output cross-attention.

caption_channels (`int`, defaultnya `2304`) : Jumlah channel dalam caption embeddings.

mlp_ratio (`float`, defaultnya `2.5`) : Rasio ekspansi yang digunakan di lapisan GLUMBConv.

dropout (`float`, defaultnya `0.0`) : Probabilitas dropout.

attention_bias (`bool`, defaultnya `False`) : Apakah akan menggunakan bias di lapisan perhatian.

sample_size (`int`, defaultnya `32`) : Ukuran dasar dari input laten.

patch_size (`int`, defaultnya `1`) : Ukuran patch yang akan digunakan di lapisan patch embedding.

norm_elementwise_affine (`bool`, defaultnya `False`) : Apakah akan menggunakan afinitas elemen per elemen di lapisan normalisasi.

norm_eps (`float`, defaultnya `1e-6`) : Nilai epsilon untuk lapisan normalisasi.

qk_norm (`str`, *opsional*, defaultnya `None`) : Normalisasi yang digunakan untuk query dan key.

timestep_scale (`float`, defaultnya `1.0`) : Skala yang digunakan untuk timesteps.

Model Transformer 2D yang diperkenalkan dalam keluarga model [Sana](https://huggingface.co/papers/2410.10629).

#### forward[[diffusers.SanaTransformer2DModel.forward]]

```python
forward(hidden_states: Tensor, encoder_hidden_states: Tensor, timestep: Tensor, guidance: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, attention_kwargs: dict[str, typing.Any] | None = None, controlnet_block_samples: tuple[torch.Tensor] | None = None, return_dict: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/sana_transformer.py#L419)

**Parameter:**

hidden_states (`torch.Tensor` dengan bentuk `(batch_size, in_channels, height, width)`) : Input `hidden_states`.

encoder_hidden_states (`torch.Tensor` dengan bentuk `(batch_size, sequence_len, embed_dims)`) : Embedding kondisional (embedding yang dihitung dari kondisi input seperti prompt) yang akan digunakan.

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

guidance (`torch.Tensor`, *opsional*) : Embedding skala panduan.

encoder_attention_mask (`torch.Tensor`, *opsional*) : Mask cross-attention yang diterapkan pada `encoder_hidden_states`.

attention_mask (`torch.Tensor`, *opsional*) : Mask self-attention yang diterapkan pada `hidden_states`.

attention_kwargs (`dict`, *opsional*) : 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).

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

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `~models.transformer_2d.Transformer2DModelOutput` alih-alih tuple biasa.

**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 [SanaTransformer2DModel](/docs/diffusers/main/id/api/models/sana_transformer2d#diffusers.SanaTransformer2DModel).

## 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/main/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/main/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/main/id/api/models/transformer2d#diffusers.Transformer2DModel).