# AutoencodeurSAME

L'autoencodeur **SAME** (Semantically-Aligned Music Encoder) est utilisé par [Stable Audio 3](https://stability.ai/news-updates/meet-stable-audio-3-the-model-family-built-for-artistic-experimentation-with-open-weight-models) pour compresser les formes d'onde audio stéréo en une séquence latente compacte et les reconstruire.

L'encodeur empile des modules `SAMETransformerResamplingBlock`, chacun regroupant un nombre fixe de trames de patch audio et produisant un jeton de sortie apprenable via un transformeur différentiel. Le décodeur inverse ce processus, en étendant chaque jeton latent en un patch de trames audio.

Un goulot d'étranglement soft-norm (`SoftNormBottleneck`) normalise les latents avant et après le modèle de diffusion, offrant des dynamiques d'entraînement stables.

## AutoencodeurSAME[[diffusers.AutoencoderSAME]]

#### diffusers.AutoencoderSAME[[diffusers.AutoencoderSAME]]

```python
diffusers.AutoencoderSAME(audio_channels: int = 2, patch_size: int = 256, encoder_channels: int = 128, encoder_c_mults: typing.List[int] = (6,), encoder_strides: typing.List[int] = (16,), encoder_transformer_depths: typing.List[int] = (6,), latent_dim: int = 256, use_differential_attention: bool = True, dim_heads: int = 64, ff_mult: int = 3, sliding_window: int = 1, encoder_sinusoidal_blocks: typing.List[int] = (0,), decoder_sinusoidal_blocks: typing.List[int] = (0,), sampling_rate: int = 44100)
```

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

**Paramètres :**

audio_channels : Nombre de canaux audio (2 pour la stéréo).

patch_size : Taille de patch non chevauchante appliquée avant l'encodeur TRB (et inversée après le décodeur TRB). Contribue à `patch_size ×` au ratio total de sous-échantillonnage. Valeur de production : 256.

encoder_channels : Nombre de canaux de base pour le TRB. 128 pour SAME-S, 256 pour SAME-L.

encoder_c_mults : Multiplicateur de canaux pour chaque niveau TRB (une entrée par TRB). SAME-S et SAME-L utilisent tous deux `(6,)` — un seul TRB dont la dimension cachée est `encoder_channels × 6`.

encoder_strides : Pas de sous-/sur-échantillonnage pour chaque niveau TRB. SAME-S et SAME-L utilisent tous deux `(16,)` — un TRB avec un pas de 16.

encoder_transformer_depths : Nombre de couches Transformer par niveau TRB. 6 pour SAME-S, 12 pour SAME-L.

latent_dim : Dimension de l'espace latent. 256 pour les deux variantes.

use_differential_attention : Si `True`, utilise l'attention différentielle à l'intérieur de chaque bloc transformer TRB (activé par défaut pour SAME-S/L).

dim_heads : Dimension de la tête d'attention. 64 pour SAME-S/L de production.

ff_mult : facteur d'expansion du réseau de propagation avant SwiGLU.

sliding_window : Demi-largeur de la fenêtre glissante (en latents) pour l'attention par masque de bande. La production SAME-S/L utilise 1.

encoder_sinusoidal_blocks : Nombre de couches de transformeur de fin qui utilisent le gating FFN `sin` dans l'encodeur, par TRB (SAME-L : `(0,)`).

decoder_sinusoidal_blocks : Nombre de couches de transformeur de fin de TRB qui utilisent le gating FFN `sin` dans le décodeur (SAME-L : `(8,)`).

sampling_rate : Fréquence d'échantillonnage audio en Hz (par exemple, 44100).

Autoencodeur Semantically-Aligned Music Encoder (SAME) issu de *Stable Audio 3* ([arXiv 2605.17991](https://arxiv.org/abs/2605.17991)).

Le modèle est composé de :

- **Embedding de patch** — redimensionne l'audio stéréo en patches non superposés, échangeant le temps contre les canaux (`patch_size ×` de sous-échantillonnage, aucun paramètre appris).
- **Pile TRB de l'encodeur** — des blocs `SAMETransformerResamplingBlock` qui effectuent un sous-échantillonnage supplémentaire par un facteur de `∏(encoder_strides)`.
- **Bouteille à col de norme douce** — normalisation affine apprenable avec écart-type courant.
- **Pile TRB du décodeur** — miroir de l'encodeur en sens inverse.
- **Unpatch** — redonne aux canaux leur dimension temporelle.

Taux de sous-échantillonnage total : `patch_size × ∏(encoder_strides)`.

Les hyperparamètres par défaut correspondent au point de contrôle **SAME-S** (`stabilityai/SAME-S`). Pour charger **SAME-L** (`stabilityai/SAME-L`, utilisé par SA3 Medium), passez `encoder_channels=256, encoder_transformer_depths=(12,)`.

```python
# SAME-S (108 M params, used by SA3 small models) model = AutoencoderSAME() # default values

# SAME-L (852 M params, used by SA3 Medium) model = AutoencoderSAME(encoder_channels=256,
encoder_transformer_depths=(12,))
```

#### encode[[diffusers.AutoencoderSAME.encode]]

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

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

**Paramètres :**

sample : tenseur d'onde `(B, audio_channels, T)`.

return_dict : Si `True`, renvoie un `AutoencoderSAMEOutput`.

**Retourne :**

Tenseur latent de forme `(B, latent_dim, T // downsampling_ratio)` (enveloppé dans `AutoencoderSAMEOutput` lorsque *return_dict* est `True`).

Encoder l'audio stéréo en latents.

#### decode[[diffusers.AutoencoderSAME.decode]]

```python
decode(latents: Tensor, return_dict: bool = True)
```

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

**Paramètres :**

latents : tenseur latent `(B, latent_dim, T_latent)`.

return_dict : Si `True`, renvoie un `AutoencoderSAMEDecoderOutput`.

**Retourne :**

Tenseur de forme `(B, audio_channels, T_latent × downsampling_ratio)` (enveloppé dans `AutoencoderSAMEDecoderOutput` lorsque *return_dict* est `True`).

Décoder les latents en audio stéréo.

#### forward[[diffusers.AutoencoderSAME.forward]]

```python
forward(sample: Tensor, return_dict: bool = True)
```

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

**Paramètres :**

sample : tenseur d'onde `(B, audio_channels, T)`.

return_dict : Si `True`, renvoie un `AutoencoderSAMEDecoderOutput`.

**Retourne :**

Forme d’onde reconstruite (même forme que *sample*, potentiellement plus longue en raison du bourrage), encapsulée dans `AutoencoderSAMEDecoderOutput` lorsque *return_dict* est `True`.

Encoder puis décoder immédiatement *sample* (reconstruction).

## SAMETransformerResamplingBlock[[diffusers.models.autoencoders.autoencoder_same.SAMETransformerResamplingBlock]]

#### diffusers.models.autoencoders.autoencoder_same.SAMETransformerResamplingBlock[[diffusers.models.autoencoders.autoencoder_same.SAMETransformerResamplingBlock]]

```python
diffusers.models.autoencoders.autoencoder_same.SAMETransformerResamplingBlock(in_channels: int, out_channels: int, stride: int, mode: str = 'encoder', transformer_depth: int = 3, dim_heads: int = 128, use_differential: bool = True, ff_mult: int = 3, sliding_window: int = 1, sinusoidal_blocks: int = 0)
```

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

**Paramètres :**

in_channels : Nombre de canaux d'entrée.

out_channels : Nombre de canaux de sortie.

stride : Facteur de sous-/sur-échantillonnage.

mode : `"encoder"` ou `"decoder"`.

transformer_depth : Nombre de couches `TransformerBlock`.

dim_heads : Dimension des têtes d'attention.

use_differential : Indique s'il faut utiliser l'attention différentielle.

ff_mult : Facteur d'expansion du réseau de propagation avant.

sliding_window : Demi-largeur de la fenêtre glissante en latents (la demi-largeur de la bande est `sliding_window * (stride + 1)`).

sinusoidal_blocks : Nombre de couches de transformer finales qui utilisent le gating FFN `sin` au lieu de SiLU.

Bloc de construction principal de SAME.

**Mode encodeur** (pas S) : regroupe S trames d’entrée consécutives en un segment, y ajoute un unique embedding de sortie apprenable, puis exécute D couches de transformeur sur la séquence de segment aplatie complète et ne conserve que l’embedding de sortie → sous-échantillonnage par S.

**Mode décodeur** (pas S) : regroupe 1 trame d'entrée avec S embeddings de sortie apprenables, exécute D couches de transformeur sur la séquence aplatie complète, puis conserve les S embeddings de sortie → suréchantillonnage par S.

L'attention utilise un masque de bande à *fenêtre glissante* chevauchante sur la séquence de segments aplatie : chaque jeton porte son attention sur `sliding_window * (stride + 1)` voisins de chaque côté. Le RoPE est calculé sur la longueur totale de la séquence. Cela correspond exactement à l'implémentation de référence (un seul morceau non chevauchant ne correspondrait que pour un segment).

## AutoencoderSAMEOutput[[diffusers.models.autoencoders.autoencoder_same.AutoencoderSAMEOutput]]

#### diffusers.models.autoencoders.autoencoder_same.AutoencoderSAMEOutput[[diffusers.models.autoencoders.autoencoder_same.AutoencoderSAMEOutput]]

```python
diffusers.models.autoencoders.autoencoder_same.AutoencoderSAMEOutput(latents: Tensor)
```

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

Sortie de [AutoencoderSAME.encode()](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_same#diffusers.AutoencoderSAME.encode).

## AutoencoderSAMEDecoderOutput[[diffusers.models.autoencoders.autoencoder_same.AutoencoderSAMEDecoderOutput]]

#### diffusers.models.autoencoders.autoencoder_same.AutoencoderSAMEDecoderOutput[[diffusers.models.autoencoders.autoencoder_same.AutoencoderSAMEDecoderOutput]]

```python
diffusers.models.autoencoders.autoencoder_same.AutoencoderSAMEDecoderOutput(sample: Tensor)
```

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

Sortie de [AutoencoderSAME.decode()](/docs/diffusers/v0.43.0/fr/api/models/autoencoder_same#diffusers.AutoencoderSAME.decode).