# Tiny AutoEncoder

O Tiny AutoEncoder for Stable Diffusion (TAESD) foi introduzido em [madebyollin/taesd](https://github.com/madebyollin/taesd) por Ollin Boer Bohan. Trata-se de uma versão pequena e destilada do VAE do Stable Diffusion que consegue decodificar rapidamente os latentes em um [StableDiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) ou [StableDiffusionXLPipeline](/docs/diffusers/main/pt/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline) quase instantaneamente.

Para usar com Stable Diffusion v-2.1:

```python
import torch
from diffusers import DiffusionPipeline, AutoencoderTiny

pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-2-1-base", dtype=torch.float16
)
pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd", dtype=torch.float16)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "slice of delicious New York-style berry cheesecake"
image = pipe(prompt, num_inference_steps=25).images[0]
image
```

Para usar com Stable Diffusion XL 1.0

```python
import torch
from diffusers import DiffusionPipeline, AutoencoderTiny

pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16
)
pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesdxl", dtype=torch.float16)
pipe = pipe.to("cuda")  # or "mps", "xpu", "cpu"

prompt = "slice of delicious New York-style berry cheesecake"
image = pipe(prompt, num_inference_steps=25).images[0]
image
```

## AutoencoderTiny[[diffusers.AutoencoderTiny]]

#### diffusers.AutoencoderTiny[[diffusers.AutoencoderTiny]]

```python
diffusers.AutoencoderTiny(in_channels: int = 3, out_channels: int = 3, encoder_block_out_channels: tuple = (64, 64, 64, 64), decoder_block_out_channels: tuple = (64, 64, 64, 64), act_fn: str = 'relu', upsample_fn: str = 'nearest', latent_channels: int = 4, upsampling_scaling_factor: int = 2, num_encoder_blocks: tuple = (1, 3, 3, 3), num_decoder_blocks: tuple = (3, 3, 3, 1), latent_magnitude: int = 3, latent_shift: float = 0.5, force_upcast: bool = False, scaling_factor: float = 1.0, shift_factor: float = 0.0)
```

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

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

encoder_block_out_channels (`tuple[int]`, *opcional*, padrão `(64, 64, 64, 64)`) : tupla de inteiros representando o número de canais de saída para cada bloco do codificador. O comprimento da tupla deve ser igual ao número de blocos do codificador.

decoder_block_out_channels (`tuple[int]`, *opcional*, padrão `(64, 64, 64, 64)`) : tupla de inteiros representando o número de canais de saída para cada bloco do decodificador. O comprimento da tupla deve ser igual ao número de blocos do decodificador.

act_fn (`str`, *opcional*, padrão `"relu"`) : Função de ativação a ser usada em todo o modelo.

latent_channels (`int`, *opcional*, padrão 4) : Número de canais na representação latente. O espaço latente atua como uma representação comprimida da imagem de entrada.

upsampling_scaling_factor (`int`, *opcional*, padrão 2) : Fator de escala para o upsampling no decodificador. Ele determina o tamanho da imagem de saída durante o processo de upsampling.

num_encoder_blocks (`tuple[int]`, *opcional*, padrão `(1, 3, 3, 3)`) : tupla de inteiros representando o número de blocos de codificador em cada etapa do processo de codificação. O comprimento da tupla deve ser igual ao número de etapas no codificador. Cada etapa possui um número diferente de blocos de codificador.

num_decoder_blocks (`tuple[int]`, *opcional*, padrão `(3, 3, 3, 1)`) : tupla de inteiros representando o número de blocos do decodificador em cada etapa do processo de decodificação. O comprimento da tupla deve ser igual ao número de etapas no decodificador. Cada etapa possui um número diferente de blocos do decodificador.

latent_magnitude (`float`, *opcional*, padrão 3.0) : Magnitude da representação latente. Este parâmetro escala os valores da representação latente para controlar o grau de preservação de informações.

latent_shift (float, *opcional*, padrão 0.5) : Deslocamento aplicado à representação latente. Este parâmetro controla o centro do espaço latente.

scaling_factor (`float`, *opcional*, padrão 1.0) : 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). Para este Autoencoder, no entanto, nenhum fator de escala foi usado, portanto, o valor de 1.0 como padrão.

force_upcast (`bool`, *opcional*, padrão `False`) : Se habilitado, forçará o VAE a executar em float32 para pipelines de alta resolução de imagem, como o SD-XL. O VAE pode ser ajustado / treinado para uma faixa menor sem perder muita precisão, caso em que `force_upcast` pode ser definido como `False` (veja este [AutoEncoder](https://huggingface.co/madebyollin/sdxl-vae-fp16-fix) compatível com fp16).

Um pequeno modelo de VAE destilado para codificar imagens em latentes e decodificar representações latentes em imagens.

[AutoencoderTiny](/docs/diffusers/main/pt/api/models/autoencoder_tiny#diffusers.AutoencoderTiny) é um wrapper em torno da implementação original de `TAESD`.

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.AutoencoderTiny.forward]]

```python
forward(sample: Tensor, return_dict: bool = True)
```

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

**Parâmetros:**

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

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

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

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

#### scale_latents[[diffusers.AutoencoderTiny.scale_latents]]

```python
scale_latents(x: Tensor)
```

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

latentes brutos -> [0, 1]

#### unscale_latents[[diffusers.AutoencoderTiny.unscale_latents]]

```python
unscale_latents(x: Tensor)
```

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

[0, 1] -> latentes brutos

## AutoencoderTinyOutput[[diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput]]

#### diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput[[diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput]]

```python
diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput(latents: Tensor)
```

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

**Parâmetros:**

latents (`torch.Tensor`) : Saídas codificadas do `Encoder`.

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