Transformers documentation
MusicGen
Ce modèle a été publié dans HF papers le 2023-06-08 et contribué à Hugging Face Transformers le 2023-06-29.
MusicGen
Aperçu
Le modèle MusicGen a été proposé dans l'article 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 est un modèle Transformer auto-régressif à un seul étage capable de générer des échantillons de musique de haute qualité conditionnés par des descriptions textuelles ou des prompts audio. Les descriptions textuelles sont transmises à un modèle d'encodeur de texte figé afin d'obtenir une séquence de représentations d'états cachés. MusicGen est ensuite entraîné à prédire des jetons audio discrets, ou codes audio, conditionnés par ces états cachés. Ces jetons audio sont ensuite décodés à l'aide d'un modèle de compression audio, tel qu'EnCodec, afin de récupérer la forme d'onde audio.
Grâce à un motif efficace d'entrelacement des jetons, MusicGen n'a pas besoin d'une représentation sémantique auto-supervisée des prompts texte/audio, éliminant ainsi la nécessité de mettre en cascade plusieurs modèles pour prédire un ensemble de codebooks (par exemple de manière hiérarchique ou par suréchantillonnage). Il est en mesure de générer tous les codebooks en une seule passe avant.
L'abstract de l'article est le suivant :
Nous abordons la tâche de génération musicale conditionnelle. Nous présentons MusicGen, un unique modèle de langage (LM) qui opère sur plusieurs flux de représentation musicale discrète compressée, c'est-à-dire des jetons. Contrairement aux travaux antérieurs, MusicGen est composé d'un LM transformer à un seul stade associé à des motifs d'entrelacement de jetons efficaces, ce qui élimine le besoin de chaîner plusieurs modèles, par exemple de manière hiérarchique ou par suréchantillonnage. En suivant cette approche, nous démontrons comment MusicGen peut générer des échantillons de haute qualité, tout en étant conditionné par une description textuelle ou des caractéristiques mélodiques, permettant un meilleur contrôle sur la sortie générée. Nous menons une évaluation empirique approfondie, en tenant compte à la fois d'études automatiques et humaines, montrant que l'approche proposée est supérieure aux lignes de base évaluées sur un benchmark standard de texte vers musique. Grâce à des études d'ablation, nous mettons en lumière l'importance de chacun des composants constituant MusicGen.
Ce modèle a été contribué par sanchit-gandhi. Le code d'origine peut être trouvé ici. Les points de contrôle pré-entraînés sont disponibles sur le Hugging Face Hub.
Conseils d'utilisation
- 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 dans
src/transformers/models/musicgen/convert_musicgen_transformers.pyavec la commande suivante :
python src/transformers/models/musicgen/convert_musicgen_transformers.py \
--checkpoint small --pytorch_dump_folder /output/pathGénération
MusicGen est compatible avec deux modes de génération : greedy et sampling. En pratique, le sampling donne des résultats nettement meilleurs que le greedy, nous encourageons donc à utiliser le mode sampling lorsque c’est possible. Le sampling est activé par défaut et peut être explicitement spécifié en définissant do_sample=True dans l’appel à MusicgenForConditionalGeneration.generate(), ou en écrasant la configuration de génération du modèle (voir ci-dessous).
La génération est limitée par les embeddings positionnels sinusoïdaux à des entrées de 30 secondes. Autrement dit, MusicGen ne peut pas générer plus de 30 secondes d’audio (1503 tokens), et l’audio d’entrée transmis par la génération avec prompt audio contribue à cette limite. Ainsi, pour une entrée de 20 secondes d’audio, MusicGen ne peut pas générer plus de 10 secondes d’audio supplémentaire.
Transformers prend en charge les variantes mono (1 canal) et stéréo (2 canaux) de MusicGen. Les versions mono génèrent un seul ensemble de codebooks. Les versions stéréo génèrent 2 ensembles de codebooks, 1 pour chaque canal (gauche/droite), et chaque ensemble de codebooks est décodé indépendamment par le modèle de compression audio. Les flux audio de chaque canal sont combinés pour produire la sortie stéréo finale.
Génération non conditionnelle
Les entrées pour la génération inconditionnelle (ou « nulle ») peuvent être obtenues via la méthode MusicgenForConditionalGeneration.get_unconditional_inputs() :
from transformers import MusicgenForConditionalGeneration
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")
unconditional_inputs = model.get_unconditional_inputs(num_samples=1)
audio_values = model.generate(**unconditional_inputs, do_sample=True, max_new_tokens=256)Les sorties audio sont des tenseurs Torch tridimensionnels de forme (batch_size, num_channels, sequence_length). Pour écouter les échantillons audio générés, vous pouvez soit les lire dans un notebook ipynb :
from IPython.display import Audio
sampling_rate = model.config.audio_encoder.sampling_rate
Audio(audio_values[0].numpy(), rate=sampling_rate)Ou enregistrez-les dans un fichier .wav à l'aide d'une bibliothèque tierce, par exemple scipy :
import scipy
sampling_rate = model.config.audio_encoder.sampling_rate
scipy.io.wavfile.write("musicgen_out.wav", rate=sampling_rate, data=audio_values[0, 0].numpy())Génération conditionnelle par le texte
Le modèle peut générer un échantillon audio conditionné par un prompt texte en utilisant le MusicgenProcessor pour pré-traiter les entrées :
from transformers import AutoProcessor, MusicgenForConditionalGeneration
processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")
inputs = processor(
text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
padding=True,
return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)Le 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 « null »). 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).
Génération pilotée par l'audio
Le même MusicgenProcessor peut être utilisé pour pré-traiter un prompt audio servant à la continuation audio. Dans l’exemple suivant, nous chargeons un fichier audio à l’aide de la bibliothèque 🤗 Datasets, qui peut être installée via pip grâce à la commande ci-dessous :
pip install --upgrade pip pip install datasets[audio]
from datasets import load_dataset
from transformers import AutoProcessor, MusicgenForConditionalGeneration
processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")
dataset = load_dataset("sanchit-gandhi/gtzan", split="train", streaming=True)
sample = next(iter(dataset))["audio"]
# take the first half of the audio sample
sample["array"] = sample["array"][: len(sample["array"]) // 2]
inputs = processor(
audio=sample["array"],
sampling_rate=sample["sampling_rate"],
text=["80s blues track with groovy saxophone"],
padding=True,
return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)Pour la génération audio par lots, les audio_values générés peuvent être post-traités pour supprimer le bourrage à l'aide de la classe MusicgenProcessor :
from datasets import load_dataset
from transformers import AutoProcessor, MusicgenForConditionalGeneration
processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")
dataset = load_dataset("sanchit-gandhi/gtzan", split="train", streaming=True)
sample = next(iter(dataset))["audio"]
# take the first quarter of the audio sample
sample_1 = sample["array"][: len(sample["array"]) // 4]
# take the first half of the audio sample
sample_2 = sample["array"][: len(sample["array"]) // 2]
inputs = processor(
audio=[sample_1, sample_2],
sampling_rate=sample["sampling_rate"],
text=["80s blues track with groovy saxophone", "90s rock song with loud guitars and heavy drums"],
padding=True,
return_tensors="pt",
)
audio_values = model.generate(**inputs, do_sample=True, guidance_scale=3, max_new_tokens=256)
# post-process to remove padding from the batched audio
audio_values = processor.batch_decode(audio_values, padding_mask=inputs.padding_mask)Configuration de génération
Les paramètres par défaut qui contrôlent le processus de génération, tels que l’échantillonnage, l’échelle de guidage et le nombre de jetons générés, peuvent être trouvés dans la configuration de génération du modèle et mis à jour selon vos besoins :
from transformers import MusicgenForConditionalGeneration
model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto")
# inspect the default generation config
model.generation_config
# increase the guidance scale to 4.0
model.generation_config.guidance_scale = 4.0
# decrease the max length to 256 tokens
model.generation_config.max_length = 256Notez 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 :
- 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
- Décodeur MusicGen : un modèle de langage (LM) qui génère de manière auto-régressive des jetons audio (ou des codes) conditionnés sur les représentations d'états cachés du codeur
- Encodeur/décodeur audio : utilisé pour encoder un prompt audio afin de l'utiliser comme jetons de prompt, et pour récupérer la forme d'onde audio à partir des jetons audio prédits par le décodeur
Ainsi, le modèle MusicGen peut être utilisé soit comme modèle décodeur autonome, correspondant à la classe MusicgenForCausalLM,
soit comme modèle composite incluant l’encodeur de texte et l’encodeur/décodeur audio, correspondant à la classe MusicgenForConditionalGeneration. Si seul le décodeur doit être chargé depuis le point de contrôle pré-entraîné, il peut être chargé en spécifiant d’abord la configuration correcte, ou être accédé via l’attribut .decoder du modèle composite :
from transformers import AutoConfig, MusicgenForCausalLM, MusicgenForConditionalGeneration
# Option 1: get decoder config and pass to `.from_pretrained`
decoder_config = AutoConfig.from_pretrained("facebook/musicgen-small").decoder
decoder = MusicgenForCausalLM.from_pretrained("facebook/musicgen-small", **decoder_config, device_map="auto")
# Option 2: load the entire composite model, but only return the decoder
decoder = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small", device_map="auto").decoderLes modèles d'encodeur de texte et d'encodeur/décodeur audio étant figés pendant l'entraînement, le décodeur MusicGen MusicgenForCausalLM peut être entraîné de manière autonome sur un jeu de données d'états cachés de l'encodeur et de codes audio. Pour l'inférence, le décodeur entraîné peut être combiné avec l'encodeur de texte figé et les encodeurs/décodeurs audio pour reconstituer le modèle composite MusicgenForConditionalGeneration.
Astuces :
- MusicGen est entraîné sur le point de contrôle 32 kHz d'Encodec. Vous devez vous assurer d'utiliser une version compatible du modèle Encodec.
- Le mode d’échantillonnage tend à donner de meilleurs résultats que le mode glouton – vous pouvez activer l’échantillonnage avec la variable
do_sampledans l’appel àMusicgenForConditionalGeneration.generate()
MusicgenDecoderConfig
classe transformers.MusicgenDecoderConfig
< 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 = 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 = Falsecross_attention_hidden_size: int | None = None )
Paramètres
- vocab_size (
int, facultatif, par défaut2048) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - max_position_embeddings (
int, facultatif, par défaut2048) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - num_hidden_layers (
int, facultatif, par défaut24) — Nombre de couches cachées dans le décodeur Transformer. - ffn_dim (
int, facultatif, par défaut4096) — Dimension des représentations MLP. - num_attention_heads (
int, facultatif, valeur par défaut16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - layerdrop (
Union[float, int], facultatif, par défaut0.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éfautTrue) — 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 siconfig.is_decoder=Trueou si le modèle est un modèle génératif uniquement décodeur. - activation_function (
str, facultatif, par défautgelu) — 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éfaut1024) — Dimension des représentations cachées. - dropout (
Union[float, int], facultatif, par défaut0.1) — Le taux appliqué à toutes les couches de dropout. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - activation_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée. - initializer_factor (
float, facultatif, par défaut0.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éfautFalse) — Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model). - num_codebooks (
int, facultatif, par défaut4) — Le nombre de codebooks parallèles utilisés par le modèle. - audio_channels (
int, facultatif, par défaut1) — Le nombre de canaux d'entrée. - pad_token_id (
int, facultatif, par défaut2048) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut2048) — 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éfautFalse) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle. - is_decoder (
bool, facultatif, par défautFalse) — Indique si le modèle est utilisé comme décodeur ou non. SiFalse, le modèle est utilisé comme encodeur. - add_cross_attention (
bool, facultatif, valeur par défautFalse) — Indique si des couches d'attention croisée doivent être ajoutées au modèle. - cross_attention_hidden_size (
int, facultatif) — Taille des sorties de l'encodeur projetées dans l'espace clé/valeur de l'attention croisée du décodeur. Utilisé lorsque l'encodeur et le décodeur ont des tailles cachées différentes.
Ceci est la classe de configuration destinée à stocker la configuration d'un MusicgenModel. Elle est utilisée pour instancier un modèle Musicgen en fonction des arguments spécifiés, 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-small
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.
MusicgenConfig
classe transformers.MusicgenConfig
< 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 = Nonetext_encoder: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneaudio_encoder: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedecoder: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneinitializer_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. - initializer_factor (
float, facultatif, par défaut0.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 MusicgenModel. Elle est utilisée pour instancier un modèle Musicgen 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-small
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 (
... MusicgenConfig,
... MusicgenDecoderConfig,
... T5Config,
... EncodecConfig,
... MusicgenForConditionalGeneration,
... )
>>> # Initializing text encoder, audio encoder, and decoder model configurations
>>> text_encoder_config = T5Config()
>>> audio_encoder_config = EncodecConfig()
>>> decoder_config = MusicgenDecoderConfig()
>>> configuration = MusicgenConfig(
... text_encoder=text_encoder_config,
... audio_encoder=audio_encoder_config,
... decoder=decoder_config,
... )
>>> # Initializing a MusicgenForConditionalGeneration (with random weights) from the facebook/musicgen-small style configuration
>>> model = MusicgenForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> config_text_encoder = model.config.text_encoder
>>> config_audio_encoder = model.config.audio_encoder
>>> config_decoder = model.config.decoder
>>> # Saving the model, including its configuration
>>> model.save_pretrained("musicgen-model")
>>> # loading model and config from pretrained folder
>>> musicgen_config = MusicgenConfig.from_pretrained("musicgen-model")
>>> model = MusicgenForConditionalGeneration.from_pretrained("musicgen-model", config=musicgen_config)MusicgenProcessor
classe transformers.MusicgenProcessor
< source >( feature_extractortokenizer )
Construit un MusicgenProcessor qui encapsule un extracteur de caractéristiques et un tokenizer en un seul processeur.
MusicgenProcessor offre toutes les fonctionnalités de EncodecFeatureExtractor et de T5Tokenizer. Consultez ~EncodecFeatureExtractor et ~T5Tokenizer pour plus d’informations.
__call__
< source >( *args**kwargs )
Paramètres
- return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets NumPynp.ndarray.
MusicgenModel
classe transformers.MusicgenModel
< source >( config: MusicgenDecoderConfig )
Paramètres
- config (MusicgenDecoderConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle Musicgen brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.
Ce modèle hérite de PreTrainedModel. 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] = 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'> ) → BaseModelOutputWithPastAndCrossAttentions or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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_idssont 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 queinput_ids. - 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.
- encoder_hidden_states (
torch.Tensorde forme(batch_size, encoder_sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisée dans l'attention croisée du décodeur. - encoder_attention_mask (
torch.LongTensorde forme(batch_size, encoder_sequence_length), facultatif) — Masque pour éviter d'effectuer une attention croisée sur les indices des jetons de bourrage de encoder_input_ids. 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.
- 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
BaseModelOutputWithPastAndCrossAttentions ou tuple(torch.Tensor)
Un BaseModelOutputWithPastAndCrossAttentions ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MusicgenConfig) et des entrées.
La méthode forward du MusicgenModel redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
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.
last_hidden_state (
torch.Tensorde 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_valuesest 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.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éepast_key_values) pour accélérer le décodage séquentiel.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.
cross_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueetconfig.add_cross_attention=Truesont passés ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
MusicgenForCausalLM
classe transformers.MusicgenForCausalLM
< source >( config: MusicgenDecoderConfig )
Paramètres
- config (MusicgenDecoderConfig) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle décodeur MusicGen avec une tête de modélisation de langage au sommet.
Ce modèle hérite de PreTrainedModel. 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] = 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] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithCrossAttentions or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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_idssont 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 queinput_ids. - 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.
- encoder_hidden_states (
torch.Tensorde forme(batch_size, encoder_sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisée dans l'attention croisée du décodeur. - encoder_attention_mask (
torch.LongTensorde forme(batch_size, encoder_sequence_length), facultatif) — Masque pour éviter d'effectuer une attention croisée sur les indices des jetons de bourrage de encoder_input_ids. 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.
- 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, 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éfinirlabels = input_idsLes indices sont sélectionnés dans[-100, 0, ..., config.vocab_size]Toutes les étiquettes définies sur-100sont 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 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
CausalLMOutputWithCrossAttentions ou tuple(torch.Tensor)
Un CausalLMOutputWithCrossAttentions ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MusicgenConfig) et des entrées.
La méthode forward de MusicgenForCausalLM redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
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 (scores pour chaque jeton du vocabulaire avant SoftMax).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.
cross_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 croisées après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
past_key_values (
Cache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.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'attention) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.
MusicgenForConditionalGeneration
classe transformers.MusicgenForConditionalGeneration
< source >( config: transformers.models.musicgen.configuration_musicgen.MusicgenConfig | None = Nonetext_encoder: transformers.modeling_utils.PreTrainedModel | None = Noneaudio_encoder: transformers.modeling_utils.PreTrainedModel | None = Nonedecoder: transformers.models.musicgen.modeling_musicgen.MusicgenForCausalLM | None = None )
Paramètres
- config (MusicgenConfig, facultatif) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
- text_encoder (
PreTrainedModel, facultatif) — Le modèle d'encodeur de texte qui encode le texte en états cachés pour le conditionnement. - audio_encoder (
PreTrainedModel, facultatif) — Le modèle d’encodeur audio qui encode l’audio en états cachés pour le conditionnement. - decoder (
MusicgenForCausalLM, facultatif) — Le modèle décodeur qui génère des jetons audio à partir de signaux de conditionnement.
Le modèle composite MusicGen avec un encodeur de texte, un encodeur audio et un décodeur Musicgen,
Ce modèle hérite de PreTrainedModel. 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] = Noneattention_mask: typing.Optional[torch.BoolTensor] = Noneinput_values: typing.Optional[torch.Tensor] = Nonepadding_mask: typing.Optional[torch.BoolTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[torch.Tensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = 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'> ) → Seq2SeqLMOutput 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.
- attention_mask (
torch.BoolTensorde 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.
- input_values (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Valeurs flottantes de la forme d’onde brute de l’entrée audio. Les valeurs peuvent être obtenues en chargeant un fichier audio.flacou.wavdans un tableau de typelist[float], unnumpy.ndarrayou untorch.Tensor, par exemple via la bibliothèque torchcodec (pip install torchcodec) ou la bibliothèque soundfile (pip install soundfile). Pour préparer le tableau eninput_values, il faut utiliser AutoProcessor pour le bourrage (padding) et la conversion en tenseur de typetorch.Tensor. Voir MusicgenProcessor.call() pour plus de détails. - padding_mask (
torch.BoolTensorde 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.
- decoder_input_ids (
torch.LongTensorde 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_idssont 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 quedecoder_input_ids. - decoder_attention_mask (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Comportement par défaut : générer un tenseur qui ignore les jetons de remplissage dansdecoder_input_ids. Un masque causal sera également utilisé par défaut. - encoder_outputs (
tuple[torch.Tensor], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence d’états cachés à la sortie de la dernière couche de l’encodeur. Utilisé dans l’attention croisée du décodeur. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et 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. - decoder_inputs_embeds (
torch.Tensorde forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - labels (
torch.LongTensorde 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éfinirlabels = input_idsLes indices sont sélectionnés dans[-100, 0, ..., config.vocab_size]Toutes les étiquettes définies sur-100sont 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 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
Seq2SeqLMOutput ou tuple(torch.Tensor)
Un Seq2SeqLMOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MusicgenConfig) et des entrées.
La méthode forward de MusicgenForConditionalGeneration redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
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.logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. 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 dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.decoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé 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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_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 d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple(torch.Tensor), facultatif, renvoyé 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 d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.encoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé 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 de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_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 d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemples :
>>> from transformers import AutoProcessor, MusicgenForConditionalGeneration
>>> import torch
>>> processor = AutoProcessor.from_pretrained("facebook/musicgen-small")
>>> model = MusicgenForConditionalGeneration.from_pretrained("facebook/musicgen-small")
>>> inputs = processor(
... text=["80s pop track with bassy drums and synth", "90s rock song with loud guitars and heavy drums"],
... padding=True,
... return_tensors="pt",
... )
>>> pad_token_id = model.generation_config.pad_token_id
>>> decoder_input_ids = (
... torch.ones((inputs.input_ids.shape[0] * model.decoder.num_codebooks, 1), dtype=torch.long)
... * pad_token_id
... )
>>> logits = model(**inputs, decoder_input_ids=decoder_input_ids).logits
>>> logits.shape # (bsz * num_codebooks, tgt_len, vocab_size)
torch.Size([8, 1, 2048])