# AceStepTransformer1DModel

Un Diffusion Transformer 1D pour la génération musicale issu de [ACE-Step 1.5](https://github.com/ace-step/ACE-Step-1.5). Le modèle opère sur les latents stéréo à 25 Hz produits par [AutoencoderOobleck](/docs/diffusers/main/fr/api/models/autoencoder_oobleck#diffusers.AutoencoderOobleck) en utilisant le flow matching, et est entraîné avec un backbone dérivé de Qwen3 (attention à requêtes groupées, embedding de position rotatif, RMSNorm, conditionnement du pas de temps par AdaLN-Zero) ainsi qu'une cross-attention vers les conditions texte / paroles / timbre construites par `AceStepConditionEncoder`.

## AceStepTransformer1DModel[[diffusers.AceStepTransformer1DModel]]

#### diffusers.AceStepTransformer1DModel[[diffusers.AceStepTransformer1DModel]]

```python
diffusers.AceStepTransformer1DModel(hidden_size: int = 2048, intermediate_size: int = 6144, num_hidden_layers: int = 24, num_attention_heads: int = 16, num_key_value_heads: int = 8, head_dim: int = 128, in_channels: int = 192, audio_acoustic_hidden_dim: int = 64, patch_size: int = 2, rope_theta: float = 1000000.0, attention_bias: bool = False, attention_dropout: float = 0.0, rms_norm_eps: float = 1e-06, sliding_window: int = 128, layer_types: typing.Optional[typing.List[str]] = None, encoder_hidden_size: typing.Optional[int] = None, is_turbo: bool = False, model_version: typing.Optional[str] = None)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/ace_step_transformer.py#L432)

Diffusion Transformer pour la génération musicale ACE-Step 1.5.

Génère des latents audio conditionnés sur le texte, les paroles et le timbre. Utilise un encodage de patch 1D (`Conv1d` avec un pas de `patch_size`) suivi d'une pile de `AceStepTransformerBlock` avec une attention glissante / complète alternée sur la branche d'auto-attention. L'attention croisée consomme les `encoder_hidden_states` empaquetés produits par `AceStepConditionEncoder`.

#### forward[[diffusers.AceStepTransformer1DModel.forward]]

```python
forward(hidden_states: Tensor, timestep: Tensor, timestep_r: Tensor, encoder_hidden_states: Tensor, context_latents: Tensor, attention_kwargs: typing.Optional[dict] = None, return_dict: bool = True)
```

[Source](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/transformers/ace_step_transformer.py#L532)

**Paramètres :**

hidden_states (`torch.Tensor` de forme `(batch_size, seq_len, channels)`) : Entrée latente bruitée pour le processus de diffusion.

timestep (`torch.Tensor` de forme `(batch_size,)`) : Pas de diffusion actuel `t`.

timestep_r (`torch.Tensor` de forme `(batch_size,)`) : Pas de temps de référence `r` (fixé égal à `t` pour une inférence standard).

encoder_hidden_states (`torch.Tensor` de forme `(batch_size, encoder_seq_len, hidden_size)`) : Embeddings de conditionnement issus de l'encodeur de condition (texte + paroles + timbre).

context_latents (`torch.Tensor` de forme `(batch_size, seq_len, context_dim)`) : Latents de contexte (latents source concaténés avec les masques de blocs) — transmis à la convolution patchify avec `hidden_states`.

attention_kwargs (`dict`, *facultatif*) : Un dictionnaire de kwargs transmis à l'`AttentionProcessor`. Utilisé pour passer l'échelle LoRA via `{"scale": float}`.

return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un `Transformer2DModelOutput` ou un simple tuple.

**Retourne :** `Transformer2DModelOutput` ou `tuple`

Le champ de vitesse prédit.

La méthode forward du [AceStepTransformer1DModel](/docs/diffusers/main/fr/api/models/ace_step_transformer#diffusers.AceStepTransformer1DModel).