# Lumina2Transformer2DModel

Một mô hình Diffusion Transformer cho dữ liệu dạng video 3D đã được giới thiệu trong [Lumina Image 2.0](https://huggingface.co/Alpha-VLLM/Lumina-Image-2.0) bởi Alpha-VLLM.

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

```python
from diffusers import Lumina2Transformer2DModel

transformer = Lumina2Transformer2DModel.from_pretrained("Alpha-VLLM/Lumina-Image-2.0", subfolder="transformer", dtype=torch.bfloat16)
```

## Lumina2Transformer2DModel[[diffusers.Lumina2Transformer2DModel]]

#### diffusers.Lumina2Transformer2DModel[[diffusers.Lumina2Transformer2DModel]]

```python
diffusers.Lumina2Transformer2DModel(sample_size: int = 128, patch_size: int = 2, in_channels: int = 16, out_channels: int | None = None, hidden_size: int = 2304, num_layers: int = 26, num_refiner_layers: int = 2, num_attention_heads: int = 24, num_kv_heads: int = 8, multiple_of: int = 256, ffn_dim_multiplier: float | None = None, norm_eps: float = 1e-05, scaling_factor: float = 1.0, axes_dim_rope: tuple[int, int, int] = (32, 32, 32), axes_lens: tuple[int, int, int] = (300, 512, 512), cap_feat_dim: int = 1024)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_lumina2.py#L327)

**Tham số:**

sample_size (`int`) : Độ rộng của các ảnh tiềm ẩn. Giá trị này được cố định trong quá trình huấn luyện vì nó được dùng để học một số lượng embedding vị trí.

patch_size (`int`, *optional*, (`int`, *optional*, mặc định là 2) : Kích thước của mỗi patch trong ảnh. Tham số này xác định độ phân giải của các patch được đưa vào mô hình.

in_channels (`int`, *tuỳ chọn*, mặc định là 4) : Số lượng kênh đầu vào của mô hình. Thông thường, con số này khớp với số lượng kênh trong các hình ảnh đầu vào.

hidden_size (`int`, *optional*, mặc định là 4096) : Độ chiều của các lớp ẩn trong mô hình. Tham số này xác định độ rộng của các biểu diễn ẩn của mô hình.

num_layers (`int`, *tuỳ chọn*, mặc định là 32) : Số lượng lớp trong mô hình. Tham số này xác định độ sâu của mạng nơ-ron.

num_attention_heads (`int`, *tuỳ chọn*, mặc định là 32) : Số lượng đầu chú ý trong mỗi lớp chú ý. Tham số này chỉ định số lượng cơ chế chú ý riêng biệt được sử dụng.

num_kv_heads (`int`, *tuỳ chọn*, mặc định là 8) : Số lượng đầu key-value trong cơ chế chú ý, nếu khác với số lượng đầu chú ý. Nếu là None, giá trị mặc định sẽ là num_attention_heads.

multiple_of (`int`, *optional*, mặc định là 256) : Một hệ số mà kích thước ẩn phải là bội số của nó. Điều này có thể giúp tối ưu hóa một số cấu hình phần cứng nhất định.

ffn_dim_multiplier (`float`, *optional*) : Hệ số nhân cho chiều của mạng feed-forward. Nếu là None, nó sẽ sử dụng giá trị mặc định dựa trên cấu hình của mô hình.

norm_eps (`float`, *optional*, mặc định là 1e-5) : Một giá trị nhỏ được cộng vào mẫu số để đảm bảo ổn định số học trong các lớp chuẩn hóa.

scaling_factor (`float`, *optional*, mặc định là 1.0) : Một hệ số tỷ lệ được áp dụng cho một số tham số hoặc lớp nhất định trong mô hình. Điều này có thể được sử dụng để điều chỉnh tỷ lệ tổng thể của các thao tác trong mô hình.

Lumina2NextDiT: Mô hình khuếch tán với bộ khung Transformer.

#### forward[[diffusers.Lumina2Transformer2DModel.forward]]

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

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/transformer_lumina2.py#L460)

**Tham số:**

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

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

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.

encoder_attention_mask (`torch.Tensor`) : Mặt nạ được áp dụng cho `encoder_hidden_states` trong quá trình chú ý.

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

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 [Lumina2Transformer2DModel](/docs/diffusers/main/vi/api/models/lumina2_transformer2d#diffusers.Lumina2Transformer2DModel).

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