Hugging Face's logo

Transformers documentation

MusicGen Melody

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2023-06-08 et ajouté à Hugging Face Transformers le 2024-03-18.

MusicGen Melody

FlashAttention SDPA

Aperçu

Le modèle MusicGen Melody a été proposé dans Simple and Controllable Music Generation 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. Le code d'origine peut être trouvé ici. Les points de contrôle pré-entraînés sont disponibles sur le Hugging Face Hub.

Différence avec 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.
  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 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 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 :

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

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

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 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 avant d’utiliser l’extrait de code suivant :

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 :

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 :

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 :

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 :

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 peut être utilisé pour pré-traiter un prompt texte uniquement.

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 guidance_scale est utilisé dans le classifier free guidance (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 « nul »). Une valeur de guidance scale plus élevée encourage 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. Le CFG est activé en définissant guidance_scale > 1. Pour de meilleurs résultats, utilisez guidance_scale=3 (par défaut).

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


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() :

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, peuvent être trouvés dans la configuration de génération du modèle et mis à jour selon vos besoins :

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, soit comme modèle composite incluant l’encodeur de texte et l’encodeur audio, correspondant à la classe 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 :

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

Conversion de points de contrôle

  • Après avoir téléchargé les points de contrôle originaux depuis ici, 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 :
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

classe transformers.MusicgenMelodyDecoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 2048max_position_embeddings: int = 2048num_hidden_layers: int = 24ffn_dim: int = 4096num_attention_heads: int = 16layerdrop: float | int = 0.0use_cache: bool = Trueactivation_function: str = 'gelu'hidden_size: int = 1024dropout: float | int = 0.1attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0initializer_factor: float = 0.02scale_embedding: bool = Falsenum_codebooks: int = 4audio_channels: int = 1pad_token_id: int | None = 2048bos_token_id: int | None = 2048eos_token_id: int | list[int] | None = Nonetie_word_embeddings: bool = Falseis_decoder: bool = Falseadd_cross_attention: bool = False )

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, par défaut 2048) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
  • num_hidden_layers (int, facultatif, par défaut 24) — Nombre de couches cachées dans le décodeur Transformer.
  • ffn_dim (int, facultatif, 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, par défaut 0.0) — La probabilité de LayerDrop. Consultez l'article [LayerDrop](voir 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). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
  • activation_function (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à 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 appliqué aux 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, par défaut False) — Indique s'il faut mettre à l'échelle les embeddings 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, par défaut 2048) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
  • bos_token_id (int, facultatif, par défaut 2048) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
  • eos_token_id (Union[int, list[int]], facultatif) — Identifiant du 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, par défaut False) — Indique si le modèle est utilisé comme décodeur ou non. Si False, le modèle est utilisé comme encodeur.
  • add_cross_attention (bool, facultatif, valeur par défaut False) — Indique si des couches d'attention croisée doivent être ajoutées au modèle.

Ceci est 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, définissant ainsi 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

MusicgenMelodyProcessor

classe transformers.MusicgenMelodyProcessor

< >

( feature_extractortokenizer )

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 offre toutes les fonctionnalités de MusicgenMelodyFeatureExtractor et de T5Tokenizer. Consultez ~MusicgenMelodyFeatureExtractor et ~T5Tokenizer pour plus d’informations.

__call__

< >

( *args**kwargs )

Paramètres

  • return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.

get_unconditional_inputs

< >

( num_samples = 1return_tensors = 'pt' )

Paramètres

  • num_samples (int, facultatif) — Nombre d'échantillons audio à générer sans condition.

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

Exemple :

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

classe transformers.MusicgenMelodyFeatureExtractor

< >

( feature_size = 12sampling_rate = 32000hop_length = 4096chunk_length = 30n_fft = 16384num_chroma = 12padding_value = 0.0return_attention_mask = Falsestem_indices = [3, 2]**kwargs )

Paramètres

  • feature_size (int, facultatif, valeur par défaut 12) — La dimension des caractéristiques des fonctionnalités extraites.
  • sampling_rate (int, facultatif, valeur par défaut 32000) — La fréquence d'échantillonnage à laquelle les fichiers audio doivent être numérisés, exprimée en hertz (Hz).
  • hop_length (int, facultatif, par défaut 4096) — Longueur des fenêtres superposées pour la STFT utilisée pour obtenir les coefficients de fréquence de Mel.
  • chunk_length (int, facultatif, valeur par défaut 30) — Nombre maximal de chunks de sampling_rate échantillons utilisés pour rognner et compléter les séquences audio plus longues ou plus courtes.
  • n_fft (int, facultatif, par défaut 16384) — Taille de la transformée de Fourier.
  • num_chroma (int, facultatif, valeur par défaut 12) — Nombre de bins 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, 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 ?

    Pour les modèles Whisper, attention_mask doit toujours être transmis lors de l'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 fonctionnalités hérite de SequenceFeatureExtractor, qui contient la plupart des méthodes principales. Les utilisateurs doivent se référer à cette superclasse pour plus d'informations sur ces méthodes.

Cette classe extrait les caractéristiques chroma à partir d’audio traité par Demucs ou directement à partir de la forme d’onde audio brute.

MusicgenMelodyConfig

classe transformers.MusicgenMelodyConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonetext_encoder: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_encoder: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedecoder: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonenum_chroma: int = 12chroma_length: int = 235initializer_factor: float = 0.02 )

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 chroma à utiliser.
  • chroma_length (int, facultatif, par défaut 235) — Durée maximale du 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).

Ceci est 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, définissant ainsi 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

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.MusicgenMelodyModel

< >

( config: MusicgenMelodyDecoderConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)

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 des codes audio, comme avec EncodecModel. Voir EncodecModel.encode() pour plus de détails. Qu'est-ce que les identifiants d'entrée ? Les input_ids sont automatiquement convertis 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, comme 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 input_ids.

    Les indices peuvent être obtenus en encodant un prompt audio avec un modèle d’encodeur audio pour prédire des codes audio, comme avec le EncodecModel. Consultez EncodecModel.encode() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

    Les input_ids sont automatiquement converties 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, 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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. 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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 que la matrice de recherche d’intégration interne du modèle.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).

Retourne

BaseModelOutputWithPast ou tuple(torch.Tensor)

Un BaseModelOutputWithPast 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 (None) et des entrées.

La méthode forward du 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. Pour plus de détails, consultez notre guide sur le cache kv.

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

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

MusicgenMelodyForCausalLM

classe transformers.MusicgenMelodyForCausalLM

< >

( config: MusicgenMelodyDecoderConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneencoder_attention_mask: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MusicgenMelodyOutputWithPast or tuple(torch.Tensor)

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 des codes audio, comme avec EncodecModel. Voir EncodecModel.encode() pour plus de détails. Qu'est-ce que les identifiants d'entrée ? Les input_ids sont automatiquement convertis 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, comme 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 input_ids.

    Les indices peuvent être obtenus en encodant un prompt audio avec un modèle d’encodeur audio pour prédire des codes audio, comme avec le EncodecModel. Consultez EncodecModel.encode() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

    Les input_ids sont automatiquement converties 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, 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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. 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • past_key_values (~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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 que la matrice de recherche d’intégration interne du modèle.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur 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 en fonction de la configuration (MusicgenMelodyConfig) et des entrées.

La méthode forward de 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. Pour plus de détails, consultez notre guide sur le cache kv.

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

    Poids des attentions après le softmax d'attention, utilisés 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 :

MusicgenMelodyForConditionalGeneration

classe transformers.MusicgenMelodyForConditionalGeneration

< >

( config: MusicgenMelodyConfig = Nonetext_encoder: transformers.modeling_utils.PreTrainedModel | None = Noneaudio_encoder: transformers.modeling_utils.PreTrainedModel | None = Nonedecoder: transformers.models.musicgen_melody.modeling_musicgen_melody.MusicgenMelodyForCausalLM | None = None )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.BoolTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneencoder_hidden_states: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MusicgenMelodyOutputWithPast or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • attention_mask (torch.BoolTensor 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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. Voir MusicgenMelodyFeatureExtractor.__call__() pour plus de détails (MusicgenMelodyProcessor utilise 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. Consultez EncodecModel.encode() pour plus de détails. Que sont les IDs d'entrée du décodeur ? Les decoder_input_ids sont automatiquement convertis 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, 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.

    Les indices peuvent être obtenus en encodant un prompt audio avec un modèle d’encodeur audio pour prédire des codes audio, comme avec le EncodecModel. Consultez EncodecModel.encode() pour plus de détails.

    Quelles sont les identifiants d'entrée du décodeur ?

    Les decoder_input_ids sont automatiquement converties 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, 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 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 d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'est transmis, DynamicCache sera initialisé par défaut.

    Le modèle produira le même format de cache qui est 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 n’ont pas été 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é comme signal conditionnel, il sera donc concaténé 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 que 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é, facultativement, seules les dernières decoder_inputs_embeds doivent être entrées (voir past_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion des decoder_input_ids indices en vecteurs associés que 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 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 en fonction de la configuration (MusicgenMelodyConfig) et des entrées.

La méthode forward de 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. Pour plus de détails, consultez notre guide sur le cache kv.

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

    Poids des attentions après le softmax d'attention, utilisés 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 :

>>> 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])
Update on GitHub

←MusicGen Nemotron 3 Diarization→