Buckets:
| # Tiny AutoEncoder | |
| Tiny AutoEncoder for Stable Diffusion (TAESD) a été introduit dans [madebyollin/taesd](https://github.com/madebyollin/taesd) par Ollin Boer Bohan. Il s'agit d'une version distillée et compacte du VAE de Stable Diffusion, capable de décoder les latents d'un [StableDiffusionPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) ou d'un [StableDiffusionXLPipeline](/docs/diffusers/v0.43.0/fr/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline) quasi instantanément. | |
| Pour l'utiliser avec Stable Diffusion v-2.1 : | |
| ```python | |
| import torch | |
| from diffusers import DiffusionPipeline, AutoencoderTiny | |
| pipe = DiffusionPipeline.from_pretrained( | |
| "stabilityai/stable-diffusion-2-1-base", dtype=torch.float16 | |
| ) | |
| pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesd", dtype=torch.float16) | |
| pipe = pipe.to("cuda") # or "mps", "xpu", "cpu" | |
| prompt = "slice of delicious New York-style berry cheesecake" | |
| image = pipe(prompt, num_inference_steps=25).images[0] | |
| image | |
| ``` | |
| Pour utiliser avec Stable Diffusion XL 1.0 | |
| ```python | |
| import torch | |
| from diffusers import DiffusionPipeline, AutoencoderTiny | |
| pipe = DiffusionPipeline.from_pretrained( | |
| "stabilityai/stable-diffusion-xl-base-1.0", dtype=torch.float16 | |
| ) | |
| pipe.vae = AutoencoderTiny.from_pretrained("madebyollin/taesdxl", dtype=torch.float16) | |
| pipe = pipe.to("cuda") # or "mps", "xpu", "cpu" | |
| prompt = "slice of delicious New York-style berry cheesecake" | |
| image = pipe(prompt, num_inference_steps=25).images[0] | |
| image | |
| ``` | |
| ## AutoencoderTiny[[diffusers.AutoencoderTiny]] | |
| #### diffusers.AutoencoderTiny[[diffusers.AutoencoderTiny]] | |
| ```python | |
| diffusers.AutoencoderTiny(in_channels: int = 3, out_channels: int = 3, encoder_block_out_channels: tuple[int, ...] = (64, 64, 64, 64), decoder_block_out_channels: tuple[int, ...] = (64, 64, 64, 64), act_fn: str = 'relu', upsample_fn: str = 'nearest', latent_channels: int = 4, upsampling_scaling_factor: int = 2, num_encoder_blocks: tuple[int, ...] = (1, 3, 3, 3), num_decoder_blocks: tuple[int, ...] = (3, 3, 3, 1), latent_magnitude: int = 3, latent_shift: float = 0.5, force_upcast: bool = False, scaling_factor: float = 1.0, shift_factor: float = 0.0) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_tiny.py#L40) | |
| **Paramètres :** | |
| in_channels (`int`, *facultatif*, valeur par défaut 3) : Nombre de canaux dans l'image d'entrée. | |
| out_channels (`int`, *facultatif*, valeur par défaut 3) : Nombre de canaux dans la sortie. | |
| encoder_block_out_channels (`tuple[int]`, *facultatif*, par défaut `(64, 64, 64, 64)`) : tuple d'entiers représentant le nombre de canaux de sortie pour chaque bloc d'encodeur. La longueur du tuple doit être égale au nombre de blocs d'encodeur. | |
| decoder_block_out_channels (`tuple[int]`, *facultatif*, par défaut `(64, 64, 64, 64)`) : tuple d'entiers représentant le nombre de canaux de sortie pour chaque bloc du décodeur. La longueur du tuple doit être égale au nombre de blocs du décodeur. | |
| act_fn (`str`, *facultatif*, valeur par défaut `"relu"`) : Fonction d'activation à utiliser dans tout le modèle. | |
| latent_channels (`int`, *facultatif*, valeur par défaut 4) : Nombre de canaux dans la représentation latente. L'espace latent agit comme une représentation compressée de l'image d'entrée. | |
| upsampling_scaling_factor (`int`, *facultatif*, valeur par défaut 2) : Facteur d'échelle pour le suréchantillonnage dans le décodeur. Il détermine la taille de l'image de sortie lors du processus de suréchantillonnage. | |
| num_encoder_blocks (`tuple[int]`, *facultatif*, valeur par défaut `(1, 3, 3, 3)`) : tuple d'entiers représentant le nombre de blocs d'encodeur à chaque étape du processus d'encodage. La longueur du tuple doit être égale au nombre d'étapes de l'encodeur. Chaque étape possède un nombre différent de blocs d'encodeur. | |
| num_decoder_blocks (`tuple[int]`, *facultatif*, valeur par défaut `(3, 3, 3, 1)`) : tuple d'entiers représentant le nombre de blocs décodeur à chaque étape du processus de décodage. La longueur du tuple doit être égale au nombre d'étapes du décodeur. Chaque étape possède un nombre différent de blocs décodeur. | |
| latent_magnitude (`float`, *facultatif*, valeur par défaut 3.0) : Magnitude de la représentation latente. Ce paramètre met à l'échelle les valeurs de la représentation latente afin de contrôler le degré de préservation des informations. | |
| latent_shift (float, *facultatif*, valeur par défaut 0.5) : Décalage appliqué à la représentation latente. Ce paramètre contrôle le centre de l'espace latent. | |
| scaling_factor (`float`, *facultatif*, valeur par défaut 1.0) : 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](https://huggingface.co/papers/2112.10752). Cependant, pour ce Autoencoder, aucun facteur d'échelle de ce type n'a été utilisé, d'où la valeur par défaut de 1.0. | |
| force_upcast (`bool`, *facultatif*, par défaut `False`) : 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 ce [AutoEncoder](https://huggingface.co/madebyollin/sdxl-vae-fp16-fix) compatible fp16). | |
| Un petit modèle VAE distillé pour encoder des images en latents et décoder des représentations latentes en images. | |
| [AutoencoderTiny](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_tiny#diffusers.AutoencoderTiny) est un wrapper autour de l'implémentation originale de `TAESD`. | |
| Ce modèle hérite de [ModelMixin](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin). Consultez la documentation de la classe parente pour ses méthodes génériques implémentées pour tous les modèles (téléchargement ou sauvegarde, par exemple). | |
| #### forward[[diffusers.AutoencoderTiny.forward]] | |
| ```python | |
| forward(sample: Tensor, return_dict: bool = True) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_tiny.py#L291) | |
| **Paramètres :** | |
| sample (`torch.Tensor`) : Échantillon d'entrée. | |
| return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `DecoderOutput` plutôt qu'un simple tuple. | |
| **Retourne :** `DecoderOutput` ou `tuple` | |
| Si `return_dict` est True, un `DecoderOutput` est renvoyé, sinon un simple `tuple` est renvoyé. | |
| #### scale_latents[[diffusers.AutoencoderTiny.scale_latents]] | |
| ```python | |
| scale_latents(x: Tensor) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_tiny.py#L156) | |
| latents bruts -> [0, 1] | |
| #### unscale_latents[[diffusers.AutoencoderTiny.unscale_latents]] | |
| ```python | |
| unscale_latents(x: Tensor) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_tiny.py#L160) | |
| [0, 1] -> latents bruts | |
| ## AutoencoderTinyOutput[[diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput]] | |
| #### diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput[[diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput]] | |
| ```python | |
| diffusers.models.autoencoders.autoencoder_tiny.AutoencoderTinyOutput(latents: Tensor) | |
| ``` | |
| [Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_tiny.py#L28) | |
| **Paramètres :** | |
| latents (`torch.Tensor`) : Sorties encodées du `Encoder`. | |
| Sortie de la méthode d'encodage d'AutoencoderTiny. | |
Xet Storage Details
- Size:
- 8.27 kB
- Xet hash:
- 0b0511e79df3179911101879a1eb2c213140070172915704a2521cdbbd8490b7
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.