# AutoencoderKL

Model variational autoencoder (VAE) dengan kerugian KL diperkenalkan dalam [Auto-Encoding Variational Bayes](https://huggingface.co/papers/1312.6114v11) oleh Diederik P. Kingma dan Max Welling. Model ini digunakan dalam 🤗 Diffusers untuk mengkodekan gambar menjadi latens dan untuk mendekodekan representasi latens menjadi gambar.

Abstrak dari makalah tersebut adalah:

*Bagaimana kita dapat melakukan inferensi dan pembelajaran yang efisien pada model probabilistik terarah, di mana terdapat variabel laten kontinu dengan distribusi posterior yang tidak dapat dihitung (intractable), serta dataset besar? Kami memperkenalkan algoritma inferensi dan pembelajaran variational stokastik yang dapat diskalakan ke dataset besar dan, di bawah beberapa kondisi diferensibilitas yang ringan, bahkan berfungsi pada kasus yang tidak dapat dihitung. Kontribusi kami bersifat dua arah. Pertama, kami menunjukkan bahwa reparameterisasi dari batas bawah variational menghasilkan estimator batas bawah yang dapat dioptimalkan secara langsung menggunakan metode gradien stokastik standar. Kedua, kami menunjukkan bahwa untuk dataset i.i.d. dengan variabel laten kontinu per datapoint, inferensi posterior dapat dibuat sangat efisien dengan menyesuaikan model inferensi aproksimasi (juga disebut model pengenalan) ke posterior yang tidak dapat dihitung menggunakan estimator batas bawah yang diusulkan. Keunggulan teoretis tercermin dalam hasil eksperimen.*

## Memuat dari format asli

Secara default, [AutoencoderKL](/docs/diffusers/v0.43.0/id/api/models/autoencoderkl#diffusers.AutoencoderKL) harus dimuat dengan [from_pretrained()](/docs/diffusers/v0.43.0/id/api/models/overview#diffusers.ModelMixin.from_pretrained), tetapi juga dapat dimuat dari format asli menggunakan `FromOriginalModelMixin.from_single_file` sebagai berikut:

```py
from diffusers import AutoencoderKL

url = "https://huggingface.co/stabilityai/sd-vae-ft-mse-original/blob/main/vae-ft-mse-840000-ema-pruned.safetensors"  # can also be a local file
model = AutoencoderKL.from_single_file(url)
```

## AutoencoderKL[[diffusers.AutoencoderKL]]

#### diffusers.AutoencoderKL[[diffusers.AutoencoderKL]]

```python
diffusers.AutoencoderKL(in_channels: int = 3, out_channels: int = 3, down_block_types: tuple[str] = ('DownEncoderBlock2D',), up_block_types: tuple[str] = ('UpDecoderBlock2D',), block_out_channels: tuple[int] = (64,), layers_per_block: int = 1, act_fn: str = 'silu', latent_channels: int = 4, norm_num_groups: int = 32, sample_size: int = 32, scaling_factor: float = 0.18215, shift_factor: float | None = None, latents_mean: tuple[float] | None = None, latents_std: tuple[float] | None = None, force_upcast: bool = True, use_quant_conv: bool = True, use_post_quant_conv: bool = True, mid_block_add_attention: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl.py#L36)

**Parameter:**

in_channels (int, *opsional*, default 3) : Jumlah channel pada gambar input.

out_channels (int,  *opsional*, default 3) : Jumlah channel pada output.

down_block_types (`tuple[str]`, *opsional*, defaultnya `("DownEncoderBlock2D",)`) : tuple dari tipe blok downsample.

up_block_types (`tuple[str]`, *opsional*, defaultnya `("UpDecoderBlock2D",)`) : tuple dari tipe blok upsample.

block_out_channels (`tuple[int]`, *opsional*, defaultnya `(64,)`) : tuple dari kanal output blok.

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

latent_channels (`int`, *opsional*, defaultnya 4) : Jumlah channel di ruang laten.

sample_size (`int`, *opsional*, defaultnya `32`) : Ukuran input sampel.

scaling_factor (`float`, *opsional*, default 0.18215) : Deviasi standar per komponen dari ruang laten yang dilatih, dihitung menggunakan batch pertama dari set pelatihan. Nilai ini digunakan untuk menskalakan ruang laten agar memiliki varians satu saat melatih model difusi. Laten diskalakan dengan rumus `z = z * scaling_factor` sebelum diteruskan ke model difusi. Saat decoding, laten diskalakan kembali ke skala aslinya dengan rumus: `z = 1 / scaling_factor * z`. Untuk detail lebih lanjut, lihat bagian 4.3.2 dan D.1 dari paper [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752).

force_upcast (`bool`, *opsional*, default `True`) : Jika diaktifkan, parameter ini akan memaksa VAE untuk berjalan dalam float32 pada pipeline resolusi gambar tinggi, seperti SD-XL. VAE dapat dihaluskan / dilatih ke rentang yang lebih rendah tanpa kehilangan terlalu banyak presisi, di mana dalam kasus tersebut `force_upcast` dapat diatur ke `False` - lihat: https://huggingface.co/madebyollin/sdxl-vae-fp16-fix

mid_block_add_attention (`bool`, *opsional*, default ke `True`) : Jika diaktifkan, mid_block dari Encoder dan Decoder akan memiliki blok attention. Jika diatur ke false, mid_block hanya akan memiliki blok resnet

Model VAE dengan kerugian KL untuk mengkodekan gambar menjadi latens dan mendekodekan representasi latens menjadi gambar.

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

#### decode[[diffusers.AutoencoderKL.decode]]

```python
decode(z: FloatTensor, return_dict: bool = True, generator = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl.py#L213)

**Parameter:**

z (`torch.Tensor`) : Batch input dari vektor laten.

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

**Mengembalikan:** `~models.vae.DecoderOutput` atau `tuple`

Jika return_dict adalah True, sebuah `~models.vae.DecoderOutput` dikembalikan, selain itu sebuah `tuple` biasa dikembalikan.

Decode sekelompok gambar.

#### encode[[diffusers.AutoencoderKL.encode]]

```python
encode(x: Tensor, return_dict: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl.py#L170)

**Parameter:**

x (`torch.Tensor`) : Batch input gambar.

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

**Mengembalikan:**

Representasi laten dari gambar yang dikodekan. Jika `return_dict` bernilai True, sebuah `~models.autoencoder_kl.AutoencoderKLOutput` dikembalikan, selain itu sebuah `tuple` polos yang dikembalikan.

Enkodekan batch gambar menjadi latents.

#### forward[[diffusers.AutoencoderKL.forward]]

```python
forward(sample: Tensor, sample_posterior: bool = False, return_dict: bool = True, generator: typing.Optional[torch.Generator] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl.py#L413)

**Parameter:**

sample (`torch.Tensor`) : Sampel input.

sample_posterior (`bool`, *opsional*, defaultnya `False`) : Apakah akan melakukan sampling dari posterior.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `DecoderOutput` alih-alih tuple biasa.

generator (`torch.Generator`, *opsional*) : Sebuah [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) untuk membuat sampling menjadi deterministik.

**Mengembalikan:** `~models.vae.DecoderOutput` atau `tuple`

Jika `return_dict` bernilai True, sebuah `~models.vae.DecoderOutput` akan dikembalikan, selain itu sebuah `tuple` biasa akan dikembalikan.

#### fuse_qkv_projections[[diffusers.AutoencoderKL.fuse_qkv_projections]]

```python
fuse_qkv_projections()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl.py#L450)

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_default_attn_processor[[diffusers.AutoencoderKL.set_default_attn_processor]]

```python
set_default_attn_processor()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl.py#L143)

Menonaktifkan prosesor perhatian kustom dan mengatur implementasi perhatian default.

#### tiled_decode[[diffusers.AutoencoderKL.tiled_decode]]

```python
tiled_decode(z: Tensor, return_dict: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl.py#L364)

**Parameter:**

z (`torch.Tensor`) : Batch input dari vektor laten.

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

**Mengembalikan:** `~models.vae.DecoderOutput` atau `tuple`

Jika return_dict adalah True, sebuah `~models.vae.DecoderOutput` dikembalikan, selain itu sebuah `tuple` biasa dikembalikan.

Decode batch gambar menggunakan decoder bertile.

#### tiled_encode[[diffusers.AutoencoderKL.tiled_encode]]

```python
tiled_encode(x: Tensor, return_dict: bool = True)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl.py#L302)

**Parameter:**

x (`torch.Tensor`) : Batch input gambar.

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

**Mengembalikan:** `~models.autoencoder_kl.AutoencoderKLOutput` atau `tuple`

If return_dict is True, a `~models.autoencoder_kl.AutoencoderKLOutput` is returned, otherwise a plain `tuple` is returned.

Enkodekan batch gambar menggunakan encoder bertile.

Ketika opsi ini diaktifkan, VAE akan membagi tensor input menjadi ubin (tiles) untuk menghitung encoding dalam beberapa langkah. Hal ini berguna untuk menjaga penggunaan memori tetap konstan terlepas dari ukuran gambar. Hasil akhir dari encoding bertile berbeda dari encoding non-tile karena setiap ubin menggunakan encoder yang berbeda. Untuk menghindari artefak tiling, ubin-ubin tersebut saling tumpang tindih dan dicampur (blended) untuk membentuk output yang halus. Anda mungkin masih melihat perubahan berukuran ubin pada output, tetapi seharusnya jauh lebih tidak terlihat.

#### unfuse_qkv_projections[[diffusers.AutoencoderKL.unfuse_qkv_projections]]

```python
unfuse_qkv_projections()
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl.py#L472)

Menonaktifkan proyeksi QKV yang digabungkan jika diaktifkan.

> [!WARNING] > API ini 🧪 eksperimental.

## AutoencoderKLOutput[[diffusers.models.modeling_outputs.AutoencoderKLOutput]]

#### diffusers.models.modeling_outputs.AutoencoderKLOutput[[diffusers.models.modeling_outputs.AutoencoderKLOutput]]

```python
diffusers.models.modeling_outputs.AutoencoderKLOutput(latent_dist: DiagonalGaussianDistribution)
```

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

**Parameter:**

latent_dist (`DiagonalGaussianDistribution`) : Output hasil enkripsi dari `Encoder` yang direpresentasikan sebagai mean dan logvar dari `DiagonalGaussianDistribution`. `DiagonalGaussianDistribution` memungkinkan pengambilan sampel latents dari distribusi tersebut.

Output dari metode encoding AutoencoderKL.

## DecoderOutput[[diffusers.models.autoencoders.vae.DecoderOutput]]

#### diffusers.models.autoencoders.vae.DecoderOutput[[diffusers.models.autoencoders.vae.DecoderOutput]]

```python
diffusers.models.autoencoders.vae.DecoderOutput(sample: Tensor, commit_loss: typing.Optional[torch.FloatTensor] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/vae.py#L49)

**Parameter:**

sample (`torch.Tensor` dengan bentuk `(batch_size, num_channels, height, width)`) : Sampel output yang didekodekan dari lapisan terakhir model.

Output dari metode decoding.