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

Décodeur de cohérence

Le décodeur de cohérence peut être utilisé pour décoder les latents issus du UNet de débruitage dans le StableDiffusionPipeline. Ce décodeur a été introduit dans le rapport technique de DALL-E 3.

Le code source original peut être trouvé sur openai/consistencydecoder.

L'inférence n'est actuellement prise en charge que pour 2 itérations.

Le pipeline n'aurait pas pu être contribué sans l'aide de madebyollin et mrsteyk de cet issue.

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

Source

Le décodeur de cohérence utilisé avec DALL-E 3.

Exemples :

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

Source

Paramètres :

z (torch.Tensor) : Le vecteur latent d'entrée.

generator (torch.Generator | None) : Le générateur de nombres aléatoires. La valeur par défaut est None.

return_dict (bool) : Indique s'il faut renvoyer la sortie sous forme de dictionnaire. La valeur par défaut est True.

num_inference_steps (int) : Le nombre d'étapes d'inférence. La valeur par défaut est 2.

Retourne : DecoderOutput | tuple[torch.Tensor]

La sortie décodée.

Décode le vecteur latent d’entrée z à l’aide du modèle VAE du décodeur de cohérence.

encode[[diffusers.ConsistencyDecoderVAE.encode]]

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

Source

Paramètres :

x (torch.Tensor) : Lot d'images en entrée.

return_dict (bool, facultatif, valeur par défaut True) : Indique s'il faut retourner un ConsistencyDecoderVAEOutput plutôt qu'un simple tuple.

Retourne :

Les représentations latentes des images encodées. Si return_dict est True, un ConsistencyDecoderVAEOutput est renvoyé, sinon un simple tuple est renvoyé.

Encode un lot d'images en latents.

forward[[diffusers.ConsistencyDecoderVAE.forward]]

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

Source

Paramètres :

sample (torch.Tensor) : Échantillon d'entrée.

sample_posterior (bool, facultatif, par défaut False) : Indique s'il faut échantillonner à partir de la distribution a posteriori.

return_dict (bool, facultatif, par défaut True) : Indique s'il faut retourner un DecoderOutput plutôt qu'un simple tuple.

generator (torch.Generator, facultatif, par défaut None) : Générateur à utiliser pour l'échantillonnage.

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

set_default_attn_processor()

Source

Désactive les processeurs d'attention personnalisés et définit l'implémentation d'attention par défaut.

tiled_encode[[diffusers.ConsistencyDecoderVAE.tiled_encode]]

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

Source

Paramètres :

x (torch.Tensor) : Lot d'images en entrée.

return_dict (bool, facultatif, valeur par défaut True) : Indique s'il faut retourner un ConsistencyDecoderVAEOutput plutôt qu'un simple tuple.

Retourne : ConsistencyDecoderVAEOutput ou tuple

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

Encoder un lot d'images à l'aide d'un encodeur tuilé.

Lorsque cette option est activée, le VAE divise le tenseur d’entrée en tuiles pour calculer l’encodage en plusieurs étapes. Cela est utile pour maintenir une utilisation de la mémoire constante, indépendamment de la taille de l’image. Le résultat final de l’encodage par tuiles diffère de celui de l’encodage non tuilé, car chaque tuile utilise un encodeur différent. Pour éviter les artefacts de tuilage, les tuiles se chevauchent et sont fusionnées pour former une sortie lisse. Vous pouvez encore observer des variations de la taille des tuiles dans la sortie, mais elles devraient être beaucoup moins perceptibles.