# MusicGen Melody

## Aperçu

Le modèle MusicGen Melody a été proposé dans [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 Melody est un modèle Transformer auto-régressif à un seul stade 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, pour 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 [ylacombe](https://huggingface.co/ylacombe). 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).

## Différence avec [MusicGen](./musicgen)

Il y a deux différences clés par rapport à MusicGen :

1. L’invite audio est utilisée ici comme signal conditionnel pour l’échantillon audio généré, tandis qu’elle sert à la continuation audio dans [MusicGen](./musicgen).
2. Les signaux conditionnels de texte et d'audio sont concaténés aux états cachés du décodeur, au lieu d'être utilisés comme signal d'attention croisée, comme dans MusicGen.

## Génération

MusicGen Melody 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 à `MusicgenMelodyForConditionalGeneration.generate()`, ou en écrasant la configuration de génération du modèle (voir ci-dessous).

Transformers prend en charge les variantes mono (1 canal) et stéréo (2 canaux) de MusicGen Melody. 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 via 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 conditionnelle audio

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

Dans les exemples suivants, nous chargeons un fichier audio à l'aide de la bibliothèque 🤗 Datasets, qui peut être installée via pip à l'aide de la commande ci-dessous :

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

Le fichier audio que nous allons utiliser est chargé comme suit :

```python
from datasets import load_dataset

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

L’invite audio doit idéalement être exempte des signaux de basse fréquence généralement produits par des instruments tels que les tambours et les basses. Le modèle [Demucs](https://github.com/adefossez/demucs/tree/main) peut être utilisé pour séparer les voix et les autres signaux des composantes tambours et basses.

Si vous souhaitez utiliser Demucs, vous devez d’abord suivre les étapes d’installation [ici](https://github.com/adefossez/demucs/tree/main?tab=readme-ov-file#for-musicians) avant d’utiliser l’extrait de code suivant :

```python
import torch
from demucs import pretrained
from demucs.apply import apply_model
from demucs.audio import convert_audio

wav = torch.tensor(sample["array"]).to(torch.float32)

demucs = pretrained.get_model('htdemucs')

wav = convert_audio(wav[None], sample["sampling_rate"], demucs.samplerate, demucs.audio_channels)
wav = apply_model(demucs, wav[None])
```

Vous pouvez ensuite utiliser le fragment de code suivant pour générer de la musique :

```python
from transformers import AutoProcessor, MusicgenMelodyForConditionalGeneration

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

inputs = processor(
    audio=wav,
    sampling_rate=demucs.samplerate,
    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)
```

Vous pouvez également passer le signal audio directement sans utiliser Demucs, bien que la qualité de la génération soit probablement dégradée :

```python
from transformers import AutoProcessor, MusicgenMelodyForConditionalGeneration

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

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)
```

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 `soundfile` :

```python
import soundfile as sf

sampling_rate = model.config.audio_encoder.sampling_rate
sf.write("musicgen_out.wav", audio_values[0].T.numpy(), sampling_rate)
```

### Génération conditionnelle uniquement sur le texte

Le même [MusicgenMelodyProcessor](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyProcessor) peut être utilisé pour pré-traiter un prompt texte uniquement.

```python
from transformers import AutoProcessor, MusicgenMelodyForConditionalGeneration

processor = AutoProcessor.from_pretrained("facebook/musicgen-melody")
model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody", 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).

Vous pouvez également générer par lot :

```python

from transformers import AutoProcessor, MusicgenMelodyForConditionalGeneration

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

# 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)
```

### Génération non conditionnelle

Les entrées pour la génération inconditionnelle (ou « nulle ») peuvent être obtenues via la méthode [MusicgenMelodyProcessor.get_unconditional_inputs()](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyProcessor.get_unconditional_inputs) :

```python
from transformers import MusicgenMelodyForConditionalGeneration, MusicgenMelodyProcessor

model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody", device_map="auto")
unconditional_inputs = MusicgenMelodyProcessor.from_pretrained("facebook/musicgen-melody").get_unconditional_inputs(num_samples=1)

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

### 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 MusicgenMelodyForConditionalGeneration

model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody", 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 de mélodie 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. Décodeur audio : utilisé 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 [MusicgenMelodyForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyForCausalLM), soit comme modèle composite incluant l’encodeur de texte et l’encodeur audio, correspondant à la classe [MusicgenMelodyForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyForConditionalGeneration). 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 correcte, ou être accédé via l’attribut `.decoder` du modèle composite :

```python
from transformers import AutoConfig, MusicgenMelodyForCausalLM, MusicgenMelodyForConditionalGeneration

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

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

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

## Conversion de points de contrôle

- 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 à l'adresse `src/transformers/models/musicgen_melody/convert_musicgen_melody_transformers.py` avec la commande suivante :

```bash
python src/transformers/models/musicgen_melody/convert_musicgen_melody_transformers.py \
    --checkpoint="facebook/musicgen-melody" --pytorch_dump_folder /output/path 
```

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 à `MusicgenMelodyForConditionalGeneration.generate()`

## MusicgenMelodyDecoderConfig[[transformers.MusicgenMelodyDecoderConfig]]

#### transformers.MusicgenMelodyDecoderConfig[[transformers.MusicgenMelodyDecoderConfig]]

```python
transformers.MusicgenMelodyDecoderConfig(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)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen_melody/configuration_musicgen_melody.py#L28)

**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*, valeur par défaut : 1) : Nombre de canaux audio utilisés par le modèle (mono ou stéréo). Les modèles stéréo génèrent un flux audio distinct pour les canaux de sortie gauche/droite. Les modèles mono génèrent un seul flux audio en sortie.

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.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un MusicgenMelodyModel. Elle est utilisée pour instancier un modèle Musicgen Melody 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-melody](https://huggingface.co/facebook/musicgen-melody)

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.

## MusicgenMelodyProcessor[[transformers.MusicgenMelodyProcessor]]

#### transformers.MusicgenMelodyProcessor[[transformers.MusicgenMelodyProcessor]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen_melody/processing_musicgen_melody.py#L29)

**Paramètres :**

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

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

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

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

#### __appel__[[transformers.MusicgenMelodyProcessor.__call__]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen_melody/processing_musicgen_melody.py#L37)

**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.

#### get_unconditional_inputs[[transformers.MusicgenMelodyProcessor.get_unconditional_inputs]]

```python
get_unconditional_inputs(num_samples = 1, return_tensors = 'pt')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen_melody/processing_musicgen_melody.py#L90)

**Paramètres :**

num_samples (int, *facultatif*) : Nombre d'échantillons audio à générer inconditionnellement.

Fonction utilitaire pour obtenir des entrées nulles pour la génération non conditionnelle, permettant d'utiliser le modèle sans extracteur de caractéristiques ni tokeniseur.

Exemple :
```python
>>> from transformers import MusicgenMelodyForConditionalGeneration, MusicgenMelodyProcessor

>>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody")

>>> # get the unconditional (or 'null') inputs for the model
>>> processor = MusicgenMelodyProcessor.from_pretrained("facebook/musicgen-melody")
>>> unconditional_inputs = processor.get_unconditional_inputs(num_samples=1)

>>> audio_samples = model.generate(**unconditional_inputs, max_new_tokens=256)
```

## MusicgenMelodyFeatureExtractor[[transformers.MusicgenMelodyFeatureExtractor]]

#### transformers.MusicgenMelodyFeatureExtractor[[transformers.MusicgenMelodyFeatureExtractor]]

```python
transformers.MusicgenMelodyFeatureExtractor(feature_size = 12, sampling_rate = 32000, hop_length = 4096, chunk_length = 30, n_fft = 16384, num_chroma = 12, padding_value = 0.0, return_attention_mask = False, stem_indices = [3, 2], **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen_melody/feature_extraction_musicgen_melody.py#L40)

**Paramètres :**

feature_size (`int`, *facultatif*, par défaut 12) : La dimension des caractéristiques des fonctionnalités extraites.

sampling_rate (`int`, *facultatif*, valeur par défaut 32000) : Le taux d'échantillonnage auquel les fichiers audio doivent être numérisés, exprimé en hertz (Hz).

hop_length (`int`, *facultatif*, valeur par défaut 4096) : Longueur des fenêtres superposées pour la STFT utilisée pour obtenir les coefficients de fréquence Mel.

chunk_length (`int`, *facultatif*, valeur par défaut : 30) : Nombre maximal de blocs de `sampling_rate` échantillons utilisés pour rober et compléter les séquences audio plus longues ou plus courtes.

n_fft (`int`, *facultatif*, valeur par défaut 16384) : Taille de la transformée de Fourier.

num_chroma (`int`, *facultatif*, valeur par défaut 12) : Nombre de bins de chroma à utiliser.

padding_value (`float`, *facultatif*, valeur par défaut 0.0) : Valeur de bourrage utilisée pour bourrer l'audio.

return_attention_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut retourner le masque d'attention. Peut être écrasé lors de l'appel de l'extracteur de caractéristiques.  [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask)    Pour les modèles Whisper, `attention_mask` doit toujours être transmis pour une inférence par lots, afin d'éviter des bugs subtils.

stem_indices (`list[int]`, *facultatif*, par défaut `[3, 2]`) : Canaux de tige à extraire si des sorties demucs sont transmises.

Construit un extracteur de fonctionnalités MusicgenMelody.

Cet extracteur de caractéristiques hérite de [SequenceFeatureExtractor](/docs/transformers/v5.23.0/fr/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), qui contient la plupart des méthodes principales. Les utilisateurs doivent se reporter à cette superclasse pour plus d'informations sur ces méthodes.

Cette classe extrait les caractéristiques chroma à partir d’audio traité par [Demucs](https://github.com/adefossez/demucs/tree/main) ou directement à partir de la forme d’onde audio brute.

## MusicgenMelodyConfig[[transformers.MusicgenMelodyConfig]]

#### transformers.MusicgenMelodyConfig[[transformers.MusicgenMelodyConfig]]

```python
transformers.MusicgenMelodyConfig(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, num_chroma: int = 12, chroma_length: int = 235, initializer_factor: float = 0.02)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen_melody/configuration_musicgen_melody.py#L86)

**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.

num_chroma (`int`, *facultatif*, valeur par défaut 12) : Nombre de bins de chroma à utiliser.

chroma_length (`int`, *facultatif*, valeur par défaut : 235) : Durée maximale de la chroma si l'audio est utilisé pour conditionner le modèle. Correspond à la durée maximale utilisée lors de l'entraînement.

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 MusicgenMelodyModel. Elle est utilisée pour instancier un modèle Musicgen Melody 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-melody](https://huggingface.co/facebook/musicgen-melody)

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 (
...     MusicgenMelodyConfig,
...     MusicgenMelodyDecoderConfig,
...     T5Config,
...     EncodecConfig,
...     MusicgenMelodyForConditionalGeneration,
... )

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

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

>>> # Initializing a MusicgenMelodyForConditionalGeneration (with random weights) from the facebook/musicgen-melody style configuration
>>> model = MusicgenMelodyForConditionalGeneration(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_melody-model")

>>> # loading model and config from pretrained folder
>>> musicgen_melody_config = MusicgenMelodyConfig.from_pretrained("musicgen_melody-model")
>>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("musicgen_melody-model", config=musicgen_melody_config)
```

## MusicgenMelodyModel[[transformers.MusicgenMelodyModel]]

#### transformers.MusicgenMelodyModel[[transformers.MusicgenMelodyModel]]

```python
transformers.MusicgenMelodyModel(config: MusicgenMelodyDecoderConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen_melody/modeling_musicgen_melody.py#L539)

**Paramètres :**

config ([MusicgenMelodyDecoderConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyDecoderConfig)) : 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 Melody brut, produisant 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.MusicgenMelodyModel.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_melody/modeling_musicgen_melody.py#L552)

**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 représentant la concaténation de la sortie du codeur de texte et de la sortie du codeur audio traité. Utilisé comme signal conditionnel, il sera donc concaténé aux `decoder_input_ids` projetés.

encoder_attention_mask (`torch.LongTensor` de forme `(batch_size, encoder_sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention sur les états cachés conditionnels. Valeurs du masque 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 :** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 (`None`) et les entrées.

La méthode forward du [MusicgenMelodyModel](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyModel) 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.

## MusicgenMelodyForCausalLM[[transformers.MusicgenMelodyForCausalLM]]

#### transformers.MusicgenMelodyForCausalLM[[transformers.MusicgenMelodyForCausalLM]]

```python
transformers.MusicgenMelodyForCausalLM(config: MusicgenMelodyDecoderConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen_melody/modeling_musicgen_melody.py#L623)

**Paramètres :**

config ([MusicgenMelodyDecoderConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyDecoderConfig)) : 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 de décodeur Musicgen Melody 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.MusicgenMelodyForCausalLM.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, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen_melody/modeling_musicgen_melody.py#L651)

**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 représentant la concaténation de la sortie du codeur de texte et de la sortie du codeur audio traité. Utilisé comme signal conditionnel, il sera donc concaténé aux `decoder_input_ids` projetés.

encoder_attention_mask (`torch.LongTensor` de forme `(batch_size, encoder_sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention sur les états cachés conditionnels. Valeurs du masque 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`).

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]`

**Retourne :** `MusicgenMelodyOutputWithPast` ou `tuple(torch.Tensor)`

Un `MusicgenMelodyOutputWithPast` 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 ([MusicgenMelodyConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyConfig)) et les entrées.

La méthode forward de [MusicgenMelodyForCausalLM](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyForCausalLM) 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).
- **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) 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.
- **encoder_hidden_states** (`torch.Tensor` de forme `(batch_size, encoder_sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés conditionnels représentant la concaténation de la sortie du codeur de texte projetée et de la sortie du codeur audio projetée. Utilisé comme signal conditionnel.

Exemple :

```python
```

## MusicgenMelodyForConditionalGeneration[[transformers.MusicgenMelodyForConditionalGeneration]]

#### transformers.MusicgenMelodyForConditionalGeneration[[transformers.MusicgenMelodyForConditionalGeneration]]

```python
transformers.MusicgenMelodyForConditionalGeneration(config: MusicgenMelodyConfig = None, text_encoder: transformers.modeling_utils.PreTrainedModel | None = None, audio_encoder: transformers.modeling_utils.PreTrainedModel | None = None, decoder: transformers.models.musicgen_melody.modeling_musicgen_melody.MusicgenMelodyForCausalLM | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/musicgen_melody/modeling_musicgen_melody.py#L1091)

**Paramètres :**

config ([MusicgenMelodyConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyConfig), *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 (`MusicgenMelodyForCausalLM`, *facultatif*) : Le modèle décodeur qui génère des jetons audio à partir de signaux de conditionnement.

Le modèle Musicgen Melody pour la génération de jetons conditionnée sur d'autres modalités (par exemple, la génération d'image-texte vers texte).

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.MusicgenMelodyForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.BoolTensor] = None, input_features: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_attention_mask: typing.Optional[torch.BoolTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, encoder_hidden_states: typing.Optional[torch.Tensor] = 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_melody/modeling_musicgen_melody.py#L1388)

**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_features (`torch.Tensor` de forme `(batch_size, sequence_length, feature_dim)`, *facultatif*) : Les tenseurs correspondant aux caractéristiques audio d’entrée. Les caractéristiques audio peuvent être obtenues à l’aide de [MusicgenMelodyFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyFeatureExtractor). Voir `MusicgenMelodyFeatureExtractor.__call__()` pour plus de détails ([MusicgenMelodyProcessor](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyProcessor) utilise [MusicgenMelodyFeatureExtractor](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyFeatureExtractor) pour le traitement des audios).

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.

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)`.

encoder_hidden_states (`torch.Tensor` de forme `(batch_size, encoder_sequence_length, hidden_size)`, *facultatif*) : Séquence d'états cachés conditionnels représentant la concaténation de la sortie du codeur de texte projetée et de la sortie du codeur audio projetée. Utilisée comme signal conditionnel, elle sera donc concaténée aux `decoder_input_ids` projetés.

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 :** `MusicgenMelodyOutputWithPast` ou `tuple(torch.Tensor)`

Un `MusicgenMelodyOutputWithPast` 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 ([MusicgenMelodyConfig](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyConfig)) et les entrées.

La méthode forward de [MusicgenMelodyForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/musicgen_melody#transformers.MusicgenMelodyForConditionalGeneration) 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).
- **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) 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.
- **encoder_hidden_states** (`torch.Tensor` de forme `(batch_size, encoder_sequence_length, hidden_size)`, *facultatif*) -- Séquence d'états cachés conditionnels représentant la concaténation de la sortie du codeur de texte projetée et de la sortie du codeur audio projetée. Utilisé comme signal conditionnel.

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

>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-melody")
>>> model = MusicgenMelodyForConditionalGeneration.from_pretrained("facebook/musicgen-melody")

>>> 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, encoder_len + tgt_len, vocab_size)
torch.Size([8, 249, 2048])
```

