# UNet2DConditionModel

Model [UNet](https://huggingface.co/papers/1505.04597) awalnya diperkenalkan oleh Ronneberger dkk. untuk segmentasi citra biomedis, tetapi juga umum digunakan di 🤗 Diffusers karena menghasilkan citra dengan ukuran yang sama dengan input. Ini adalah salah satu komponen terpenting dalam sistem difusi karena memfasilitasi proses difusi itu sendiri. Terdapat beberapa varian model UNet di 🤗 Diffusers, tergantung pada jumlah dimensinya dan apakah model tersebut bersifat kondisional atau tidak. Ini adalah model UNet kondisional 2D.

Abstrak dari makalah tersebut adalah:

*Ada konsensus besar bahwa pelatihan jaringan dalam yang sukses membutuhkan ribuan sampel pelatihan berlabel. Dalam makalah ini, kami menyajikan sebuah jaringan dan strategi pelatihan yang mengandalkan penggunaan kuat augmentasi data untuk menggunakan sampel berlabel yang tersedia secara lebih efisien. Arsitekturnya terdiri dari jalur kontraktif untuk menangkap konteks dan jalur ekspansi simetris yang memungkinkan lokalisasi yang presisi. Kami menunjukkan bahwa jaringan semacam ini dapat dilatih end-to-end dari sangat sedikit gambar dan melampaui metode terbaik sebelumnya (jaringan konvolusional sliding-window) pada tantangan ISBI untuk segmentasi struktur neuron dalam tumpukan mikroskop elektron. Menggunakan jaringan yang sama yang dilatih pada gambar mikroskopi cahaya transmisi (kontras fase dan DIC), kami memenangkan tantangan pelacakan sel ISBI 2015 dalam kategori-kategori tersebut dengan selisih yang besar. Selain itu, jaringan ini cepat. Segmentasi gambar 512x512 membutuhkan waktu kurang dari satu detik pada GPU terbaru. Implementasi lengkap (berbasis Caffe) dan jaringan yang telah dilatih tersedia di 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[str, ...] = ('CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'CrossAttnDownBlock2D', 'DownBlock2D'), mid_block_type: str | None = 'UNetMidBlock2DCrossAttn', up_block_types: tuple[str, ...] = ('UpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D', 'CrossAttnUpBlock2D'), only_cross_attention: bool | tuple[bool] = False, block_out_channels: tuple[int, ...] = (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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/unets/unet_2d_condition.py#L76)

**Parameter:**

sample_size (`int` atau `tuple[int, int]`, *opsional*, defaultnya `None`) : Tinggi dan lebar sampel input/output.

in_channels (`int`, *opsional*, defaultnya 4) : Jumlah channel dalam sampel input.

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

center_input_sample (`bool`, *opsional*, defaultnya `False`) : Apakah akan memusatkan sampel input.

flip_sin_to_cos (`bool`, *opsional*, defaultnya `True`) : Apakah akan membalik sin menjadi cos dalam time embedding.

freq_shift (`int`, *opsional*, default 0) : Pergeseran frekuensi yang diterapkan pada time embedding.

down_block_types (`tuple[str]`, *opsional*, defaultnya `("CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "CrossAttnDownBlock2D", "DownBlock2D")`) : Tuple dari blok downsample yang akan digunakan.

mid_block_type (`str`, *opsional*, defaultnya `"UNetMidBlock2DCrossAttn"`) : Jenis blok untuk bagian tengah UNet, dapat berupa salah satu dari `UNetMidBlock2DCrossAttn`, `UNetMidBlock2D`, atau `UNetMidBlock2DSimpleCrossAttn`. Jika `None`, lapisan blok tengah dilewati.

up_block_types (`tuple[str]`, *opsional*, defaultnya `("UpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D", "CrossAttnUpBlock2D")`) : Tuple dari blok upsample yang akan digunakan.

only_cross_attention(`bool` atau `tuple[bool]`, *opsional*, default ke `False`) : Apakah akan menyertakan self-attention dalam blok transformer dasar, lihat `BasicTransformerBlock`.

block_out_channels (`tuple[int]`, *opsional*, defaultnya `(320, 640, 1280, 1280)`) : Tuple dari output channels untuk setiap block.

layers_per_block (`int`, *opsional*, defaultnya 2) : Jumlah lapisan per blok.

downsample_padding (`int`, *opsional*, default 1) : Padding yang digunakan untuk konvolusi downsampling.

mid_block_scale_factor (`float`, *opsional*, default 1.0) : Faktor skala yang digunakan untuk blok tengah.

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

act_fn (`str`, *opsional*, defaultnya `"silu"`) : Fungsi aktivasi yang akan digunakan.

norm_num_groups (`int`, *opsional*, default 32) : Jumlah grup yang digunakan untuk normalisasi. Jika `None`, lapisan normalisasi dan aktivasi dilewati dalam pascapemrosesan.

norm_eps (`float`, *opsional*, default 1e-5) : Epsilon yang digunakan untuk normalisasi.

cross_attention_dim (`int` atau `tuple[int]`, *opsional*, default 1280) : Dimensi dari fitur cross attention.

transformer_layers_per_block (`int`, `tuple[int]`, atau `tuple[tuple]` , *opsional*, default 1) : Jumlah blok transformer bertipe `BasicTransformerBlock`. Hanya relevan untuk `CrossAttnDownBlock2D`, `CrossAttnUpBlock2D`, `UNetMidBlock2DCrossAttn`.

reverse_transformer_layers_per_block : (`tuple[tuple]`, *opsional*, defaultnya None): Jumlah blok transformer bertipe `BasicTransformerBlock`, di dalam blok upsampling dari U-Net. Hanya relevan jika `transformer_layers_per_block` bertipe `tuple[tuple]` dan untuk `CrossAttnDownBlock2D`, `CrossAttnUpBlock2D`, `UNetMidBlock2DCrossAttn`.

encoder_hid_dim (`int`, *opsional*, defaultnya None) : Jika `encoder_hid_dim_type` didefinisikan, `encoder_hidden_states` akan diproyeksikan dari dimensi `encoder_hid_dim` ke `cross_attention_dim`.

encoder_hid_dim_type (`str`, *opsional*, defaultnya `None`) : Jika diberikan, `encoder_hidden_states` dan kemungkinan embedding lainnya akan di-down-project ke embedding teks dengan dimensi `cross_attention` sesuai dengan `encoder_hid_dim_type`.

attention_head_dim (`int`, *opsional*, defaultnya 8) : Dimensi dari kepala perhatian (attention heads).

num_attention_heads (`int`, *opsional*) : Jumlah kepala perhatian. Jika tidak didefinisikan, secara default menggunakan `attention_head_dim`

resnet_time_scale_shift (`str`, *opsional*, defaultnya `"default"`) : Konfigurasi pergeseran skala waktu untuk blok ResNet (lihat `ResnetBlock2D`). Pilih dari `default` atau `scale_shift`.

class_embed_type (`str`, *opsional*, defaultnya `None`) : Jenis class embedding yang akan digunakan, yang pada akhirnya dijumlahkan dengan time embeddings. Pilih dari `None`, `"timestep"`, `"identity"`, `"projection"`, atau `"simple_projection"`.

addition_embed_type (`str`, *opsional*, defaultnya `None`) : Mengonfigurasi embedding opsional yang akan dijumlahkan dengan embedding waktu. Pilih dari `None` atau "text". "text" akan menggunakan lapisan `TextTimeEmbedding`.

addition_time_embed_dim : (`int`, *opsional*, defaultnya `None`): Dimensi untuk embedding timestep.

num_class_embeds (`int`, *opsional*, defaultnya `None`) : Dimensi input dari matriks embedding yang dapat dipelajari untuk diproyeksikan ke `time_embed_dim`, saat melakukan kondisioning kelas dengan `class_embed_type` yang sama dengan `None`.

time_embedding_type (`str`, *opsional*, defaultnya `positional`) : Jenis position embedding yang digunakan untuk timesteps. Pilih dari `positional` atau `fourier`.

time_embedding_dim (`int`, *opsional*, defaultnya `None`) : Penggantian opsional untuk dimensi dari time embedding yang diproyeksikan.

time_embedding_act_fn (`str`, *opsional*, defaultnya `None`) : Fungsi aktivasi opsional yang hanya digunakan sekali pada time embeddings sebelum diteruskan ke bagian lain dari UNet. Pilih dari `silu`, `mish`, `gelu`, dan `swish`.

timestep_post_act (`str`, *opsional*, defaultnya `None`) : Fungsi aktivasi kedua yang digunakan dalam penanaman timestep. Pilih dari `silu`, `mish` dan `gelu`.

time_cond_proj_dim (`int`, *opsional*, defaultnya `None`) : Dimensi dari lapisan `cond_proj` dalam embedding timestep.

conv_in_kernel (`int`, *opsional*, default ke `3`) : Ukuran kernel dari layer `conv_in`.

conv_out_kernel (`int`, *opsional*, default ke `3`) : Ukuran kernel dari lapisan `conv_out`.

projection_class_embeddings_input_dim (`int`, *opsional*) : Dimensi dari input `class_labels` ketika `class_embed_type="projection"`. Wajib diisi ketika `class_embed_type="projection"`.

class_embeddings_concat (`bool`, *opsional*, defaultnya `False`) : Apakah akan menggabungkan time embeddings dengan class embeddings.

mid_block_only_cross_attention (`bool`, *opsional*, defaultnya `None`) : Apakah akan menggunakan cross attention dengan mid block saat menggunakan `UNetMidBlock2DSimpleCrossAttn`. Jika `only_cross_attention` diberikan sebagai satu boolean dan `mid_block_only_cross_attention` adalah `None`, nilai `only_cross_attention` digunakan sebagai nilai untuk `mid_block_only_cross_attention`. Defaultnya `False` jika tidak.

Model 2D UNet bersyarat yang menerima sampel berisik, kondisi, dan langkah waktu, lalu mengembalikan keluaran berbentuk sampel.

Model ini mewarisi dari [ModelMixin](/docs/diffusers/v0.43.0/id/api/models/overview#diffusers.ModelMixin). Periksa dokumentasi kelas induk untuk metode generiknya yang diimplementasikan untuk semua model (seperti mengunduh atau menyimpan).

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

```python
disable_freeu()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/unets/unet_2d_condition.py#L814)

Menonaktifkan mekanisme FreeU.

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

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/unets/unet_2d_condition.py#L790)

**Parameter:**

s1 (`float`) : Faktor penskalaan untuk tahap 1 untuk meredam kontribusi fitur skip. Hal ini dilakukan untuk memitigasi "efek over-smoothing" dalam proses denoising yang ditingkatkan.

s2 (`float`) : Faktor penskalaan untuk tahap 2 untuk meredam kontribusi fitur skip. Hal ini dilakukan untuk memitigasi "efek oversmoothing" dalam proses denoising yang ditingkatkan.

b1 (`float`) : Faktor penskalaan untuk tahap 1 untuk memperkuat kontribusi fitur backbone.

b2 (`float`) : Faktor penskalaan untuk tahap 2 untuk memperkuat kontribusi fitur backbone.

Mengaktifkan mekanisme FreeU dari https://huggingface.co/papers/2309.11497.

Sufiks setelah faktor penskalaan mewakili blok tahap tempat faktor tersebut diterapkan.

Silakan merujuk ke [respositori resmi](https://github.com/ChenyangSi/FreeU) untuk kombinasi nilai yang diketahui bekerja dengan baik untuk berbagai pipeline seperti Stable Diffusion v1, v2, dan 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)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/unets/unet_2d_condition.py#L978)

**Parameter:**

sample (`torch.Tensor`) : Tensor input berisik dengan bentuk berikut `(batch, channel, height, width)`.

timestep (`torch.Tensor` atau `float` atau `int`) : Jumlah timestep untuk mendenoise input.

encoder_hidden_states (`torch.Tensor`) : Hidden states encoder dengan bentuk `(batch, sequence_length, feature_dim)`.

class_labels (`torch.Tensor`, *opsional*, defaultnya `None`) : Label kelas opsional untuk kondisioning. Embedding-nya akan dijumlahkan dengan embedding timestep.

timestep_cond : (`torch.Tensor`, *opsional*, defaultnya `None`): Embedding kondisional untuk timestep. Jika diberikan, embedding akan dijumlahkan dengan sampel yang melewati lapisan `self.time_embedding` untuk mendapatkan embedding timestep.

attention_mask (`torch.Tensor`, *opsional*, defaultnya `None`) : Mask attention dengan bentuk `(batch, key_tokens)` diterapkan pada `encoder_hidden_states`. Jika `1`, mask dipertahankan, sedangkan jika `0`, mask dibuang. Mask akan dikonversi menjadi bias, yang menambahkan nilai negatif besar ke skor attention yang sesuai dengan token "buang".

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

added_cond_kwargs : (`dict`, *opsional*): Kamus kwargs yang berisi embedding tambahan yang, jika ditentukan, akan ditambahkan ke embedding yang diteruskan ke blok UNet.

down_block_additional_residuals : (`tuple` dari `torch.Tensor`, *opsional*): Tuple dari tensor yang, jika ditentukan, akan ditambahkan ke residual dari blok down unet.

mid_block_additional_residual : (`torch.Tensor`, *opsional*): Tensor yang jika ditentukan akan ditambahkan ke residual dari blok unet tengah.

down_intrablock_additional_residuals (`tuple` dari `torch.Tensor`, *opsional*) : residual tambahan yang akan ditambahkan di dalam blok down UNet, misalnya dari model sisi T2I-Adapter

encoder_attention_mask (`torch.Tensor`) : Mask cross-attention dengan bentuk `(batch, sequence_length)` diterapkan pada `encoder_hidden_states`. Jika `True`, mask dipertahankan; jika `False`, mask dibuang. Mask akan dikonversi menjadi bias, yang menambahkan nilai negatif besar ke skor attention yang sesuai dengan token "discard".

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan [UNet2DConditionOutput](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) alih-alih tuple biasa.

**Mengembalikan:** [UNet2DConditionOutput](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) atau `tuple`

Jika `return_dict` bernilai True, sebuah [UNet2DConditionOutput](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.models.unets.unet_2d_condition.UNet2DConditionOutput) akan dikembalikan, selain itu sebuah `tuple` akan dikembalikan di mana elemen pertama adalah tensor sampel.

Metode forward dari [UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel).

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

```python
fuse_qkv_projections()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/unets/unet_2d_condition.py#L822)

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_attention_slice[[diffusers.UNet2DConditionModel.set_attention_slice]]

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/unets/unet_2d_condition.py#L725)

**Parameter:**

slice_size (`str` atau `int` atau `list(int)`, *opsional*, defaultnya `"auto"`) : Ketika `"auto"`, input ke attention heads dipangkas setengahnya, sehingga attention dihitung dalam dua langkah. Jika `"max"`, jumlah memori yang dihemat maksimal dengan hanya menjalankan satu slice pada satu waktu. Jika angka diberikan, digunakan sebanyak slice sebanyak `attention_head_dim // slice_size`. Dalam kasus ini, `attention_head_dim` harus merupakan kelipatan dari `slice_size`.

Aktifkan perhitungan perhatian terpotong.

Ketika opsi ini diaktifkan, modul perhatian membagi tensor input menjadi beberapa potongan untuk menghitung perhatian dalam beberapa langkah. Hal ini berguna untuk menghemat sebagian memori dengan mengorbankan sedikit penurunan kecepatan.

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

```python
set_default_attn_processor()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/unets/unet_2d_condition.py#L710)

Menonaktifkan prosesor perhatian kustom dan mengatur implementasi perhatian default.

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

```python
unfuse_qkv_projections()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/unets/unet_2d_condition.py#L843)

Menonaktifkan proyeksi QKV yang digabungkan jika diaktifkan.

> [!WARNING] > API ini 🧪 eksperimental.

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

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/unets/unet_2d_condition.py#L64)

**Parameter:**

sample (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)`) : Output hidden states yang dikondisikan pada input `encoder_hidden_states`. Output dari lapisan terakhir model.

Output dari [UNet2DConditionModel](/docs/diffusers/v0.43.0/id/api/models/unet2d-cond#diffusers.UNet2DConditionModel).