# VAEs de Kandinsky 6

Kandinsky 6 utiliza un K-VAE 3D causal para la superresolución de video y el VAE de mel-espectrograma de MMAudio, junto con un [MMAudioVocoder](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVocoder) BigVGAN independiente, para la generación de audio sincronizado.

## Kandinsky6SRVAE[[diffusers.Kandinsky6SRVAE]]

El K-VAE causal 3D utilizado por [Kandinsky6SRPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline). Procesa videos de longitud arbitraria en segmentos de memoria acotada, reproduciendo la salida exacta de una única pasada no segmentada.

```python
import torch
from diffusers import Kandinsky6SRVAE

vae = Kandinsky6SRVAE.from_pretrained(
    "kandinskylab/Kandinsky-6.0-VSR-5s-Diffusers", subfolder="vae", torch_dtype=torch.bfloat16
)
```

#### diffusers.Kandinsky6SRVAE[[diffusers.Kandinsky6SRVAE]]

```python
diffusers.Kandinsky6SRVAE(in_channels: int = 3, out_channels: int = 3, latent_channels: int = 64, encoder_block_out_channels: tuple[int, ...] = (16, 128, 256, 512, 1024), decoder_block_out_channels: tuple[int, ...] = (16, 256, 512, 1024, 2048), layers_per_block: int = 2, temporal_compression_ratio: int = 4, temporal_compression_start_level: int = 1, scaling_factor: float = 0.910344004631042)
```

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

**Parámetros:**

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

out_channels (`int`, por defecto `3`) : Número de canales de píxeles reconstruidos.

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

encoder_block_out_channels (`tuple[int, ...]`, por defecto `(16, 128, 256, 512, 1024)`) : Ancho de salida de los bloques residuales en cada nivel del codificador; cada nivel, excepto el último, reduce a la mitad el tamaño espacial y duplica el ancho al pasar al siguiente nivel.

decoder_block_out_channels (`tuple[int, ...]`, por defecto `(16, 256, 512, 1024, 2048)`) : Ancho de salida de los bloques residuales en cada nivel del decodificador.

layers_per_block (`int`, por defecto `2`) : Número de bloques residuales por nivel del codificador; el decodificador usa uno más por nivel.

temporal_compression_ratio (`int`, por defecto `4`) : Factor de compresión temporal; `log2` de sus niveles consecutivos también comprime el tiempo.

temporal_compression_start_level (`int`, por defecto `1`) : Primer nivel que comprime el tiempo.

scaling_factor (`float`, por defecto `0.910344`) : Escala aplicada a los latentes antes de que entren en el transformador de difusión.

Causal 3D K-VAE utilizado por [Kandinsky6SRPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6SRPipeline) para codificar y decodificar video.

Los videos se procesan en segmentos temporales de 16 fotogramas de píxeles (más el fotograma inicial). Las convoluciones causales conservan su estado de relleno entre segmentos, por lo que la segmentación solo limita la memoria máxima y no altera el resultado.

#### encode[[diffusers.Kandinsky6SRVAE.encode]]

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

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

**Parámetros:**

x (`torch.Tensor` de forma `(batch_size, channels, num_frames, height, width)`) : Video de píxeles en `[-1, 1]`. `num_frames` debe ser `1 + k * temporal_compression_ratio`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un [AutoencoderKLOutput](/docs/diffusers/main/es/api/models/autoencoderkl_qwenimage#diffusers.models.modeling_outputs.AutoencoderKLOutput) en lugar de una tupla simple.

Codifica un video en su distribución latente.

#### decode[[diffusers.Kandinsky6SRVAE.decode]]

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

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

**Parámetros:**

z (`torch.Tensor` de forma `(batch_size, latent_channels, num_latent_frames, height, width)`) : Latentes, ya divididos por `scaling_factor`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un `~models.autoencoder_kl.DecoderOutput` en lugar de una tupla simple.

Decodifica los latentes en un video.

#### forward[[diffusers.Kandinsky6SRVAE.forward]]

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

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

**Parámetros:**

sample (`torch.Tensor` de forma `(batch_size, channels, num_frames, height, width)`) : Video de píxeles en `[-1, 1]`. `num_frames` debe ser `1 + k * temporal_compression_ratio`.

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

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un `~models.autoencoder_kl.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.autoencoder_kl.DecoderOutput` o `tuple`

Si `return_dict` es True, se devuelve un `~models.autoencoder_kl.DecoderOutput`; en caso contrario, se devuelve una `tuple` simple. Su `sample` es el video reconstruido.

## MMAudioVAE[[diffusers.MMAudioVAE]]

El VAE de espectrograma mel utilizado por [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline) cuando `sample_audio=True`. La salida de su `decode` es un espectrograma mel; pásalo por [MMAudioVocoder](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVocoder) para obtener una forma de onda.

La implementación de referencia se encuentra en [hkchengrex/MMAudio](https://github.com/hkchengrex/MMAudio) (licencia MIT).

```python
import torch
from diffusers import MMAudioVAE

audio_vae = MMAudioVAE.from_pretrained(
    "kandinskylab/Kandinsky-6.0-Pro-distill-5s-Diffusers", subfolder="audio_vae", torch_dtype=torch.bfloat16
)
```

#### diffusers.MMAudioVAE[[diffusers.MMAudioVAE]]

```python
diffusers.MMAudioVAE(mel_bins: int = 128, latent_channels: int = 40, hidden_channels: int = 512, channel_multipliers: tuple[int, ...] = (1, 2, 4), layers_per_block: int = 2, sample_rate: int = 44100, n_fft: int = 2048, hop_length: int = 512, scaling_factor: float = 0.417)
```

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

**Parámetros:**

mel_bins (`int`, por defecto `128`) : Número de bins mel.

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

hidden_channels (`int`, por defecto `512`) : Ancho base del autoencoder.

channel_multipliers (`tuple[int, ...]`, por defecto `(1, 2, 4)`) : Multiplicadores de anchura de los niveles del autoencoder.

layers_per_block (`int`, por defecto `2`) : Bloques residuales por nivel del codificador; el decodificador usa uno más por nivel.

sample_rate (`int`, por defecto `44100`) : Tasa de muestreo de la forma de onda.

n_fft (`int`, por defecto `2048`) : Tamaño de la FFT del frente mel.

hop_length (`int`, por defecto `512`) : Longitud del salto de la parte frontal mel. Debe coincidir con el factor total de remuestreo ascendente del [MMAudioVocoder](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVocoder) con el que se empareja este VAE.

scaling_factor (`float`, por defecto `0.417`) : Escala aplicada a los latentes antes de que entren en el transformador de difusión.

VAE de audio de [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline): un autoencoder que preserva la magnitud sobre espectrogramas log-mel (MMAudio, https://arxiv.org/abs/2412.15322).

`encode` convierte una forma de onda en una distribución latente; `decode` convierte los latentes de vuelta en un espectrograma mel, que [MMAudioVocoder](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVocoder) luego convierte en una forma de onda. Un marco latente cubre `hop_length * 2` muestras.

#### encode[[diffusers.MMAudioVAE.encode]]

```python
encode(audio: torch.Tensor, return_dict: bool = True)
```

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

**Parámetros:**

audio (`torch.Tensor` de forma `(batch_size, num_samples)`) : Forma de onda mono en `[-1, 1]` a `sample_rate`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un [AutoencoderKLOutput](/docs/diffusers/main/es/api/models/autoencoderkl_qwenimage#diffusers.models.modeling_outputs.AutoencoderKLOutput) en lugar de una tupla simple.

Codifica una forma de onda en su distribución latente.

#### decode[[diffusers.MMAudioVAE.decode]]

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

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

**Parámetros:**

z (`torch.Tensor` de forma `(batch_size, latent_channels, num_latent_frames)`) : Latentes, ya divididos por `scaling_factor`.

return_dict (`bool`, por defecto `True`) : Si se debe devolver un `~models.autoencoder_kl.DecoderOutput` en lugar de una tupla simple.

**Devuelve:**

El espectrograma mel de forma `(batch_size, mel_bins, num_mel_frames)`, listo para [MMAudioVocoder](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVocoder).

Decodifica los latentes en un espectrograma mel.

#### forward[[diffusers.MMAudioVAE.forward]]

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

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

**Parámetros:**

sample (`torch.Tensor` de forma `(batch_size, num_samples)`) : Forma de onda mono en `[-1, 1]` a `sample_rate` para codificar y reconstruir como un espectrograma mel.

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

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un `~models.autoencoder_kl.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.autoencoder_kl.DecoderOutput` o `tuple`

Si `return_dict` es True, se devuelve un `~models.autoencoder_kl.DecoderOutput`; en caso contrario, se devuelve una `tuple` simple. Su `sample` es el espectrograma mel reconstruido de forma `(batch_size, mel_bins, num_mel_frames)`.

## MMAudioVocoder[[diffusers.MMAudioVocoder]]

Adaptado de los paquetes de vocoder MMAudio de BigVGAN-v2, a su vez de [NVIDIA/BigVGAN](https://github.com/NVIDIA/BigVGAN) (licencia MIT), con las activaciones Snake anti-alias de [alias-free-torch](https://github.com/junjun3518/alias-free-torch) (Apache License 2.0).

#### diffusers.MMAudioVocoder[[diffusers.MMAudioVocoder]]

```python
diffusers.MMAudioVocoder(num_mels: int = 128, upsample_initial_channel: int = 1536, upsample_rates: tuple[int, ...] = (8, 4, 2, 2, 2, 2), upsample_kernel_sizes: tuple[int, ...] = (16, 8, 4, 4, 4, 4), resblock_kernel_sizes: tuple[int, ...] = (3, 7, 11), resblock_dilation_sizes: tuple[tuple[int, ...], ...] = ((1, 3, 5), (1, 3, 5), (1, 3, 5)))
```

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

**Parámetros:**

num_mels (`int`, por defecto `128`) : Número de bins mel del espectrograma de entrada. Debe coincidir con `mel_bins` del [MMAudioVAE](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVAE) emparejado.

upsample_initial_channel (`int`, por defecto `1536`) : Ancho de la primera capa.

upsample_rates (`tuple[int, ...]`, por defecto `(8, 4, 2, 2, 2, 2)`) : Factores de remuestreo ascendente de las etapas del vocoder. Su producto es el factor total de remuestreo ascendente y debe coincidir con el `hop_length` del [MMAudioVAE](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVAE) emparejado.

upsample_kernel_sizes (`tuple[int, ...]`, por defecto `(16, 8, 4, 4, 4, 4)`) : Tamaños de los núcleos de la convolución transpuesta de las etapas del vocoder.

resblock_kernel_sizes (`tuple[int, ...]`, por defecto `(3, 7, 11)`) : Tamaños de los núcleos de los bloques residuales.

resblock_dilation_sizes (`tuple[tuple[int, ...], ...]`, por defecto `((1, 3, 5), (1, 3, 5), (1, 3, 5))`) : Dilataciones de los bloques residuales.

Vocoder BigVGAN-v2 (https://github.com/NVIDIA/BigVGAN, licencia MIT) con las activaciones Snake anti-alias de https://github.com/junjun3518/alias-free-torch (Apache 2.0), que convierte los espectrogramas mel que decodifica [MMAudioVAE](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVAE) en formas de onda para [Kandinsky6TI2VAPipeline](/docs/diffusers/main/es/api/pipelines/kandinsky6#diffusers.Kandinsky6TI2VAPipeline).

#### forward[[diffusers.MMAudioVocoder.forward]]

```python
forward(mel: torch.Tensor, return_dict: bool = True)
```

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

**Parámetros:**

mel (`torch.Tensor` de forma `(batch_size, num_mels, num_mel_frames)`) : Espectrograma mel, decodificado por [MMAudioVAE](/docs/diffusers/main/es/api/models/kandinsky6_vae#diffusers.MMAudioVAE).

return_dict (`bool`, por defecto `True`) : Si se debe devolver un `~models.autoencoder_kl.DecoderOutput` en lugar de una tupla simple.

**Devuelve:**

La forma de onda de forma `(batch_size, 1, num_samples)` en `[-1, 1]`.