# AutoencoderKLMiniMaxH3

El modelo de autoencoder variacional (VAE) de video con pérdida KL utilizado en [MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3) de MiniMax. Combina un codificador de CNN 3D causal con un decodificador ViT no causal y comprime 16 veces espacialmente y 4 veces temporalmente.

Tres cosas lo distinguen de la mayoría de los autoencodidores de la biblioteca:

- **Los latentes se normalizan por canal.** No hay `scaling_factor`: un pipeline codifica con `(latent - latents_mean) / latents_std` y decodifica con `latent * latents_std + latents_mean`.
- **La convención de píxeles es RGB normalizado según ImageNet sobre un rango base de `[0, 1]`**, no el habitual `[-1, 1]`. `encode` espera `(pixel - imagenet_mean) / imagenet_std` y `decode` devuelve valores en ese mismo espacio, por lo que un pipeline aplica `sample * imagenet_std + imagenet_mean` y limita a `[0, 1]` antes del posprocesamiento.
- **El mosaico espacial está activado de forma predeterminada.** MiniMax-H3 se lanzó con el mosaico activado tanto para la codificación como para la decodificación, y los fotogramas publicados son los de mosaico combinado, por lo que desactivarlo cambia la salida. Use `enable_tiling` para cambiar la geometría del mosaico y `disable_tiling` para desactivarlo.

La geometría temporal está fijada por `clip_length` (17 fotogramas de píxeles por bloque del codificador) y `token_drop` (3 fotogramas latentes finales descartados por codificación), por lo que `17 * n + 5` fotogramas de píxeles se mapean a `5 * n + 2` fotogramas latentes.

```python
import torch
from diffusers import AutoencoderKLMiniMaxH3

vae = AutoencoderKLMiniMaxH3.from_pretrained(
    "MiniMaxAI/MiniMax-H3", subfolder="vae", dtype=torch.float32
).to("cuda")  # or "mps", "xpu", "cpu"
```

## AutoencoderKLMiniMaxH3[[diffusers.AutoencoderKLMiniMaxH3]]

#### diffusers.AutoencoderKLMiniMaxH3[[diffusers.AutoencoderKLMiniMaxH3]]

```python
diffusers.AutoencoderKLMiniMaxH3(in_channels: int = 3, out_channels: int = 3, latent_channels: int = 24, block_out_channels: tuple[int, ...] = (128, 256, 256, 512, 512, 1024), layers_per_block: int = 2, spatial_downsample_factors: tuple[int, ...] = (2, 2, 2, 2, 1, 1), temporal_downsample_factors: tuple[int, ...] = (1, 2, 2, 1, 1, 1), norm_num_groups: int = 32, norm_eps: float = 1e-06, spatial_padding_mode: str = 'reflect', decoder_num_layers: int = 36, decoder_num_attention_heads: int = 32, decoder_attention_head_dim: int = 64, decoder_num_register_tokens: int = 4, decoder_ffn_mult: int = 4, decoder_rope_theta: float = 100.0, decoder_rope_dim_ratio: float = 0.75, decoder_norm_eps: float = 1e-05, clip_length: int = 17, token_drop: int = 3, latents_mean: tuple[float, ...] = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), latents_std: tuple[float, ...] = (1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0))
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py#L505)

Un modelo VAE con un codificador de CNN 3D causal y un decodificador ViT no causal, utilizado en [MiniMax-H3](https://huggingface.co/MiniMaxAI).

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

Los latentes se normalizan con `latents_mean` / `latents_std` por canal, en lugar de un `scaling_factor`; un pipeline codifica con `(latent - latents_mean) / latents_std` y decodifica con `latent * latents_std + latents_mean`.

La convención de píxeles es RGB normalizado con ImageNet sobre un rango base de `[0, 1]`, no el habitual `[-1, 1]`: `encode` espera `(pixel - imagenet_mean) / imagenet_std` y `decode` devuelve valores en ese mismo espacio, por lo que un pipeline debe aplicar `sample * imagenet_std + imagenet_mean` (media `(0.485, 0.456, 0.406)`, desviación estándar `(0.229, 0.224, 0.225)`) y recortar a `[0, 1]` antes del postprocesamiento.

La geometría temporal se fija mediante `clip_length` (17 fotogramas de píxeles por bloque del codificador) y `token_drop` (3 fotogramas latentes finales descartados por codificación): `17 * n + 5` fotogramas de píxeles se mapean a `5 * n + 2` fotogramas latentes.

A diferencia de la mayoría de los autoencoders de la biblioteca, el mosaico espacial está **activado por defecto**: MiniMax-H3 se publicó con el mosaico habilitado tanto para la codificación como para la decodificación, y los fotogramas publicados son los de mosaico combinado, por lo que deshabilitar el mosaico cambia la salida. Utilice `enable_tiling` para cambiar la geometría del mosaico y `disable_tiling` para desactivarlo.

#### encode[[diffusers.AutoencoderKLMiniMaxH3.encode]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py#L855)

**Parámetros:**

x (`torch.Tensor`) : Lote de entrada de videos, forma `(batch_size, in_channels, num_frames, height, width)`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un [AutoencoderKLOutput](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_qwenimage#diffusers.models.modeling_outputs.AutoencoderKLOutput) en lugar de una tupla simple.

**Devuelve:**

La distribución latente de los videos codificados. Tenga en cuenta que MiniMax-H3 normaliza los latentes muestreados con `latents_mean` / `latents_std` posteriormente.

Codifica un lote de videos en latentes.

#### decode[[diffusers.AutoencoderKLMiniMaxH3.decode]]

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

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py#L883)

**Parámetros:**

z (`torch.Tensor`) : Lote de entrada de videos latentes, con forma `(batch_size, latent_channels, num_latent_frames, height, width)`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un [DecoderOutput](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) en lugar de una tupla simple.

**Devuelve:** [DecoderOutput](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) o `tuple`

Los videos decodificados, con forma `(batch_size, out_channels, num_frames, height, width)`.

Decodificar un lote de videos latentes.

#### enable_tiling[[diffusers.AutoencoderKLMiniMaxH3.enable_tiling]]

```python
enable_tiling(tile_sample_min_height: int | None = None, tile_sample_min_width: int | None = None, tile_sample_min_overlap_height: int | None = None, tile_sample_min_overlap_width: int | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py#L628)

**Parámetros:**

tile_sample_min_height (`int`, *opcional*) : La altura de la tesela en el espacio de píxeles. Los fotogramas más altos que este valor se dividen a lo largo de la dimensión de altura.

tile_sample_min_width (`int`, *opcional*) : El ancho de la tesela en espacio de píxeles. Los fotogramas más anchos que este valor se dividen a lo largo de la dimensión de ancho.

tile_sample_min_overlap_height (`int`, *opcional*) : La superposición mínima, en píxeles, entre dos mosaicos verticales consecutivos.

tile_sample_min_overlap_width (`int`, *opcional*) : La superposición mínima, en píxeles, entre dos mosaicos horizontales consecutivos.

Habilita la codificación/decodificación de VAE por mosaicos. Cuando esta opción está habilitada, el VAE divide los fotogramas en mosaicos, codifica o decodifica cada mosaico por separado y combina linealmente las superposiciones. Esto reduce el requisito de memoria y permite procesar fotogramas más grandes.

#### forward[[diffusers.AutoencoderKLMiniMaxH3.forward]]

```python
forward(sample: Tensor, sample_posterior: bool = False, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py#L908)

**Parámetros:**

sample (`torch.Tensor`) : Lote de entrada de videos, forma `(batch_size, in_channels, num_frames, height, width)`.

sample_posterior (`bool`, *opcional*, por defecto `False`) : Si se debe muestrear la posterior en lugar de tomar su modo.

generator (`torch.Generator`, *opcional*) : Generador utilizado cuando `sample_posterior=True`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un [DecoderOutput](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) en lugar de una tupla simple.

**Devuelve:** [DecoderOutput](/docs/diffusers/v0.43.0/es/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) o `tuple`

Los videos de ida y vuelta, con forma `(batch_size, out_channels, num_frames, height, width)`.

Codificar y luego decodificar un lote de videos.