# AutoencoderKLLTXVideo

El modelo de autoencoder variacional (VAE) 3D con pérdida KL utilizado en [LTX](https://huggingface.co/Lightricks/LTX-Video) fue introducido por Lightricks.

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

```python
from diffusers import AutoencoderKLLTXVideo

vae = AutoencoderKLLTXVideo.from_pretrained("Lightricks/LTX-Video", subfolder="vae", dtype=torch.float32).to("cuda")  # or "mps", "xpu", "cpu"
```

## AutoencoderKLLTXVideo[[diffusers.AutoencoderKLLTXVideo]]

#### diffusers.AutoencoderKLLTXVideo[[diffusers.AutoencoderKLLTXVideo]]

```python
diffusers.AutoencoderKLLTXVideo(in_channels: int = 3, out_channels: int = 3, latent_channels: int = 128, block_out_channels: tuple = (128, 256, 512, 512), down_block_types: tuple = ('LTXVideoDownBlock3D', 'LTXVideoDownBlock3D', 'LTXVideoDownBlock3D', 'LTXVideoDownBlock3D'), decoder_block_out_channels: tuple = (128, 256, 512, 512), layers_per_block: tuple = (4, 3, 3, 3, 4), decoder_layers_per_block: tuple = (4, 3, 3, 3, 4), spatio_temporal_scaling: tuple = (True, True, True, False), decoder_spatio_temporal_scaling: tuple = (True, True, True, False), decoder_inject_noise: tuple = (False, False, False, False, False), downsample_type: tuple = ('conv', 'conv', 'conv', 'conv'), upsample_residual: tuple = (False, False, False, False), upsample_factor: tuple = (1, 1, 1, 1), timestep_conditioning: bool = False, patch_size: int = 4, patch_size_t: int = 1, resnet_norm_eps: float = 1e-06, scaling_factor: float = 1.0, encoder_causal: bool = True, decoder_causal: bool = False, spatial_compression_ratio: int = None, temporal_compression_ratio: int = None)
```

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

**Parámetros:**

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

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

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

block_out_channels (`tuple[int, ...]`, por defecto `(128, 256, 512, 512)`) : El número de canales de salida para cada bloque.

spatio_temporal_scaling (`tuple[bool, ...], defaults to `(True, True, True, False)` : Whether a block should contain spatio-temporal downscaling or not.

layers_per_block (`tuple[int, ...]`, por defecto `(4, 3, 3, 3, 4)`) : El número de capas por bloque.

patch_size (`int`, por defecto `4`) : El tamaño de los parches espaciales.

patch_size_t (`int`, por defecto `1`) : El tamaño de los parches temporales.

resnet_norm_eps (`float`, por defecto `1e-6`) : Valor de epsilon para las capas de normalización de ResNet.

scaling_factor (`float`, *opcional*, valor predeterminado `1.0`) : La desviación estándar por 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).

encoder_causal (`bool`, por defecto `True`) : Si el codificador debe comportarse de forma causal (los fotogramas futuros dependen solo de los fotogramas pasados) o no.

decoder_causal (`bool`, por defecto `False`) : Si el decodificador debe comportarse de forma causal (los fotogramas futuros dependen solo de los fotogramas pasados) o no.

Un modelo VAE con pérdida KL para codificar imágenes en latentes y decodificar representaciones latentes en imágenes. Se utiliza en [LTX](https://huggingface.co/Lightricks/LTX-Video).

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

```python
decode(z: Tensor, temb: typing.Optional[torch.Tensor] = None, return_dict: bool = True)
```

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

**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.AutoencoderKLLTXVideo.encode]]

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

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

**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 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 imágenes en latentes.

#### enable_tiling[[diffusers.AutoencoderKLLTXVideo.enable_tiling]]

```python
enable_tiling(tile_sample_min_height: int | None = None, tile_sample_min_width: int | None = None, tile_sample_min_num_frames: int | None = None, tile_sample_stride_height: float | None = None, tile_sample_stride_width: float | None = None, tile_sample_stride_num_frames: float | None = None)
```

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

**Parámetros:**

tile_sample_min_height (`int`, *opcional*) : La altura mínima requerida para que una muestra se separe en mosaicos a lo largo de la dimensión de altura.

tile_sample_min_width (`int`, *opcional*) : El ancho mínimo requerido para que una muestra se separe en mosaicos a lo largo de la dimensión de ancho.

tile_sample_stride_height (`int`, *opcional*) : La cantidad mínima de solapamiento entre dos mosaicos verticales consecutivos. Esto garantiza que no se produzcan artefactos de mosaico a lo largo de la dimensión de altura.

tile_sample_stride_width (`int`, *opcional*) : El desplazamiento entre dos mosaicos horizontales consecutivos. Esto garantiza que no se produzcan artefactos de mosaico a lo largo de la dimensión de ancho.

Habilita la decodificación de VAE en mosaicos. Cuando esta opción está habilitada, el VAE dividirá el tensor de entrada en mosaicos para calcular la decodificación y la codificación en varios pasos. Esto es útil para ahorrar una gran cantidad de memoria y para permitir el procesamiento de imágenes más grandes.

#### forward[[diffusers.AutoencoderKLLTXVideo.forward]]

```python
forward(sample: Tensor, temb: typing.Optional[torch.Tensor] = None, 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_ltx.py#L1517)

**Parámetros:**

sample (`torch.Tensor`) : Muestra de entrada.

temb (`torch.Tensor`, *opcional*) : Tensor de incrustación de paso temporal opcional utilizado para condicionar el decodificador.

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.

#### tiled_decode[[diffusers.AutoencoderKLLTXVideo.tiled_decode]]

```python
tiled_decode(z: Tensor, temb: typing.Optional[torch.Tensor], return_dict: bool = True)
```

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

**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.AutoencoderKLLTXVideo.tiled_encode]]

```python
tiled_encode(x: Tensor)
```

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

**Parámetros:**

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

**Devuelve:** `torch.Tensor`

La representación latente de los videos codificados.

Codifica un lote de imágenes usando un codificador por mosaicos.

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