diffusers/main/es/api/models/consistency_decoder_vae.md

Decodificador de consistencia

El decodificador de consistencia se puede utilizar para decodificar los latentes de la UNet de desruido en el StableDiffusionPipeline. Este decodificador se introdujo en el informe técnico de DALL-E 3.

El código original se puede encontrar en openai/consistencydecoder.

Por ahora, la inferencia solo se admite para 2 iteraciones.

El pipeline no habría podido ser contribuido sin la ayuda de madebyollin y mrsteyk de este problema.

ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

diffusers.ConsistencyDecoderVAE[[diffusers.ConsistencyDecoderVAE]]

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

El decodificador de consistencia utilizado con DALL-E 3.

Ejemplos:

>>> 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]]

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

Fuente

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]]

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

Fuente

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]]

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

Fuente

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]]

set_default_attn_processor()

Fuente

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

tiled_encode[[diffusers.ConsistencyDecoderVAE.tiled_encode]]

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

Fuente

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.