Transformers documentation
Moshi
Ce modèle a été publié dans HF papers le 2024-09-17 et ajouté à Hugging Face Transformers le 2024-10-16.
Moshi
Aperçu
Le modèle Moshi a été proposé dans Moshi: a speech-text foundation model for real-time dialogue par Alexandre Défossez, Laurent Mazaré, Manu Orsini, Amélie Royer, Patrick Pérez, Hervé Jégou, Edouard Grave et Neil Zeghidour.
Moshi est un modèle de fondation pour le texte et la parole qui conçoit le dialogue oral comme une génération de parole à parole. À partir d’un squelette de modèle de langage textuel, Moshi génère la parole sous forme de jetons issus du quantificateur résiduel d’un codec audio neuronal, tout en modélisant séparément sa propre parole et celle de l’utilisateur dans des flux parallèles. Cela permet de supprimer les tours de parole explicites et de modéliser des dynamiques conversationnelles arbitraires. Moshi prédit également des jetons de texte alignés dans le temps comme préfixe aux jetons audio. Cette méthode « Inner Monologue » améliore considérablement la qualité linguistique de la parole générée et fournit une reconnaissance vocale en flux et une synthèse vocale. En conséquence, Moshi est le premier grand modèle de langage oral full-duplex en temps réel, avec une latence théorique de 160 ms, et de 200 ms en pratique.
L'abstract de l'article est le suivant :
Nous présentons Moshi, un modèle de fondation pour le texte-parlé et un cadre de dialogue oral en duplex intégral. Les systèmes actuels de dialogue oral reposent sur des pipelines de composants indépendants, à savoir la détection d’activité vocale, la reconnaissance vocale, le dialogue textuel et la synthèse vocale. De tels cadres ne peuvent pas reproduire l’expérience d’une conversation réelle. D’une part, leur complexité induit une latence de plusieurs secondes entre les interactions. D’autre part, le texte étant la modalité intermédiaire du dialogue, les informations non linguistiques qui modifient le sens — telles que l’émotion ou les sons non vocaux — sont perdues lors de l’interaction. Enfin, ils reposent sur une segmentation en tours de parole, qui ne prend pas en compte les chevauchements de parole, les interruptions et les interjections. Moshi résout ces problèmes indépendants de manière globale en formulant le dialogue oral comme une génération de parole à partir de la parole. À partir d’un socle de modèle de langage textuel, Moshi génère la parole sous forme de jetons issus du quantificateur résiduel d’un codec audio neuronal, tout en modélisant séparément sa propre parole et celle de l’utilisateur dans des flux parallèles. Cela permet de supprimer les tours de parole explicites et de modéliser des dynamiques conversationnelles arbitraires. Nous étendons en outre la génération hiérarchique de jetons sémantiques à acoustiques du travail précédent afin de prédire d’abord des jetons de texte alignés dans le temps comme préfixe aux jetons audio. Non seulement cette méthode « Inner Monologue » améliore considérablement la qualité linguistique de la parole générée, mais nous illustrons également comment elle peut fournir la reconnaissance vocale en flux et la synthèse vocale. Notre modèle résultant est le premier grand modèle de langage oral en duplex intégral en temps réel, avec une latence théorique de 160 ms, 200 ms en pratique, et est disponible sur github.com/kyutai-labs/moshi.
Moshi gère 3 flux d'informations :
- L’audio de l’utilisateur
- L’audio de Moshi
- Sortie textuelle de Moshi
De manière similaire à ~MusicgenModel, l'audio est représenté par des codebooks audio, qui peuvent être interprétés comme des jetons. La principale différence entre les jetons de texte et les codebooks audio est que les codebooks audio introduisent une dimension d'information supplémentaire.
Les jetons de texte sont généralement de dimension (batch_size, sequence_length), mais les jetons audio sont de dimension (batch_size, num_codebooks, sequence_length).
Moshi est composé de 3 composants :
1. Le décodeur principal (Helium dans l'article)
Il correspond à MoshiForCausalLM. Il s'agit strictement d'un LLM de texte classique, qui utilise une architecture similaire à celle de ~GemmaForCausalLM. Autrement dit, il prend des jetons de texte, les encode, les fait passer par le décodeur et une tête de langage, afin d'obtenir des logits de texte.
2. Le décodeur de profondeur
À lui seul, c’est aussi un LLM classique, mais cette fois, au lieu de générer sur la dimension temporelle, il génère sur la dimension du codebook.
Cela signifie également que sa longueur de contexte est num_codebooks, il ne peut donc pas générer plus de num_codebooks.
Notez que chaque horodatage - c'est-à-dire chaque codebook - possède son propre ensemble de Linear Layers et d'Embeddings.
3. MimiModel
C’est l’encodeur audio de Kyutai, récemment intégré à transformers, qui sert à « tokeniser » l’audio. Il remplit le même rôle que ~EncodecModel dans ~MusicgenModel.
Astuces
Les points de contrôle d'origine peuvent être convertis à l'aide du script de conversion src/transformers/models/moshi/convert_moshi_transformers.py
Comment utiliser le modèle
Cette implémentation poursuit deux objectifs principaux :
- tester rapidement la génération d'un modèle en simplifiant l'API d'origine
- simplifier l’entraînement. Un guide d’entraînement sera bientôt disponible, mais les contributions des utilisateurs sont les bienvenues !
Elle est conçue pour un usage intermédiaire. Nous recommandons vivement d'utiliser l'implémentation originale pour inférer le modèle en streaming en temps réel.
1. Génération du modèle
Moshi est un modèle auto-régressif en streaming doté de deux flux audio. Autrement dit, un flux audio correspond à ce que le modèle a dit/ira dire et l'autre flux audio correspond à ce que l'utilisateur a dit/ira dire.
MoshiForConditionalGeneration.generate() nécessite donc 3 entrées :
input_ids- correspondant à l'historique des jetons de textemoshi_input_valuesoumoshi_audio_codes- correspondant à l'historique audio du modèleuser_input_valuesouuser_audio_codes- correspondant à l'historique audio de l'utilisateur
Ces trois entrées doivent être synchronisées. Autrement dit, leurs longueurs doivent correspondre au même nombre de jetons.
Vous pouvez utiliser dynamiquement les 3 entrées en fonction de ce que vous souhaitez tester :
- Il suffit de vérifier la réponse du modèle à un prompt utilisateur : dans ce cas,
input_idspeut être rempli de jetons de bourrage etuser_input_valuespeut être un tenseur nul de la même forme que le prompt utilisateur. - Tester un comportement plus complexe - dans ce cas, vous devez faire attention à la manière dont les jetons d'entrée sont synchronisés avec les audios.
Le modèle original est un texte synchronisé avec l'audio en ajoutant des espaces de remplissage entre chaque énonciation de jeton.
Pour suivre l'exemple de l'image ci-dessous,
"Hello, I'm Moshi"pourrait être transformé en"Hello,<pad><unk>I'm Moshi".
MoshiForConditionalGeneration.generate() alimente ensuite de manière auto-régressive son propre flux audio, mais comme il n’a pas accès au flux d’entrée de l’utilisateur lors de l’utilisation de transformers, il suppose donc que l’utilisateur produit un audio vide.
import math
import torch
from datasets import Audio, load_dataset
from transformers import AutoFeatureExtractor, AutoTokenizer
librispeech_dummy = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
feature_extractor = AutoFeatureExtractor.from_pretrained("kyutai/moshiko-pytorch-bf16")
tokenizer = AutoTokenizer.from_pretrained("kyutai/moshiko-pytorch-bf16")
dtype = torch.bfloat16
# prepare user input audio
librispeech_dummy = librispeech_dummy.cast_column("audio", Audio(sampling_rate=feature_extractor.sampling_rate))
audio_sample = librispeech_dummy[-1]["audio"]["array"]
user_input_values = feature_extractor(raw_audio=audio_sample, sampling_rate=feature_extractor.sampling_rate, return_tensors="pt").to(device=device, dtype=dtype)
# prepare moshi input values - we suppose moshi didn't say anything while the user spoke
moshi_input_values = torch.zeros_like(user_input_values.input_values)
# prepare moshi input ids - we suppose moshi didn't say anything while the user spoke
num_tokens = math.ceil(moshi_input_values.shape[-1] * waveform_to_token_ratio)
input_ids = torch.ones((1, num_tokens), device=device, dtype=torch.int64) * tokenizer.encode("<pad>")[0]
# generate 25 new tokens (around 2s of audio)
output = model.generate(input_ids=input_ids, user_input_values=user_input_values.input_values, moshi_input_values=moshi_input_values, max_new_tokens=25)
text_tokens = output.sequences
audio_waveforms = output.audio_sequences2. Entraînement du modèle
La majeure partie du travail doit être effectuée lors de la création/prétraitement des données, en raison de la nécessité d’aligner/synchroniser les flux.
Une fois terminé, il suffit de transmettre text_labels et audio_labels à MoshiForConditionalGeneration.forward(), en plus des entrées habituelles, pour obtenir la perte du modèle.
Un guide d'entraînement sera bientôt disponible, mais les contributions des utilisateurs sont les bienvenues !
Comment le modèle transmet-il les entrées / génère
Les flux d'entrée sont intégrés et combinés dans
inputs_embeds.inputs_embedsest transmis au décodeur principal, qui le traite comme un LLM classique le ferait.Le décodeur principal produit des
text logitsmais aussi sonlast hidden state, appelétemporal contextdans l'article.Le décodeur de profondeur bascule la dimension sur laquelle nous effectuons le passage avant / la génération (les codebooks au lieu du temps). Il utilise le jeton généré à partir des
text logitset dutemporal contextpour générer de manière auto-régressive les codebooks audio.
Ce modèle a été contribué par Yoach Lacombe (ylacombe).
Le code original peut être trouvé ici.
MoshiConfig
classe transformers.MoshiConfig
< 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 = 32000hidden_size: int = 4096num_hidden_layers: int = 32num_attention_heads: int = 32num_key_value_heads: int | None = Noneaudio_vocab_size: int | None = Nonemax_position_embeddings: int = 3000rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonehidden_act: str = 'silu'head_dim: int | None = Noneinitializer_range: float = 0.02use_cache: bool = Truesliding_window: int = 3000attention_dropout: float | int = 0.0ffn_dim: int = 22528rms_norm_eps: float = 1e-08num_codebooks: int = 8tie_word_embeddings: bool = Falsepad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = Noneaudio_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedepth_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )
Paramètres
- vocab_size (
int, facultatif, par défaut32000) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - hidden_size (
int, facultatif, par défaut4096) — Dimension des représentations cachées. - num_hidden_layers (
int, facultatif, par défaut32) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut32) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_key_value_heads (
int, facultatif) — Ceci est le nombre de têtes key_value à utiliser pour implémenter la Grouped Query Attention. Sinum_key_value_heads=num_attention_heads, le modèle utilisera la Multi Head Attention (MHA), sinum_key_value_heads=1le modèle utilisera la Multi Query Attention (MQA), sinon la GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite par moyennage (meanpooling) de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut estnum_attention_heads. - audio_vocab_size (
int, facultatif) — Taille du vocabulaire de la partie audio du modèle. Définit le nombre de jetons différents qui peuvent être représentés par lesaudio_codespassés lors de l’appel des modèles Moshi. - max_position_embeddings (
int, facultatif, par défaut3000) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], facultatif) — Dictionnaire contenant les paramètres de configuration pour les 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. - hidden_act (
str, facultatif, par défautsilu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - head_dim (
int, facultatif) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - 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. - sliding_window (
int, facultatif, par défaut3000) — Taille de la fenêtre d'attention glissante. SiNone, aucune fenêtre glissante n'est appliquée. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - ffn_dim (
int, facultatif, par défaut 22528) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du bloc décodeur principal. Doit être un nombre pair. - rms_norm_eps (
float, facultatif, valeur par défaut1e-08) — L'épsilon utilisé par les couches de normalisation rms. - num_codebooks (
int, facultatif, par défaut8) — Le nombre de codebooks parallèles utilisés par le modèle. - 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. - pad_token_id (
int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif) — 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. - audio_encoder_config (
PreTrainedConfig | dict, facultatif) — Configuration de l'encodeur audio. - depth_decoder_config (
PreTrainedConfig | dict, facultatif) — Configuration du décodeur de profondeur.
Ceci est la classe de configuration destinée à stocker la configuration d'un MoshiModel. Elle est utilisée pour instancier un modèle Moshi 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 kmhf/hf-moshika
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 (
... MoshiConfig,
... MoshiForConditionalGeneration,
... )
>>> configuration = MoshiConfig()
>>> # Initializing a MoshiForConditionalGeneration (with random weights) from the kmhf/hf-moshika style configuration
>>> model = MoshiForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # Saving the model, including its configuration
>>> model.save_pretrained("kmhf/hf-moshika")
>>> # loading model and config from pretrained folder
>>> moshi_config = MoshiConfig.from_pretrained("kmhf/hf-moshika")
>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshika", config=moshi_config)from_audio_encoder_config
< source >( audio_encoder_config: PreTrainedConfig**kwargs ) → MoshiConfig
Retourne
Une instance d'un objet de configuration
Instanciez un MoshiConfig (ou une classe dérivée) à partir d'une configuration d'encodeur audio.
MoshiDepthConfig
classe transformers.MoshiDepthConfig
< 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 = 32000hidden_size: int = 1024input_size: int = 4096num_hidden_layers: int = 6num_attention_heads: int = 16num_key_value_heads: int | None = Noneaudio_vocab_size: int = 2048max_position_embeddings: int = 9hidden_act: str = 'silu'head_dim: int | None = Noneinitializer_range: float = 0.02use_cache: bool = Truesliding_window: int = 8attention_dropout: float | int = 0.0ffn_dim: int = 5632rms_norm_eps: float = 1e-08num_codebooks: int = 8tie_word_embeddings: bool = Falsepad_token_id: int | None = Nonebos_token_id: int | None = Noneeos_token_id: int | list[int] | None = None )
Paramètres
- vocab_size (
int, facultatif, par défaut32000) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés parinput_ids. - hidden_size (
int, facultatif, par défaut1024) — Dimension des représentations cachées. - input_size (
int, facultatif, valeur par défaut 4096) — Dimension des états cachés d'entrée. Utilisé pour connecter le décodeur principal au décodeur de profondeur. - num_hidden_layers (
int, facultatif, par défaut6) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_key_value_heads (
int, facultatif) — Ceci est le nombre de têtes key_value à utiliser pour implémenter la Grouped Query Attention. Sinum_key_value_heads=num_attention_heads, le modèle utilisera la Multi Head Attention (MHA), sinum_key_value_heads=1le modèle utilisera la Multi Query Attention (MQA), sinon la GQA est utilisée. Lors de la conversion d'un checkpoint multi-têtes en checkpoint GQA, chaque tête clé et valeur de groupe doit être construite par moyennage (meanpooling) de toutes les têtes d'origine au sein de ce groupe. Pour plus de détails, consultez ce papier. S'il n'est pas spécifié, la valeur par défaut estnum_attention_heads. - audio_vocab_size (
int, facultatif, valeur par défaut 2048) — Taille du vocabulaire de la partie audio du modèle. Définit le nombre de jetons différents qui peuvent être représentés par lesaudio_codespassés lors de l’appel des modèles Moshi. - max_position_embeddings (
int, facultatif, par défaut9) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - hidden_act (
str, facultatif, par défautsilu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - head_dim (
int, facultatif) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - 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. - sliding_window (
int, facultatif, par défaut8) — Taille de la fenêtre d'attention glissante. SiNone, aucune fenêtre glissante n'est appliquée. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - ffn_dim (
int, facultatif, par défaut 5632) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du bloc du décodeur de profondeur. Doit être un nombre pair. - rms_norm_eps (
float, facultatif, valeur par défaut1e-08) — L'épsilon utilisé par les couches de normalisation rms. - num_codebooks (
int, facultatif, par défaut8) — Le nombre de codebooks parallèles utilisés par le modèle. - 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. - pad_token_id (
int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif) — 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.
Ceci est la classe de configuration destinée à stocker la configuration d'un MoshiModel. Elle est utilisée pour instancier un modèle Moshi 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 kmhf/hf-moshika
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 (
... MoshiDepthConfig,
... MoshiDepthDecoder,
... )
>>> configuration = MoshiDepthConfig()
>>> # Initializing a MoshiDepthDecoder (with random weights) from the kmhf/hf-moshika style configuration
>>> model = MoshiDepthDecoder(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMoshiModel
classe transformers.MoshiModel
< source >( config: MoshiConfig )
Paramètres
- config (MoshiConfig) — 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 Moshi 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] = 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'> ) → BaseModelOutputWithPast 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.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
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 (MoshiConfig) et des entrées.
La méthode forward du MoshiModel 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.
MoshiForCausalLM
classe transformers.MoshiForCausalLM
< source >( config: MoshiConfig )
Paramètres
- config (MoshiConfig) — 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 Moshi avec une tête de modélisation de langage textuel en haut. Utilisable uniquement pour le 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
< source >( input_ids: typing.Optional[torch.LongTensor] = 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 = Nonelabels: typing.Optional[torch.LongTensor] = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MoshiCausalLMOutputWithPast 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.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). - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - 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
MoshiCausalLMOutputWithPast ou tuple(torch.Tensor)
Un MoshiCausalLMOutputWithPast 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 (MoshiConfig) et des entrées.
La méthode forward de MoshiForCausalLM 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).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 du modèle.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) 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é 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.
Exemple :
>>> from transformers import AutoTokenizer, MoshiForCausalLM
>>> model = MoshiForCausalLM.from_pretrained("kmhf/hf-moshika")
>>> tokenizer = AutoTokenizer.from_pretrained("kmhf/hf-moshika")
>>> prompt = "What is your favorite condiment?"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is your favorite condiment?"MoshiForConditionalGeneration
classe transformers.MoshiForConditionalGeneration
< source >( config: MoshiConfig )
Paramètres
- config (MoshiConfig) — 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 Moshi d'origine, avec un encodeur audio, un décodeur de profondeur Moshi et un décodeur Moshi, pour la conversion de la parole en parole.
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] = Noneuser_input_values: typing.Optional[torch.Tensor] = Noneuser_audio_codes: typing.Optional[torch.Tensor] = Nonemoshi_input_values: typing.Optional[torch.Tensor] = Nonemoshi_audio_codes: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonetext_labels: typing.Optional[torch.LongTensor] = Noneaudio_labels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = None**kwargs ) → MoshiConditionalGenerationOutputWithPast 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.
- user_input_values (
torch.Tensorde forme `(batch_size, 1, audio_sequence_length), facultatif) — Les formes d’onde audio utilisées comme invite utilisateur audio pour la génération. - user_audio_codes (
torch.Tensorof shape(batch_size, num_codebooks, sequence_length), *optional*) -- The audio codes used as audio user prompt for the generation. Has priority overuser_input_valuesand represents the audio "tokens" ofuser_input_values` once passed through the audio encoder. - moshi_input_values (
torch.Tensorde forme `(batch_size, 1, audio_sequence_length), facultatif) — Les formes d’onde audio utilisées comme invite audio Moshi pour la génération. - moshi_audio_codes (
torch.Tensorof shape(batch_size, num_codebooks, sequence_length), *optional*) -- The audio codes used as audio Moshi prompt for the generation. Has priority overmoshi_input_valuesand represents the audio "tokens" ofmoshi_input_values` once passed through the audio encoder. - 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_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresinputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desinput_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
input_idsetinputs_embedssont tous deux non définis,inputs_embedsprend la valeur deinputs_embeds. - text_labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le modélisation du langage textuel. 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 à-100sont ignorées (masquées), la perte n’est calculée que pour les étiquettes dans[0, ..., config.vocab_size] - audio_labels (
torch.LongTensorde forme(batch_size, num_codebooks, sequence_length), 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.audio_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
MoshiConditionalGenerationOutputWithPast ou tuple(torch.Tensor)
Un MoshiConditionalGenerationOutputWithPast 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 (MoshiConfig) et des entrées.
La méthode forward de MoshiForConditionalGeneration 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é lorsquetext_labelsest fourni) — Perte de modélisation du langage pour le texte (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 textuel (scores pour chaque jeton du vocabulaire avant SoftMax).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 du modèle.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) 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é 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.
depth_loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsqueaudio_labelsest fourni) — Perte de modélisation du langage audio (pour la prédiction du jeton suivant).audio_logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction des têtes de modélisation du langage audio.depth_past_key_values (
Cache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Valeurs clés passées du décodeur de profondeur.depth_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — États cachés du décodeur de profondeurdepth_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Poids des attentions du décodeur de profondeur 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 MoshiForConditionalGeneration
>>> import torch
>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshika")
>>> inputs = moshi.get_unconditional_inputs()
>>> logits = model(**inputs, ).logits
>>> logits.shape # (bsz, seq_len, text_vocab_size)
torch.Size([1, 1, 32000])generate
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneuser_input_values: typing.Optional[torch.Tensor] = Noneuser_audio_codes: typing.Optional[torch.Tensor] = Nonemoshi_input_values: typing.Optional[torch.Tensor] = Nonemoshi_audio_codes: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonereturn_audio_waveforms: bool | None = Truereturn_audio_codes: bool | None = Noneconcat_unconditional_inputs: bool | None = True**kwargs )
Paramètres
- input_ids (
torch.Tensorde forme `(batch_size, sequence_length), facultatif) — La séquence utilisée comme invite de texte pour la génération. - user_input_values (
torch.Tensorde forme `(batch_size, 1, audio_sequence_length), facultatif) — Les formes d’onde audio utilisées comme invite utilisateur audio pour la génération. - user_audio_codes (
torch.Tensorof shape(batch_size, num_codebooks, sequence_length), *optional*) -- The audio codes used as audio user prompt for the generation. Has priority overuser_input_valuesand represents the audio "tokens" ofuser_input_values` once passed through the audio encoder. - moshi_input_values (
torch.Tensorde forme `(batch_size, 1, audio_sequence_length), facultatif) — Les formes d’onde audio utilisées comme invite audio Moshi pour la génération. - moshi_audio_codes (
torch.Tensorof shape(batch_size, num_codebooks, sequence_length), *optional*) -- The audio codes used as audio Moshi prompt for the generation. Has priority overmoshi_input_valuesand represents the audio "tokens" ofmoshi_input_values` once passed through the audio encoder. - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_idset les entrées audio, 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 entrées en vecteurs associés que la matrice de recherche d’intégration interne du modèle. - return_audio_waveforms (
bool, facultatif, par défautTrue) — SiFalse, les formes d’onde audio ne sont pas générées. - return_audio_codes (
bool, facultatif) — SiTrue, renvoie également les codes audio générés, c’est-à-dire les « tokens » audio intermédiaires qui se transforment enaudio_sequencesune fois passés par le décodeur audio. - concat_unconditional_inputs (
bool, facultatif, valeur par défautTrue) — SiFalse, les jetons audio et texte initiaux ne sont pas concaténés. - kwargs (
dict[str, Any], facultatif) — Dictionnaire restant des arguments par mot-clé transmis à la méthodegenerate. Reportez-vous aux docstrings d’origine degeneratepour plus d’informations sur leur utilisation. Notez que les mots-clés préfixés par depth_ seront utilisés en entrée pour la méthodegeneratedu décodificateur de profondeur. Sinon, ce dernier utilisera sa configuration de génération par défaut.
Génère des séquences d’identifiants de jetons de texte et d’identifiants de jetons audio.
get_unconditional_inputs
< source >( num_samples = 1 )
Paramètres
- num_samples (int, facultatif) — Nombre d'échantillons audio à générer sans condition.
- max_new_tokens (int, facultatif) — Nombre de jetons à générer pour chaque exemple. Plus il y a de jetons, plus les échantillons audio sont longs, au prix d'une inférence plus longue (puisque davantage de jetons audio doivent être générés par exemple).
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 MoshiForConditionalGeneration
>>> model = MoshiForConditionalGeneration.from_pretrained("kmhf/hf-moshika")
>>> # get the unconditional (or 'null') inputs for the model
>>> unconditional_inputs = model.get_unconditional_inputs(num_samples=1)
>>> audio_samples = model.generate(**unconditional_inputs, max_new_tokens=256)