# AutoencoderDC

O modelo Autoencoder 2D utilizado em [SANA](https://huggingface.co/papers/2410.10629) e introduzido em [DCAE](https://huggingface.co/papers/2410.10733) pelos autores Junyu Chen\*, Han Cai\*, Junsong Chen, Enze Xie, Shang Yang, Haotian Tang, Muyang Li, Yao Lu, Song Han do MIT HAN Lab.

O resumo do artigo é:

*Apresentamos o Deep Compression Autoencoder (DC-AE), uma nova família de modelos de autoencoder para acelerar modelos de difusão de alta resolução. Modelos de autoencoder existentes demonstraram resultados impressionantes com uma razão de compressão espacial moderada (por exemplo, 8x), mas falham em manter uma precisão de reconstrução satisfatória para razões de compressão espacial altas (por exemplo, 64x). Abordamos esse desafio introduzindo duas técnicas-chave: (1) Residual Autoencoding, em que projetamos nossos modelos para aprender resíduos com base em recursos transformados de espaço para canal, a fim de aliviar a dificuldade de otimização de autoencoders de alta compressão espacial; (2) Decoupled High-Resolution Adaptation, uma estratégia de treinamento desacoplada em três fases eficiente para mitigar a penalidade de generalização de autoencoders de alta compressão espacial. Com esses designs, melhoramos a razão de compressão espacial do autoencoder até 128, mantendo a qualidade de reconstrução. Ao aplicar nosso DC-AE a modelos de difusão latente, alcançamos uma aceleração significativa sem perda de precisão. Por exemplo, no ImageNet 512x512, nosso DC-AE fornece uma aceleração de inferência de 19.1x e uma aceleração de treinamento de 17.9x na GPU H100 para o UViT-H, ao mesmo tempo em que atinge um FID melhor, em comparação com o autoencoder SD-VAE-f8 amplamente utilizado. Nosso código está disponível em [this https URL](https://github.com/mit-han-lab/efficientvit).*

Os seguintes modelos DCAE foram lançados e são suportados no Diffusers.

| Formato Diffusers | Formato original |
|:----------------:|:---------------:|
| [`mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-sana-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0)
| [`mit-han-lab/dc-ae-f32c32-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-in-1.0)
| [`mit-han-lab/dc-ae-f32c32-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f32c32-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f32c32-mix-1.0)
| [`mit-han-lab/dc-ae-f64c128-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f64c128-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-in-1.0)
| [`mit-han-lab/dc-ae-f64c128-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f64c128-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f64c128-mix-1.0)
| [`mit-han-lab/dc-ae-f128c512-in-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0-diffusers) | [`mit-han-lab/dc-ae-f128c512-in-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0)
| [`mit-han-lab/dc-ae-f128c512-mix-1.0-diffusers`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0-diffusers) | [`mit-han-lab/dc-ae-f128c512-mix-1.0`](https://huggingface.co/mit-han-lab/dc-ae-f128c512-mix-1.0)

Este modelo foi contribuído por [lawrence-cj](https://github.com/lawrence-cj).

Carregue um modelo no formato Diffusers com [from_pretrained()](/docs/diffusers/v0.43.0/pt/api/models/overview#diffusers.ModelMixin.from_pretrained).

```python
from diffusers import AutoencoderDC

ae = AutoencoderDC.from_pretrained("mit-han-lab/dc-ae-f32c32-sana-1.0-diffusers", dtype=torch.float32).to("cuda")  # or "mps", "xpu", "cpu"
```

## Carregue um modelo no Diffusers via `from_single_file`

```python
from difusers import AutoencoderDC

ckpt_path = "https://huggingface.co/mit-han-lab/dc-ae-f32c32-sana-1.0/blob/main/model.safetensors"
model = AutoencoderDC.from_single_file(ckpt_path) 

```

O modelo `AutoencoderDC` possui variantes de checkpoint em arquivo único `in` e `mix` que possuem chaves de checkpoint correspondentes, mas utilizam fatores de escala diferentes. Não é possível para o Diffusers inferir automaticamente o arquivo de configuração correto a ser usado com o modelo com base apenas no checkpoint e, por padrão, configurará o modelo usando o arquivo de configuração da variante `mix`. Para substituir a configuração determinada automaticamente, use o argumento `config` ao usar o carregamento em arquivo único com checkpoints da variante `in`.

```python
from diffusers import AutoencoderDC

ckpt_path = "https://huggingface.co/mit-han-lab/dc-ae-f128c512-in-1.0/blob/main/model.safetensors"
model = AutoencoderDC.from_single_file(ckpt_path, config="mit-han-lab/dc-ae-f128c512-in-1.0-diffusers")
```

## AutoencoderDC[[diffusers.AutoencoderDC]]

#### diffusers.AutoencoderDC[[diffusers.AutoencoderDC]]

```python
diffusers.AutoencoderDC(in_channels: int = 3, latent_channels: int = 32, attention_head_dim: int = 32, encoder_block_types: str | tuple[str] = 'ResBlock', decoder_block_types: str | tuple[str] = 'ResBlock', encoder_block_out_channels: tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), decoder_block_out_channels: tuple[int, ...] = (128, 256, 512, 512, 1024, 1024), encoder_layers_per_block: tuple[int, ...] = (2, 2, 2, 3, 3, 3), decoder_layers_per_block: tuple[int, ...] = (3, 3, 3, 3, 3, 3), encoder_qkv_multiscales: tuple[tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), decoder_qkv_multiscales: tuple[tuple[int, ...], ...] = ((), (), (), (5,), (5,), (5,)), upsample_block_type: str = 'pixel_shuffle', downsample_block_type: str = 'pixel_unshuffle', decoder_norm_types: str | tuple[str] = 'rms_norm', decoder_act_fns: str | tuple[str] = 'silu', encoder_out_shortcut: bool = True, decoder_in_shortcut: bool = True, decoder_conv_act_fn: str = 'relu', scaling_factor: float = 1.0)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_dc.py#L380)

**Parâmetros:**

in_channels (`int`, padrão `3`) : O número de canais de entrada nas amostras.

latent_channels (`int`, padrão `32`) : O número de canais na representação do espaço latente.

encoder_block_types (`str | tuple[str]`, padrão `"ResBlock"`) : O(s) tipo(s) de bloco a ser usado no codificador.

decoder_block_types (`str | tuple[str]`, padrão `"ResBlock"`) : O(s) tipo(s) de bloco a ser usado no decodificador.

encoder_block_out_channels (`tuple[int, ...]`, padrão `(128, 256, 512, 512, 1024, 1024)`) : O número de canais de saída para cada bloco no codificador.

decoder_block_out_channels (`tuple[int, ...]`, padrão `(128, 256, 512, 512, 1024, 1024)`) : O número de canais de saída para cada bloco no decodificador.

encoder_layers_per_block (`tuple[int]`, padrão `(2, 2, 2, 3, 3, 3)`) : O número de camadas por bloco no codificador.

decoder_layers_per_block (`tuple[int]`, padrão `(3, 3, 3, 3, 3, 3)`) : O número de camadas por bloco no decodificador.

encoder_qkv_multiscales (`tuple[tuple[int, ...], ...]`, padrão `((), (), (), (5,), (5,), (5,))`) : Configurações multiescala para as transformações QKV (query-key-value) do codificador.

decoder_qkv_multiscales (`tuple[tuple[int, ...], ...]`, padrão `((), (), (), (5,), (5,), (5,))`) : Configurações multiescala para as transformações QKV (query-key-value) do decodificador.

upsample_block_type (`str`, padrão `"pixel_shuffle"`) : O tipo de bloco a ser usado para o aumento de resolução no decodificador.

downsample_block_type (`str`, padrão `"pixel_unshuffle"`) : O tipo de bloco a ser usado para o downsampling no encoder.

decoder_norm_types (`str | tuple[str]`, padrão `"rms_norm"`) : O(s) tipo(s) de normalização a serem usados no decodificador.

decoder_act_fns (`str | tuple[str]`, padrão `"silu"`) : A(s) função(ões) de ativação a ser(em) usada(s) no decodificador.

encoder_out_shortcut  (`bool`, padrão `True`) : Se deve usar um atalho no final do codificador.

decoder_in_shortcut (`bool`, padrão `True`) : Se deve usar o atalho no início do decodificador.

decoder_conv_act_fn (`str`, padrão `"relu"`) : A função de ativação a ser usada no final do decodificador.

scaling_factor (`float`, padrão `1.0`) : O inverso multiplicativo da raiz quadrada da média dos quadrados das características latentes. Isso é usado para escalar o espaço latente para ter variância unitária durante o treinamento do 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 reescalados para a escala original com a fórmula: `z = 1 / scaling_factor * z`.

Um modelo Autoencoder introduzido em [DCAE](https://huggingface.co/papers/2410.10733) e utilizado em [SANA](https://huggingface.co/papers/2410.10629).

Este modelo herda de [ModelMixin](/docs/diffusers/v0.43.0/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).

#### encode[[diffusers.AutoencoderDC.encode]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_dc.py#L548)

**Parâmetros:**

x (`torch.Tensor`) : Lote de entrada de imagens.

return_dict (`bool`, padrão `True`) : Se deve retornar um `~models.vae.EncoderOutput` em vez de uma tupla simples.

**Retorna:**

As representações latentes dos vídeos codificados. Se `return_dict` for True, um `~models.vae.EncoderOutput` é retornado; caso contrário, uma `tuple` simples é retornada.

Codifica um lote de imagens em latentes.

#### decode[[diffusers.AutoencoderDC.decode]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_dc.py#L582)

**Parâmetros:**

z (`torch.Tensor`) : Lote de entrada de vetores latentes.

return_dict (`bool`, padrão `True`) : Se deve retornar um `~models.vae.DecoderOutput` em vez de uma tupla simples.

**Retorna:** `~models.vae.DecoderOutput` ou `tuple`

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

Decodifique um lote de imagens.

#### enable_tiling[[diffusers.AutoencoderDC.enable_tiling]]

```python
enable_tiling(tile_sample_min_height: int | None = None, tile_sample_min_width: int | None = None, tile_sample_stride_height: float | None = None, tile_sample_stride_width: float | None = None)
```

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_dc.py#L506)

**Parâmetros:**

tile_sample_min_height (`int`, *opcional*) : A altura mínima necessária para que uma amostra seja separada em tiles ao longo da dimensão de altura.

tile_sample_min_width (`int`, *opcional*) : A largura mínima necessária para que uma amostra seja separada em tiles ao longo da dimensão de largura.

tile_sample_stride_height (`int`, *opcional*) : A quantidade mínima de sobreposição entre duas tiles verticais consecutivas. Isso garante que não haja artefatos de tiling produzidos ao longo da dimensão de altura.

tile_sample_stride_width (`int`, *opcional*) : O deslocamento entre duas tiles horizontais consecutivas. Isso garante que não haja artefatos de tiling produzidos ao longo da dimensão de largura.

Ative a decodificação em blocos do AE. Quando essa opção está ativada, o AE divide o tensor de entrada em blocos para calcular a decodificação e a codificação em várias etapas. Isso é útil para economizar uma grande quantidade de memória e permitir o processamento de imagens maiores.

#### forward[[diffusers.AutoencoderDC.forward]]

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

[Fonte](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_dc.py#L708)

**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:** `~models.vae.DecoderOutput` ou `tuple`

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

## 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/v0.43.0/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.