Buckets:
| # Tiny AutoEncoder | |
| Tiny AutoEncoder for Stable Diffusion (TAESD) fue introducido en [madebyollin/taesd](https://github.com/madebyollin/taesd) por Ollin Boer Bohan. Es una versión destilada y reducida del VAE de Stable Diffusion que puede decodificar rápidamente los latentes en un [StableDiffusionPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/text2img#diffusers.StableDiffusionPipeline) o [StableDiffusionXLPipeline](/docs/diffusers/v0.43.0/es/api/pipelines/stable_diffusion/stable_diffusion_xl#diffusers.StableDiffusionXLPipeline) casi al instante. | |
| Para usar con 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 | |
| ``` | |
| Para usar con 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) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_tiny.py#L40) | |
| **Parámetros:** | |
| in_channels (`int`, *opcional*, valor predeterminado 3) : Número de canales en la imagen de entrada. | |
| out_channels (`int`, *opcional*, valor predeterminado 3) : Número de canales en la salida. | |
| encoder_block_out_channels (`tuple[int]`, *opcional*, valor predeterminado `(64, 64, 64, 64)`) : tupla de enteros que representa el número de canales de salida para cada bloque del codificador. La longitud de la tupla debe ser igual al número de bloques del codificador. | |
| decoder_block_out_channels (`tuple[int]`, *opcional*, valor predeterminado `(64, 64, 64, 64)`) : tupla de enteros que representa el número de canales de salida para cada bloque del decodificador. La longitud de la tupla debe ser igual al número de bloques del decodificador. | |
| act_fn (`str`, *opcional*, valor predeterminado `"relu"`) : Función de activación que se utilizará en todo el modelo. | |
| latent_channels (`int`, *opcional*, valor predeterminado 4) : Número de canales en la representación latente. El espacio latente actúa como una representación comprimida de la imagen de entrada. | |
| upsampling_scaling_factor (`int`, *opcional*, valor predeterminado 2) : Factor de escala para el remuestreo ascendente en el decodificador. Determina el tamaño de la imagen de salida durante el proceso de remuestreo ascendente. | |
| num_encoder_blocks (`tuple[int]`, *opcional*, valor predeterminado `(1, 3, 3, 3)`) : tupla de enteros que representa el número de bloques del codificador en cada etapa del proceso de codificación. La longitud de la tupla debe ser igual al número de etapas del codificador. Cada etapa tiene un número diferente de bloques del codificador. | |
| num_decoder_blocks (`tuple[int]`, *opcional*, valor predeterminado `(3, 3, 3, 1)`) : tupla de enteros que representa el número de bloques decodificadores en cada etapa del proceso de decodificación. La longitud de la tupla debe ser igual al número de etapas del decodificador. Cada etapa tiene un número diferente de bloques decodificadores. | |
| latent_magnitude (`float`, *opcional*, valor predeterminado 3.0) : Magnitud de la representación latente. Este parámetro escala los valores de la representación latente para controlar el grado de preservación de la información. | |
| latent_shift (float, *opcional*, valor predeterminado 0.5) : Desplazamiento aplicado a la representación latente. Este parámetro controla el centro del espacio latente. | |
| scaling_factor (`float`, *opcional*, valor predeterminado 1.0) : La desviación estándar componente a componente del espacio latente entrenado, calculada utilizando el primer lote del conjunto de entrenamiento. Esto se utiliza para escalar el espacio latente para que tenga varianza unitaria al entrenar el modelo de difusión. Los latentes se escalan con la fórmula `z = z * scaling_factor` antes de ser pasados al modelo de difusión. Al decodificar, los latentes se escalan de vuelta a la escala original con la fórmula: `z = 1 / scaling_factor * z`. Para más detalles, consulte las secciones 4.3.2 y D.1 del artículo [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752). Sin embargo, para este Autoencoder, no se utilizó ningún factor de escala de este tipo, de ahí el valor de 1.0 como predeterminado. | |
| force_upcast (`bool`, *opcional*, valor predeterminado `False`) : Si se habilita, forzará que el VAE se ejecute en float32 para pipelines de alta resolución de imagen, como SD-XL. El VAE puede ajustarse o entrenarse para un rango inferior sin perder demasiada precisión, en cuyo caso `force_upcast` se puede establecer en `False` (vea este [AutoEncoder](https://huggingface.co/madebyollin/sdxl-vae-fp16-fix) compatible con fp16). | |
| Un pequeño modelo VAE destilado para codificar imágenes en latentes y decodificar representaciones latentes en imágenes. | |
| [AutoencoderTiny](/docs/diffusers/v0.43.0/es/api/models/autoencoder_tiny#diffusers.AutoencoderTiny) es un envoltorio de la implementación original de `TAESD`. | |
| Este modelo hereda de [ModelMixin](/docs/diffusers/v0.43.0/es/api/models/overview#diffusers.ModelMixin). Consulta la documentación de la superclase para sus métodos genéricos implementados para todos los modelos (como la descarga o el guardado). | |
| #### forward[[diffusers.AutoencoderTiny.forward]] | |
| ```python | |
| forward(sample: Tensor, return_dict: bool = True) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_tiny.py#L291) | |
| **Parámetros:** | |
| sample (`torch.Tensor`) : Muestra de entrada. | |
| return_dict (`bool`, *opcional*, por defecto `True`) : Si se devuelve un `DecoderOutput` en lugar de una tupla simple. | |
| **Devuelve:** `DecoderOutput` o `tuple` | |
| Si `return_dict` es True, se devuelve un `DecoderOutput`; en caso contrario, se devuelve una `tuple` simple. | |
| #### scale_latents[[diffusers.AutoencoderTiny.scale_latents]] | |
| ```python | |
| scale_latents(x: Tensor) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_tiny.py#L156) | |
| latentes sin procesar -> [0, 1] | |
| #### unscale_latents[[diffusers.AutoencoderTiny.unscale_latents]] | |
| ```python | |
| unscale_latents(x: Tensor) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_tiny.py#L160) | |
| [0, 1] -> latentes sin procesar | |
| ## 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) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_tiny.py#L28) | |
| **Parámetros:** | |
| latents (`torch.Tensor`) : Salidas codificadas del `Encoder`. | |
| Salida del método de codificación de AutoencoderTiny. | |
Xet Storage Details
- Size:
- 8.33 kB
- Xet hash:
- 43c051c44f015ea646fc0475068fcad1c4c6db0eafcdc32fd9b08e7999e88352
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.