Buckets:

hf-doc-build
/

doc

Files

xet

hf-doc-build/doc / diffusers /main /pt /api /models /autoencoderkl.md

mishig

about 3 hours ago

preview code

download

raw

12.2 kB

# AutoencoderKL

O modelo de autoencoder variacional (VAE) com perda KL foi introduzido em [Auto-Encoding Variational Bayes](https://huggingface.co/papers/1312.6114) por Diederik P. Kingma e Max Welling. O modelo é usado no 🤗 Diffusers para codificar imagens em latentes e para decodificar representações latentes em imagens.

O resumo do artigo é:

*Como podemos realizar inferência e aprendizado eficientes em modelos probabilísticos direcionados, na presença de variáveis latentes contínuas com distribuições posteriores intratáveis e grandes conjuntos de dados? Introduzimos um algoritmo de inferência e aprendizado variacional estocástico que escala para grandes conjuntos de dados e, sob algumas condições de diferenciabilidade suaves, funciona até mesmo no caso intratável. Nossas contribuições são duplas. Primeiro, mostramos que uma reparametrização do limite inferior variacional produz um estimador de limite inferior que pode ser otimizado de forma direta usando métodos padrão de gradiente estocástico. Segundo, mostramos que para conjuntos de dados i.i.d. com variáveis latentes contínuas por ponto de dados, a inferência posterior pode ser feita especialmente eficiente ao ajustar um modelo de inferência aproximado (também chamado de modelo de reconhecimento) à posterior intratável usando o estimador de limite inferior proposto. As vantagens teóricas são refletidas nos resultados experimentais.*

## Carregando do formato original

Por padrão, o [AutoencoderKL](/docs/diffusers/main/pt/api/models/autoencoderkl#diffusers.AutoencoderKL) deve ser carregado com [from_pretrained()](/docs/diffusers/main/pt/api/models/overview#diffusers.ModelMixin.from_pretrained), mas também pode ser carregado do formato original usando `FromOriginalModelMixin.from_single_file` da seguinte forma:

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

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

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

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

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

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

force_upcast (`bool`, *opcional*, padrão `True`) : 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: https://huggingface.co/madebyollin/sdxl-vae-fp16-fix

mid_block_add_attention (`bool`, *opcional*, padrão `True`) : Se habilitado, o mid_block do Encoder e do Decoder terá blocos de atenção. Se definido como false, o mid_block terá apenas blocos resnet
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).
#### decode[[diffusers.AutoencoderKL.decode]]
```python
decode(z: FloatTensor, return_dict: bool = True, generator = None)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L213)
**Parâmetros:**
z (`torch.Tensor`) : Lote de entrada de vetores latentes.
return_dict (`bool`, *opcional*, 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.
#### encode[[diffusers.AutoencoderKL.encode]]
```python
encode(x: Tensor, return_dict: bool = True)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L170)
**Parâmetros:**
x (`torch.Tensor`) : Lote de entrada de imagens.
return_dict (`bool`, *opcional*, padrão `True`) : Se deve retornar um `~models.autoencoder_kl.AutoencoderKLOutput` em vez de uma tupla simples.

**Retorna:**

As representações latentes das imagens codificadas. Se `return_dict` for True, um `~models.autoencoder_kl.AutoencoderKLOutput` é retornado; caso contrário, uma `tuple` simples é retornada.

Codifica um lote de imagens em latentes.

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

```python
forward(sample: Tensor, 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_kl.py#L413)

**Parâmetros:**

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

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

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

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

```python
fuse_qkv_projections()
```

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

Ativa as projeções QKV fundidas. Para os módulos de autoatenção, todas as matrizes de projeção (ou seja, query, key, value) são fundidas. Para os módulos de atenção cruzada, as matrizes de projeção de key e value são fundidas.

> [!WARNING] > Esta API é 🧪 experimental.

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

```python
set_default_attn_processor()
```

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

Desativa os processadores de atenção personalizados e define a implementação padrão de atenção.

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

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

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

**Parâmetros:**

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

return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não 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 usando um decodificador em mosaico.

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

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

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

**Parâmetros:**

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

return_dict (`bool`, *opcional*, padrão `True`) : Indica se deve retornar um `~models.autoencoder_kl.AutoencoderKLOutput` em vez de uma tupla simples.

**Retorna:** `~models.autoencoder_kl.AutoencoderKLOutput` ou `tuple`

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

Codifique um lote de imagens usando um codificador em mosaico.

Quando esta opção está habilitada, o VAE divide o tensor de entrada em blocos para calcular a codificação em várias etapas. Isso é útil para manter o uso de memória constante, independentemente do tamanho da imagem. O resultado final da codificação em blocos é diferente da codificação sem blocos, pois cada bloco utiliza um codificador diferente. Para evitar artefatos de blocos, os blocos se sobrepõem e são mesclados para formar uma saída suave. Você ainda pode observar variações do tamanho do bloco na saída, mas elas devem ser muito menos perceptíveis.

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

```python
unfuse_qkv_projections()
```

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

Desativa a projeção QKV fundida, se estiver habilitada.

> [!WARNING] > Esta API é 🧪 experimental.

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

Xet Storage Details

Size:: 12.2 kB
Xet hash:: bfe6150183032a2dedda654c1b66e3c47509877158ec8467916cc771ea77a410

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.

	# AutoencoderKL

	O modelo de autoencoder variacional (VAE) com perda KL foi introduzido em [Auto-Encoding Variational Bayes](https://huggingface.co/papers/1312.6114) por Diederik P. Kingma e Max Welling. O modelo é usado no 🤗 Diffusers para codificar imagens em latentes e para decodificar representações latentes em imagens.

	O resumo do artigo é:

	Como podemos realizar inferência e aprendizado eficientes em modelos probabilísticos direcionados, na presença de variáveis latentes contínuas com distribuições posteriores intratáveis e grandes conjuntos de dados? Introduzimos um algoritmo de inferência e aprendizado variacional estocástico que escala para grandes conjuntos de dados e, sob algumas condições de diferenciabilidade suaves, funciona até mesmo no caso intratável. Nossas contribuições são duplas. Primeiro, mostramos que uma reparametrização do limite inferior variacional produz um estimador de limite inferior que pode ser otimizado de forma direta usando métodos padrão de gradiente estocástico. Segundo, mostramos que para conjuntos de dados i.i.d. com variáveis latentes contínuas por ponto de dados, a inferência posterior pode ser feita especialmente eficiente ao ajustar um modelo de inferência aproximado (também chamado de modelo de reconhecimento) à posterior intratável usando o estimador de limite inferior proposto. As vantagens teóricas são refletidas nos resultados experimentais.

	## Carregando do formato original

	Por padrão, o [AutoencoderKL](/docs/diffusers/main/pt/api/models/autoencoderkl#diffusers.AutoencoderKL) deve ser carregado com [from_pretrained()](/docs/diffusers/main/pt/api/models/overview#diffusers.ModelMixin.from_pretrained), mas também pode ser carregado do formato original usando `FromOriginalModelMixin.from_single_file` da seguinte forma:

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

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

	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.

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

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

	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.

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

	force_upcast (`bool`, opcional, padrão `True`) : 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: https://huggingface.co/madebyollin/sdxl-vae-fp16-fix

	mid_block_add_attention (`bool`, opcional, padrão `True`) : Se habilitado, o mid_block do Encoder e do Decoder terá blocos de atenção. Se definido como false, o mid_block terá apenas blocos resnet

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

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

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

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

	Parâmetros:

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

	return_dict (`bool`, opcional, 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.

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

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

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

	Parâmetros:

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

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

	Retorna:

	As representações latentes das imagens codificadas. Se `return_dict` for True, um `~models.autoencoder_kl.AutoencoderKLOutput` é retornado; caso contrário, uma `tuple` simples é retornada.

	Codifica um lote de imagens em latentes.

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

	```python
	forward(sample: Tensor, 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_kl.py#L413)

	Parâmetros:

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

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

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

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

	```python
	fuse_qkv_projections()
	```

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

	Ativa as projeções QKV fundidas. Para os módulos de autoatenção, todas as matrizes de projeção (ou seja, query, key, value) são fundidas. Para os módulos de atenção cruzada, as matrizes de projeção de key e value são fundidas.

	> [!WARNING] > Esta API é 🧪 experimental.

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

	```python
	set_default_attn_processor()
	```

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

	Desativa os processadores de atenção personalizados e define a implementação padrão de atenção.

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

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

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

	Parâmetros:

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

	return_dict (`bool`, opcional, padrão `True`) : Se deve ou não 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 usando um decodificador em mosaico.

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

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

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

	Parâmetros:

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

	return_dict (`bool`, opcional, padrão `True`) : Indica se deve retornar um `~models.autoencoder_kl.AutoencoderKLOutput` em vez de uma tupla simples.

	Retorna: `~models.autoencoder_kl.AutoencoderKLOutput` ou `tuple`

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

	Codifique um lote de imagens usando um codificador em mosaico.

	Quando esta opção está habilitada, o VAE divide o tensor de entrada em blocos para calcular a codificação em várias etapas. Isso é útil para manter o uso de memória constante, independentemente do tamanho da imagem. O resultado final da codificação em blocos é diferente da codificação sem blocos, pois cada bloco utiliza um codificador diferente. Para evitar artefatos de blocos, os blocos se sobrepõem e são mesclados para formar uma saída suave. Você ainda pode observar variações do tamanho do bloco na saída, mas elas devem ser muito menos perceptíveis.

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

	```python
	unfuse_qkv_projections()
	```

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

	Desativa a projeção QKV fundida, se estiver habilitada.

	> [!WARNING] > Esta API é 🧪 experimental.

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