Transformers documentation
Mixtral
Ce modèle a été publié dans HF papers le 2024-01-08 et contribué à Hugging Face Transformers le 2023-12-11.
Mixtral
Aperçu
Mixtral-8x7B a été présenté dans le blogpost Mixtral of Experts par Albert Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lélio Renard Lavaud, Lucile Saulnier, Marie-Anne Lachaux, Pierre Stock, Teven Le Scao, Thibaut Lavril, Thomas Wang, Timothée Lacroix, William El Sayed.
L'introduction du billet de blog indique :
Aujourd’hui, l’équipe est fière de publier Mixtral 8x7B, un modèle de haute qualité de type sparse mixture of experts (SMoE) aux poids ouverts. Il est sous licence Apache 2.0. Mixtral surpasse Llama 2 70B sur la plupart des benchmarks avec une inférence 6 fois plus rapide. C’est le modèle aux poids ouverts le plus performant sous licence permissive et le meilleur modèle global en termes de compromis coût/performance. En particulier, il égale ou surpasse GPT3.5 sur la plupart des benchmarks standard.
Mixtral-8x7B est le deuxième grand modèle de langage (LLM) publié par mistral.ai, après Mistral-7B.
Détails architecturaux
Mixtral-8x7B est un Transformer à décodeur uniquement avec les choix architecturaux suivants :
- Mixtral est un modèle Mixture of Experts (MoE) doté de 8 experts par MLP, pour un total de 45 milliards de paramètres. Pour en savoir plus sur les architectures mixture-of-experts, consultez le article de blog.
- Bien que le modèle possède 45 milliards de paramètres, la puissance de calcul requise pour un seul passage avant est identique à celle d'un modèle de 14 milliards de paramètres. Cela s'explique par le fait que, même si chaque expert doit être chargé en RAM (exigence de RAM de 70 Go), chaque jeton issu des états cachés est acheminé deux fois (routage top 2) et que le calcul (l'opération requise à chaque calcul avant) est donc simplement de 2 X sequence_length.
Les détails d’implémentation suivants sont partagés avec le premier modèle de Mistral AI, Mistral-7B :
- Attention à fenêtre glissante - Entraîné avec une longueur de contexte de 8k et une taille de cache fixe, avec une portée théorique de l'attention de 128K jetons
- GQA (Grouped Query Attention) - permettant une inférence plus rapide et une taille de cache réduite.
- Tokeniseur BPE avec repli sur les octets - garantit que les caractères ne sont jamais mappés sur des jetons hors vocabulaire.
Pour plus de détails, consultez le article de blog sur la version.
Licence
Mixtral-8x7B est publié sous licence Apache 2.0.
Conseils d'utilisation
L'équipe Mistral a publié 2 points de contrôle :
- un modèle de base, Mixtral-8x7B-v0.1, pré-entraîné pour prédire le jeton suivant sur des données à l'échelle d'Internet.
- un modèle ajusté par instructions, Mixtral-8x7B-Instruct-v0.1, qui est le modèle de base optimisé pour la conversation à l’aide de l’ajustement fin supervisé (SFT) et de l’optimisation directe des préférences (DPO).
Le modèle de base peut être utilisé comme suit :
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
prompt = "My favourite condiment is"
model_inputs = tokenizer([prompt], return_tensors="pt").to(model.device)
generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"My favourite condiment is to ..."Le modèle ajusté sur les instructions peut être utilisé comme suit :
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
messages = [
{"role": "user", "content": "What is your favourite condiment?"},
{"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
{"role": "user", "content": "Do you have mayonnaise recipes?"}
]
model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
generated_ids = model.generate(model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"Mayonnaise can be made as follows: (...)"Comme on peut le voir, le modèle ajusté sur les instructions nécessite l'application d'un chat template afin de s'assurer que les entrées sont préparées dans le bon format.
Accélérer Mixtral en utilisant Flash Attention
Les extraits de code ci-dessus illustrent l’inférence sans aucune astuce d’optimisation. Il est toutefois possible d’accélérer considérablement le modèle en exploitant Flash Attention, qui est une implémentation plus rapide du mécanisme d’attention utilisé à l’intérieur du modèle.
Premièrement, assurez-vous d'installer la dernière version de Flash Attention 2 afin d'inclure la fonctionnalité d'attention à fenêtre glissante.
pip install -U flash-attn --no-build-isolation
Assurez-vous également de disposer d'un matériel compatible avec Flash-Attention 2. En savoir plus à ce sujet dans la documentation officielle du dépôt flash attention. Assurez-vous également de charger votre modèle en demi-précision (par exemple torch.float16)
Pour charger et exécuter un modèle en utilisant Flash Attention-2, reportez-vous à l'extrait de code ci-dessous :
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1", attn_implementation="flash_attention_2", device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
prompt = "My favourite condiment is"
model_inputs = tokenizer([prompt], return_tensors="pt").to(model.device)
generated_ids = model.generate(**model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"The expected output"Accélérations attendues
Ci-dessous se trouve un diagramme de l’accélération attendue qui compare le temps d’inférence pur entre l’implémentation native dans mistralai/Mixtral-8x7B-v0.1 et la version Flash Attention 2 du modèle.
Attention à fenêtre glissante
L’implémentation actuelle prend en charge le mécanisme d’attention à fenêtre glissante et la gestion efficace de la mémoire du cache.
Pour activer l’attention à fenêtre glissante, assurez-vous simplement de disposer d’une version de flash-attn compatible avec l’attention à fenêtre glissante (>=2.3.0).
Le modèle Flash Attention-2 utilise également un mécanisme de tranchage de cache plus efficace en mémoire - conformément à la recommandation de l'implémentation officielle du modèle Mistral qui utilise un mécanisme de cache défilant, nous conservons la taille du cache fixe (self.config.sliding_window), nous prenons en charge la génération par lots uniquement pour padding_side="left" et nous utilisons la position absolue du jeton actuel pour calculer l'incorporation positionnelle.
Réduire Mixtral à l'aide de la quantification
Le modèle Mixtral comptant 45 milliards de paramètres, il nécessiterait environ 90 Go de mémoire GPU en demi-précision (float16), chaque paramètre étant stocké sur 2 octets. Il est toutefois possible de réduire la taille du modèle à l’aide de la quantification. Si le modèle est quantifié sur 4 bits (soit un demi-octet par paramètre), une seule A100 dotée de 40 Go de mémoire suffit à accueillir l’ensemble du modèle, car dans ce cas, environ 27 Go de mémoire seulement sont requis.
La quantification d’un modèle est aussi simple que de passer un quantization_config au modèle. Ci-dessous, nous utiliserons la bibliothèque de quantification bitsandbytes (mais consultez cette page pour d’autres méthodes de quantification) :
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
# specify how to quantize the model
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype="torch.float16",
)
model = AutoModelForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1", quantization_config=True, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
prompt = "My favourite condiment is"
messages = [
{"role": "user", "content": "What is your favourite condiment?"},
{"role": "assistant", "content": "Well, I'm quite partial to a good squeeze of fresh lemon juice. It adds just the right amount of zesty flavour to whatever I'm cooking up in the kitchen!"},
{"role": "user", "content": "Do you have mayonnaise recipes?"}
]
model_inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
generated_ids = model.generate(model_inputs, max_new_tokens=100, do_sample=True)
tokenizer.batch_decode(generated_ids)[0]
"The expected output"Ce modèle a été contribué par Younes Belkada et Arthur Zucker . Le code d'origine peut être trouvé ici.
Ressources
Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec Mixtral. Si vous souhaitez soumettre une ressource pour qu'elle soit incluse ici, n'hésitez pas à ouvrir une Pull Request et nous la examinerons ! La ressource devrait idéalement démontrer quelque chose de nouveau plutôt que de dupliquer une ressource existante.
- Un notebook de démonstration pour effectuer un fine-tuning supervisé (SFT) de Mixtral-8x7B est disponible ici. 🌎
- Un article de blog sur le fine-tuning de Mixtral-8x7B à l'aide de PEFT. 🌎
- Le Alignment Handbook de Hugging Face contient des scripts et des recettes pour effectuer un fine-tuning supervisé (SFT) et une optimisation directe des préférences avec Mistral-7B. Cela inclut des scripts pour le fine-tuning complet, QLoRa sur un seul accélérateur ainsi que le fine-tuning multi-accélérateurs.
- Guide de la tâche de modélisation de langage causale
MixtralConfig
classe transformers.MixtralConfig
< 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 = 4096intermediate_size: int = 14336num_hidden_layers: int = 32num_attention_heads: int = 32num_key_value_heads: int = 8head_dim: int | None = Nonehidden_act: str = 'silu'max_position_embeddings: int = 131072initializer_range: float = 0.02rms_norm_eps: float = 1e-05use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = 1eos_token_id: int | list[int] | None = 2tie_word_embeddings: bool = Falsesliding_window: int | None = Noneattention_dropout: float | int = 0.0num_experts_per_tok: int = 2num_local_experts: int = 8output_router_logits: bool = Falserouter_aux_loss_coef: float = 0.001router_jitter_noise: float = 0.0rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | 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. - intermediate_size (
int, facultatif, par défaut14336) — Dimension des représentations du MLP. - 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, valeur par défaut8) — Ceci est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Sinum_key_value_heads=num_attention_heads, le modèle utilisera l'attention Multi Head (MHA), sinum_key_value_heads=1le modèle utilisera l'attention Multi Query (MQA), sinon l'attention 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 en effectuant un 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 seranum_attention_heads. - head_dim (
int, facultatif) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads - 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. - max_position_embeddings (
int, facultatif, par défaut131072) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - rms_norm_eps (
float, facultatif, valeur par défaut1e-05) — L'épsilon utilisé par les couches de normalisation rms. - 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. - pad_token_id (
int, facultatif) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. - bos_token_id (
int, facultatif, par défaut1) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. - eos_token_id (
Union[int, list[int]], facultatif, par défaut2) — 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. - sliding_window (
int, facultatif) — 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. - num_experts_per_tok (
int, facultatif, valeur par défaut2) — Nombre d'experts auxquels chaque jeton doit être routé. Il s'agit de la valeur top-k pour le routage par choix de jeton. - num_local_experts (
int, facultatif, par défaut8) — Nombre d'experts locaux sur chaque appareil.num_expertsdoit être divisible parnum_local_experts. - output_router_logits (
bool, facultatif, par défautFalse) — Indique si les logits du routeur doivent être renvoyés par le modèle. L’activation de cette option permet également au modèle de renvoyer la perte auxiliaire, incluant la perte d’équilibrage de charge et la perte z du routeur. - router_aux_loss_coef (
float, facultatif, valeur par défaut0.001) — Coefficient de la perte d'équilibrage de charge auxiliaire. Utilisé pour pénaliser un routage inégal des experts dans les modèles MoE. - router_jitter_noise (
float, facultatif, valeur par défaut0.0) — Quantité de bruit à ajouter aux logits du routeur pendant l’entraînement pour un meilleur équilibrage de charge. - 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.
Ceci est la classe de configuration permettant de stocker la configuration d'un MixtralModel. Elle est utilisée pour instancier un modèle Mixtral 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 mistralai/Mixtral-8x7B-v0.1
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 MixtralModel, MixtralConfig
>>> # Initializing a Mixtral 7B style configuration
>>> configuration = MixtralConfig()
>>> # Initializing a model from the Mixtral 7B style configuration
>>> model = MixtralModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMistralCommonBackend
classe transformers.MistralCommonBackend
< source >( tokenizer_path: str | os.PathLike | pathlib.Pathmode: str | ValidationMode = 'test'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )
Classe destinée à encapsuler les tokenizers de mistral-common.
mistral-common est la bibliothèque de tokenisation officielle pour les modèles Mistral AI. Pour l’utiliser, vous devez l’installer avec :
pip install transformers[mistral-common]
Sinon, le tokenizer bascule sur l'implémentation du tokenizer de Transformers.
Pour plus d'informations sur mistral-common, consultez mistral-common.
Cette classe est un wrapper autour d’un mistral_common.tokens.tokenizers.mistral.MistralTokenizer.
Elle fournit une interface compatible Hugging Face pour la tokenisation à l’aide du tokeniseur officiel mistral-common et hérite de la classe PreTrainedTokenizerBase.
Voici les principales différences de comportement par rapport à la classe PythonBackend :
- Les paires de séquences ne sont pas prises en charge. La signature a été conservée pour des raisons de compatibilité, mais tous les arguments liés aux paires de séquences sont ignorés. Les valeurs de retour pour les paires sont renvoyées sous forme de
None. - L'argument
is_split_into_wordsn'est pas pris en charge. - Il n'est pas possible d'ajouter de nouveaux jetons au tokenizer. Les jetons spéciaux sont gérés différemment par rapport à Transformers. Dans
mistral-common, les jetons spéciaux ne sont jamais encodés directement. Cela signifie que :tokenizer.encode("<s>")ne renverra pas l'ID du jeton<s>. En revanche, il renverra une liste d'IDs correspondant à la tokenisation de la chaîne"<s>". Pour plus d'informations, consultez la documentation de mistral-common.
Si vous avez des suggestions pour améliorer cette classe, veuillez ouvrir un ticket sur le dépôt GitHub mistral-common si cela concerne le tokenizer, ou sur le dépôt GitHub Transformers si cela concerne l’interface Hugging Face.
add_special_tokens
< source >( special_tokens_dict: dictreplace_extra_special_tokens: bool = True )
MistralCommonBackend n’implémente pas add_special_tokens par conception.
Si vous souhaitez que ce comportement soit implémenté, veuillez ouvrir un ticket dans les dépôts Transformers ou mistral-common pour le demander.
MistralCommonBackend n’implémente pas add_special_tokens par conception.
Si vous souhaitez que ce comportement soit implémenté, veuillez ouvrir un ticket dans les dépôts Transformers ou mistral-common pour le demander.
apply_chat_template
< source >( conversation: list[dict[str, str]] | list[list[dict[str, str]]]tools: list[dict | collections.abc.Callable] | None = Noneadd_generation_prompt: bool = Falsecontinue_final_message: bool = Falsetokenize: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool = Falsemax_length: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_dict: bool = Truereasoning_effort: ReasoningEffort | None = None**kwargs ) → Union[str, list[int], list[str], list[list[int]], BatchEncoding]
Paramètres
- conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) — A list of dicts with “role” and “content” keys, representing the chat history so far.
- tools (
List[Union[Dict, Callable]], facultatif) — Une liste d’outils (fonctions appelables) qui seront accessibles au modèle. Si le modèle de dialogue ne prend pas en charge l’appel de fonctions, cet argument n’aura aucun effet. Chaque outil doit être transmis sous forme de schéma JSON, indiquant le nom, la description et les types d’arguments de l’outil. Consultez notre guide sur les modèles de dialogue pour plus d’informations. - add_generation_prompt (
bool, facultatif) — Cet argument est ignoré parMistralCommonBackend. Cependant, il ne peut pas être utilisé en même temps quecontinue_final_messageafin de conserver la cohérence de l’API. Si une conversation se termine par un message de l’assistant, une erreur sera levée. Dans ce cas, utilisez plutôtcontinue_final_message. - continue_final_message (bool, facultatif) —
Si ce paramètre est défini, la conversation sera formatée de manière à ce que le dernier message de la conversation soit ouvert, sans jetons EOS. Le modèle poursuivra ce message au lieu d’en démarrer un nouveau. Cela permet de « préremplir » une partie de la réponse du modèle. Ne peut pas être utilisé en même temps que
add_generation_prompt. - tokenize (
bool, par défautTrue) — Indique s'il faut tokeniser la sortie. SiFalse, la sortie sera une chaîne de caractères. - padding (
bool,strou PaddingStrategy, facultatif, défaut :False) — Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi les options suivantes :Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
- truncation (
bool, par défautFalse) — Indique s'il faut tronquer les séquences à la longueur maximale. N'a aucun effet si tokenize estFalse. - max_length (
int, facultatif) — Longueur maximale (en jetons) à utiliser pour le bourrage ou la troncature. N’a aucun effet si tokenize estFalse. Si non spécifié, l’attributmax_lengthdu tokeniseur sera utilisé par défaut. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. N'a aucun effet si tokenize estFalse. Valeurs acceptables :'pt': Renvoie des objetstorch.Tensorde PyTorch.
- return_dict (
bool, par défautFalse) — Indique s'il faut retourner un dictionnaire avec des sorties nommées. N'a aucun effet si tokenize estFalse. Si au moins une conversation contient une image, ses valeurs de pixels seront retournées dans la clépixel_valueset les dimensions des images dans la cléimage_sizes. - reasoning_effort (
ReasoningEffort, facultatif) — L'effort de raisonnement à utiliser pour la complétion de chat pour les modèles qui le prennent en charge. Les valeurs possibles sont :ReasoningEffort.none: le modèle ne raisonne pas.ReasoningEffort.high: le modèle utilisera une approche de raisonnement. Si non spécifié, l'effort de raisonnement par défaut sera utilisé.
- kwargs (arguments supplémentaires par mot-clé, facultatif) —
Arguments supplémentaires transmis à la méthode
ChatCompletionRequest.from_openaide mistral-common.
Retourne
Union[str, list[int], list[str], list[list[int]], BatchEncoding]
La conversation tokenisée jusqu’à présent, y compris les jetons de contrôle. Cette sortie est prête à être transmise au modèle, soit directement, soit via des méthodes telles que generate().
Convertit une liste de dictionnaires avec les clés "role" et "content" en une liste d'identifiants de jetons.
batch_decode
< source >( sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → list[str]
Paramètres
- sequences (
Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — Liste des identifiants d’entrée tokenisés. Peut être obtenue à l’aide de la méthode__call__. - skip_special_tokens (
bool, facultatif, valeur par défautFalse) — Indique s'il faut supprimer les jetons spéciaux lors du décodage. - clean_up_tokenization_spaces (
bool, facultatif) — Indique s'il faut nettoyer les espaces de tokenisation. SiNone, la valeur par défaut estself.clean_up_tokenization_spaces. - kwargs (arguments supplémentaires par mot-clé, facultatif) —
Non pris en charge par
MistralCommonBackend.batch_decode. Levera une erreur s'il est utilisé.
Retourne
list[str]
La liste des phrases décodées.
Convertir une liste de listes d'identifiants de jetons en une liste de chaînes en appelant decode.
Cette méthode est fournie pour la compatibilité ascendante. La méthode decode gère désormais nativement les entrées par lots,
vous pouvez donc utiliser directement decode au lieu de batch_decode.
build_inputs_with_special_tokens
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
Construire les entrées du modèle à partir d'une séquence en ajoutant des jetons spéciaux.
Cette méthode construit dynamiquement les entrées en fonction du mode du tokenizer :
"test": seq0 [EOS]"finetuning": [BOS] seq0
convert_added_tokens
< source >( obj: tokenizers.AddedToken | typing.Anysave: bool = Falseadd_type_field: bool = True )
MistralCommonBackend n’implémente pas convert_added_tokens par conception.
Si vous souhaitez que ce comportement soit implémenté, veuillez ouvrir un ticket dans les dépôts Transformers ou mistral-common pour le demander.
create_token_type_ids_from_sequences
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
Créez un masque de zéros à partir des identifiants de jetons avec les jetons spéciaux ajoutés.
Conservé pour correspondre à l'implémentation de Transformers.
décoder
< source >( token_ids: typing.Union[int, list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → Union[str, list[str]]
Paramètres
- token_ids (
Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]) — Une séquence unique ou un lot (liste de séquences) d’identifiants d’entrée tokenisés. Peut être obtenu à l’aide de la méthode__call__. - skip_special_tokens (
bool, facultatif, valeur par défautFalse) — Indique s'il faut supprimer les jetons spéciaux lors du décodage. - clean_up_tokenization_spaces (
bool, facultatif) — Indique s'il faut nettoyer les espaces de tokenisation. SiNone, la valeur par défaut estself.clean_up_tokenization_spaces. - kwargs (arguments supplémentaires par mot-clé, facultatif) —
Non pris en charge par
MistralCommonBackend.decode. Levera une erreur s'il est utilisé.
Retourne
Union[str, list[str]]
La chaîne décodée pour une séquence unique, ou une liste de chaînes décodées pour un lot de séquences.
Convertit une séquence d'identifiants en chaîne de caractères, en utilisant le tokenizer et le vocabulaire, avec des options pour supprimer les jetons spéciaux et nettoyer les espaces de tokenization.
encode
< source >( text: str | list[int]text_pair: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Noneverbose: bool = Truereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[int], torch.Tensor
Paramètres
- text (
stroulist[int]) — La première séquence à encoder. Il peut s’agir d’une chaîne de caractères ou d’une liste d’entiers (identifiants de jetons d’une chaîne tokenisée). - text_pair (
None, facultatif) — Non pris en charge parMistralCommonBackend.encode. Conservé pour correspondre à la signature dePreTrainedTokenizerBase.encode. - add_special_tokens (
bool, facultatif, par défautTrue) — Indique s'il faut ou non ajouter des jetons spéciaux lors de l'encodage des séquences. Cela utilise la fonction sous-jacentePretrainedTokenizerBase.build_inputs_with_special_tokens, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetonsbosoueos. Lorsque le Tokenizer est chargé en modefinetuning, il ajoute à la foisboseteos. Sinon, en mode « test », il n'ajoute quebos. - padding (
bool,strou PaddingStrategy, facultatif, défaut :False) — Active et contrôle le padding. Accepte les valeurs suivantes :Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
- truncation (
bool,strou TruncationStrategy, facultatif, défaut :False) — Active et contrôle la troncature. Accepte les valeurs suivantes :Trueou'longest_first': Tronquer à une longueur maximale spécifiée avec l’argumentmax_lengthou à la longueur d’entrée maximale acceptable pour le modèle si cet argument n’est pas fourni.Falseou'do_not_truncate'(par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).
- max_length (
int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.Si non défini ou défini sur
None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé. - stride (
int, facultatif, valeur par défaut 0) — Si défini à un nombre avecmax_length, les jetons en dépassement renvoyés lorsquereturn_overflowing_tokens=Truecontiendront certains jetons de la fin de la séquence tronquée renvoyée afin de fournir un chevauchement entre les séquences tronquées et les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement. - pad_to_multiple_of (
int, facultatif) — Si défini, la séquence est rembourrée jusqu'à un multiple de la valeur fournie. Nécessite l'activation depadding. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul>= 7.5(Volta). - padding_side (
str, facultatif) — Le côté sur lequel le modèle doit appliquer le bourrage. Doit être choisi parmi [‘right’, ‘left’]. La valeur par défaut est choisie à partir de l’attribut de classe du même nom. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.
- **kwargs — Non pris en charge par
MistralCommonBackend.encode. Levera une erreur s'il est utilisé.
Retourne
list[int], torch.Tensor
Les identifiants tokenisés du texte.
Convertit une chaîne de caractères en une séquence d'identifiants (entiers), en utilisant le tokenizer et le vocabulaire.
from_pretrained
< source >( pretrained_model_name_or_path: str | os.PathLike*init_inputsmode: str | ValidationMode = 'test'cache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )
Paramètres
- pretrained_model_name_or_path (
strouos.PathLike) — Peut être soit :- Une chaîne de caractères, l'identifiant du modèle d'un tokeniseur prédéfini hébergé dans un dépôt de modèles sur huggingface.co.
- Chemin vers un dossier contenant la configuration du tokenizer, par exemple sauvegardée à l’aide de la méthode
MistralCommonBackend.tokenization_mistral_common.save_pretrained, par exemple./my_model_directory/.
- mode (
Union[str, ValidationMode], facultatif, défaut surValidationMode.test) — Mode de validation pour leMistralTokenizertokenizer. Les valeurs possibles sont :"finetuning"ouValidationMode.finetuning: le mode de fine-tuning."test"ouValidationMode.test: le mode test. Il modifie la manière dont le tokenizer valide l'entrée et prépare la requête destinée au modèle.
- cache_dir (
strouos.PathLike, facultatif) — Chemin vers un répertoire dans lequel les fichiers de vocabulaire de tokenizer prédéfinis téléchargés doivent être mis en cache si le cache standard ne doit pas être utilisé. - force_download (
bool, facultatif, par défautFalse) — Indique s'il faut forcer le (re)téléchargement des fichiers de vocabulaire et remplacer les versions en cache si elles existent. - token (
strou bool, facultatif) — Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. SiTrue, utilise le jeton généré lors de l’exécution dehf auth login(stocké dans~/.huggingface). - local_files_only (
bool, facultatif, valeur par défautFalse) — Indique s'il faut s'appuyer uniquement sur les fichiers locaux et ne pas tenter de télécharger de fichiers. - revision (
str, facultatif, par défaut"main") — La version spécifique du modèle à utiliser. Il peut s’agir du nom d’une branche, du nom d’une étiquette ou d’un identifiant de commit, car nous utilisons un système basé sur git pour stocker les modèles et autres artefacts sur huggingface.co, de sorte querevisionpeut être n’importe quel identifiant autorisé par git. - max_length (
int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.Si non défini ou défini sur
None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé. - padding_side (
str, facultatif, par défaut"left") — Le côté sur lequel le modèle doit appliquer le bourrage. Doit être sélectionné parmi [‘right’, ‘left’]. La valeur par défaut est choisie à partir de l’attribut de classe du même nom. - truncation_side (
str, facultatif, par défaut"right") — Le côté sur lequel le modèle doit appliquer la troncature. Doit être sélectionné parmi [‘right’, ‘left’]. - model_input_names (
List[str], facultatif) — La liste des entrées acceptées par le passage avant du modèle (comme"token_type_ids"ou"attention_mask"). La valeur par défaut est choisie à partir de l'attribut de classe du même nom. - clean_up_tokenization_spaces (
bool, facultatif, valeur par défautFalse) — Indique si le modèle doit nettoyer les espaces ajoutés lors de la division du texte d’entrée pendant le processus de tokenisation. - kwargs (arguments supplémentaires par mot-clé, facultatif) —
Non pris en charge par
MistralCommonBackend.from_pretrained. Levera une erreur s'il est utilisé.
Instanciez un MistralCommonBackend à partir d'un
tokeniseur prédéfini.
MistralCommonBackend n’implémente pas get_chat_template par conception, car mistral-common n’utilise pas de modèles de discussion.
get_special_tokens_mask
< source >( token_ids_0: listtoken_ids_1: None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]
Paramètres
- token_ids_0 (
list[int]) — Liste des identifiants de la séquence. - token_ids_1 (
None, facultatif) — None, conservé pour correspondre à l’implémentation de Transformers. - already_has_special_tokens (
bool, facultatif, par défautFalse) — Indique si la liste de jetons est déjà formatée avec les jetons spéciaux du modèle.
Retourne
Une liste d'entiers dans l'intervalle [0, 1]
1 pour un jeton spécial, 0 pour un jeton de séquence.
Récupère les identifiants de séquences à partir d'une liste de jetons qui ne contient pas de jetons spéciaux ajoutés. Cette méthode est appelée lors de l'ajout de jetons spéciaux à l'aide des méthodes prepare_for_model ou encode_plus du tokenizer.
Retourne le vocabulaire sous forme de dictionnaire associant chaque jeton à son index.
Il s'agit d'une conversion avec perte. Plusieurs identifiants de jetons peuvent se décoder en la même chaîne en raison de séquences d'octets UTF-8 partielles converties en �.
num_special_tokens_to_add
< source >( pair: typing.Literal[False] = False ) → int
Retourne le nombre de jetons ajoutés lors de l’encodage d’une séquence avec des jetons spéciaux.
Cela encode une entrée factice et vérifie le nombre de jetons ajoutés, ce qui n'est donc pas efficace. Ne placez pas cela dans votre boucle d'entraînement.
prepare_for_model
< source >( ids: listpair_ids: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_length: bool = Falseverbose: bool = Trueprepend_batch_axis: bool = Falsereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → BatchEncoding
Paramètres
- ids (
list[int]) — Identifiants des jetons d'entrée de la première séquence. - pair_ids (
None, facultatif) — Non pris en charge parMistralCommonBackend. Conservé pour correspondre à l’interface dePreTrainedTokenizerBase. - add_special_tokens (
bool, facultatif, par défautTrue) — Indique s'il faut ou non ajouter des jetons spéciaux lors de l'encodage des séquences. Cela utilise la fonction sous-jacentePretrainedTokenizerBase.build_inputs_with_special_tokens, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetonsbosoueos. Lorsque le Tokenizer est chargé en modefinetuning, il ajoute à la foisboseteos. Sinon, en mode « test », il n'ajoute quebos. - padding (
bool,strou PaddingStrategy, facultatif, défaut :False) — Active et contrôle le padding. Accepte les valeurs suivantes :Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
- truncation (
bool,strou TruncationStrategy, facultatif, défaut :False) — Active et contrôle la troncature. Accepte les valeurs suivantes :Trueou'longest_first': Tronquer à une longueur maximale spécifiée avec l’argumentmax_lengthou à la longueur d’entrée maximale acceptable pour le modèle si cet argument n’est pas fourni.Falseou'do_not_truncate'(par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).
- max_length (
int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.Si non défini ou défini sur
None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé. - stride (
int, facultatif, valeur par défaut 0) — Si défini à un nombre avecmax_length, les jetons en dépassement renvoyés lorsquereturn_overflowing_tokens=Truecontiendront certains jetons de la fin de la séquence tronquée renvoyée afin de fournir un chevauchement entre les séquences tronquées et les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement. - pad_to_multiple_of (
int, facultatif) — Si défini, la séquence est rembourrée jusqu'à un multiple de la valeur fournie. Nécessite l'activation depadding. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul>= 7.5(Volta). - padding_side (
str, facultatif) — Le côté sur lequel le modèle doit appliquer le bourrage. Doit être choisi parmi [‘right’, ‘left’]. La valeur par défaut est choisie à partir de l’attribut de classe du même nom. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.
- return_token_type_ids (
bool, facultatif) — Indique s'il faut renvoyer les identifiants de type de jeton. PourMistralCommonBackend, il renvoie une liste de zéros de la longueur de la séquence, car seule une séquence est prise en charge. - return_attention_mask (
bool, facultatif) — Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attributreturn_outputs. - return_overflowing_tokens (
bool, facultatif, par défautFalse) — Indique s'il faut ou non retourner les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avectruncation_strategy = longest_firstouTrue, une erreur est levée au lieu de retourner les jetons en dépassement. - return_special_tokens_mask (
bool, facultatif, par défautFalse) — Indique s'il faut ou non retourner les informations du masque des jetons spéciaux. - return_length (
bool, facultatif, par défautFalse) — Indique s'il faut retourner les longueurs des entrées encodées. - verbose (
bool, facultatif, par défautTrue) — Indique s'il faut afficher plus d'informations et d'avertissements. - return_offsets_mapping (
Literal[False], facultatif) — False, conservé pour correspondre à la signature de Transformers. - split_special_tokens (
Literal[False], facultatif) — False, conservé pour correspondre à la signature de Transformers. - **kwargs — transmis à la méthode
self.tokenize()
Retourne
Un BatchEncoding avec les champs suivants :
-
input_ids — Liste des identifiants de jetons à fournir à un modèle.
-
attention_mask — Liste d’indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque
return_attention_mask=Trueou si “attention_mask” est présent dansself.model_input_names). -
overflowing_tokens — Liste des séquences de jetons en dépassement (lorsqu'une
max_lengthest spécifiée etreturn_overflowing_tokens=True). -
num_truncated_tokens — Nombre de jetons tronqués (lorsqu'une
max_lengthest spécifiée etreturn_overflowing_tokens=True). -
special_tokens_mask — Liste de 0 et de 1, où 1 indique les jetons spéciaux ajoutés et 0 indique les jetons de séquence réguliers (lorsque
add_special_tokens=Trueetreturn_special_tokens_mask=True). -
length — La longueur des entrées (lorsque
return_length=True)
Prépare une séquence d’identifiants d’entrée afin qu’elle puisse être utilisée par le modèle. Il ajoute des jetons spéciaux, tronque les séquences en cas de dépassement en tenant compte des jetons spéciaux et gère une fenêtre glissante (avec un pas défini par l’utilisateur) pour les jetons en dépassement.
save_chat_templates
< source >( save_directory: str | os.PathLiketokenizer_config: dictfilename_prefix: str | Nonesave_jinja_files: bool )
MistralCommonBackend n’implémente pas save_chat_templates par conception, car mistral-common n’utilise pas de modèles de discussion.
save_pretrained
< source >( save_directory: str | os.PathLike | pathlib.Pathpush_to_hub: bool = Falsetoken: str | bool | None = Nonecommit_message: str | None = Nonerepo_id: str | None = Noneprivate: bool | None = Nonesave_format: str | None = None**kwargs ) → tuple[str, ...]
Paramètres
- save_directory (
str | os.PathLike | Path) — Répertoire où le tokenizer sera enregistré. - push_to_hub (
bool, facultatif, par défautFalse) — Pousse vers le HF Hub après l'enregistrement. - token (
stroubool, facultatif) — Jeton pour l’authentification au Hub. - commit_message (
str, facultatif) — Message de commit lors de la poussée. - repo_id (
str, facultatif) — Identifiant du dépôt sur le Hub. - private (
bool, facultatif) — Indique si le dépôt est privé. - save_format (
str, facultatif) —"mistral"pour enregistrer au format tekken natif,"hf"pour le format HuggingFace. None conserve le format d'origine. - kwargs (
dict, facultatif) — Non pris en charge — lève une erreur.
Retourne
tuple[str, ...]
Chemin des fichiers enregistrés.
Enregistrer l'état complet du tokenizer.
Lorsque save_format est "mistral" (ou None pour un tokenizer tekken),
le fichier de tokenizer d'origine (par ex. tekken.json) est écrit dans save_directory. Lorsque save_format est "hf", des fichiers au format HF
(tokenizer.json + tokenizer_config.json) sont produits à la place.
MistralCommonBackend n’implémente pas save_vocabulary par conception.
Cela est dû au fait que mistral-common est configuré par un seul fichier de tokenizer. Si vous souhaitez enregistrer le vocabulaire, veuillez envisager d'utiliser la méthode save_pretrained à la place.
tokenize
< source >( text: strreturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[str]
Paramètres
- text (
str) — La séquence à encoder. - return_offsets_mapping (
Literal[False], facultatif) — False, conservé pour correspondre à la signature de Transformers. - split_special_tokens (
Literal[False], facultatif) — False, conservé pour correspondre à la signature de Transformers. - **kwargs (arguments supplémentaires par mot-clé) —
Non pris en charge par
MistralCommonBackend.tokenize. Levera une erreur s'il est utilisé.
Retourne
list[str]
La liste de jetons.
Convertit une chaîne de caractères en une séquence de jetons, en utilisant le tokeniseur.
Découpe en mots pour les vocabulaires basés sur les mots ou en sous-mots pour les vocabulaires basés sur les sous-mots.
truncate_sequences
< source >( ids: listpair_ids: None = Nonenum_tokens_to_remove: int = 0truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first'stride: int = 0**kwargs ) → Tuple[list[int], None, list[int]]
Paramètres
- ids (
list[int]) — Identifiants d’entrée tokenisés. Ils peuvent être obtenus à partir d’une chaîne en enchaînant les méthodestokenizeetconvert_tokens_to_ids. - pair_ids (
None, facultatif) — Non pris en charge parMistralCommonBackend. Conservé pour correspondre à la signature dePreTrainedTokenizerBase.truncate_sequences. - num_tokens_to_remove (
int, facultatif, valeur par défaut 0) — Nombre de jetons à supprimer en utilisant la stratégie de troncature. - truncation_strategy (
strou TruncationStrategy, facultatif, défaut :'longest_first') — La stratégie à suivre pour la troncature. Peut être :'longest_first': Tronque à une longueur maximale spécifiée avec l'argumentmax_lengthou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.'do_not_truncate'(par défaut) : aucune troncature (c.-à-d. peut produire un lot dont les longueurs de séquences dépassent la taille d’entrée maximale admissible par le modèle).
- stride (
int, facultatif, valeur par défaut 0) — Si défini sur un nombre positif, les jetons en dépassement renvoyés contiendront certains jetons de la séquence principale renvoyée. La valeur de cet argument définit le nombre de jetons supplémentaires.
Retourne
Tuple[list[int], None, list[int]]
Les ids tronqués et la liste des
jetons en dépassement. None est retourné pour correspondre à la signature de Transformers.
Tronque une paire de séquences sur place selon la stratégie.
MixtralModel
classe transformers.MixtralModel
< source >( config: MixtralConfig )
Paramètres
- config (MixtralConfig) — 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 Mixtral 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'> ) → MoeModelOutputWithPast 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
MoeModelOutputWithPast ou tuple(torch.Tensor)
Un MoeModelOutputWithPast 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 (MixtralConfig) et des entrées.
La méthode forward de MixtralModel 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.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.
router_logits (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_router_probs=Trueetconfig.add_router_probs=Truesont passés ou lorsqueconfig.output_router_probs=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, sequence_length, num_experts).Logits bruts du routeur (après softmax) calculés par les routeurs MoE, ces termes sont utilisés pour calculer la perte auxiliaire des modèles Mixture of Experts.
MixtralForCausalLM
classe transformers.MixtralForCausalLM
< source >( config: MixtralConfig )
Paramètres
- config (MixtralConfig) — 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 Mixtral pour la modélisation de langage causale.
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] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_router_logits: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MoeCausalLMOutputWithPast 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. - 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]. - 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). - output_router_logits (
bool, facultatif) — Indique s'il faut ou non retourner les logits de tous les routeurs. Ils sont utiles pour calculer la perte du routeur et ne doivent pas être retournés lors de l'inférence. - 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
MoeCausalLMOutputWithPast ou tuple(torch.Tensor)
Un MoeCausalLMOutputWithPast 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 (MixtralConfig) et des entrées.
La méthode forward de MixtralForCausalLM 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).aux_loss (
torch.Tensor, facultatif, renvoyé lorsqueoutput_router_logits=Trueest passé ou lorsqueconfig.output_router_logits=True, et que le modèle entraîne son routeur avec une perte d’équilibrage de charge) — Perte auxiliaire d’équilibrage de charge pour les modules creux. Les modèles qui équilibrent leurs experts au moyen d’un biais de routeur à la place (DeepSeek-V3 et les architectures dérivées de celui-ci) renvoientNoneici tout en renvoyant toujoursrouter_logits.router_logits (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_router_logits=Trueest passé ou lorsqueconfig.output_router_logits=True) — Tuple detorch.Tensor(un pour chaque couche creuse) de forme(batch_size * sequence_length, num_experts).Logits bruts du routeur calculés par les routeurs MoE. Ils peuvent être utilisés pour calculer une perte d'équilibrage de charge ou pour inspecter la manière dont les jetons sont acheminés vers les experts.
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, MixtralForCausalLM
>>> model = MixtralForCausalLM.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
>>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mixtral-8x7B-v0.1")
>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> 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]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."MixtralForSequenceClassification
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.Tensor | None = Nonelabels: torch.LongTensor | None = Noneuse_cache: bool | None = None**kwargs: Unpack[TransformersKwargs] ) → SequenceClassifierOutputWithPast
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, 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,), facultatif) — Étiquettes pour le calcul de la perte de classification/régression de séquence. Les indices doivent être dans[0, ..., config.num_labels - 1]. Siconfig.num_labels == 1, une perte de régression est calculée (perte du carré moyen). Siconfig.num_labels > 1, une perte de classification est calculée (entropie croisée). - 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
SequenceClassifierOutputWithPast
La méthode forward de GenericForSequenceClassification 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.
MixtralForTokenClassification
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.Tensor | None = Nonelabels: torch.LongTensor | None = Noneuse_cache: bool | None = None**kwargs: Unpack[TransformersKwargs] ) → TokenClassifierOutput
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, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de classification de jetons. Les indices doivent être dans[0, ..., config.num_labels - 1]. - 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
TokenClassifierOutput
La méthode forward de GenericForTokenClassification 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.
MixtralForQuestionAnswering
forward
< source >( input_ids: torch.LongTensor | None = Noneattention_mask: torch.Tensor | None = Noneposition_ids: torch.LongTensor | None = Nonepast_key_values: Cache | None = Noneinputs_embeds: torch.Tensor | None = Nonestart_positions: torch.LongTensor | None = Noneend_positions: torch.LongTensor | None = None**kwargs: Unpack[TransformersKwargs] ) → QuestionAnsweringModelOutput
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, 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. - start_positions (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) du début de l'interval étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont bornées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte. - end_positions (
torch.LongTensorde forme(batch_size,), facultatif) — Étiquettes pour la position (index) de fin de l'intervalle étiqueté, utilisées pour le calcul de la perte de classification de jetons. Les positions sont bornées à la longueur de la séquence (sequence_length). Les positions situées en dehors de la séquence ne sont pas prises en compte pour le calcul de la perte.
Retourne
QuestionAnsweringModelOutput
La méthode forward de GenericForQuestionAnswering 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.