Buckets:

hf-doc-build
/

doc

Files

xet

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

mishig

1 day ago

preview code

download

raw

6.97 kB

# Decodificador de consistencia

El decodificador de consistencia se puede utilizar para decodificar los latentes de la UNet de desruido en el [StableDiffusionPipeline](/docs/diffusers/main/es/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline). Este decodificador se introdujo en el [informe técnico de DALL-E 3](https://openai.com/dall-e-3).

El código original se puede encontrar en [openai/consistencydecoder](https://github.com/openai/consistencydecoder).

> [!WARNING]
> Por ahora, la inferencia solo se admite para 2 iteraciones.

El pipeline no habría podido ser contribuido sin la ayuda de [madebyollin](https://github.com/madebyollin) y [mrsteyk](https://github.com/mrsteyk) de [este problema](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'))
```

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

El decodificador de consistencia utilizado con DALL-E 3.

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

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

**Parámetros:**

z (torch.Tensor) : El vector latente de entrada.

generator (torch.Generator | None) : El generador de números aleatorios. El valor predeterminado es None.

return_dict (bool) : Si se debe devolver la salida como un diccionario. El valor predeterminado es True.
num_inference_steps (int) : El número de pasos de inferencia. El valor predeterminado es 2.
**Devuelve:** DecoderOutput | tuple[torch.Tensor]
La salida decodificada.
Decodifica el vector latente de entrada `z` utilizando el modelo VAE decodificador de consistencia.
#### encode[[diffusers.ConsistencyDecoderVAE.encode]]
```python
encode(x: Tensor, return_dict: bool = True)
```
[Fuente](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 imágenes.
return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un `ConsistencyDecoderVAEOutput` en lugar de una tupla simple.
**Devuelve:**
Las representaciones latentes de las imágenes codificadas. Si `return_dict` es True, se devuelve un `ConsistencyDecoderVAEOutput`; de lo contrario, se devuelve una `tuple` simple.
Codifica un lote de imágenes en latentes.
#### forward[[diffusers.ConsistencyDecoderVAE.forward]]
```python
forward(sample: Tensor, sample_posterior: bool = False, return_dict: bool = True, generator: typing.Optional[torch.Generator] = None)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L336)
**Parámetros:**
sample (`torch.Tensor`) : Muestra de entrada.
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*, valor predeterminado `None`) : Generador a utilizar para el muestreo.
**Devuelve:** `DecoderOutput` o `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()
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/consistency_decoder_vae.py#L170)
Desactiva los procesadores de atención personalizados y establece la implementación de atención predeterminada.
#### tiled_encode[[diffusers.ConsistencyDecoderVAE.tiled_encode]]
```python
tiled_encode(x: Tensor, return_dict: bool = True)
```
[Fuente](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 imágenes.
return_dict (`bool`, *opcional*, por defecto `True`) : Indica si se debe devolver una `ConsistencyDecoderVAEOutput` en lugar de una tupla simple.

**Devuelve:** `ConsistencyDecoderVAEOutput` o `tuple`

If return_dict is True, a `ConsistencyDecoderVAEOutput` is returned, otherwise a plain `tuple` is returned.
Codifica un lote de imágenes usando un codificador por mosaicos.
Cuando esta opción está habilitada, el VAE dividirá el tensor de entrada en mosaicos para calcular la codificación en varios pasos. Esto es útil para mantener el uso de memoria constante independientemente del tamaño de la imagen. El resultado final de la codificación por mosaicos es diferente al de la codificación sin mosaicos, ya que cada mosaico utiliza un codificador diferente. Para evitar artefactos de mosaico, los mosaicos se superponen y se fusionan para formar una salida suave. Aún puede ver cambios del tamaño de un mosaico en la salida, pero deberían ser mucho menos notorios.

Xet Storage Details

Size:: 6.97 kB
Xet hash:: 84134f2b2dfb756699776299fd78c86ead990b7ab9e93011bb5611afbe9554ba

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

	# Decodificador de consistencia

	El decodificador de consistencia se puede utilizar para decodificar los latentes de la UNet de desruido en el [StableDiffusionPipeline](/docs/diffusers/main/es/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline). Este decodificador se introdujo en el [informe técnico de DALL-E 3](https://openai.com/dall-e-3).

	El código original se puede encontrar en [openai/consistencydecoder](https://github.com/openai/consistencydecoder).

	> [!WARNING]
	> Por ahora, la inferencia solo se admite para 2 iteraciones.

	El pipeline no habría podido ser contribuido sin la ayuda de [madebyollin](https://github.com/madebyollin) y [mrsteyk](https://github.com/mrsteyk) de [este problema](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'))
	```

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

	El decodificador de consistencia utilizado con DALL-E 3.

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

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

	Parámetros:

	z (torch.Tensor) : El vector latente de entrada.

	generator (torch.Generator \| None) : El generador de números aleatorios. El valor predeterminado es None.

	return_dict (bool) : Si se debe devolver la salida como un diccionario. El valor predeterminado es True.

	num_inference_steps (int) : El número de pasos de inferencia. El valor predeterminado es 2.

	Devuelve: DecoderOutput \| tuple[torch.Tensor]

	La salida decodificada.

	Decodifica el vector latente de entrada `z` utilizando el modelo VAE decodificador de consistencia.

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

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

	[Fuente](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 imágenes.

	return_dict (`bool`, opcional, valor predeterminado `True`) : Si se debe devolver un `ConsistencyDecoderVAEOutput` en lugar de una tupla simple.

	Devuelve:

	Las representaciones latentes de las imágenes codificadas. Si `return_dict` es True, se devuelve un `ConsistencyDecoderVAEOutput`; de lo contrario, se devuelve una `tuple` simple.

	Codifica un lote de imágenes en latentes.

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

	```python
	forward(sample: Tensor, sample_posterior: bool = False, return_dict: bool = True, generator: typing.Optional[torch.Generator] = None)
	```

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

	Parámetros:

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

	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, valor predeterminado `None`) : Generador a utilizar para el muestreo.

	Devuelve: `DecoderOutput` o `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()
	```

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

	Desactiva los procesadores de atención personalizados y establece la implementación de atención predeterminada.

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

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

	[Fuente](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 imágenes.

	return_dict (`bool`, opcional, por defecto `True`) : Indica si se debe devolver una `ConsistencyDecoderVAEOutput` en lugar de una tupla simple.

	Devuelve: `ConsistencyDecoderVAEOutput` o `tuple`

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

	Codifica un lote de imágenes usando un codificador por mosaicos.

	Cuando esta opción está habilitada, el VAE dividirá el tensor de entrada en mosaicos para calcular la codificación en varios pasos. Esto es útil para mantener el uso de memoria constante independientemente del tamaño de la imagen. El resultado final de la codificación por mosaicos es diferente al de la codificación sin mosaicos, ya que cada mosaico utiliza un codificador diferente. Para evitar artefactos de mosaico, los mosaicos se superponen y se fusionan para formar una salida suave. Aún puede ver cambios del tamaño de un mosaico en la salida, pero deberían ser mucho menos notorios.