# AutoencoderKLLTXVideo

Le modèle d'auto-encodeur variationnel 3D (VAE) avec perte KL utilisé dans [LTX](https://huggingface.co/Lightricks/LTX-Video) a été introduit par Lightricks.

Le modèle peut être chargé à l'aide du fragment de code suivant.

```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[int, ...] = (128, 256, 512, 512), down_block_types: tuple[str, ...] = ('LTXVideoDownBlock3D', 'LTXVideoDownBlock3D', 'LTXVideoDownBlock3D', 'LTXVideoDownBlock3D'), decoder_block_out_channels: tuple[int, ...] = (128, 256, 512, 512), layers_per_block: tuple[int, ...] = (4, 3, 3, 3, 4), decoder_layers_per_block: tuple[int, ...] = (4, 3, 3, 3, 4), spatio_temporal_scaling: tuple[bool, ...] = (True, True, True, False), decoder_spatio_temporal_scaling: tuple[bool, ...] = (True, True, True, False), decoder_inject_noise: tuple[bool, ...] = (False, False, False, False, False), downsample_type: tuple[str, ...] = ('conv', 'conv', 'conv', 'conv'), upsample_residual: tuple[bool, ...] = (False, False, False, False), upsample_factor: tuple[int, ...] = (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)
```

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

**Paramètres :**

in_channels (`int`, par défaut `3`) : Nombre de canaux d'entrée.

out_channels (`int`, par défaut `3`) : Nombre de canaux de sortie.

latent_channels (`int`, par défaut `128`) : Nombre de canaux latents.

block_out_channels (`tuple[int, ...]`, par défaut `(128, 256, 512, 512)`) : Le nombre de canaux de sortie pour chaque bloc.

spatio_temporal_scaling (`tuple[bool, ...], defaults to `(True, True, True, False)` : Indique si un bloc doit contenir une réduction spatio-temporelle ou non.

layers_per_block (`tuple[int, ...]`, par défaut `(4, 3, 3, 3, 4)`) : Le nombre de couches par bloc.

patch_size (`int`, par défaut `4`) : La taille des patches spatiaux.

patch_size_t (`int`, par défaut `1`) : La taille des patches temporels.

resnet_norm_eps (`float`, par défaut `1e-6`) : Valeur d'épsilon pour les couches de normalisation de ResNet.

scaling_factor (`float`, *facultatif*, valeur par défaut `1.0`) : L'écart-type par composante de l'espace latent entraîné, calculé à l'aide du premier lot du jeu de données d'entraînement. Il est utilisé pour mettre à l'échelle l'espace latent afin qu'il ait une variance unitaire lors de l'entraînement du modèle de diffusion. Les latents sont mis à l'échelle avec la formule `z = z * scaling_factor` avant d'être transmis au modèle de diffusion. Lors du décodage, les latents sont remis à l'échelle d'origine avec la formule : `z = 1 / scaling_factor * z`. Pour plus de détails, consultez les sections 4.3.2 et D.1 de l'article [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752).

encoder_causal (`bool`, par défaut `True`) : Indique si l'encodeur doit se comporter de manière causale (les trames futures ne dépendent que des trames passées) ou non.

decoder_causal (`bool`, par défaut `False`) : Indique si le décodeur doit se comporter de manière causale (les trames futures ne dépendent que des trames passées) ou non.

Un modèle VAE avec perte KL pour encoder des images en latents et décoder des représentations latentes en images. Utilisé dans [LTX](https://huggingface.co/Lightricks/LTX-Video).

Ce modèle hérite de [ModelMixin](/docs/diffusers/v0.43.0/fr/api/models/overview#diffusers.ModelMixin). Consultez la documentation de la classe parente pour ses méthodes génériques implémentées pour tous les modèles (tels que le téléchargement ou l'enregistrement).

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

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

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

**Paramètres :**

z (`torch.Tensor`) : Lot d'entrée de vecteurs latents.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~models.vae.DecoderOutput` plutôt qu'un simple tuple.

**Retourne :** `~models.vae.DecoderOutput` ou `tuple`

Si `return_dict` est True, un `~models.vae.DecoderOutput` est renvoyé, sinon un simple `tuple` est renvoyé.

Décoder un lot d'images.

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

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

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

**Paramètres :**

x (`torch.Tensor`) : Lot d'images en entrée.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~models.autoencoder_kl.AutoencoderKLOutput` plutôt qu'un simple tuple.

**Retourne :**

Les représentations latentes des vidéos encodées. Si `return_dict` est True, un `~models.autoencoder_kl.AutoencoderKLOutput` est renvoyé, sinon un simple `tuple` est renvoyé.

Encode un lot d'images en latents.

#### 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)
```

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

**Paramètres :**

tile_sample_min_height (`int`, *facultatif*) : La hauteur minimale requise pour qu'un échantillon soit séparé en tuiles le long de la dimension de hauteur.

tile_sample_min_width (`int`, *facultatif*) : La largeur minimale requise pour qu'un échantillon soit séparé en tuiles le long de la dimension de la largeur.

tile_sample_stride_height (`int`, *facultatif*) : La quantité minimale de chevauchement entre deux tuiles verticales consécutives. Cela permet de s'assurer qu'aucun artefact de tuilage n'est produit le long de la dimension de hauteur.

tile_sample_stride_width (`int`, *facultatif*) : Le pas entre deux tuiles horizontales consécutives. Cela permet de s'assurer qu'aucun artefact de tuilage n'est produit le long de la dimension de largeur.

Active le décodage VAE par tuiles. Lorsque cette option est activée, le VAE divise le tenseur d’entrée en tuiles pour effectuer le décodage et l’encodage en plusieurs étapes. Cela est utile pour économiser une grande quantité de mémoire et pour permettre le traitement d’images plus 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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/autoencoder_kl_ltx.py#L1517)

**Paramètres :**

sample (`torch.Tensor`) : Échantillon d'entrée.

temb (`torch.Tensor`, *facultatif*) : Tenseur d'incorporation de pas de temps facultatif utilisé pour conditionner le décodeur.

sample_posterior (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut échantillonner à partir de la distribution a posteriori.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `DecoderOutput` plutôt qu'un simple tuple.

generator (`torch.Generator`, *facultatif*) : Un [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) pour rendre l'échantillonnage déterministe.

**Retourne :** `~models.vae.DecoderOutput` ou `tuple`

Si `return_dict` est True, un `~models.vae.DecoderOutput` est renvoyé, sinon un simple `tuple` est renvoyé.

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

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

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

**Paramètres :**

z (`torch.Tensor`) : Lot d'entrée de vecteurs latents.

return_dict (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut retourner un `~models.vae.DecoderOutput` plutôt qu'un simple tuple.

**Retourne :** `~models.vae.DecoderOutput` ou `tuple`

Si `return_dict` est True, un `~models.vae.DecoderOutput` est renvoyé, sinon un simple `tuple` est renvoyé.

Décoder un lot d'images à l'aide d'un décodeur tuilé.

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

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

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

**Paramètres :**

x (`torch.Tensor`) : Lot d'entrée de vidéos.

**Retourne :** `torch.Tensor`

La représentation latente des vidéos encodées.

Encoder un lot d'images à l'aide d'un encodeur tuilé.

## 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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/modeling_outputs.py#L7)

**Paramètres :**

latent_dist (`DiagonalGaussianDistribution`) : Sorties encodées de `Encoder` représentées par la moyenne et le logvar de `DiagonalGaussianDistribution`. `DiagonalGaussianDistribution` permet d'échantillonner des latents à partir de la distribution.

Sortie de la méthode d'encodage d'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)
```

[Source](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/models/autoencoders/vae.py#L49)

**Paramètres :**

sample (`torch.Tensor` de forme `(batch_size, num_channels, height, width)`) : L'échantillon de sortie décodé de la dernière couche du modèle.

Sortie de la méthode de décodage.