# UNet2DConditionModel

Mô hình [UNet](https://huggingface.co/papers/1505.04597) ban đầu được Ronneberger và cộng sự giới thiệu cho phân đoạn ảnh y sinh, nhưng nó cũng được sử dụng phổ biến trong 🤗 Diffusers vì nó tạo ra các ảnh có cùng kích thước với đầu vào. Đây là một trong những thành phần quan trọng nhất của một hệ thống khuếch tán vì nó hỗ trợ quá trình khuếch tán thực sự. Có một số biến thể của mô hình UNet trong 🤗 Diffusers, tùy thuộc vào số chiều của nó và việc nó có phải là mô hình có điều kiện hay không. Đây là một mô hình UNet có điều kiện 2D.

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

*Có sự đồng thuận rộng rãi rằng việc huấn luyện thành công các mạng sâu đòi hỏi hàng nghìn mẫu huấn luyện đã được chú thích. Trong bài báo này, chúng tôi trình bày một kiến trúc mạng và chiến lược huấn luyện dựa vào việc sử dụng mạnh mẽ kỹ thuật tăng cường dữ liệu để tận dụng hiệu quả hơn các mẫu đã được chú thích sẵn có. Kiến trúc bao gồm một đường co (contracting path) để nắm bắt ngữ cảnh và một đường mở rộng đối xứng (expanding path) cho phép định vị chính xác. Chúng tôi cho thấy rằng một mạng như vậy có thể được huấn luyện end-to-end từ rất ít hình ảnh và vượt trội hơn so với phương pháp tốt nhất trước đó (một mạng tích chập cửa sổ trượt) trong thử thách ISBI về phân đoạn các cấu trúc thần kinh trong các chồng ảnh hiển vi điện tử. Sử dụng cùng một mạng được huấn luyện trên các ảnh hiển vi ánh sáng truyền qua (tương phản pha và DIC), chúng tôi đã giành chiến thắng trong thử thách theo dõi tế bào ISBI 2015 ở các hạng mục này với khoảng cách lớn. Hơn nữa, mạng này hoạt động nhanh. Việc phân đoạn một ảnh 512x512 mất chưa đến một giây trên một GPU đời mới. Mã nguồn hoàn chỉnh (dựa trên Caffe) và các mạng đã được huấn luyện có sẵn tại http://lmb.informatik.uni-freiburg.de/people/ronneber/u-net.*

## UNet2DConditionModel[[diffusers.UNet2DConditionModel]]

#### diffusers.UNet2DConditionModel[[diffusers.UNet2DConditionModel]]

```python
diffusers.UNet2DConditionModel(sample_size: int | tuple[int, int] | None = None, in_channels: int = 4, out_channels: int = 4, center_input_sample: bool = False, flip_sin_to_cos: bool = True, freq_shift: int = 0, down_block_types: tuple = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str | None = 'UNetMidBlock2DCrossAttn', up_block_types: tuple = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple = (320, 640, 1280, 1280), layers_per_block: int | tuple[int] = 2, downsample_padding: int = 1, mid_block_scale_factor: float = 1, dropout: float = 0.0, act_fn: str = 'silu', norm_num_groups: int | None = 32, norm_eps: float = 1e-05, cross_attention_dim: int | tuple[int] = 1280, transformer_layers_per_block: int | tuple[int] | tuple[tuple] = 1, reverse_transformer_layers_per_block: tuple[tuple[int]] | None = None, encoder_hid_dim: int | None = None, encoder_hid_dim_type: str | None = None, attention_head_dim: int | tuple[int] = 8, num_attention_heads: int | tuple[int] | None = None, dual_cross_attention: bool = False, use_linear_projection: bool = False, class_embed_type: str | None = None, addition_embed_type: str | None = None, addition_time_embed_dim: int | None = None, num_class_embeds: int | None = None, upcast_attention: bool = False, resnet_time_scale_shift: str = 'default', resnet_skip_time_act: bool = False, resnet_out_scale_factor: float = 1.0, time_embedding_type: str = 'positional', time_embedding_dim: int | None = None, time_embedding_act_fn: str | None = None, timestep_post_act: str | None = None, time_cond_proj_dim: int | None = None, conv_in_kernel: int = 3, conv_out_kernel: int = 3, projection_class_embeddings_input_dim: int | None = None, attention_type: str = 'default', class_embeddings_concat: bool = False, mid_block_only_cross_attention: bool | None = None, cross_attention_norm: str | None = None, addition_embed_type_num_heads: int = 64)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L76)

**Tham số:**

sample_size (`int` hoặc `tuple[int, int]`, *tùy chọn*, mặc định là `None`) : Chiều cao và chiều rộng của mẫu đầu vào/đầu ra.

in_channels (`int`, *tuỳ chọn*, mặc định là 4) : Số kênh trong mẫu đầu vào.

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

center_input_sample (`bool`, *tùy chọn*, mặc định là `False`) : Có căn giữa mẫu đầu vào hay không.

flip_sin_to_cos (`bool`, *tùy chọn*, mặc định là `True`) : Có nên đảo sin thành cos trong time embedding hay không.

freq_shift (`int`, *optional*, mặc định là 0) : Độ dịch tần số cần áp dụng cho nhúng thời gian.

down_block_types (`tuple[str]`, *tùy chọn*, mặc định là `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : Bộ tuple các khối hạ mẫu (downsample) cần sử dụng.

mid_block_type (`str`, *tùy chọn*, mặc định là `"UNetMidBlock2DCrossAttn"`) : Kiểu khối cho phần giữa của UNet, có thể là một trong `UNetMidBlock2DCrossAttn`, `UNetMidBlock2D`, hoặc `UNetMidBlock2DSimpleCrossAttn`. Nếu là `None`, lớp khối giữa sẽ bị bỏ qua.

up_block_types (`tuple[str]`, *tùy chọn*, mặc định là `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : Bộ tuple các khối upsample cần sử dụng.

only_cross_attention(`bool` hoặc `tuple[bool]`, *tùy chọn*, mặc định là `False`) : Có bao gồm self-attention trong các khối transformer cơ bản hay không, xem `BasicTransformerBlock`.

block_out_channels (`tuple[int]`, *optional*, mặc định là `(320, 640, 1280, 1280)`) : Bộ tuple các kênh đầu ra cho mỗi khối.

layers_per_block (`int`, *tuỳ chọn*, mặc định là 2) : Số lượng lớp trong mỗi khối.

downsample_padding (`int`, *optional*, mặc định là 1) : Padding được sử dụng cho phép tích chập hạ mẫu.

mid_block_scale_factor (`float`, *tuỳ chọn*, mặc định là 1.0) : Hệ số tỷ lệ cần sử dụng cho khối giữa.

dropout (`float`, *tuỳ chọn*, mặc định là 0.0) : Xác suất dropout cần sử dụng.

act_fn (`str`, *tùy chọn*, mặc định là `"silu"`) : Hàm kích hoạt cần sử dụng.

norm_num_groups (`int`, *optional*, mặc định là 32) : Số nhóm được sử dụng cho phép chuẩn hóa. Nếu `None`, các lớp chuẩn hóa và kích hoạt sẽ bị bỏ qua trong xử lý hậu kỳ.

norm_eps (`float`, *tuỳ chọn*, mặc định là 1e-5) : Epsilon được sử dụng cho phép chuẩn hóa.

cross_attention_dim (`int` hoặc `tuple[int]`, *tùy chọn*, mặc định là 1280) : Kích thước của các đặc trưng chú ý chéo (cross attention).

transformer_layers_per_block (`int`, `tuple[int]`, hoặc `tuple[tuple]` , *tùy chọn*, mặc định là 1) : Số lượng khối transformer có kiểu `BasicTransformerBlock`. Chỉ liên quan đến `CrossAttnDownBlock2D`, `CrossAttnUpBlock2D`, `UNetMidBlock2DCrossAttn`.

reverse_transformer_layers_per_block : (`tuple[tuple]`, *optional*, mặc định là None): Số lượng khối transformer có kiểu `BasicTransformerBlock`, trong các khối upsampling của U-Net. Chỉ liên quan nếu `transformer_layers_per_block` có kiểu `tuple[tuple]` và đối với `CrossAttnDownBlock2D`, `CrossAttnUpBlock2D`, `UNetMidBlock2DCrossAttn`.

encoder_hid_dim (`int`, *tuỳ chọn*, mặc định là None) : Nếu `encoder_hid_dim_type` được định nghĩa, `encoder_hidden_states` sẽ được chiếu từ chiều `encoder_hid_dim` sang `cross_attention_dim`.

encoder_hid_dim_type (`str`, *tùy chọn*, mặc định là `None`) : Nếu được cung cấp, `encoder_hidden_states` và các embedding khác (nếu có) sẽ được down-project xuống các embedding văn bản có chiều `cross_attention` theo `encoder_hid_dim_type`.

attention_head_dim (`int`, *tuỳ chọn*, mặc định là 8) : Kích thước của các đầu chú ý.

num_attention_heads (`int`, *tuỳ chọn*) : Số lượng đầu chú ý. Nếu không được định nghĩa, mặc định là `attention_head_dim`

resnet_time_scale_shift (`str`, *tùy chọn*, mặc định là `"default"`) : Cấu hình dịch chuyển thang thời gian cho các khối ResNet (xem `ResnetBlock2D`). Chọn từ `default` hoặc `scale_shift`.

class_embed_type (`str`, *tùy chọn*, mặc định là `None`) : Loại class embedding được sử dụng, cuối cùng sẽ được cộng với các time embeddings. Chọn từ `None`, `"timestep"`, `"identity"`, `"projection"` hoặc `"simple_projection"`.

addition_embed_type (`str`, *tùy chọn*, mặc định là `None`) : Cấu hình một embedding tùy chọn sẽ được cộng với các time embeddings. Chọn từ `None` hoặc "text". "text" sẽ sử dụng lớp `TextTimeEmbedding`.

addition_time_embed_dim : (`int`, *không bắt buộc*, mặc định là `None`): Kích thước cho các embedding của timestep.

num_class_embeds (`int`, *tuỳ chọn*, mặc định là `None`) : Kích thước đầu vào của ma trận nhúng có thể học được để chiếu sang `time_embed_dim`, khi thực hiện điều kiện theo lớp với `class_embed_type` bằng `None`.

time_embedding_type (`str`, *tùy chọn*, mặc định là `positional`) : Kiểu nhúng vị trí cần sử dụng cho các bước thời gian. Chọn từ `positional` hoặc `fourier`.

time_embedding_dim (`int`, *tuỳ chọn*, mặc định là `None`) : Một giá trị ghi đè tuỳ chọn cho chiều của time embedding đã được chiếu (projected).

time_embedding_act_fn (`str`, *tùy chọn*, mặc định là `None`) : Hàm kích hoạt tùy chọn để chỉ sử dụng một lần trên các nhúng thời gian trước khi chúng được truyền đến phần còn lại của UNet. Chọn từ `silu`, `mish`, `gelu` và `swish`.

timestep_post_act (`str`, *tùy chọn*, mặc định là `None`) : Hàm kích hoạt thứ hai được sử dụng trong nhúng bước thời gian. Chọn từ `silu`, `mish` và `gelu`.

time_cond_proj_dim (`int`, *tuỳ chọn*, mặc định là `None`) : Kích thước của lớp `cond_proj` trong phần nhúng bước thời gian (timestep embedding).

conv_in_kernel (`int`, *tuỳ chọn*, mặc định là `3`) : Kích thước kernel của lớp `conv_in`.

conv_out_kernel (`int`, *tuỳ chọn*, mặc định là `3`) : Kích thước kernel của lớp `conv_out`.

projection_class_embeddings_input_dim (`int`, *optional*) : Kích thước của đầu vào `class_labels` khi `class_embed_type="projection"`. Bắt buộc khi `class_embed_type="projection"`.

class_embeddings_concat (`bool`, *tùy chọn*, mặc định là `False`) : Có nối các embedding thời gian với các embedding lớp hay không.

mid_block_only_cross_attention (`bool`, *tuỳ chọn*, mặc định là `None`) : Có sử dụng cross attention với mid block khi dùng `UNetMidBlock2DSimpleCrossAttn` hay không. Nếu `only_cross_attention` được truyền dưới dạng một boolean duy nhất và `mid_block_only_cross_attention` là `None`, giá trị của `only_cross_attention` sẽ được dùng làm giá trị cho `mid_block_only_cross_attention`. Mặc định là `False` trong các trường hợp khác.

Một mô hình 2D UNet có điều kiện, nhận vào một mẫu nhiễu, trạng thái điều kiện và một bước thời gian, sau đó trả về một đầu ra có hình dạng của mẫu.

Mô hình này kế thừa từ [ModelMixin](/docs/diffusers/main/vi/api/models/overview#diffusers.ModelMixin). Hãy xem tài liệu của lớp cha để biết các phương thức chung được triển khai cho tất cả các mô hình (chẳng hạn như tải xuống hoặc lưu trữ).

#### disable_freeu[[diffusers.UNet2DConditionModel.disable_freeu]]

```python
disable_freeu()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L814)

Tắt cơ chế FreeU.

#### enable_freeu[[diffusers.UNet2DConditionModel.enable_freeu]]

```python
enable_freeu(s1: float, s2: float, b1: float, b2: float)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L790)

**Tham số:**

s1 (`float`) : Hệ số tỷ lệ cho giai đoạn 1 để làm suy giảm đóng góp của các đặc trưng skip. Việc này được thực hiện để giảm thiểu "hiệu ứng làm mịn quá mức" trong quá trình khử nhiễu được tăng cường.

s2 (`float`) : Hệ số tỷ lệ cho giai đoạn 2 để làm suy giảm đóng góp của các đặc trưng skip. Việc này được thực hiện để giảm thiểu "hiệu ứng làm mịn quá mức" trong quá trình khử nhiễu được tăng cường.

b1 (`float`) : Hệ số tỷ lệ cho giai đoạn 1 để khuếch đại đóng góp của các đặc trưng backbone.

b2 (`float`) : Hệ số tỷ lệ cho giai đoạn 2 để khuếch đại đóng góp của các đặc trưng backbone.

Bật cơ chế FreeU từ https://huggingface.co/papers/2309.11497.

Các hậu tố sau các hệ số tỷ lệ đại diện cho các khối giai đoạn mà chúng được áp dụng.

Vui lòng tham khảo [kho mã nguồn chính thức](https://github.com/ChenyangSi/FreeU) để biết các tổ hợp giá trị được biết là hoạt động tốt cho các pipeline khác nhau như Stable Diffusion v1, v2 và Stable Diffusion XL.

#### forward[[diffusers.UNet2DConditionModel.forward]]

```python
forward(sample: Tensor, timestep: typing.Union[torch.Tensor, float, int], encoder_hidden_states: Tensor, class_labels: typing.Optional[torch.Tensor] = None, timestep_cond: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, cross_attention_kwargs: dict[str, typing.Any] | None = None, added_cond_kwargs: dict[str, torch.Tensor] | None = None, down_block_additional_residuals: tuple[torch.Tensor] | None = None, mid_block_additional_residual: typing.Optional[torch.Tensor] = None, down_intrablock_additional_residuals: tuple[torch.Tensor] | None = None, encoder_attention_mask: typing.Optional[torch.Tensor] = None, return_dict: bool = True)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L978)

**Tham số:**

sample (`torch.Tensor`) : Tensor đầu vào có nhiễu với hình dạng `(batch, channel, height, width)` như sau.

timestep (`torch.Tensor` hoặc `float` hoặc `int`) : Số bước thời gian để khử nhiễu cho một đầu vào.

encoder_hidden_states (`torch.Tensor`) : Trạng thái ẩn của bộ mã hóa với hình dạng `(batch, sequence_length, feature_dim)`.

class_labels (`torch.Tensor`, *tùy chọn*, mặc định là `None`) : Nhãn lớp tùy chọn để điều kiện. Các embedding của chúng sẽ được cộng với các embedding của bước thời gian.

timestep_cond : (`torch.Tensor`, *tùy chọn*, mặc định là `None`): Các embedding điều kiện cho timestep. Nếu được cung cấp, các embedding này sẽ được cộng với các mẫu đi qua lớp `self.time_embedding` để thu được các embedding timestep.

attention_mask (`torch.Tensor`, *tùy chọn*, mặc định là `None`) : Một attention mask có shape `(batch, key_tokens)` được áp dụng cho `encoder_hidden_states`. Nếu là `1`, mask được giữ lại; ngược lại, nếu là `0`, nó sẽ bị loại bỏ. Mask sẽ được chuyển đổi thành một bias, thêm các giá trị âm lớn vào các điểm attention tương ứng với các token "loại bỏ".

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

added_cond_kwargs : (`dict`, *tùy chọn*): Một từ điển kwargs chứa các embeddings bổ sung, nếu được chỉ định sẽ được thêm vào các embeddings được truyền đến các khối UNet.

down_block_additional_residuals : (`tuple` của `torch.Tensor`, *tùy chọn*): Một tuple 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 down unet.

mid_block_additional_residual : (`torch.Tensor`, *tùy chọn*): Một tensor mà nếu được chỉ định sẽ được cộng vào phần dư (residual) của khối unet ở giữa.

down_intrablock_additional_residuals (`tuple` của `torch.Tensor`, *tùy chọn*) : các phần dư bổ sung cần được cộng thêm bên trong các khối xuống (down blocks) của UNet, ví dụ từ các mô hình phụ T2I-Adapter

encoder_attention_mask (`torch.Tensor`) : Một mặt nạ cross-attention có hình dạng `(batch, sequence_length)` được áp dụng cho `encoder_hidden_states`. Nếu `True`, mặt nạ được giữ lại; ngược lại, nếu `False`, nó sẽ bị loại bỏ. Mặt nạ sẽ được chuyển đổi thành một bias, thêm các giá trị âm lớn vào các điểm chú ý tương ứng với các token "loại bỏ".

return_dict (`bool`, *tùy chọn*, mặc định là `True`) : Có nên trả về một [UNet2DConditionOutput](/docs/diffusers/main/vi/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) thay vì một tuple thông thường hay không.

**Trả về:** [UNet2DConditionOutput](/docs/diffusers/main/vi/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) hoặc `tuple`

Nếu `return_dict` là True, một [UNet2DConditionOutput](/docs/diffusers/main/vi/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) sẽ được trả về, ngược lại một `tuple` sẽ được trả về trong đó phần tử đầu tiên là tensor mẫu.

Phương thức forward của [UNet2DConditionModel](/docs/diffusers/main/vi/api/models/unet2d-cond#diffusers.UNet2DConditionModel).

#### fuse_qkv_projections[[diffusers.UNet2DConditionModel.fuse_qkv_projections]]

```python
fuse_qkv_projections()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L822)

Bật các phép chiếu QKV đã hợp nhất. Đối với các module tự chú ý, tất cả các ma trận chiếu (tức là truy vấn, khóa, giá trị) đều được hợp nhất. Đối với các module chú ý chéo, các ma trận chiếu khóa và giá trị được hợp nhất.

> [!WARNING] > API này 🧪 đang ở giai đoạn thử nghiệm.

#### set_attention_slice[[diffusers.UNet2DConditionModel.set_attention_slice]]

```python
set_attention_slice(slice_size: str | int | list[int] = 'auto')
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L725)

**Tham số:**

slice_size (`str` hoặc `int` hoặc `list(int)`, *tuỳ chọn*, mặc định là `"auto"`) : Khi `"auto"`, đầu vào cho các đầu chú ý sẽ được chia đôi, do đó chú ý được tính toán trong hai bước. Nếu `"max"`, lượng bộ nhớ tối đa được tiết kiệm bằng cách chỉ chạy một lát một lần. Nếu cung cấp một số, sẽ sử dụng nhiều lát bằng `attention_head_dim // slice_size`. Trong trường hợp này, `attention_head_dim` phải là bội số của `slice_size`.

Bật tính toán chú ý dạng lát cắt.

Khi tùy chọn này được bật, module attention sẽ chia tensor đầu vào thành các lát để tính toán attention qua nhiều bước. Điều này hữu ích để tiết kiệm một phần bộ nhớ, đổi lại là sự giảm tốc độ nhỏ.

#### set_default_attn_processor[[diffusers.UNet2DConditionModel.set_default_attn_processor]]

```python
set_default_attn_processor()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L710)

Tắt các bộ xử lý chú ý tùy chỉnh và đặt cài đặt chú ý mặc định.

#### unfuse_qkv_projections[[diffusers.UNet2DConditionModel.unfuse_qkv_projections]]

```python
unfuse_qkv_projections()
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L843)

Tắt dự phóng QKV hợp nhất nếu đã được bật.

> [!WARNING] > API này 🧪 đang ở giai đoạn thử nghiệm.

## UNet2DConditionOutput[[diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput]]

#### diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput[[diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput]]

```python
diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput(sample: Tensor = None)
```

[Nguồn](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/unets/unet_2d_condition.py#L64)

**Tham số:**

sample (`torch.Tensor` có hình dạng `(batch_size, num_channels, height, width)`) : Trạng thái ẩn đầu ra được điều kiện bởi đầu vào `encoder_hidden_states`. Đầu ra của lớp cuối cùng của mô hình.

Đầu ra của [UNet2DConditionModel](/docs/diffusers/main/vi/api/models/unet2d-cond#diffusers.UNet2DConditionModel).