diffusers/v0.43.0/fr/api/models/autoencoderkl.md

AutoencoderKL

Le modèle d'auto-encodeur variationnel (VAE) avec perte KL a été introduit dans Auto-Encoding Variational Bayes par Diederik P. Kingma et Max Welling. Le modèle est utilisé dans 🤗 Diffusers pour encoder des images en latents et pour décoder des représentations latentes en images.

L'abstract de l'article est :

Comment effectuer une inférence et un apprentissage efficaces dans les modèles probabilistes dirigés, en présence de variables latentes continues aux distributions a posteriori intraitables, et de grands jeux de données ? Nous introduisons un algorithme d’inférence et d’apprentissage variationnels stochastiques qui s’adapte aux grands jeux de données et qui, sous certaines conditions de différentiabilité modérées, fonctionne même dans le cas intraitable. Nos contributions sont doubles. Premièrement, nous montrons qu’une reparamétrisation de la borne inférieure variationnelle produit un estimateur de borne inférieure qui peut être optimisé de manière simple à l’aide de méthodes standard de gradient stochastique. Deuxièmement, nous montrons que, pour des jeux de données i.i.d. avec des variables latentes continues par point de données, l’inférence a posteriori peut être rendue particulièrement efficace en ajustant un modèle d’inférence approximatif (également appelé modèle de reconnaissance) à la distribution a posteriori intraitable à l’aide de l’estimateur de borne inférieure proposé. Les avantages théoriques sont reflétés dans les résultats expérimentaux.

Chargement depuis le format d'origine

Par défaut, le AutoencoderKL doit être chargé avec from_pretrained(), mais il peut également être chargé depuis le format d’origine à l’aide de FromOriginalModelMixin.from_single_file comme suit :

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

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)

Source

Paramètres :

in_channels (int, facultatif, valeur par défaut 3) : Nombre de canaux de l'image d'entrée.

out_channels (int, facultatif, valeur par défaut 3) : Nombre de canaux dans la sortie.

down_block_types (tuple[str], facultatif, par défaut ("DownEncoderBlock2D",)) : tuple des types de blocs de downsampling.

up_block_types (tuple[str], facultatif, par défaut ("UpDecoderBlock2D",)) : tuple des types de blocs de suréchantillonnage.

block_out_channels (tuple[int], facultatif, par défaut (64,)) : tuple des canaux de sortie des blocs.

act_fn (str, facultatif, par défaut "silu") : La fonction d'activation à utiliser.

latent_channels (int, facultatif, par défaut 4) : Nombre de canaux dans l'espace latent.

sample_size (int, facultatif, par défaut 32) : Taille d'entrée d'échantillonnage.

scaling_factor (float, facultatif, valeur par défaut 0.18215) : L'écart-type par composante de l'espace latent entraîné, calculé à l'aide du premier lot du jeu de données d'entraînement. Il est utilisé pour mettre à l'échelle l'espace latent afin qu'il ait une variance unitaire lors de l'entraînement du modèle de diffusion. Les latents sont mis à l'échelle avec la formule z = z * scaling_factor avant d'être transmis au modèle de diffusion. Lors du décodage, les latents sont remis à l'échelle d'origine avec la formule : z = 1 / scaling_factor * z. Pour plus de détails, consultez les sections 4.3.2 et D.1 de l'article High-Resolution Image Synthesis with Latent Diffusion Models.

force_upcast (bool, facultatif, par défaut True) : Si activé, force le VAE à s'exécuter en float32 pour les pipelines à haute résolution d'image, tels que SD-XL. Le VAE peut être affiné / entraîné sur une plage inférieure sans perdre trop de précision, auquel cas force_upcast peut être défini sur False - voir : https://huggingface.co/madebyollin/sdxl-vae-fp16-fix

mid_block_add_attention (bool, facultatif, par défaut True) : Si activé, le mid_block de l'Encoder et du Decoder contiendra des blocs d'attention. Si défini sur false, le mid_block ne contiendra que des blocs resnet

Un modèle VAE avec perte KL pour encoder des images en latents et décoder des représentations latentes en images.

Ce modèle hérite de ModelMixin. Consultez la documentation de la classe parente pour ses méthodes génériques implémentées pour tous les modèles (tels que le téléchargement ou l'enregistrement).

decode[[diffusers.AutoencoderKL.decode]]

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

Source

Paramètres :

z (torch.Tensor) : Lot d'entrée de vecteurs latents.

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

Retourne : ~models.vae.DecoderOutput ou tuple

Si return_dict est True, un ~models.vae.DecoderOutput est renvoyé, sinon un simple tuple est renvoyé.

Décoder un lot d'images.

encode[[diffusers.AutoencoderKL.encode]]

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

Source

Paramètres :

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

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

Retourne :

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

Encode un lot d'images en latents.

forward[[diffusers.AutoencoderKL.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) : Un torch.Generator pour rendre l'échantillonnage déterministe.

Retourne : ~models.vae.DecoderOutput ou tuple

Si return_dict est True, un ~models.vae.DecoderOutput est renvoyé, sinon un simple tuple est renvoyé.

fuse_qkv_projections[[diffusers.AutoencoderKL.fuse_qkv_projections]]

fuse_qkv_projections()

Source

Active les projections QKV fusionnées. Pour les modules d'auto-attention, toutes les matrices de projection (c'est-à-dire requête, clé, valeur) sont fusionnées. Pour les modules d'attention croisée, les matrices de projection des clés et des valeurs sont fusionnées.

> Cette API est 🧪 expérimentale.

set_default_attn_processor[[diffusers.AutoencoderKL.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_decode[[diffusers.AutoencoderKL.tiled_decode]]

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

Source

Paramètres :

z (torch.Tensor) : Lot d'entrée de vecteurs latents.

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

Retourne : ~models.vae.DecoderOutput ou tuple

Si return_dict est True, un ~models.vae.DecoderOutput est renvoyé, sinon un simple tuple est renvoyé.

Décoder un lot d'images à l'aide d'un décodeur tuilé.

tiled_encode[[diffusers.AutoencoderKL.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, par défaut True) : Indique s'il faut retourner un ~models.autoencoder_kl.AutoencoderKLOutput plutôt qu'un simple tuple.

Retourne : ~models.autoencoder_kl.AutoencoderKLOutput ou tuple

If return_dict is True, a ~models.autoencoder_kl.AutoencoderKLOutput 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.

unfuse_qkv_projections[[diffusers.AutoencoderKL.unfuse_qkv_projections]]

unfuse_qkv_projections()

Source

Désactive la projection QKV fusionnée si elle est activée.

> Cette API est 🧪 expérimentale.

AutoencoderKLOutput[[diffusers.models.modeling_outputs.AutoencoderKLOutput]]

diffusers.models.modeling_outputs.AutoencoderKLOutput[[diffusers.models.modeling_outputs.AutoencoderKLOutput]]

diffusers.models.modeling_outputs.AutoencoderKLOutput(latent_dist: DiagonalGaussianDistribution)

Source

Paramètres :

latent_dist (DiagonalGaussianDistribution) : Sorties encodées de Encoder représentées par la moyenne et le logvar de DiagonalGaussianDistribution. DiagonalGaussianDistribution permet d'échantillonner des latents à partir de la distribution.

Sortie de la méthode d'encodage d'AutoencoderKL.

DecoderOutput[[diffusers.models.autoencoders.vae.DecoderOutput]]

diffusers.models.autoencoders.vae.DecoderOutput[[diffusers.models.autoencoders.vae.DecoderOutput]]

diffusers.models.autoencoders.vae.DecoderOutput(sample: Tensor, commit_loss: typing.Optional[torch.FloatTensor] = None)

Source

Paramètres :

sample (torch.Tensor de forme (batch_size, num_channels, height, width)) : L'échantillon de sortie décodé de la dernière couche du modèle.

Sortie de la méthode de décodage.