Buckets:
| # AutoencoderKLMiniMaxH3 | |
| O modelo de autoencoder variacional de vídeo (VAE) com perda KL usado em [MiniMax-H3](https://huggingface.co/MiniMaxAI/MiniMax-H3) pela MiniMax. Ele combina um codificador de CNN 3D causal com um decodificador ViT não causal e comprime 16x espacialmente e 4x temporalmente. | |
| Três coisas o diferenciam da maioria dos autoencoders na biblioteca: | |
| - **Os latentes são normalizados por canal.** Não há `scaling_factor`: um pipeline codifica com `(latent - latents_mean) / latents_std` e decodifica com `latent * latents_std + latents_mean`. | |
| - **A convenção de pixels é RGB normalizado pelo ImageNet sobre um intervalo base de `[0, 1]`**, e não o intervalo usual de `[-1, 1]`. `encode` espera `(pixel - imagenet_mean) / imagenet_std` e `decode` retorna valores nesse mesmo espaço, de modo que um pipeline aplica `sample * imagenet_std + imagenet_mean` e limita para `[0, 1]` antes do pós-processamento. | |
| - **O tileamento espacial está ativado por padrão.** O MiniMax-H3 foi lançado com o tileamento ativado tanto para codificação quanto para decodificação, e os quadros liberados são os de tiles mesclados, portanto desativá-lo altera a saída. Use `enable_tiling` para alterar a geometria dos tiles e `disable_tiling` para desativá-lo. | |
| A geometria temporal é fixada por `clip_length` (17 quadros de pixels por bloco do codificador) e `token_drop` (3 quadros latentes finais descartados por codificação), de modo que `17 * n + 5` quadros de pixels correspondem a `5 * n + 2` quadros 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)) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py#L505) | |
| Um modelo VAE com um codificador de CNN 3D causal e um decodificador ViT não causal, usado no [MiniMax-H3](https://huggingface.co/MiniMaxAI). | |
| 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). | |
| Os latentes são normalizados com `latents_mean` / `latents_std` por canal, em vez de um `scaling_factor`; um pipeline codifica com `(latent - latents_mean) / latents_std` e decodifica com `latent * latents_std + latents_mean`. | |
| A convenção de pixels é RGB normalizado pelo ImageNet sobre uma faixa base de `[0, 1]`, e não a usual `[-1, 1]`: `encode` espera `(pixel - imagenet_mean) / imagenet_std` e `decode` retorna valores nesse mesmo espaço, portanto um pipeline deve aplicar `sample * imagenet_std + imagenet_mean` (média `(0.485, 0.456, 0.406)`, desvio padrão `(0.229, 0.224, 0.225)`) e limitar para `[0, 1]` antes do pós-processamento. | |
| A geometria temporal é fixada por `clip_length` (17 quadros de pixels por bloco do codificador) e `token_drop` (3 quadros latentes finais descartados por codificação): `17 * n + 5` quadros de pixels mapeiam para `5 * n + 2` quadros latentes. | |
| Diferente da maioria dos autoencoders da biblioteca, o tiling espacial está **ativado por padrão**: o MiniMax-H3 foi lançado com o tiling habilitado tanto para codificação quanto para decodificação, e os quadros publicados são os de tiles mesclados, portanto, desativar o tiling altera a saída. Use `enable_tiling` para alterar a geometria dos tiles e `disable_tiling` para desativá-lo. | |
| #### encode[[diffusers.AutoencoderKLMiniMaxH3.encode]] | |
| ```python | |
| encode(x: Tensor, return_dict: bool = True) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py#L855) | |
| **Parâmetros:** | |
| x (`torch.Tensor`) : Lote de entrada de vídeos, com forma `(batch_size, in_channels, num_frames, height, width)`. | |
| return_dict (`bool`, *opcional*, padrão `True`) : Se deve retornar um [AutoencoderKLOutput](/docs/diffusers/main/pt/api/models/autoencoderkl_qwenimage#diffusers.models.modeling_outputs.AutoencoderKLOutput) em vez de uma tupla simples. | |
| **Retorna:** | |
| A distribuição latente dos vídeos codificados. Observe que o MiniMax-H3 normaliza os latentes amostrados com `latents_mean` / `latents_std` em seguida. | |
| Codifique um lote de vídeos em latentes. | |
| #### decode[[diffusers.AutoencoderKLMiniMaxH3.decode]] | |
| ```python | |
| decode(z: Tensor, return_dict: bool = True) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py#L883) | |
| **Parâmetros:** | |
| z (`torch.Tensor`) : Lote de entrada de vídeos latentes, formato `(batch_size, latent_channels, num_latent_frames, height, width)`. | |
| return_dict (`bool`, *opcional*, padrão `True`) : Se deve retornar um [DecoderOutput](/docs/diffusers/main/pt/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) em vez de uma tupla simples. | |
| **Retorna:** [DecoderOutput](/docs/diffusers/main/pt/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) ou `tuple` | |
| Os vídeos decodificados, com forma `(batch_size, out_channels, num_frames, height, width)`. | |
| Decodifique um lote de vídeos 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) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py#L628) | |
| **Parâmetros:** | |
| tile_sample_min_height (`int`, *opcional*) : A altura do tile no espaço de pixels. Quadros mais altos que isso são divididos ao longo da dimensão de altura. | |
| tile_sample_min_width (`int`, *opcional*) : A largura do tile no espaço de pixels. Quadros mais largos que isso são divididos ao longo da dimensão de largura. | |
| tile_sample_min_overlap_height (`int`, *opcional*) : O mínimo de sobreposição, em pixels, entre duas tiles verticais consecutivas. | |
| tile_sample_min_overlap_width (`int`, *opcional*) : O mínimo de sobreposição, em pixels, entre duas tiles horizontais consecutivas. | |
| Ativa a codificação/decodificação em blocos (tiled) do VAE. Quando essa opção está ativada, o VAE divide os quadros em blocos, codifica ou decodifica cada bloco separadamente e mescla linearmente as sobreposições novamente. Isso reduz o requisito de memória e permite o processamento de quadros maiores. | |
| #### forward[[diffusers.AutoencoderKLMiniMaxH3.forward]] | |
| ```python | |
| forward(sample: Tensor, sample_posterior: bool = False, generator: typing.Optional[torch.Generator] = None, return_dict: bool = True) | |
| ``` | |
| [Fonte](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/autoencoders/autoencoder_kl_minimax_h3.py#L908) | |
| **Parâmetros:** | |
| sample (`torch.Tensor`) : Lote de entrada de vídeos, com forma `(batch_size, in_channels, num_frames, height, width)`. | |
| sample_posterior (`bool`, *opcional*, padrão `False`) : Se deve amostrar a posterior em vez de tomar seu modo. | |
| generator (`torch.Generator`, *opcional*) : Gerador usado quando `sample_posterior=True`. | |
| return_dict (`bool`, *opcional*, padrão `True`) : Se deve retornar um [DecoderOutput](/docs/diffusers/main/pt/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) em vez de uma tupla simples. | |
| **Retorna:** [DecoderOutput](/docs/diffusers/main/pt/api/models/autoencoderkl_qwenimage#diffusers.models.autoencoders.vae.DecoderOutput) ou `tuple` | |
| Os vídeos de ida e volta, com forma `(batch_size, out_channels, num_frames, height, width)`. | |
| Codifique e depois decodifique um lote de vídeos. | |
Xet Storage Details
- Size:
- 9.06 kB
- Xet hash:
- 08030691d870c395cd2f74553ffe86b8620d4a277f42b84584c2e215a5e27e54
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.