# SanaTransformer2DModel

Một mô hình Diffusion Transformer cho dữ liệu 2D từ [SANA: Efficient High-Resolution Image Synthesis with Linear Diffusion Transformers](https://huggingface.co/papers/2410.10629) đã được giới thiệu bởi NVIDIA và MIT HAN Lab, do Enze Xie, Junsong Chen, Junyu Chen, Han Cai, Haotian Tang, Yujun Lin, Zhekai Zhang, Muyang Li, Ligeng Zhu, Yao Lu, Song Han thực hiện.

Tóm tắt từ bài báo là:

*Chúng tôi giới thiệu Sana, một framework tạo ảnh từ văn bản có khả năng tạo ảnh hiệu quả với độ phân giải lên đến 4096×4096. Sana có thể tổng hợp các hình ảnh độ phân giải cao, chất lượng cao với sự tương ứng mạnh mẽ giữa văn bản và hình ảnh ở tốc độ cực kỳ nhanh, có thể triển khai trên GPU của laptop. Các thiết kế cốt lõi bao gồm: (1) Autoencoder nén sâu: khác với các AE truyền thống chỉ nén ảnh 8×, chúng tôi đã huấn luyện một AE có thể nén ảnh 32×, giảm hiệu quả số lượng token tiềm ẩn. (2) Linear DiT: chúng tôi thay thế tất cả các vanilla attention trong DiT bằng linear attention, hiệu quả hơn ở độ phân giải cao mà không làm giảm chất lượng. (3) Text encoder chỉ có decoder: chúng tôi thay thế T5 bằng các LLM nhỏ hiện đại chỉ có decoder làm text encoder và thiết kế các chỉ dẫn phức tạp từ con người với in-context learning để tăng cường sự tương ứng giữa hình ảnh và văn bản. (4) Huấn luyện và lấy mẫu hiệu quả: chúng tôi đề xuất Flow-DPM-Solver để giảm số bước lấy mẫu, kết hợp với việc gắn nhãn và chọn lọc caption hiệu quả để tăng tốc hội tụ. Kết quả là, Sana-0.6B rất cạnh tranh với các mô hình khuếch tán khổng lồ hiện đại (ví dụ: Flux-12B), nhỏ hơn 20 lần và nhanh hơn 100+ lần về thông lượng đo được. Hơn nữa, Sana-0.6B có thể được triển khai trên GPU laptop 16GB, mất ít hơn 1 giây để tạo một hình ảnh độ phân giải 1024×1024. Sana cho phép tạo nội dung với chi phí thấp. Mã và mô hình sẽ được công bố công khai.*

Mô hình có thể được tải bằng đoạn mã sau.

```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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/sana_transformer.py#L294)

**Tham số:**

in_channels (`int`, mặc định là `32`) : Số lượng kênh trong đầu vào.

out_channels (`int`, *tuỳ chọn*, mặc định là `32`) : Số lượng kênh trong đầu ra.

num_attention_heads (`int`, mặc định là `70`) : Số lượng đầu được sử dụng cho chú ý đa đầu (multi-head attention).

attention_head_dim (`int`, mặc định là `32`) : Số lượng kênh trong mỗi head.

num_layers (`int`, mặc định là `20`) : Số lượng lớp khối Transformer cần sử dụng.

num_cross_attention_heads (`int`, *tuỳ chọn*, mặc định là `20`) : Số lượng đầu (heads) được sử dụng cho cross-attention.

cross_attention_head_dim (`int`, *tuỳ chọn*, mặc định là `112`) : Số lượng kênh trong mỗi đầu cho cross-attention.

cross_attention_dim (`int`, *tùy chọn*, mặc định là `2240`) : Số lượng kênh trong đầu ra của cross-attention.

caption_channels (`int`, mặc định là `2304`) : Số lượng kênh trong các embedding mô tả.

mlp_ratio (`float`, mặc định là `2.5`) : Tỷ lệ mở rộng được sử dụng trong lớp GLUMBConv.

dropout (`float`, mặc định là `0.0`) : Xác suất dropout.

attention_bias (`bool`, mặc định là `False`) : Có sử dụng bias trong lớp attention hay không.

sample_size (`int`, mặc định là `32`) : Kích thước cơ bản của latent đầu vào.

patch_size (`int`, mặc định là `1`) : Kích thước của các patch được sử dụng trong lớp nhúng patch.

norm_elementwise_affine (`bool`, mặc định là `False`) : Có sử dụng độ tương thích từng phần tử trong lớp chuẩn hóa hay không.

norm_eps (`float`, mặc định là `1e-6`) : Giá trị epsilon cho lớp chuẩn hóa.

qk_norm (`str`, *tùy chọn*, mặc định là `None`) : Phương pháp chuẩn hóa cần sử dụng cho query và key.

timestep_scale (`float`, mặc định là `1.0`) : Thang đo cần sử dụng cho các bước thời gian (timesteps).

Mô hình Transformer 2D được giới thiệu trong dòng mô hình [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)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/transformers/sana_transformer.py#L419)

**Tham số:**

hidden_states (`torch.Tensor` có hình dạng `(batch_size, in_channels, height, width)`) : `hidden_states` đầu vào.

encoder_hidden_states (`torch.Tensor` có shape `(batch_size, sequence_len, embed_dims)`) : Các embeddings điều kiện (embeddings được tính từ các điều kiện đầu vào như prompts) cần sử dụng.

timestep (`torch.LongTensor`) : Dùng để chỉ bước khử nhiễu.

guidance (`torch.Tensor`, *tùy chọn*) : Nhúng thang độ dẫn hướng.

encoder_attention_mask (`torch.Tensor`, *tùy chọn*) : Mặt nạ chú ý chéo (cross-attention mask) được áp dụng cho `encoder_hidden_states`.

attention_mask (`torch.Tensor`, *tùy chọn*) : Mặt nạ tự chú ý (self-attention mask) được áp dụng cho `hidden_states`.

attention_kwargs (`dict`, *tùy chọn*) : Một từ điển kwargs mà nếu được chỉ định sẽ được truyền đến `AttentionProcessor` như đã định nghĩa dưới `self.processor` trong [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).

controlnet_block_samples (`tuple` của `torch.Tensor`, *tùy chọn*) : Một danh sách các tensor mà nếu được chỉ định sẽ được cộng vào phần dư (residuals) của các khối transformer.

return_dict (`bool`, *tùy chọn*, mặc định là `True`) : Có nên trả về một `~models.transformer_2d.Transformer2DModelOutput` thay vì một tuple thông thường hay không.

**Trả về:**

Nếu `return_dict` là True, một `~models.transformer_2d.Transformer2DModelOutput` sẽ được trả về, ngược lại một `tuple` trong đó phần tử đầu tiên là tensor mẫu.

Phương thức forward của [SanaTransformer2DModel](/docs/diffusers/v0.43.0/vi/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)
```

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

**Tham số:**

sample (`torch.Tensor` có shape `(batch_size, num_channels, height, width)` hoặc `(batch size, num_vector_embeds - 1, num_latent_pixels)` nếu [Transformer2DModel](/docs/diffusers/v0.43.0/vi/api/models/transformer2d#diffusers.Transformer2DModel) là discrete) : Đầu ra của hidden states được điều kiện bởi đầu vào `encoder_hidden_states`. Nếu là discrete, trả về các phân phối xác suất cho các latent pixels chưa bị nhiễu.

Đầu ra của [Transformer2DModel](/docs/diffusers/v0.43.0/vi/api/models/transformer2d#diffusers.Transformer2DModel).