# AutoencoderKLAllegro

El modelo de autoencoder variacional (VAE) 3D con pérdida KL utilizado en [Allegro](https://github.com/rhymes-ai/Allegro) fue introducido en [Allegro: Open the Black Box of Commercial-Level Video Generation Model](https://huggingface.co/papers/2410.15458) por RhymesAI.

El modelo se puede cargar con el siguiente fragmento de código.

```python
from diffusers import AutoencoderKLAllegro

vae = AutoencoderKLAllegro.from_pretrained("rhymes-ai/Allegro", subfolder="vae", dtype=torch.float32).to("cuda")  # or "mps", "xpu", "cpu"
```

## AutoencoderKLAllegro[[diffusers.AutoencoderKLAllegro]]

#### diffusers.AutoencoderKLAllegro[[diffusers.AutoencoderKLAllegro]]

```python
diffusers.AutoencoderKLAllegro(in_channels: int = 3, out_channels: int = 3, down_block_types: tuple = ('AllegroDownBlock3D', 'AllegroDownBlock3D', 'AllegroDownBlock3D', 'AllegroDownBlock3D'), up_block_types: tuple = ('AllegroUpBlock3D', 'AllegroUpBlock3D', 'AllegroUpBlock3D', 'AllegroUpBlock3D'), block_out_channels: tuple = (128, 256, 512, 512), temporal_downsample_blocks: tuple = (True, True, False, False), temporal_upsample_blocks: tuple = (False, True, True, False), latent_channels: int = 4, layers_per_block: int = 2, act_fn: str = 'silu', norm_num_groups: int = 32, temporal_compression_ratio: float = 4, sample_size: int = 320, scaling_factor: float = 0.13, force_upcast: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_allegro.py#L676)

**Parámetros:**

in_channels (int, por defecto `3`) : Número de canales en la imagen de entrada.

out_channels (int, por defecto `3`) : Número de canales en la salida.

down_block_types (`tuple[str, ...]`, por defecto `("AllegroDownBlock3D", "AllegroDownBlock3D", "AllegroDownBlock3D", "AllegroDownBlock3D")`) : tupla de cadenas que indica qué tipos de bloques de reducción (down blocks) utilizar.

up_block_types (`tuple[str, ...]`, por defecto `("AllegroUpBlock3D", "AllegroUpBlock3D", "AllegroUpBlock3D", "AllegroUpBlock3D")`) : tupla de cadenas que indica qué tipos de bloques de subida usar.

block_out_channels (`tuple[int, ...]`, por defecto `(128, 256, 512, 512)`) : tupla de enteros que indica el número de canales de salida en cada bloque.

temporal_downsample_blocks (`tuple[bool, ...]`, por defecto `(True, True, False, False)`) : tupla de booleanos que indica en qué bloques habilitar el muestreo temporal reducido.

latent_channels (`int`, por defecto `4`) : Número de canales en los latentes.

layers_per_block (`int`, por defecto `2`) : Número de capas de resnet o atención o convolución temporal por bloque de down/up.

act_fn (`str`, por defecto `"silu"`) : La función de activación a utilizar.

norm_num_groups (`int`, por defecto `32`) : Número de grupos a utilizar en las capas de normalización.

temporal_compression_ratio (`int`, por defecto `4`) : Proporción en la que se comprime la dimensión temporal de las muestras.

sample_size (`int`, por defecto `320`) : Tamaño latente predeterminado.

scaling_factor (`float`, por defecto `0.13235`) : 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`, por defecto `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 afinarse / 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

Un modelo VAE con pérdida KL para codificar videos en latentes y decodificar representaciones latentes en videos. Se utiliza en [Allegro](https://github.com/rhymes-ai/Allegro).

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.AutoencoderKLAllegro.decode]]

```python
decode(z: Tensor, return_dict: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_allegro.py#L843)

**Parámetros:**

z (`torch.Tensor`) : Lote de entrada de vectores latentes.

return_dict (`bool`, 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 videos.

#### encode[[diffusers.AutoencoderKLAllegro.encode]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_allegro.py#L806)

**Parámetros:**

x (`torch.Tensor`) : Lote de entrada de videos.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un `~models.autoencoder_kl.AutoencoderKLOutput` en lugar de una tupla simple.

**Devuelve:**

Las representaciones latentes de los videos codificados. Si `return_dict` es True, se devuelve un `~models.autoencoder_kl.AutoencoderKLOutput`; de lo contrario, se devuelve una `tuple` simple.

Codifica un lote de videos en latentes.

#### forward[[diffusers.AutoencoderKLAllegro.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_allegro.py#L1041)

**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*) : Generador de números aleatorios de PyTorch.

**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.

## 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.