# MusicGen

## Aperçu

Le modèle MusicGen a été proposé dans l'article [Simple and Controllable Music Generation](https://huggingface.co/papers/2306.05284) par Jade Copet, Felix Kreuk, Itai Gat, Tal Remez, David Kant, Gabriel Synnaeve, Yossi Adi et Alexandre Défossez.

MusicGen est un modèle Transformer auto-régressif à un seul étage capable de générer des échantillons de musique de haute qualité conditionnés par des descriptions textuelles ou des prompts audio. Les descriptions textuelles sont transmises à un modèle d’encodeur de texte figé afin d’obtenir une séquence de représentations d’états cachés. MusicGen est ensuite entraîné à prédire des jetons audio discrets, ou *codes audio*, conditionnés par ces états cachés. Ces jetons audio sont ensuite décodés à l’aide d’un modèle de compression audio, tel qu’EnCodec, afin de récupérer la forme d’onde audio.

Grâce à un motif efficace d'entrelacement des jetons, MusicGen n'a pas besoin d'une représentation sémantique auto-supervisée des prompts texte/audio, éliminant ainsi la nécessité de mettre en cascade plusieurs modèles pour prédire un ensemble de codebooks (par exemple de manière hiérarchique ou par suréchantillonnage). Il est en mesure de générer tous les codebooks en une seule passe avant.

L'abstract de l'article est le suivant :

*Nous abordons la tâche de génération musicale conditionnelle. Nous présentons MusicGen, un unique modèle de langage (LM) qui opère sur plusieurs flux de représentation musicale discrète compressée, c'est-à-dire des jetons. Contrairement aux travaux antérieurs, MusicGen est composé d'un LM transformer à un seul stade associé à des motifs d'entrelacement de jetons efficaces, ce qui élimine le besoin d'enchaîner plusieurs modèles, par exemple de manière hiérarchique ou par suréchantillonnage. En suivant cette approche, nous démontrons comment MusicGen peut générer des échantillons de haute qualité, tout en étant conditionné par une description textuelle ou des caractéristiques mélodiques, permettant un meilleur contrôle sur la sortie générée. Nous menons une évaluation empirique approfondie, en tenant compte à la fois d'études automatiques et humaines, montrant que l'approche proposée est supérieure aux lignes de base évaluées sur un benchmark standard de texte vers musique. Grâce à des études d'ablation, nous mettons en lumière l'importance de chacun des composants constituant MusicGen.*

Ce modèle a été contribué par [sanchit-gandhi](https://huggingface.co/sanchit-gandhi). Le code d'origine peut être trouvé [ici](https://github.com/facebookresearch/audiocraft). Les points de contrôle pré-entraînés sont disponibles sur le [Hugging Face Hub](https://huggingface.co/models?sort=downloads&search=facebook%2Fmusicgen-).

## Conseils d'utilisation

- Après avoir téléchargé les points de contrôle originaux depuis [ici](https://github.com/facebookresearch/audiocraft/blob/main/docs/MUSICGEN.md#importing--exporting-models), vous pouvez les convertir à l'aide du **script de conversion** disponible à
`src/transformers/models/musicgen/convert_musicgen_transformers.py` avec la commande suivante :

```bash
python src/transformers/models/musicgen/convert_musicgen_transformers.py \
    --checkpoint small --pytorch_dump_folder /output/path
```

## Génération

MusicGen est compatible avec deux modes de génération : greedy et sampling. En pratique, le sampling donne des résultats nettement meilleurs que le greedy, nous vous encourageons donc à utiliser le mode sampling lorsque c’est possible. Le sampling est activé par défaut et peut être explicitement spécifié en définissant `do_sample=True` dans l’appel à `MusicgenForConditionalGeneration.generate()`, ou en écrasant la configuration de génération du modèle (voir ci-dessous).

La génération est limitée par les embeddings positionnels sinusoïdaux à des entrées de 30 secondes. Autrement dit, MusicGen ne peut pas générer plus de 30 secondes d'audio (1503 tokens), et l'audio d'entrée transmis par la génération avec prompt audio contribue à cette limite ; ainsi, pour une entrée de 20 secondes d'audio, MusicGen ne peut pas générer plus de 10 secondes d'audio supplémentaire.

Transformers prend en charge les variantes mono (1 canal) et stéréo (2 canaux) de MusicGen. Les versions mono génèrent un seul ensemble de codebooks. Les versions stéréo génèrent 2 ensembles de codebooks, 1 pour chaque canal (gauche/droite), et chaque ensemble de codebooks est décodé indépendamment par le modèle de compression audio. Les flux audio de chaque canal sont combinés pour produire la sortie stéréo finale.

### Génération non conditionnelle

Les entrées pour la génération inconditionnelle (ou « nulle ») peuvent être obtenues via la méthode `MusicgenForConditionalGeneration.get_unconditional_inputs()` :

```python
from transformers import MusicgenForConditionalGeneration

model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")
unconditional_inputs = model.get_unconditional_inputs(num_samples=1)

audio_values = model.generate(**unconditional_inputs, do_sample=True, max_new_tokens=256)
```

Les sorties audio sont des tenseurs Torch tridimensionnels de forme `(batch_size, num_channels, sequence_length)`. Pour écouter les échantillons audio générés, vous pouvez soit les lire dans un notebook ipynb :

```python
from IPython.display import Audio

sampling_rate = model.config.audio_encoder.sampling_rate
Audio(audio_values[0].numpy(), rate=sampling_rate)
```

Ou enregistrez-les dans un fichier `.wav` à l'aide d'une bibliothèque tierce, par exemple `scipy` :

```python
import scipy

sampling_rate = model.config.audio_encoder.sampling_rate
scipy.io.wavfile.write("musicgen_out.wav", rate=sampling_rate, data=audio_values[0, 0].numpy())
```

### Génération conditionnelle par le texte

Le modèle peut générer un échantillon audio conditionné par un prompt texte grâce à l'utilisation de [MusicgenProcessor](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenProcessor) pour pré-traiter les entrées :

```python
from transformers import AutoProcessor, MusicgenForConditionalGeneration

processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")

inputs = processor(
    text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
    padding=True,
    return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
```

Le paramètre `guidance_scale` est utilisé dans la guidance sans classifieur (CFG) pour définir le poids entre les logits conditionnels (prédits à partir des prompts texte) et les logits non conditionnels (prédits à partir d'un prompt non conditionnel ou « null »). Une valeur de guidance scale plus élevée incite le modèle à générer des échantillons plus étroitement liés au prompt d'entrée, généralement au détriment de la qualité audio. La CFG est activée en définissant `guidance_scale > 1`. Pour de meilleurs résultats, utilisez `guidance_scale=3` (valeur par défaut).

### Génération pilotée par l'audio

Le même [MusicgenProcessor](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenProcessor) peut être utilisé pour pré-traiter un prompt audio servant à la continuation audio. Dans l’exemple suivant, nous chargeons un fichier audio à l’aide de la bibliothèque 🤗 Datasets, qui peut être installée via pip grâce à la commande ci-dessous :

```bash
pip install --upgrade pip
pip install datasets[audio]
```

```python
from datasets import load_dataset

from transformers import AutoProcessor, MusicgenForConditionalGeneration

processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")

dataset = load_dataset("sanchit-gandhi/gtzan", split="train", streaming=True)
sample = next(iter(dataset))["audio"]

# take the first half of the audio sample
sample["array"] = sample["array"][: len(sample["array"]) // 2]

inputs = processor(
    audio=sample["array"],
    sampling_rate=sample["sampling_rate"],
    text=["80s blues track with groovy saxophone"],
    padding=True,
    return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
```

Pour la génération audio par lots, les `audio_values` générés peuvent être post-traités pour supprimer le bourrage à l'aide de la classe [MusicgenProcessor](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenProcessor) :

```python
from datasets import load_dataset

from transformers import AutoProcessor, MusicgenForConditionalGeneration

processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")

dataset = load_dataset("sanchit-gandhi/gtzan", split="train", streaming=True)
sample = next(iter(dataset))["audio"]

# take the first quarter of the audio sample
sample_1 = sample["array"][: len(sample["array"]) // 4]

# take the first half of the audio sample
sample_2 = sample["array"][: len(sample["array"]) // 2]

inputs = processor(
    audio=[sample_1, sample_2],
    sampling_rate=sample["sampling_rate"],
    text=["80s blues track with groovy saxophone", "90s rock song with loud guitars and heavy drums"],
    padding=True,
    return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)

# post-process to remove padding from the batched audio
audio_values = processor.batch_decode(audio_values, padding_mask=inputs.padding_mask)
```

### Configuration de génération

Les paramètres par défaut qui contrôlent le processus de génération, tels que l'échantillonnage, l'échelle de guidage et le nombre de jetons générés, se trouvent dans la configuration de génération du modèle et peuvent être mis à jour selon vos besoins :

```python
from transformers import MusicgenForConditionalGeneration

model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")

# inspect the default generation config
model.generation_config

# increase the guidance scale to 4.0
model.generation_config.guidance_scale = 4.0

# decrease the max length to 256 tokens
model.generation_config.max_length = 256
```

Notez que tout argument passé à la méthode generate **remplace** ceux de la configuration de génération, de sorte que définir `do_sample=False` dans l'appel à generate remplacera la valeur de `model.generation_config.do_sample` dans la configuration de génération.

## Structure du modèle

Le modèle MusicGen peut être décomposé en trois étapes distinctes :

1. Encodeur de texte : mappe les entrées textuelles vers une séquence de représentations d'états cachés. Les modèles MusicGen pré-entraînés utilisent un encodeur de texte figé issu de T5 ou de Flan-T5
2. Décodeur MusicGen : un modèle de langage (LM) qui génère de manière auto-régressive des jetons audio (ou des codes) conditionnés sur les représentations d'états cachés du codeur
3. Encodeur/décodeur audio : utilisé pour encoder un prompt audio afin de l'utiliser comme jetons de prompt, et pour récupérer la forme d'onde audio à partir des jetons audio prédits par le décodeur

Ainsi, le modèle MusicGen peut être utilisé soit comme modèle décodeur autonome, correspondant à la classe [MusicgenForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenForCausalLM), soit comme modèle composite incluant l’encodeur de texte et l’encodeur/décodeur audio, correspondant à la classe [MusicgenForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenForConditionalGeneration). Si seul le décodeur doit être chargé depuis le point de contrôle pré-entraîné, il peut être chargé en spécifiant d’abord la configuration appropriée, ou être accédé via l’attribut `.decoder` du modèle composite :

```python
from transformers import AutoConfig, MusicgenForCausalLM, MusicgenForConditionalGeneration

# Option 1: get decoder config and pass to `.from_pretrained`
decoder_config = AutoConfig.from_pretrained("facebook/musicgen-small").decoder
decoder = MusicgenForCausalLM.from_pretrained("facebook/musicgen-small", **decoder_config, device_map="auto")

# Option 2: load the entire composite model, but only return the decoder
decoder = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto").decoder
```

Les modèles d'encodeur de texte et d'encodeur/décodeur audio étant figés pendant l'entraînement, le décodeur MusicGen [MusicgenForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenForCausalLM) peut être entraîné de manière autonome sur un jeu de données d'états cachés de l'encodeur et de codes audio. Pour l'inférence, le décodeur entraîné peut être combiné avec l'encodeur de texte et les encodeurs/décodeurs audio figés afin de reconstituer le modèle composite [MusicgenForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenForConditionalGeneration).

Astuces :

* MusicGen est entraîné sur le point de contrôle 32 kHz d'Encodec. Vous devez vous assurer d'utiliser une version compatible du modèle Encodec.
* Le mode d’échantillonnage tend à donner de meilleurs résultats que le mode glouton – vous pouvez activer l’échantillonnage avec la variable `do_sample` dans l’appel à `MusicgenForConditionalGeneration.generate()`

## MusicgenDecoderConfig[[transformers.MusicgenDecoderConfig]]

#### transformers.MusicgenDecoderConfig[[transformers.MusicgenDecoderConfig]]

```python
transformers.MusicgenDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 2048, max_position_embeddings: int = 2048, num_hidden_layers: int = 24, ffn_dim: int = 4096, num_attention_heads: int = 16, layerdrop: float | int = 0.0, use_cache: bool = True, activation_function: str = 'gelu', hidden_size: int = 1024, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, initializer_factor: float = 0.02, scale_embedding: bool = False, num_codebooks: int = 4, audio_channels: int = 1, pad_token_id: int | None = 2048, bos_token_id: int | None = 2048, eos_token_id: int | list[int] | None = None, tie_word_embeddings: bool = False, is_decoder: bool = False, add_cross_attention: bool = False, cross_attention_hidden_size: int | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen/configuration_musicgen.py#L30)

**Paramètres :**

vocab_size (`int`, *facultatif*, par défaut `2048`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `2048`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

num_hidden_layers (`int`, *facultatif*, valeur par défaut `24`) : Nombre de couches cachées dans le décodeur Transformer.

ffn_dim (`int`, *facultatif*, valeur par défaut `4096`) : Dimension des représentations MLP.

num_attention_heads (`int`, *facultatif*, valeur par défaut `16`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

layerdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : La probabilité de LayerDrop. Consultez l'article [LayerDrop](see https://huggingface.co/papers/1909.11556) pour plus de détails.

use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement.

activation_function (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_size (`int`, *facultatif*, valeur par défaut `1024`) : Dimension des représentations cachées.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

activation_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée.

initializer_factor (`float`, *facultatif*, par défaut `0.02`) : un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation).

scale_embedding (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut mettre les embeddings à l'échelle en les divisant par sqrt(d_model).

num_codebooks (`int`, *facultatif*, par défaut `4`) : Le nombre de codebooks parallèles utilisés par le modèle.

audio_channels (`int`, *facultatif*, par défaut `1`) : Le nombre de canaux d'entrée.

pad_token_id (`int`, *facultatif*, valeur par défaut `2048`) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire.

bos_token_id (`int`, *facultatif*, valeur par défaut `2048`) : Identifiant de jeton utilisé pour le début de flux dans le vocabulaire.

eos_token_id (`Union[int, list[int]]`, *facultatif*) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

is_decoder (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le modèle est utilisé comme décodeur. Si `False`, le modèle est utilisé comme encodeur.

add_cross_attention (`bool`, *facultatif*, par défaut `False`) : Indique si des couches d'attention croisée doivent être ajoutées au modèle.

cross_attention_hidden_size (`int`, *facultatif*) : Taille cachée des sorties de l'encodeur projetée dans l'espace clé/valeur de l'attention croisée du décodeur. Utilisée lorsque l'encodeur et le décodeur ont des tailles cachées différentes.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un MusicgenModel. Elle est utilisée pour instancier un modèle Musicgen en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [facebook/musicgen-small](https://huggingface.co/facebook/musicgen-small)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

## MusicgenConfig[[transformers.MusicgenConfig]]

#### transformers.MusicgenConfig[[transformers.MusicgenConfig]]

```python
transformers.MusicgenConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_encoder: dict | transformers.configuration_utils.PreTrainedConfig | None = None, audio_encoder: dict | transformers.configuration_utils.PreTrainedConfig | None = None, decoder: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_factor: float = 0.02)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen/configuration_musicgen.py#L83)

**Paramètres :**

text_encoder (`Union[dict, `PretrainedConfig`]`) : Une instance d'un objet de configuration qui définit la configuration de l'encodeur de texte.

audio_encoder (`Union[dict, `PretrainedConfig`]`) : une instance d'un objet de configuration qui définit la configuration de l'encodeur audio.

decoder (`Union[dict, `PretrainedConfig`]`) : une instance d'un objet de configuration qui définit la configuration du décodeur.

initializer_factor (`float`, *facultatif*, par défaut `0.02`) : un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation).

Il s'agit de la classe de configuration destinée à stocker la configuration d'un MusicgenModel. Elle est utilisée pour instancier un modèle Musicgen en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [facebook/musicgen-small](https://huggingface.co/facebook/musicgen-small)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

Exemple :

```python
>>> from transformers import (
...     MusicgenConfig,
...     MusicgenDecoderConfig,
...     T5Config,
...     EncodecConfig,
...     MusicgenForConditionalGeneration,
... )

>>> # Initializing text encoder, audio encoder, and decoder model configurations
>>> text_encoder_config = T5Config()
>>> audio_encoder_config = EncodecConfig()
>>> decoder_config = MusicgenDecoderConfig()

>>> configuration = MusicgenConfig(
...     text_encoder=text_encoder_config,
...     audio_encoder=audio_encoder_config,
...     decoder=decoder_config,
... )

>>> # Initializing a MusicgenForConditionalGeneration (with random weights) from the facebook/musicgen-small style configuration
>>> model = MusicgenForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
>>> config_text_encoder = model.config.text_encoder
>>> config_audio_encoder = model.config.audio_encoder
>>> config_decoder = model.config.decoder

>>> # Saving the model, including its configuration
>>> model.save_pretrained("musicgen-model")

>>> # loading model and config from pretrained folder
>>> musicgen_config = MusicgenConfig.from_pretrained("musicgen-model")
>>> model = MusicgenForConditionalGeneration.from_pretrained("musicgen-model", config=musicgen_config)
```

## MusicgenProcessor[[transformers.MusicgenProcessor]]

#### transformers.MusicgenProcessor[[transformers.MusicgenProcessor]]

```python
transformers.MusicgenProcessor(feature_extractor, tokenizer)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen/processing_musicgen.py#L27)

**Paramètres :**

feature_extractor (`EncodecFeatureExtractor`) : l'extracteur de caractéristiques est une entrée obligatoire.

tokenizer (`T5Tokenizer`) : le tokenizer est une entrée obligatoire.

Construit un MusicgenProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.

[MusicgenProcessor](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenProcessor) offre toutes les fonctionnalités de [EncodecFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecFeatureExtractor) et de [T5Tokenizer](/docs/transformers/v5.23.0/fr/model_doc/t5#transformers.T5Tokenizer). Consultez [~EncodecFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecFeatureExtractor) et [~T5Tokenizer](/docs/transformers/v5.23.0/fr/model_doc/t5#transformers.T5Tokenizer) pour plus d’informations.

#### __appel__[[transformers.MusicgenProcessor.__call__]]

```python
__call__(*args, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen/processing_musicgen.py#L34)

**Paramètres :**

return_tensors (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy.

## MusicgenModel[[transformers.MusicgenModel]]

#### transformers.MusicgenModel[[transformers.MusicgenModel]]

```python
transformers.MusicgenModel(config: MusicgenDecoderConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen/modeling_musicgen.py#L551)

**Paramètres :**

config ([MusicgenDecoderConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenDecoderConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Musicgen brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.MusicgenModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen/modeling_musicgen.py#L564)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size * num_codebooks, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire, correspondant à la séquence de codes audio. Les indices peuvent être obtenus en encodant un prompt audio avec un modèle d'encodeur audio pour prédire les codes audio, par exemple avec [EncodecModel](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel). Consultez [EncodecModel.encode()](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel.encode) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) `input_ids` sera automatiquement converti de la forme `(batch_size * num_codebooks, target_sequence_length)` à `(batch_size, num_codebooks, target_sequence_length)` lors du passage avant. Si vous obtenez des codes audio à partir d'un modèle d'encodage audio, tel que [EncodecModel](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel), assurez-vous que le nombre de trames est égal à 1, et que vous redimensionnez les codes audio de `(frames, batch_size, num_codebooks, target_sequence_length)` à `(batch_size * num_codebooks, target_sequence_length)` avant de les transmettre en tant que `input_ids`.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

encoder_hidden_states (`torch.Tensor` de forme `(batch_size, encoder_sequence_length, hidden_size)`, *facultatif*) : Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisée dans l'attention croisée du décodeur.

encoder_attention_mask (`torch.LongTensor` de forme `(batch_size, encoder_sequence_length)`, *facultatif*) : Masque pour éviter d'effectuer l'attention croisée sur les indices des jetons de bourrage de l'entrée encodeur. Les valeurs du masque sont sélectionnées dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPastAndCrossAttentions](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MusicgenConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenConfig)) et les entrées.

La méthode forward du [MusicgenModel](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` et `config.add_cross_attention=True` sont passés ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.

## MusicgenForCausalLM[[transformers.MusicgenForCausalLM]]

#### transformers.MusicgenForCausalLM[[transformers.MusicgenForCausalLM]]

```python
transformers.MusicgenForCausalLM(config: MusicgenDecoderConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen/modeling_musicgen.py#L628)

**Paramètres :**

config ([MusicgenDecoderConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenDecoderConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle décodeur MusicGen avec une tête de modélisation de langage au sommet.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.MusicgenForCausalLM.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, encoder_hidden_states: typing.Optional[torch.Tensor] = None, encoder_attention_mask: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen/modeling_musicgen.py#L656)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size * num_codebooks, sequence_length)`) : Indices des jetons de la séquence d'entrée dans le vocabulaire, correspondant à la séquence de codes audio. Les indices peuvent être obtenus en encodant un prompt audio avec un modèle d'encodeur audio pour prédire les codes audio, par exemple avec [EncodecModel](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel). Consultez [EncodecModel.encode()](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel.encode) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) `input_ids` sera automatiquement converti de la forme `(batch_size * num_codebooks, target_sequence_length)` à `(batch_size, num_codebooks, target_sequence_length)` lors du passage avant. Si vous obtenez des codes audio à partir d'un modèle d'encodage audio, tel que [EncodecModel](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel), assurez-vous que le nombre de trames est égal à 1, et que vous redimensionnez les codes audio de `(frames, batch_size, num_codebooks, target_sequence_length)` à `(batch_size * num_codebooks, target_sequence_length)` avant de les transmettre en tant que `input_ids`.

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

encoder_hidden_states (`torch.Tensor` de forme `(batch_size, encoder_sequence_length, hidden_size)`, *facultatif*) : Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisée dans l'attention croisée du décodeur.

encoder_attention_mask (`torch.LongTensor` de forme `(batch_size, encoder_sequence_length)`, *facultatif*) : Masque pour éviter d'effectuer l'attention croisée sur les indices des jetons de bourrage de l'entrée encodeur. Les valeurs du masque sont sélectionnées dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length, num_codebooks)`, *facultatif*) : Étiquettes pour le modélisation du langage. Notez que les étiquettes **sont décalées** à l'intérieur du modèle, c'est-à-dire que vous pouvez définir `labels = input_ids` Les indices sont sélectionnés dans `[-100, 0, ..., config.vocab_size]` Toutes les étiquettes définies sur `-100` sont ignorées (masquées), la perte n'est calculée que pour les étiquettes dans `[0, ..., config.vocab_size]`

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) ou `tuple(torch.Tensor)`

Un [CausalLMOutputWithCrossAttentions](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithCrossAttentions) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MusicgenConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenConfig)) et les entrées.

La méthode forward de [MusicgenForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenForCausalLM) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant).
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids des attentions croisées après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.

Exemple :

```python
```

## MusicgenForConditionalGeneration[[transformers.MusicgenForConditionalGeneration]]

#### transformers.MusicgenForConditionalGeneration[[transformers.MusicgenForConditionalGeneration]]

```python
transformers.MusicgenForConditionalGeneration(config: transformers.models.musicgen.configuration_musicgen.MusicgenConfig | None = None, text_encoder: transformers.modeling_utils.PreTrainedModel | None = None, audio_encoder: transformers.modeling_utils.PreTrainedModel | None = None, decoder: transformers.models.musicgen.modeling_musicgen.MusicgenForCausalLM | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen/modeling_musicgen.py#L1104)

**Paramètres :**

config ([MusicgenConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenConfig), *facultatif*) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

text_encoder (`PreTrainedModel`, *facultatif*) : Le modèle d'encodeur de texte qui encode le texte en états cachés pour le conditionnement.

audio_encoder (`PreTrainedModel`, *facultatif*) : Le modèle d'encodeur audio qui encode l'audio en états cachés pour le conditionnement.

decoder (`MusicgenForCausalLM`, *facultatif*) : Le modèle décodeur qui génère des jetons audio à partir de signaux de conditionnement.

Le modèle composite MusicGen avec un encodeur de texte, un encodeur audio et un décodeur Musicgen,

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

#### forward[[transformers.MusicgenForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.BoolTensor] = None, input_values: typing.Optional[torch.Tensor] = None, padding_mask: typing.Optional[torch.BoolTensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: tuple[torch.Tensor] | None = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, decoder_inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen/modeling_musicgen.py#L1420)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.BoolTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'effectuer l'attention sur les indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

input_values (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Valeurs flottantes de la forme d'onde brute de l'entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio `.flac` ou `.wav` dans un tableau de type `list[float]`, un `numpy.ndarray` ou un `torch.Tensor`, *par exemple* via la bibliothèque torchcodec (`pip install torchcodec`) ou la bibliothèque soundfile (`pip install soundfile`). Pour préparer le tableau en `input_values`, il faut utiliser [AutoProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoProcessor) pour l'ajout de bourrage (padding) et la conversion en tenseur de type `torch.Tensor`. Voir [MusicgenProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenProcessor.__call__) pour plus de détails.

padding_mask (`torch.BoolTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'effectuer l'attention sur les indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` de forme `(batch_size * num_codebooks, target_sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire, correspondant à la séquence de codes audio. Les indices peuvent être obtenus en encodant un prompt audio avec un modèle d'encodeur audio pour prédire des codes audio, par exemple avec [EncodecModel](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel). Voir [EncodecModel.encode()](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel.encode) pour plus de détails. [Que sont les identifiants d'entrée du décodeur ?](../glossary#decoder-input-ids) `decoder_input_ids` sera automatiquement converti de la forme `(batch_size * num_codebooks, target_sequence_length)` à `(batch_size, num_codebooks, target_sequence_length)` lors du passage avant. Si vous obtenez des codes audio à partir d'un modèle d'encodage audio, tel que [EncodecModel](/docs/transformers/v5.23.0/fr/model_doc/encodec#transformers.EncodecModel), assurez-vous que le nombre de trames est égal à 1, et que vous redimensionnez les codes audio de `(frames, batch_size, num_codebooks, target_sequence_length)` à `(batch_size * num_codebooks, target_sequence_length)` avant de les passer en tant que `decoder_input_ids`.

decoder_attention_mask (`torch.LongTensor` de forme `(batch_size, target_sequence_length)`, *facultatif*) : Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dans `decoder_input_ids`. Un masque causal sera également utilisé par défaut.

encoder_outputs (`tuple[torch.Tensor]`, *facultatif*) : Le tuple est composé de (`last_hidden_state`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `last_hidden_state` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.

past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`.  Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut.  Le modèle renverra le même format de cache que celui fourni en entrée.  Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

decoder_inputs_embeds (`torch.Tensor` de forme `(batch_size, target_sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `decoder_input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Si `past_key_values` est utilisé, il est facultatif de n'entrer que les derniers `decoder_inputs_embeds` (voir `past_key_values`). Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `decoder_input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. Si `decoder_input_ids` et `decoder_inputs_embeds` sont tous deux non définis, `decoder_inputs_embeds` prend la valeur de `inputs_embeds`.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length, num_codebooks)`, *facultatif*) : Étiquettes pour le modélisation du langage. Notez que les étiquettes **sont décalées** à l'intérieur du modèle, c'est-à-dire que vous pouvez définir `labels = input_ids` Les indices sont sélectionnés dans `[-100, 0, ..., config.vocab_size]` Toutes les étiquettes définies sur `-100` sont ignorées (masquées), la perte n'est calculée que pour les étiquettes dans `[0, ..., config.vocab_size]`

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

**Retourne :** [Seq2SeqLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou `tuple(torch.Tensor)`

Un [Seq2SeqLMOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.Seq2SeqLMOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments en fonction de la configuration ([MusicgenConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenConfig)) et des entrées.

La méthode forward de [MusicgenForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/musicgen#transformers.MusicgenForConditionalGeneration) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage.
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **past_key_values** (`EncoderDecoderCache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [EncoderDecoderCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.EncoderDecoderCache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **decoder_hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
- **decoder_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
- **cross_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
- **encoder_last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.
- **encoder_hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`.

  États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
- **encoder_attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`.

  Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemples :
```python
>>> from transformers import AutoProcessor, MusicgenForConditionalGeneration
>>> import torch

>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")

>>> inputs = processor(
...     text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
...     padding=True,
...     return_tensors="pt",
... )

>>> pad_token_id = model.generation_config.pad_token_id
>>> decoder_input_ids = (
...     torch.ones((inputs.input_ids.shape[0] * model.decoder.num_codebooks, 1), dtype=torch.long)
...     * pad_token_id
... )

>>> logits = model(**inputs, decoder_input_ids=decoder_input_ids).logits
>>> logits.shape  # (bsz * num_codebooks, tgt_len, vocab_size)
torch.Size([8, 1, 2048])
```

