Transformers documentation
Music Flamingo
Ce modèle a été publié dans HF papers le 2025-11-13 et contribué à Hugging Face Transformers le 2026-03-30.
Music Flamingo
Aperçu
Music Flamingo est un grand modèle audio-langage entièrement ouvert, conçu pour une compréhension et un raisonnement robustes sur la musique. Il s'appuie sur l'architecture Audio Flamingo 3 en intégrant des Rotary Time Embeddings (RoTE), qui injectent des informations de position temporelle afin de permettre au modèle de traiter des séquences audio allant jusqu'à 20 minutes (1200 secondes).
Le point de contrôle du modèle est disponible à l'adresse : nvidia/music-flamingo-2601-hf
Points forts :
- Encodeur audio unifié pour la parole, les sons et la musique.
- Embeddings temporels rotatifs (RoTE) pour un modélisation temporelle améliorée, permettant de prendre en charge jusqu'à 20 minutes d'audio.
- Prise en charge étendue des longs audios via fenêtrage et alignement post-pooling (jusqu'à 20 minutes maximum). Le modèle traite l'audio par fenêtres de 30 secondes avec une limite stricte de 40 fenêtres (20 minutes au total). Tout audio d'une durée supérieure à 20 minutes sera tronqué.
- Tokens de délimitation de son spéciaux (
<|sound_bos|>et<|sound_eos|>) pour une modélisation améliorée des séquences audio. - Fusion déterministe qui préserve la longueur de la séquence en remplaçant les jetons de placeholder audio par des embeddings audio.
Ce modèle a été contribué par Lasha Koroshinadze et Eric Bezzam.
Article
Music Flamingo : l’extension de la compréhension musicale dans les modèles de langage audio
S. Ghosh, A. Goel, L. Koroshinadze, S. Lee, Z. Kong, J. F. Santos, R. Duraiswami, D. Manocha, W. Ping, M. Shoeybi, B. Catanzaro
NVIDIA et University of Maryland
Projet : https://research.nvidia.com/labs/adlr/MF/
Utilisation
Mode Instruct Audio
Le modèle prend en charge les instructions audio-texte, y compris les interactions multi-tours, le tout traité par lots.
➡️ audio + instruction text
from transformers import AutoProcessor, MusicFlamingoForConditionalGeneration
model_id = "nvidia/music-flamingo-2601-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = MusicFlamingoForConditionalGeneration.from_pretrained(model_id, device_map="auto")
conversation = [
{
"role": "user",
"content": [
{"type": "text", "text": "Describe this track in full detail - tell me the genre, tempo, and key, then dive into the instruments, production style, and overall mood it creates."},
{"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_1.mp3"},
],
}
]
inputs = processor.apply_chat_template(
conversation,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
).to(model.device)
inputs["input_features"] = inputs["input_features"].to(model.dtype)
outputs = model.generate(**inputs, max_new_tokens=500)
decoded_outputs = processor.batch_decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)➡️ multi-tours :
from transformers import AutoProcessor, MusicFlamingoForConditionalGeneration
model_id = "nvidia/music-flamingo-2601-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = MusicFlamingoForConditionalGeneration.from_pretrained(model_id, device_map="auto")
conversation = [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Write a rich caption that blends the technical details (genre, BPM, key, chords, mix) with how the song feels emotionally and dynamically as it unfolds.",
},
{"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_1.mp3"},
],
},
{
"role": "assistant",
"content": [{"type": "text", "text": "This energetic Eurodance anthem at 150 BPM in E major combines bright synth arpeggios with a punchy four-on-the-floor beat..."}],
},
{
"role": "user",
"content": [
{"type": "text", "text": "What instruments stand out the most?"},
],
},
]
inputs = processor.apply_chat_template(
conversation,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
).to(model.device)
inputs["input_features"] = inputs["input_features"].to(model.dtype)
outputs = model.generate(**inputs, max_new_tokens=500)
decoded_outputs = processor.batch_decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)➡️ inférence par lots !
from transformers import AutoProcessor, MusicFlamingoForConditionalGeneration
model_id = "nvidia/music-flamingo-2601-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = MusicFlamingoForConditionalGeneration.from_pretrained(model_id, device_map="auto")
conversations = [
[
{
"role": "user",
"content": [
{"type": "text", "text": "Describe this track in full detail - tell me the genre, tempo, and key, then dive into the instruments, production style, and overall mood it creates."},
{
"type": "audio",
"path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_1.mp3",
},
],
}
],
[
{
"role": "user",
"content": [
{
"type": "text",
"text": "Generate a structured lyric sheet from the input music.",
},
{"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_2.mp3"},
],
}
],
]
inputs = processor.apply_chat_template(
conversations,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
).to(model.device)
inputs["input_features"] = inputs["input_features"].to(model.dtype)
outputs = model.generate(**inputs, max_new_tokens=500)
decoded_outputs = processor.batch_decode(outputs[:, inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(decoded_outputs)➡️ Entraînement :
from transformers import AutoProcessor, MusicFlamingoForConditionalGeneration
model_id = "nvidia/music-flamingo-2601-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = MusicFlamingoForConditionalGeneration.from_pretrained(model_id, device_map="auto")
model.train()
conversation = [
[
{
"role": "user",
"content": [
{"type": "text", "text": "Break the track down like a critic - list its tempo, key, and chordal motion, then explain the textures, dynamics, and emotional impact of the performance."},
{"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_1.mp3"},
],
},
{
"role": "assistant",
"content": [{"type": "text", "text": "This Eurodance track operates at 150 BPM in E major, with harmonic movement centering on the I-vi-IV-V family. The production features layered synth arpeggios, a four-on-the-floor kick pattern, and a mezzo-soprano lead vocal with bright timbre. Dynamically, the track builds through verses into an anthemic chorus with full synth orchestration and backing vocals, creating an uplifting, euphoric atmosphere characteristic of late 2000s dance-pop."}],
}
],
[
{
"role": "user",
"content": [
{
"type": "text",
"text": "Describe this song from both a technical and artistic lens: mention tempo, harmony, and instrumentation, but also mood, lyrical themes, and structure.",
},
{"type": "audio", "path": "https://huggingface.co/datasets/nvidia/AudioSkills/resolve/main/assets/song_2.mp3"},
],
},
{
"role": "assistant",
"content": [{"type": "text", "text": "This electronic pop track combines upbeat production with playful lyrical themes centered around late-night pizza cravings. The structure follows a verse-chorus format with recurring melodic motifs and rhythmic patterns that emphasize the celebratory, lighthearted mood of the piece."}],
}
]
]
inputs = processor.apply_chat_template(
conversation,
tokenize=True,
add_generation_prompt=True,
return_dict=True,
processor_kwargs={"output_labels": True},
).to(model.device)
inputs["input_features"] = inputs["input_features"].to(model.dtype)
loss = model(**inputs).loss
loss.backward()Fonctionnement du modèle
Architecture
Encodeur audio Extracteur de caractéristiques et encodeur de type Whisper → moyenne sur le temps (pas 2) → LayerNorm. Produit des états cachés par image à la fréquence post-pooling.
Embeddings temporels rotatifs (RoTE) appliqués à la sortie de l'encodeur pour injecter des informations de position temporelle, permettant au modèle de traiter des séquences audio allant jusqu'à 20 minutes (1200 secondes). RoTE utilise des embeddings rotatifs axiaux 2D pour les dimensions de lot et de temps, avec une modulation des angles basée sur le temps.
MusicFlamingoMultiModalProjector Un petit MLP qui mappe les caractéristiques de l’encodeur vers la taille cachée du modèle de langage.
MusicFlamingoForConditionalGeneration Un modèle de langage causal qui accepte des embeddings de texte dans lesquels chaque emplacement de jeton de remplacement audio est remplacé, sur place, par un embedding de trame audio. Utilise des jetons de frontière spéciaux (
<|sound_bos|>et<|sound_eos|>) pour marquer les séquences audio. La fusion n’entraîne aucun changement de longueur de séquence.
Alignement au niveau du processeur
- Chaque forme d’onde brute est découpée en fenêtres de longueur fixe en fonction de
chunk_length(secondes) et desampling_rate(Hz) de l’extracteur de caractéristiques. - Pour chaque fenêtre, le processeur calcule le nombre de trames post-pooling
post_pool_lenque le encodeur produira (correspondant à l'agenda conv/pool). - Le processeur étend le jeton de placeholder audio par le nombre total de trames post-pooling sur toutes les fenêtres.
- Le modèle remplace ensuite ces positions de jetons par les embeddings audio projetés correspondants.
Audio long et fenêtrage
Important : la durée maximale de l'audio est de 20 minutes. Tout audio plus long sera tronqué.
La configuration par défaut traite des fenêtres de 30 secondes en mono à 16 kHz.
Le processeur impose une limite stricte de 40 fenêtres par échantillon, ce qui correspond à un maximum de 20 minutes d'audio (40 fenêtres × 30 secondes).
Les embeddings de temps rotatifs (RoTE) fournissent des informations de position pour des séquences allant jusqu'à 20 minutes (1200 secondes).
Pour chaque fenêtre :
mel_lenest la longueur mel rembourrée.- Une pile de convolutions réduit le temps, car
conv_output_len = (mel_len - 1) // 2 + 1. - Images par fenêtre après pooling :
post_pool_len = (conv_output_len - 2) // 2 + 1. - Un jeton de réserve audio est développé en la somme de
post_pool_lensur toutes les fenêtres.
MusicFlamingoConfig
classe transformers.MusicFlamingoConfig
< source >( 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 = Noneaudio_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_token_id: int = 151669projector_hidden_act: str = 'gelu'projector_bias: bool = Trueaudio_bos_token_id: int = 151670audio_eos_token_id: int = 151671audio_frame_step: float = 0.01rope_parameters: dict | None = None )
Paramètres
- audio_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone audio. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte. - audio_token_id (
int, facultatif, par défaut151669) — L’index du jeton audio utilisé comme espace réservé pour l’audio d’entrée. - projector_hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation utilisée par le projecteur multimodal. - projector_bias (
bool, facultatif, valeur par défautTrue) — Indique s'il faut utiliser un biais dans le projecteur multimodal. - audio_bos_token_id (
int, facultatif, valeur par défaut 151670) — L’indice du jeton de début d’audio utilisé pour marquer le début des segments audio. - audio_eos_token_id (
int, facultatif, valeur par défaut 151671) — L’index du jeton de fin d’audio utilisé pour marquer la fin des segments audio. - audio_frame_step (
float, facultatif, valeur par défaut 0.01) — Durée en secondes d'une trame mel d'entrée (entraîné avec hop_length 160 à sampling_rate 16000). - rope_parameters (
dict, facultatif) — Dictionnaire contenant les paramètres de configuration des embeddings RoPE. Le dictionnaire doit contenir une valeur pourrope_thetaet, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec desmax_position_embeddingsplus longs.
Ceci est la classe de configuration destinée à stocker la configuration d'un MusicFlamingoModel. Elle est utilisée pour instancier un modèle Musicflamingo 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 nvidia/music-flamingo-2601-hf
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 MusicFlamingoForConditionalGeneration, MusicFlamingoConfig, AudioFlamingo3EncoderConfig, Qwen2Config
>>> # Initializing an MusicFlamingoEncoder config
>>> audio_config = AudioFlamingo3EncoderConfig()
>>> # Initializing a Qwen2 config
>>> text_config = Qwen2Config()
>>> # Initializing an MusicFlamingo configuration
>>> configuration = MusicFlamingoConfig(audio_config, text_config)
>>> # Initializing a model from the musicflamingo style configuration
>>> model = MusicFlamingoForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMusicFlamingoProcessor
classe transformers.MusicFlamingoProcessor
< source >( feature_extractortokenizerchat_template = Noneaudio_token = '<sound>'audio_bos_token = '<|sound_bos|>'audio_eos_token = '<|sound_eos|>'max_audio_len = 1200 )
Paramètres
- feature_extractor (
feature_extractor_class) — L'extracteur de caractéristiques est une entrée obligatoire. - tokenizer (
tokenizer_class) — Le tokenizer est une entrée obligatoire. - chat_template (
str) — Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable. - audio_token (
Optional[str], facultatif, par défaut"<sound>") — Jeton spécial utilisé pour représenter les entrées audio dans le modèle de discussion. - audio_bos_token (
Optional[str], facultatif, par défaut"<|sound_bos|>") — Jeton spécial utilisé pour représenter le début de l’audio. - audio_eos_token (
Optional[str], facultatif, par défaut"<|sound_eos|>") — Jeton spécial utilisé pour représenter la fin de l'audio. - max_audio_len (
int, facultatif, par défaut 1200) — Longueur maximale des séquences audio, en secondes. Tout audio plus long sera tronqué.
Construit un MusicFlamingoProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.
MusicFlamingoProcessor offre toutes les fonctionnalités de feature_extractor_class et de tokenizer_class. Consultez ~feature_extractor_class et ~tokenizer_class pour plus d’informations.
MusicFlamingoModel
classe transformers.MusicFlamingoModel
< source >( config: MusicFlamingoConfig )
Paramètres
- config (MusicFlamingoConfig) — 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 MusicFlamingo (encodeur Whisper fine-tuné, projecteur multi-modal, modèle de langage Qwen2), sans tête de modélisation du langage.
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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: 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'> ) → MusicFlamingoModelOutputWithPast or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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.
- input_features (
torch.Tensorde 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 defeature_extractor_class. Consultezfeature_extractor_class.__call__pour plus de détails (MusicFlamingoProcessor utilisefeature_extractor_classpour le traitement des audios). - input_features_mask (
torch.Tensorde forme(batch_size, feature_sequence_length)) — Masque pour éviter d'appliquer l'attention aux indices de fonctionnalités de bourrage. - attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - 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 lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'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_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon 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 lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
Retourne
MusicFlamingoModelOutputWithPast ou tuple(torch.Tensor)
Un MusicFlamingoModelOutputWithPast 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 (MusicFlamingoConfig) et des entrées.
La méthode forward du MusicFlamingoModel surcharge 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
Moduleplutô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.
- audio_hidden_states (
torch.Tensor, facultatif) — États cachés audio projetés.
MusicFlamingoForConditionalGeneration
classe transformers.MusicFlamingoForConditionalGeneration
< source >( config: MusicFlamingoConfig )
Paramètres
- config (MusicFlamingoConfig) — 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 MusicFlamingo, qui se compose d'un encodeur Whisper fine-tuné, d'un embedding temporel rotatif, d'un projecteur multi-modal et d'un modèle de langage Qwen2.
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
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneinput_features: typing.Optional[torch.Tensor] = Noneinput_features_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MusicFlamingoCausalLMOutputWithPast or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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.
- input_features (
torch.Tensorde 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 defeature_extractor_class. Consultezfeature_extractor_class.__call__pour plus de détails (MusicFlamingoProcessor utilisefeature_extractor_classpour le traitement des audios). - input_features_mask (
torch.Tensorde forme(batch_size, feature_sequence_length)) — Masque pour éviter d'appliquer l'attention aux indices de fonctionnalités de bourrage. - attention_mask (
torch.Tensorde 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.
- position_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - 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 lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'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_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon 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 lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masqué. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - logits_to_keep (
Union[int, torch.Tensor], facultatif, valeur par défaut0) — Si c'est unint, calcule les logits pour leslogits_to_keepderniers jetons. Si0, calcule les logits pour tous lesinput_ids(cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est untorch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. Cela est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).
Retourne
MusicFlamingoCausalLMOutputWithPast ou tuple(torch.Tensor)
Un MusicFlamingoCausalLMOutputWithPast 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 (MusicFlamingoConfig) et des entrées.
La méthode forward de MusicFlamingoForConditionalGeneration surcharge 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage.past_key_values (
Cache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache.hidden_states (
tuple[torch.Tensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.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.
audio_hidden_states (
torch.Tensor, facultatif) — États cachés de l'encodeur audio après projection.