# AsymmetricAutoencoderKL

Modelo de autoencoder variacional (VAE) más grande mejorado con pérdida KL para la tarea 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.

El resumen del artículo es:

*StableDiffusion es un generador de texto a imagen revolucionario que está causando revuelo en el mundo de la generación y edición de imágenes. A diferencia de los métodos tradicionales que aprenden un modelo de difusión en el espacio de píxeles, StableDiffusion aprende un modelo de difusión en el espacio latente mediante un VQGAN, garantizando tanto la eficiencia como la calidad. No solo admite tareas de generación de imágenes, sino que también permite la edición de imágenes reales, como el relleno de imágenes (inpainting) y la edición local. Sin embargo, hemos observado que el VQGAN estándar utilizado en StableDiffusion provoca una pérdida de información significativa, lo que genera artefactos de distorsión incluso en las regiones de la imagen que no se han editado. Con este fin, proponemos un nuevo VQGAN asimétrico con dos diseños simples. En primer lugar, además de la entrada del codificador, el decodificador contiene una rama condicional que incorpora información de priorizados específicos de la tarea, como la región de imagen sin enmascarar en el relleno. En segundo lugar, el decodificador es mucho más pesado que el codificador, lo que permite una recuperación más detallada mientras solo aumenta ligeramente el costo total de inferencia. El costo de entrenamiento de nuestro VQGAN asimétrico es bajo, y solo necesitamos volver a entrenar un nuevo decodificador asimétrico manteniendo el codificador del VQGAN estándar y StableDiffusion sin cambios. Nuestro VQGAN asimétrico puede utilizarse ampliamente en métodos de relleno y edición local basados en StableDiffusion. Experimentos extensos demuestran que puede mejorar significativamente el rendimiento del relleno y la edición, al tiempo que mantiene la capacidad original de texto a imagen. El código está disponible en https://github.com/buxiangzhiren/Asymmetric_VQGAN*

Los resultados de la evaluación se pueden encontrar en la sección 4.1 del artículo original.

## Puntos de control disponibles

* [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)

## Ejemplo 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[str, ...] = ('DownEncoderBlock2D',), down_block_out_channels: tuple[int, ...] = (64,), layers_per_down_block: int = 1, up_block_types: tuple[str, ...] = ('UpDecoderBlock2D',), up_block_out_channels: tuple[int, ...] = (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)
```

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

**Parámetros:**

in_channels (int, *opcional*, valor predeterminado 3) : Número de canales en la imagen de entrada.

out_channels (int,  *opcional*, valor predeterminado 3) : Número de canales en la salida.

down_block_types (`tuple[str]`, *opcional*, por defecto `("DownEncoderBlock2D",)`) : tupla de tipos de bloques de muestreo descendente.

down_block_out_channels (`tuple[int]`, *opcional*, valor predeterminado `(64,)`) : tupla de canales de salida de los bloques de reducción.

layers_per_down_block (`int`, *opcional*, valor predeterminado `1`) : Número de capas para el bloque de reducción.

up_block_types (`tuple[str]`, *opcional*, por defecto `("UpDecoderBlock2D",)`) : tupla de tipos de bloques de remuestreo ascendente.

up_block_out_channels (`tuple[int]`, *opcional*, valor predeterminado `(64,)`) : tupla de canales de salida de los bloques up.

layers_per_up_block (`int`, *opcional*, valor predeterminado `1`) : Número de capas para el bloque de subida.

act_fn (`str`, *opcional*, por defecto `"silu"`) : La función de activación a utilizar.

latent_channels (`int`, *opcional*, valor predeterminado 4) : Número de canales en el espacio latente.

sample_size (`int`, *opcional*, valor predeterminado `32`) : Tamaño de entrada de muestra.

norm_num_groups (`int`, *opcional*, valor predeterminado `32`) : Número de grupos para usar en la primera capa de normalización en los bloques de ResNet.

scaling_factor (`float`, *opcional*, valor predeterminado 0.18215) : La desviación estándar componente a componente del espacio latente entrenado, calculada utilizando el primer lote del conjunto de entrenamiento. Esto se utiliza para escalar el espacio latente para que tenga varianza unitaria al entrenar el modelo de difusión. Los latentes se escalan con la fórmula `z = z * scaling_factor` antes de ser pasados al modelo de difusión. Al decodificar, los latentes se escalan de vuelta a la escala original con la fórmula: `z = 1 / scaling_factor * z`. Para más detalles, consulte las secciones 4.3.2 y D.1 del artículo [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752).

Diseño de un VQGAN asimétrico mejorado para StableDiffusion https://huggingface.co/papers/2306.04632 . Un modelo VAE con pérdida KL para codificar imágenes en latentes y decodificar representaciones latentes en imágenes.

Este modelo hereda de [ModelMixin](/docs/diffusers/v0.43.0/es/api/models/overview#diffusers.ModelMixin). Consulta la documentación de la superclase para sus métodos genéricos implementados para todos los modelos (como la descarga o el guardado).

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

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

**Parámetros:**

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

mask (`torch.Tensor`, *opcional*, por defecto `None`) : Máscara de inpainting opcional.

sample_posterior (`bool`, *opcional*, por defecto `False`) : Si se muestrea de la posterior.

return_dict (`bool`, *opcional*, por defecto `True`) : Si se devuelve un `DecoderOutput` en lugar de una tupla simple.

generator (`torch.Generator`, *opcional*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer que la muestreo sea determinista.

**Devuelve:** `DecoderOutput` o `tuple`

Si `return_dict` es True, se devuelve un `DecoderOutput`; en caso contrario, se devuelve una `tuple` simple.

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

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

**Parámetros:**

latent_dist (`DiagonalGaussianDistribution`) : Salidas codificadas de `Encoder` representadas como la media y el logvar de `DiagonalGaussianDistribution`. `DiagonalGaussianDistribution` permite muestrear latentes de la distribución.

Salida del método de codificación de 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)
```

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

**Parámetros:**

sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) : La muestra de salida decodificada de la última capa del modelo.

Salida del método de decodificación.