Buckets:
| # AutoencoderKL | |
| El modelo de autoencoder variacional (VAE) con pérdida KL se introdujo en [Auto-Encoding Variational Bayes](https://huggingface.co/papers/1312.6114) de Diederik P. Kingma y Max Welling. El modelo se utiliza en 🤗 Diffusers para codificar imágenes en latentes y para decodificar representaciones latentes en imágenes. | |
| El resumen del artículo es: | |
| *¿Cómo podemos realizar inferencia y aprendizaje eficientes en modelos probabilísticos dirigidos, en presencia de variables latentes continuas con distribuciones posteriores intratables y grandes conjuntos de datos? Introducimos un algoritmo de inferencia y aprendizaje variacional estocástico que escala a grandes conjuntos de datos y, bajo ciertas condiciones de diferenciabilidad leves, funciona incluso en el caso intratable. Nuestras contribuciones son de doble naturaleza. En primer lugar, demostramos que una reparametrización del límite inferior variacional produce un estimador de límite inferior que puede optimizarse de manera directa mediante métodos estándar de gradiente estocástico. En segundo lugar, demostramos que para conjuntos de datos i.i.d. con variables latentes continuas por punto de datos, la inferencia posterior puede hacerse especialmente eficiente ajustando un modelo de inferencia aproximado (también llamado modelo de reconocimiento) a la posterior intratable utilizando el estimador de límite inferior propuesto. Las ventajas teóricas se reflejan en los resultados experimentales.* | |
| ## Carga desde el formato original | |
| Por defecto, [AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL) debe cargarse con [from_pretrained()](/docs/diffusers/main/es/api/models/overview#diffusers.ModelMixin.from_pretrained), pero también puede cargarse desde el formato original usando `FromOriginalModelMixin.from_single_file` de la siguiente manera: | |
| ```py | |
| 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]] | |
| ```python | |
| 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) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L36) | |
| **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. | |
| down_block_types (`tuple[str]`, *opcional*, por defecto `("DownEncoderBlock2D",)`) : tupla de tipos de bloques de muestreo descendente. | |
| up_block_types (`tuple[str]`, *opcional*, por defecto `("UpDecoderBlock2D",)`) : tupla de tipos de bloques de remuestreo ascendente. | |
| block_out_channels (`tuple[int]`, *opcional*, valor predeterminado `(64,)`) : tupla de canales de salida de bloque. | |
| act_fn (`str`, *opcional*, por defecto `"silu"`) : La función de activación a utilizar. | |
| latent_channels (`int`, *opcional*, valor predeterminado 4) : Número de canales en el espacio latente. | |
| sample_size (`int`, *opcional*, valor predeterminado `32`) : Tamaño de entrada de muestra. | |
| scaling_factor (`float`, *opcional*, valor predeterminado 0.18215) : 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). | |
| force_upcast (`bool`, *opcional*, valor predeterminado `True`) : Si está habilitado, 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` - ver: https://huggingface.co/madebyollin/sdxl-vae-fp16-fix | |
| mid_block_add_attention (`bool`, *opcional*, valor predeterminado `True`) : Si está habilitado, el mid_block del Encoder y el Decoder tendrá bloques de atención. Si se establece en false, el mid_block solo tendrá bloques resnet | |
| Un modelo VAE con pérdida KL para codificar imágenes en latentes y decodificar representaciones latentes en imágenes. | |
| Este modelo hereda de [ModelMixin](/docs/diffusers/main/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). | |
| #### decode[[diffusers.AutoencoderKL.decode]] | |
| ```python | |
| decode(z: FloatTensor, return_dict: bool = True, generator = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L213) | |
| **Parámetros:** | |
| z (`torch.Tensor`) : Lote de entrada de vectores latentes. | |
| return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un `~models.vae.DecoderOutput` en lugar de una tupla simple. | |
| **Devuelve:** `~models.vae.DecoderOutput` o `tuple` | |
| Si return_dict es True, se devuelve un `~models.vae.DecoderOutput`; en caso contrario, se devuelve una `tuple` simple. | |
| Decodificar un lote de imágenes. | |
| #### encode[[diffusers.AutoencoderKL.encode]] | |
| ```python | |
| encode(x: Tensor, return_dict: bool = True) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L170) | |
| **Parámetros:** | |
| x (`torch.Tensor`) : Lote de entrada de imágenes. | |
| return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un `~models.autoencoder_kl.AutoencoderKLOutput` en lugar de una tupla simple. | |
| **Devuelve:** | |
| Las representaciones latentes de las imágenes codificadas. Si `return_dict` es True, se devuelve un `~models.autoencoder_kl.AutoencoderKLOutput`; de lo contrario, se devuelve una `tuple` simple. | |
| Codifica un lote de imágenes en latentes. | |
| #### forward[[diffusers.AutoencoderKL.forward]] | |
| ```python | |
| forward(sample: Tensor, sample_posterior: bool = False, return_dict: bool = True, generator: typing.Optional[torch.Generator] = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L413) | |
| **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*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer que la muestreo sea determinista. | |
| **Devuelve:** `~models.vae.DecoderOutput` o `tuple` | |
| Si `return_dict` es True, se devuelve un `~models.vae.DecoderOutput`; en caso contrario, se devuelve una `tuple` simple. | |
| #### fuse_qkv_projections[[diffusers.AutoencoderKL.fuse_qkv_projections]] | |
| ```python | |
| fuse_qkv_projections() | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L450) | |
| Habilita las proyecciones QKV fusionadas. Para los módulos de autoatención, todas las matrices de proyección (es decir, consulta, clave y valor) se fusionan. Para los módulos de atención cruzada, las matrices de proyección de clave y valor se fusionan. | |
| > [!WARNING] > Esta API es 🧪 experimental. | |
| #### set_default_attn_processor[[diffusers.AutoencoderKL.set_default_attn_processor]] | |
| ```python | |
| set_default_attn_processor() | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L143) | |
| Desactiva los procesadores de atención personalizados y establece la implementación de atención predeterminada. | |
| #### tiled_decode[[diffusers.AutoencoderKL.tiled_decode]] | |
| ```python | |
| tiled_decode(z: Tensor, return_dict: bool = True) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L364) | |
| **Parámetros:** | |
| z (`torch.Tensor`) : Lote de entrada de vectores latentes. | |
| return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~models.vae.DecoderOutput` en lugar de una tupla simple. | |
| **Devuelve:** `~models.vae.DecoderOutput` o `tuple` | |
| Si return_dict es True, se devuelve un `~models.vae.DecoderOutput`; en caso contrario, se devuelve una `tuple` simple. | |
| Decodificar un lote de imágenes usando un decodificador por mosaicos. | |
| #### tiled_encode[[diffusers.AutoencoderKL.tiled_encode]] | |
| ```python | |
| tiled_encode(x: Tensor, return_dict: bool = True) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L302) | |
| **Parámetros:** | |
| x (`torch.Tensor`) : Lote de entrada de imágenes. | |
| return_dict (`bool`, *opcional*, por defecto `True`) : Si se devuelve un `~models.autoencoder_kl.AutoencoderKLOutput` en lugar de una tupla simple. | |
| **Devuelve:** `~models.autoencoder_kl.AutoencoderKLOutput` o `tuple` | |
| If return_dict is True, a `~models.autoencoder_kl.AutoencoderKLOutput` 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. | |
| #### unfuse_qkv_projections[[diffusers.AutoencoderKL.unfuse_qkv_projections]] | |
| ```python | |
| unfuse_qkv_projections() | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl.py#L472) | |
| Desactiva la proyección QKV fusionada si está habilitada. | |
| > [!WARNING] > Esta API es 🧪 experimental. | |
| ## AutoencoderKLOutput[[diffusers.models.modeling_outputs.AutoencoderKLOutput]] | |
| #### diffusers.models.modeling_outputs.AutoencoderKLOutput[[diffusers.models.modeling_outputs.AutoencoderKLOutput]] | |
| ```python | |
| diffusers.models.modeling_outputs.AutoencoderKLOutput(latent_dist: DiagonalGaussianDistribution) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/modeling_outputs.py#L7) | |
| **Parámetros:** | |
| latent_dist (`DiagonalGaussianDistribution`) : Salidas codificadas de `Encoder` representadas como la media y el logvar de `DiagonalGaussianDistribution`. `DiagonalGaussianDistribution` permite muestrear latentes de la distribución. | |
| Salida del método de codificación de AutoencoderKL. | |
| ## DecoderOutput[[diffusers.models.autoencoders.vae.DecoderOutput]] | |
| #### diffusers.models.autoencoders.vae.DecoderOutput[[diffusers.models.autoencoders.vae.DecoderOutput]] | |
| ```python | |
| diffusers.models.autoencoders.vae.DecoderOutput(sample: Tensor, commit_loss: typing.Optional[torch.FloatTensor] = None) | |
| ``` | |
| [Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/vae.py#L49) | |
| **Parámetros:** | |
| sample (`torch.Tensor` de forma `(batch_size, num_channels, height, width)`) : La muestra de salida decodificada de la última capa del modelo. | |
| Salida del método de decodificación. | |
Xet Storage Details
- Size:
- 12.6 kB
- Xet hash:
- d7159a8d639815469b26b3381f04443e74687268547a58d8a26c9d954770da3e
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.