Buckets:

hf-doc-build
/

doc

Files

xet

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

mishig

1 day ago

preview code

download

raw

6.83 kB

# Decodificador de Consistência

O decodificador de consistência pode ser usado para decodificar os latentes da UNet de desruidamento no [StableDiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline). Este decodificador foi introduzido no [relatório técnico do DALL-E 3](https://openai.com/dall-e-3).

O código original pode ser encontrado em [openai/consistencydecoder](https://github.com/openai/consistencydecoder).

> [!WARNING]
> No momento, a inferência é suportada apenas para 2 iterações.

O pipeline não poderia ter sido contribuído sem a ajuda de [madebyollin](https://github.com/madebyollin) e [mrsteyk](https://github.com/mrsteyk) a partir [desta issue](https://github.com/openai/consistencydecoder/issues/1).

## ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

#### diffusers.ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

```python
diffusers.ConsistencyDecoderVAE(scaling_factor: float = 0.18215, latent_channels: int = 4, sample_size: int = 32, encoder_act_fn: str = 'silu', encoder_block_out_channels: tuple[int, ...] = (128, 256, 512, 512), encoder_double_z: bool = True, encoder_down_block_types: tuple[str, ...] = ('DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'), encoder_in_channels: int = 3, encoder_layers_per_block: int = 2, encoder_norm_num_groups: int = 32, encoder_out_channels: int = 4, decoder_add_attention: bool = False, decoder_block_out_channels: tuple[int, ...] = (320, 640, 1024, 1024), decoder_down_block_types: tuple[str, ...] = ('ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D'), decoder_downsample_padding: int = 1, decoder_in_channels: int = 7, decoder_layers_per_block: int = 3, decoder_norm_eps: float = 1e-05, decoder_norm_num_groups: int = 32, decoder_num_train_timesteps: int = 1024, decoder_out_channels: int = 6, decoder_resnet_time_scale_shift: str = 'scale_shift', decoder_time_embedding_type: str = 'learned', decoder_up_block_types: tuple[str, ...] = ('ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D'))
```

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

O decodificador de consistência usado com o DALL-E 3.

Exemplos:
```py
>>> import torch
>>> from diffusers import StableDiffusionPipeline, ConsistencyDecoderVAE
>>> vae = ConsistencyDecoderVAE.from_pretrained("openai/consistency-decoder", torch_dtype=torch.float16)
>>> pipe = StableDiffusionPipeline.from_pretrained(
...     "stable-diffusion-v1-5/stable-diffusion-v1-5", vae=vae, torch_dtype=torch.float16
... ).to("cuda")
>>> image = pipe("horse", generator=torch.manual_seed(0)).images[0]
>>> image
```

#### decode[[diffusers.ConsistencyDecoderVAE.decode]]

```python
decode(z: Tensor, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True, num_inference_steps: int = 2)
```

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

**Parâmetros:**

z (torch.Tensor) : O vetor latente de entrada.

generator (torch.Generator | None) : O gerador de números aleatórios. O padrão é None.

return_dict (bool) : Se deve retornar a saída como um dicionário. O padrão é True.
num_inference_steps (int) : O número de etapas de inferência. O padrão é 2.
**Retorna:** DecoderOutput | tuple[torch.Tensor]
A saída decodificada.
Decodifica o vetor latente de entrada `z` usando o modelo VAE do decodificador de consistência.
#### encode[[diffusers.ConsistencyDecoderVAE.encode]]
```python
encode(x: Tensor, return_dict: bool = True)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L185)
**Parâmetros:**
x (`torch.Tensor`) : Lote de entrada de imagens.
return_dict (`bool`, *opcional*, padrão `True`) : Se deve retornar um `ConsistencyDecoderVAEOutput` em vez de uma tupla simples.
**Retorna:**
As representações latentes das imagens codificadas. Se `return_dict` for True, um `ConsistencyDecoderVAEOutput` é retornado; caso contrário, uma `tuple` simples é retornada.
Codifica um lote de imagens em latentes.
#### forward[[diffusers.ConsistencyDecoderVAE.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/consistency_decoder_vae.py#L336)
**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*, padrão `None`) : Gerador a ser usado para amostragem.
**Retorna:** `DecoderOutput` ou `tuple`
If return_dict is True, a `DecoderOutput` is returned, otherwise a plain `tuple` is returned.
#### set_default_attn_processor[[diffusers.ConsistencyDecoderVAE.set_default_attn_processor]]
```python
set_default_attn_processor()
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L170)
Desativa os processadores de atenção personalizados e define a implementação padrão de atenção.
#### tiled_encode[[diffusers.ConsistencyDecoderVAE.tiled_encode]]
```python
tiled_encode(x: Tensor, return_dict: bool = True)
```
[Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L281)
**Parâmetros:**
x (`torch.Tensor`) : Lote de entrada de imagens.
return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `ConsistencyDecoderVAEOutput` em vez de uma tupla simples.

**Retorna:** `ConsistencyDecoderVAEOutput` ou `tuple`

If return_dict is True, a `ConsistencyDecoderVAEOutput` is returned, otherwise a plain `tuple` is returned.
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.

Xet Storage Details

Size:: 6.83 kB
Xet hash:: b18b2004b6059e17f77d2fe7080bd845b398dacc98779b79b558cc4de241e23b

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

	# Decodificador de Consistência

	O decodificador de consistência pode ser usado para decodificar os latentes da UNet de desruidamento no [StableDiffusionPipeline](/docs/diffusers/main/pt/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline). Este decodificador foi introduzido no [relatório técnico do DALL-E 3](https://openai.com/dall-e-3).

	O código original pode ser encontrado em [openai/consistencydecoder](https://github.com/openai/consistencydecoder).

	> [!WARNING]
	> No momento, a inferência é suportada apenas para 2 iterações.

	O pipeline não poderia ter sido contribuído sem a ajuda de [madebyollin](https://github.com/madebyollin) e [mrsteyk](https://github.com/mrsteyk) a partir [desta issue](https://github.com/openai/consistencydecoder/issues/1).

	## ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

	#### diffusers.ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

	```python
	diffusers.ConsistencyDecoderVAE(scaling_factor: float = 0.18215, latent_channels: int = 4, sample_size: int = 32, encoder_act_fn: str = 'silu', encoder_block_out_channels: tuple[int, ...] = (128, 256, 512, 512), encoder_double_z: bool = True, encoder_down_block_types: tuple[str, ...] = ('DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D', 'DownEncoderBlock2D'), encoder_in_channels: int = 3, encoder_layers_per_block: int = 2, encoder_norm_num_groups: int = 32, encoder_out_channels: int = 4, decoder_add_attention: bool = False, decoder_block_out_channels: tuple[int, ...] = (320, 640, 1024, 1024), decoder_down_block_types: tuple[str, ...] = ('ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D', 'ResnetDownsampleBlock2D'), decoder_downsample_padding: int = 1, decoder_in_channels: int = 7, decoder_layers_per_block: int = 3, decoder_norm_eps: float = 1e-05, decoder_norm_num_groups: int = 32, decoder_num_train_timesteps: int = 1024, decoder_out_channels: int = 6, decoder_resnet_time_scale_shift: str = 'scale_shift', decoder_time_embedding_type: str = 'learned', decoder_up_block_types: tuple[str, ...] = ('ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D', 'ResnetUpsampleBlock2D'))
	```

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

	O decodificador de consistência usado com o DALL-E 3.

	Exemplos:
	```py
	>>> import torch
	>>> from diffusers import StableDiffusionPipeline, ConsistencyDecoderVAE

	>>> vae = ConsistencyDecoderVAE.from_pretrained("openai/consistency-decoder", torch_dtype=torch.float16)
	>>> pipe = StableDiffusionPipeline.from_pretrained(
	... "stable-diffusion-v1-5/stable-diffusion-v1-5", vae=vae, torch_dtype=torch.float16
	... ).to("cuda")

	>>> image = pipe("horse", generator=torch.manual_seed(0)).images[0]
	>>> image
	```

	#### decode[[diffusers.ConsistencyDecoderVAE.decode]]

	```python
	decode(z: Tensor, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True, num_inference_steps: int = 2)
	```

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

	Parâmetros:

	z (torch.Tensor) : O vetor latente de entrada.

	generator (torch.Generator \| None) : O gerador de números aleatórios. O padrão é None.

	return_dict (bool) : Se deve retornar a saída como um dicionário. O padrão é True.

	num_inference_steps (int) : O número de etapas de inferência. O padrão é 2.

	Retorna: DecoderOutput \| tuple[torch.Tensor]

	A saída decodificada.

	Decodifica o vetor latente de entrada `z` usando o modelo VAE do decodificador de consistência.

	#### encode[[diffusers.ConsistencyDecoderVAE.encode]]

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

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

	Parâmetros:

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

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

	Retorna:

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

	Codifica um lote de imagens em latentes.

	#### forward[[diffusers.ConsistencyDecoderVAE.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/consistency_decoder_vae.py#L336)

	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, padrão `None`) : Gerador a ser usado para amostragem.

	Retorna: `DecoderOutput` ou `tuple`

	If return_dict is True, a `DecoderOutput` is returned, otherwise a plain `tuple` is returned.

	#### set_default_attn_processor[[diffusers.ConsistencyDecoderVAE.set_default_attn_processor]]

	```python
	set_default_attn_processor()
	```

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

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

	#### tiled_encode[[diffusers.ConsistencyDecoderVAE.tiled_encode]]

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

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

	Parâmetros:

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

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

	Retorna: `ConsistencyDecoderVAEOutput` ou `tuple`

	If return_dict is True, a `ConsistencyDecoderVAEOutput` is returned, otherwise a plain `tuple` is returned.

	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.