# AsymmetricAutoencoderKL

Modelo de autoencoder variacional (VAE) maior aprimorado com perda KL para a tarefa de inpainting: [Designing a Better Asymmetric VQGAN for StableDiffusion](https://huggingface.co/papers/2306.04632), de Zixin Zhu, Xuelu Feng, Dongdong Chen, Jianmin Bao, Le Wang, Yinpeng Chen, Lu Yuan, Gang Hua.

O resumo do artigo é:

*StableDiffusion é um gerador revolucionário de texto para imagem que está causando impacto no mundo de geração e edição de imagens. Diferente dos métodos tradicionais que aprendem um modelo de difusão no espaço de pixels, o StableDiffusion aprende um modelo de difusão no espaço latente via VQGAN, garantindo tanto eficiência quanto qualidade. Ele não apenas suporta tarefas de geração de imagens, mas também permite a edição de imagens reais, como inpainting de imagem e edição local. No entanto, observamos que o VQGAN vanilla usado no StableDiffusion leva a uma perda significativa de informações, causando artefatos de distorção mesmo em regiões de imagem não editadas. Para isso, propomos um novo VQGAN assimétrico com dois designs simples. Em primeiro lugar, além da entrada do codificador, o decodificador contém um ramo condicional que incorpora informações de priors específicos da tarefa, como a região de imagem sem máscara no inpainting. Em segundo lugar, o decodificador é muito mais pesado que o codificador, permitindo uma recuperação mais detalhada com apenas um pequeno aumento no custo total de inferência. O custo de treinamento do nosso VQGAN assimétrico é baixo, e precisamos apenas re-treinar um novo decodificador assimétrico mantendo o codificador do VQGAN vanilla e o StableDiffusion inalterados. Nosso VQGAN assimétrico pode ser amplamente usado em métodos de inpainting e edição local baseados em StableDiffusion. Experimentos extensos demonstram que ele pode melhorar significativamente o desempenho de inpainting e edição, mantendo a capacidade original de texto para imagem. O código está disponível em https://github.com/buxiangzhiren/Asymmetric_VQGAN*

Os resultados da avaliação podem ser encontrados na seção 4.1 do artigo original.

## Checkpoints disponíveis

* [https://huggingface.co/cross-attention/asymmetric-autoencoder-kl-x-1-5](https://huggingface.co/cross-attention/asymmetric-autoencoder-kl-x-1-5)
* [https://huggingface.co/cross-attention/asymmetric-autoencoder-kl-x-2](https://huggingface.co/cross-attention/asymmetric-autoencoder-kl-x-2)

## Exemplo de uso

```python
from diffusers import AsymmetricAutoencoderKL, StableDiffusionInpaintPipeline
from diffusers.utils import load_image, make_image_grid

prompt = "a photo of a person with beard"
img_url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/celeba_hq_256.png"
mask_url = "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/repaint/mask_256.png"

original_image = load_image(img_url).resize((512, 512))
mask_image = load_image(mask_url).resize((512, 512))

pipe = StableDiffusionInpaintPipeline.from_pretrained("stable-diffusion-v1-5/stable-diffusion-inpainting")
pipe.vae = AsymmetricAutoencoderKL.from_pretrained("cross-attention/asymmetric-autoencoder-kl-x-1-5")
pipe.to("cuda")  # or "mps", "xpu", "cpu"

image = pipe(prompt=prompt, image=original_image, mask_image=mask_image).images[0]
make_image_grid([original_image, mask_image, image], rows=1, cols=3)
```

## AsymmetricAutoencoderKL[[diffusers.AsymmetricAutoencoderKL]]

#### diffusers.AsymmetricAutoencoderKL[[diffusers.AsymmetricAutoencoderKL]]

```python
diffusers.AsymmetricAutoencoderKL(in_channels: int = 3, out_channels: int = 3, down_block_types: tuple = ('DownEncoderBlock2D',), down_block_out_channels: tuple = (64,), layers_per_down_block: int = 1, up_block_types: tuple = ('UpDecoderBlock2D',), up_block_out_channels: tuple = (64,), layers_per_up_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)
```

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_asym_kl.py#L24)

**Parâmetros:**

in_channels (int, *opcional*, padrão 3) : Número de canais na imagem de entrada.

out_channels (int,  *opcional*, padrão 3) : Número de canais na saída.

down_block_types (`tuple[str]`, *opcional*, padrão `("DownEncoderBlock2D",)`) : tupla de tipos de blocos de downsampling.

down_block_out_channels (`tuple[int]`, *opcional*, padrão `(64,)`) : tupla de canais de saída dos blocos de down.

layers_per_down_block (`int`, *opcional*, padrão `1`) : Número de camadas para o bloco de downsampling.

up_block_types (`tuple[str]`, *opcional*, padrão `("UpDecoderBlock2D",)`) : tupla de tipos de blocos de upsample.

up_block_out_channels (`tuple[int]`, *opcional*, padrão `(64,)`) : tupla de canais de saída dos blocos up.

layers_per_up_block (`int`, *opcional*, padrão `1`) : Número de camadas para o bloco de up.

act_fn (`str`, *opcional*, padrão `"silu"`) : A função de ativação a ser utilizada.

latent_channels (`int`, *opcional*, padrão 4) : Número de canais no espaço latente.

sample_size (`int`, *opcional*, padrão `32`) : Tamanho da entrada de amostragem.

norm_num_groups (`int`, *opcional*, padrão `32`) : Número de grupos a serem usados na primeira camada de normalização nos blocos ResNet.

scaling_factor (`float`, *opcional*, padrão 0.18215) : O desvio padrão componente a componente do espaço latente treinado, calculado usando o primeiro lote do conjunto de treinamento. Isso é usado para escalar o espaço latente para ter variância unitária ao treinar o modelo de difusão. Os latentes são escalados com a fórmula `z = z * scaling_factor` antes de serem passados para o modelo de difusão. Ao decodificar, os latentes são escalados de volta para a escala original com a fórmula: `z = 1 / scaling_factor * z`. Para mais detalhes, consulte as seções 4.3.2 e D.1 do artigo [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752).

Designing a Better Asymmetric VQGAN for StableDiffusion https://huggingface.co/papers/2306.04632 . Um modelo VAE com perda KL para codificar imagens em latentes e decodificar representações latentes em imagens.

Este modelo herda de [ModelMixin](/docs/diffusers/main/pt/api/models/overview#diffusers.ModelMixin). Consulte a documentação da superclasse para seus métodos genéricos implementados para todos os modelos (como download ou salvamento).

#### forward[[diffusers.AsymmetricAutoencoderKL.forward]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_asym_kl.py#L153)

**Parâmetros:**

sample (`torch.Tensor`) : Amostra de entrada.

mask (`torch.Tensor`, *opcional*, padrão `None`) : Máscara de inpainting opcional.

sample_posterior (`bool`, *opcional*, padrão `False`) : Se deve amostrar da posterior.

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `DecoderOutput` em vez de uma tupla simples.

generator (`torch.Generator`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a amostragem determinística.

**Retorna:** `DecoderOutput` ou `tuple`

Se `return_dict` for True, um `DecoderOutput` é retornado; caso contrário, uma `tuple` simples é retornada.

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

[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_outputs.py#L7)

**Parâmetros:**

latent_dist (`DiagonalGaussianDistribution`) : Saídas codificadas do `Encoder` representadas como a média e o logvar do `DiagonalGaussianDistribution`. O `DiagonalGaussianDistribution` permite amostrar latentes da distribuição.

Saída do método de codificação do 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)
```

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

**Parâmetros:**

sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) : A amostra de saída decodificada da última camada do modelo.

Saída do método de decodificação.