# AutoencoderKLLTX2Video O modelo de autoencoder variacional 3D (VAE) com perda KL usado em [LTX-2](https://huggingface.co/Lightricks/LTX-2) foi introduzido pela Lightricks. O modelo pode ser carregado com o seguinte trecho de código. ```python from diffusers import AutoencoderKLLTX2Video vae = AutoencoderKLLTX2Video.from_pretrained("Lightricks/LTX-2", subfolder="vae", dtype=torch.float32).to("cuda") # or "mps", "xpu", "cpu" ``` ## AutoencoderKLLTX2Video[[diffusers.AutoencoderKLLTX2Video]] #### diffusers.AutoencoderKLLTX2Video[[diffusers.AutoencoderKLLTX2Video]] ```python diffusers.AutoencoderKLLTX2Video(in_channels: int = 3, out_channels: int = 3, latent_channels: int = 128, block_out_channels: tuple[int, ...] = (256, 512, 1024, 2048), down_block_types: tuple[str, ...] = ('LTX2VideoDownBlock3D', 'LTX2VideoDownBlock3D', 'LTX2VideoDownBlock3D', 'LTX2VideoDownBlock3D'), decoder_block_out_channels: tuple[int, ...] = (256, 512, 1024), layers_per_block: tuple[int, ...] = (4, 6, 6, 2, 2), decoder_layers_per_block: tuple[int, ...] = (5, 5, 5, 5), spatio_temporal_scaling: bool | tuple[bool, ...] = (True, True, True, True), decoder_spatio_temporal_scaling: bool | tuple[bool, ...] = (True, True, True), decoder_inject_noise: bool | tuple[bool, ...] = (False, False, False, False), downsample_type: tuple[str, ...] = ('spatial', 'temporal', 'spatiotemporal', 'spatiotemporal'), upsample_type: tuple[str, ...] = ('spatiotemporal', 'spatiotemporal', 'spatiotemporal'), upsample_residual: bool | tuple[bool, ...] = (True, True, True), upsample_factor: tuple[int, ...] = (2, 2, 2), 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 = True, encoder_spatial_padding_mode: str = 'zeros', decoder_spatial_padding_mode: str = 'reflect', spatial_compression_ratio: int = None, temporal_compression_ratio: int = None) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_ltx2.py#L1025) **Parâmetros:** in_channels (`int`, padrão `3`) : Número de canais de entrada. out_channels (`int`, padrão `3`) : Número de canais de saída. latent_channels (`int`, padrão `128`) : Número de canais latentes. block_out_channels (`tuple[int, ...]`, padrão `(128, 256, 512, 512)`) : O número de canais de saída para cada bloco. spatio_temporal_scaling (`tuple[bool, ...], defaults to `(True, True, True, False)` : Se um bloco deve ou não conter redução espaço-temporal. layers_per_block (`tuple[int, ...]`, padrão `(4, 3, 3, 3, 4)`) : O número de camadas por bloco. patch_size (`int`, padrão `4`) : O tamanho dos patches espaciais. patch_size_t (`int`, padrão `1`) : O tamanho dos patches temporais. resnet_norm_eps (`float`, padrão `1e-6`) : Valor de epsilon para as camadas de normalização do ResNet. scaling_factor (`float`, *opcional*, padrão `1.0`) : O desvio padrão componente a componente do espaço latente treinado, calculado usando o primeiro lote do conjunto de treinamento. Isso é usado para escalar o espaço latente para ter variância unitária ao treinar o modelo de difusão. Os latentes são escalados com a fórmula `z = z * scaling_factor` antes de serem passados para o modelo de difusão. Ao decodificar, os latentes são escalados de volta para a escala original com a fórmula: `z = 1 / scaling_factor * z`. Para mais detalhes, consulte as seções 4.3.2 e D.1 do paper [High-Resolution Image Synthesis with Latent Diffusion Models](https://huggingface.co/papers/2112.10752). encoder_causal (`bool`, padrão `True`) : Se o codificador deve se comportar de forma causal (quadros futuros dependem apenas de quadros passados) ou não. decoder_causal (`bool`, padrão `False`) : Se o decodificador deve se comportar de forma causal (quadros futuros dependem apenas de quadros passados) ou não. Um modelo VAE com perda KL para codificar imagens em latentes e decodificar representações latentes em imagens. Usado no [LTX-2](https://huggingface.co/Lightricks/LTX-2). Este modelo herda de [ModelMixin](/docs/diffusers/main/pt/api/models/overview#diffusers.ModelMixin). Consulte a documentação da superclasse para seus métodos genéricos implementados para todos os modelos (como download ou salvamento). #### decode[[diffusers.AutoencoderKLLTX2Video.decode]] ```python decode(z: Tensor, temb: typing.Optional[torch.Tensor] = None, causal: bool | None = None, return_dict: bool = True) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_ltx2.py#L1291) **Parâmetros:** z (`torch.Tensor`) : Lote de entrada de vetores latentes. return_dict (`bool`, *opcional*, padrão `True`) : Se deve retornar um `~models.vae.DecoderOutput` em vez de uma tupla simples. **Retorna:** `~models.vae.DecoderOutput` ou `tuple` Se return_dict for True, um `~models.vae.DecoderOutput` é retornado; caso contrário, uma `tuple` simples é retornada. Decodifique um lote de imagens. #### encode[[diffusers.AutoencoderKLLTX2Video.encode]] ```python encode(x: Tensor, causal: bool | None = None, return_dict: bool = True) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_ltx2.py#L1239) **Parâmetros:** x (`torch.Tensor`) : Lote de entrada de imagens. return_dict (`bool`, *opcional*, padrão `True`) : Se deve retornar um `~models.autoencoder_kl.AutoencoderKLOutput` em vez de uma tupla simples. **Retorna:** As representações latentes dos vídeos codificados. Se `return_dict` for True, um `~models.autoencoder_kl.AutoencoderKLOutput` é retornado; caso contrário, uma `tuple` simples é retornada. Codifica um lote de imagens em latentes. #### enable_tiling[[diffusers.AutoencoderKLLTX2Video.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) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_ltx2.py#L1192) **Parâmetros:** tile_sample_min_height (`int`, *opcional*) : A altura mínima necessária para que uma amostra seja separada em tiles ao longo da dimensão de altura. tile_sample_min_width (`int`, *opcional*) : A largura mínima necessária para que uma amostra seja separada em tiles ao longo da dimensão de largura. tile_sample_stride_height (`int`, *opcional*) : A quantidade mínima de sobreposição entre duas tiles verticais consecutivas. Isso garante que não haja artefatos de tiling produzidos ao longo da dimensão de altura. tile_sample_stride_width (`int`, *opcional*) : O deslocamento entre duas tiles horizontais consecutivas. Isso garante que não haja artefatos de tiling produzidos ao longo da dimensão de largura. Ativa a decodificação do VAE em blocos (tiled). Quando essa opção está ativada, o VAE divide o tensor de entrada em blocos para calcular a decodificação e a codificação em várias etapas. Isso é útil para economizar uma grande quantidade de memória e permitir o processamento de imagens maiores. #### forward[[diffusers.AutoencoderKLLTX2Video.forward]] ```python forward(sample: Tensor, temb: typing.Optional[torch.Tensor] = None, sample_posterior: bool = False, encoder_causal: bool | None = None, decoder_causal: bool | None = None, return_dict: bool = True, generator: typing.Optional[torch.Generator] = None) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_ltx2.py#L1535) **Parâmetros:** sample (`torch.Tensor`) : Amostra de entrada. temb (`torch.Tensor`, *opcional*) : Tensor opcional de incorporação de passo de tempo usado para condicionar o decodificador. sample_posterior (`bool`, *opcional*, padrão `False`) : Se deve amostrar da posterior. encoder_causal (`bool`, *opcional*) : Se o codificador deve usar convoluções causais. Se `None`, usa o padrão do modelo. decoder_causal (`bool`, *opcional*) : Se o decodificador deve usar convoluções causais. Se `None`, usa o padrão do modelo. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `DecoderOutput` em vez de uma tupla simples. generator (`torch.Generator`, *opcional*) : Um [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) para tornar a amostragem determinística. **Retorna:** `~models.vae.DecoderOutput` ou `tuple` Se `return_dict` for True, um `~models.vae.DecoderOutput` é retornado; caso contrário, uma `tuple` simples é retornada. #### tiled_decode[[diffusers.AutoencoderKLLTX2Video.tiled_decode]] ```python tiled_decode(z: Tensor, temb: typing.Optional[torch.Tensor], causal: bool | None = None, return_dict: bool = True) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_ltx2.py#L1405) **Parâmetros:** z (`torch.Tensor`) : Lote de entrada de vetores latentes. return_dict (`bool`, *opcional*, padrão `True`) : Se deve ou não retornar um `~models.vae.DecoderOutput` em vez de uma tupla simples. **Retorna:** `~models.vae.DecoderOutput` ou `tuple` Se return_dict for True, um `~models.vae.DecoderOutput` é retornado; caso contrário, uma `tuple` simples é retornada. Decodifique um lote de imagens usando um decodificador em mosaico. #### tiled_encode[[diffusers.AutoencoderKLLTX2Video.tiled_encode]] ```python tiled_encode(x: Tensor, causal: bool | None = None) ``` [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_ltx2.py#L1353) **Parâmetros:** x (`torch.Tensor`) : Lote de entrada de vídeos. **Retorna:** `torch.Tensor` A representação latente dos vídeos codificados. Codifique um lote de imagens usando um codificador em mosaico.