# Mistral [Mistral](https://huggingface.co/papers/2310.06825) est un modèle de langage de 7 milliards de paramètres, disponible en variante pré-entraînée et en variante ajustée par instructions, conçu pour équilibrer les coûts de mise à l’échelle des grands modèles avec les performances et une inférence efficace. Ce modèle utilise l’attention à fenêtre glissante (SWA), entraînée avec une longueur de contexte de 8K et une taille de cache fixe, afin de traiter plus efficacement les séquences plus longues. L’attention à requêtes groupées (GQA) accélère l’inférence et réduit les besoins en mémoire. Mistral intègre également un tokeniseur BPE avec repli sur les octets (byte-fallback) pour améliorer le traitement et l’efficacité des jetons en garantissant qu’aucun caractère n’est associé à un jeton hors vocabulaire. Vous pouvez trouver tous les points de contrôle originaux de Mistral sous l’organisation [Mistral AI_](https://huggingface.co/mistralai). > [!TIP] > Cliquez sur les modèles Mistral dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer Mistral à différentes tâches de langage. > > Définissez `use_kernels=True` dans [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour remplacer les couches prises en charge par des noyaux optimisés du Hub. Consultez [Chargement des noyaux](../kernel_doc/loading_kernels) pour en savoir plus. L'exemple ci-dessous montre comment discuter avec [Pipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.Pipeline) ou le [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel), et depuis la ligne de commande. ```python from transformers import pipeline 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?"} ] chatbot = pipeline("text-generation", model="mistralai/Mistral-7B-Instruct-v0.3", device=0) chatbot(messages) ``` ```python from transformers import AutoModelForCausalLM, AutoTokenizer model = AutoModelForCausalLM.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3", attn_implementation="sdpa", device_map="auto") tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3") 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: (...)" ``` ```python echo -e "My favorite condiment is" | transformers chat mistralai/Mistral-7B-v0.3 --dtype auto --device 0 --attn_implementation flash_attention_2 ``` La quantification réduit la charge mémoire des grands modèles en représentant les poids avec une précision inférieure. Reportez-vous à l'aperçu de la [Quantization](../quantization/overview) pour plus d'informations sur les backends de quantification disponibles. L'exemple ci-dessous utilise [bitsandbytes](../quantization/bitsandbytes) pour quantiser uniquement les poids sur 4 bits. ```python import torch 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/Mistral-7B-Instruct-v0.3", quantization_config=quantization_config, device_map="auto") tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.3") 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" ``` Utilisez le [AttentionMaskVisualizer](https://github.com/huggingface/transformers/blob/beb9b5b02246b9b7ee81ddf938f93f44cfeaad19/src/transformers/utils/attention_visualizer.py#L139) pour mieux comprendre les jetons auxquels le modèle peut ou non prêter attention. ```python from transformers.utils.attention_visualizer import AttentionMaskVisualizer visualizer = AttentionMaskVisualizer("mistralai/Mistral-7B-Instruct-v0.3") visualizer("Do you have mayonnaise recipes?") ``` ## MistralConfig[[transformers.MistralConfig]] #### transformers.MistralConfig[[transformers.MistralConfig]] ```python transformers.MistralConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 32000, hidden_size: int = 4096, intermediate_size: int = 14336, num_hidden_layers: int = 32, num_attention_heads: int = 32, num_key_value_heads: int = 8, head_dim: int | None = None, hidden_act: str = 'silu', max_position_embeddings: int = 131072, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = 1, eos_token_id: int | list[int] | None = 2, tie_word_embeddings: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, sliding_window: int | None = 4096, attention_dropout: float | int = 0.0) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral/configuration_mistral.py#L28) **Paramètres :** vocab_size (`int`, *facultatif*, valeur par défaut `32000`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`. hidden_size (`int`, *facultatif*, valeur par défaut `4096`) : Dimension des représentations cachées. intermediate_size (`int`, *facultatif*, valeur par défaut `14336`) : Dimension des représentations MLP. num_hidden_layers (`int`, *facultatif*, valeur par défaut `32`) : Nombre de couches cachées dans le décodeur Transformer. num_attention_heads (`int`, *facultatif*, valeur par défaut `32`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. num_key_value_heads (`int`, *facultatif*, valeur par défaut `8`) : C'est le nombre de têtes key_value à utiliser pour implémenter l'attention Grouped Query. Si `num_key_value_heads=num_attention_heads`, le modèle utilisera l'attention Multi Head (MHA) ; si `num_key_value_heads=1`, il utilisera l'attention Multi Query (MQA) ; sinon, c'est la GQA qui est utilisée. Lors de la conversion d'un checkpoint multi-têtes vers un checkpoint GQA, chaque tête clé et valeur de groupe doit être construite en effectuant un meanpooling de toutes les têtes d'origine appartenant à ce groupe. Pour plus de détails, consultez [cet article](https://huggingface.co/papers/2305.13245). S'il n'est pas spécifié, la valeur par défaut est `num_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éfaut `silu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. max_position_embeddings (`int`, *facultatif*, valeur par défaut `131072`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. rms_norm_eps (`float`, *facultatif*, valeur par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation rms. use_cache (`bool`, *facultatif*, valeur par défaut `True`) : Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement. pad_token_id (`int`, *facultatif*) : Identifiant de jeton utilisé pour le bourrage dans le vocabulaire. bos_token_id (`int`, *facultatif*, valeur par défaut `1`) : Identifiant du jeton utilisé pour le début de flux dans le vocabulaire. eos_token_id (`Union[int, list[int]]`, *facultatif*, valeur par défaut `2`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire. tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle. 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 pour `rope_theta` et, le cas échéant, les paramètres utilisés pour le mise à l'échelle si vous souhaitez utiliser RoPE avec des `max_position_embeddings` plus longs. sliding_window (`int`, *facultatif*, valeur par défaut `4096`) : Taille de la fenêtre de l'attention à fenêtre glissante. Si `None`, aucune fenêtre glissante n'est appliquée. attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. Il s’agit de la classe de configuration destinée à stocker la configuration d’un MistralModel. Elle est utilisée pour instancier un modèle Mistral en fonction des arguments spécifiés, en définissant l’architecture du modèle. L’instanciation d’une configuration avec les valeurs par défaut produira une configuration similaire à celle de [mistralai/Mistral-7B-v0.1](https://huggingface.co/mistralai/Mistral-7B-v0.1) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> from transformers import MistralModel, MistralConfig >>> # Initializing a Mistral 7B style configuration >>> configuration = MistralConfig() >>> # Initializing a model from the Mistral 7B style configuration >>> model = MistralModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## MistralCommonBackend[[transformers.MistralCommonBackend]] #### transformers.MistralCommonBackend[[transformers.MistralCommonBackend]] ```python transformers.MistralCommonBackend(tokenizer_path: str | os.PathLike | pathlib.Path, mode: str | ValidationMode = 'test', model_max_length: int = 1000000000000000019884624838656, padding_side: str = 'left', truncation_side: str = 'right', model_input_names: list[str] | None = None, clean_up_tokenization_spaces: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L194) 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 : ```bash 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](https://github.com/mistralai/mistral-common). Cette classe est un wrapper autour de `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_words` n'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("")` ne renverra pas l'ID du jeton ``. En revanche, il renverra une liste d'IDs correspondant à la tokenisation de la chaîne `""`. Pour plus d'informations, consultez la [documentation de mistral-common](https://mistralai.github.io/mistral-common/usage/tokenizers/#special-tokens). Si vous avez des suggestions pour améliorer cette classe, veuillez ouvrir un ticket sur le [dépôt GitHub mistral-common](https://github.com/mistralai/mistral-common/issues) si cela concerne le tokenizer, ou sur le [dépôt GitHub Transformers](https://github.com/huggingface/transformers/issues) si cela concerne l’interface Hugging Face. #### add_special_tokens[[transformers.MistralCommonBackend.add_special_tokens]] ```python add_special_tokens(special_tokens_dict: dict, replace_extra_special_tokens: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1679) `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. #### add_tokens[[transformers.MistralCommonBackend.add_tokens]] ```python add_tokens(special_tokens_dict: dict, replace_extra_special_tokens: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1691) `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[[transformers.MistralCommonBackend.apply_chat_template]] ```python apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], tools: list[dict | collections.abc.Callable] | None = None, add_generation_prompt: bool = False, continue_final_message: bool = False, tokenize: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool = False, max_length: int | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_dict: bool = True, reasoning_effort: ReasoningEffort | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1038) **Paramètres :** conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) : une liste de dictionnaires avec les clés "role" et "content", représentant l'historique de la conversation jusqu'à présent. 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](https://huggingface.co/docs/transformers/main/en/chat_templating#automated-function-conversion-for-tool-use) pour plus d'informations. add_generation_prompt (`bool`, *facultatif*) : Cet argument est sans effet pour `MistralCommonBackend`. Toutefois, il ne peut pas être utilisé en même temps que `continue_final_message` afin de maintenir 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ôt `continue_final_message`. continue_final_message (bool, *facultatif*) : Si cette option est définie, la conversation sera formatée de manière à ce que le dernier message 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éfaut `True`) : Indique s'il faut tokeniser la sortie. Si `False`, la sortie sera une chaîne de caractères. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, valeur par 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 : - `True` ou `'longest'` : Met en place le padding jusqu'à la séquence la plus longue du lot (ou aucun padding si une seule séquence est fournie). - `'max_length'` : Met en place le padding jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes). truncation (`bool`, par défaut `False`) : Indique s'il faut tronquer les séquences à la longueur maximale. Sans effet si tokenize est `False`. max_length (`int`, *facultatif*) : Longueur maximale (en jetons) à utiliser pour le bourrage ou la troncature. N'a aucun effet si tokenize est `False`. Si non spécifié, l'attribut `max_length` du tokeniseur sera utilisé par défaut. return_tensors (`str` ou [TensorType](/docs/transformers/main/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. N'a aucun effet si tokenize est `False`. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. return_dict (`bool`, par défaut `False`) : Indique s'il faut retourner un dictionnaire avec des sorties nommées. N'a aucun effet si tokenize est `False`. Si au moins une conversation contient une image, ses valeurs de pixels seront retournées dans la clé `pixel_values` et 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 utilise une approche de raisonnement. Si non spécifié, l'effort de raisonnement par défaut sera utilisé. kwargs (arguments supplémentaires, *facultatifs*) : Arguments supplémentaires transmis à la méthode `ChatCompletionRequest.from_openai` de 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[[transformers.MistralCommonBackend.batch_decode]] ```python batch_decode(sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L512) **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éfaut `False`) : 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. Si `None`, la valeur par défaut est `self.clean_up_tokenization_spaces`. kwargs (arguments supplémentaires, *facultatifs*) : non pris en charge par `MistralCommonBackend.batch_decode`. Une erreur sera levée s'ils sont utilisés. **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 des raisons de rétrocompatibilité. La méthode `decode` gère désormais nativement les entrées par lot, vous pouvez donc utiliser `decode` directement au lieu de `batch_decode`. #### build_inputs_with_special_tokens[[transformers.MistralCommonBackend.build_inputs_with_special_tokens]] ```python build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1284) **Paramètres :** token_ids_0 (`list[int]`) : Liste d'identifiants auxquels les jetons spéciaux seront ajoutés. token_ids_1 (`None`, *facultatif*) : None, conservé pour correspondre à la signature de Transformers. **Retourne :** `list[int]` Liste des identifiants d'entrée avec les jetons spéciaux appropriés. 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[[transformers.MistralCommonBackend.convert_added_tokens]] ```python convert_added_tokens(obj: tokenizers.AddedToken | typing.Any, save: bool = False, add_type_field: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1704) `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[[transformers.MistralCommonBackend.create_token_type_ids_from_sequences]] ```python create_token_type_ids_from_sequences(token_ids_0: list, token_ids_1: None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1313) **Paramètres :** token_ids_0 (`list[int]`) : Liste d'identifiants. token_ids_1 (`None`, *facultatif*) : None, conservé pour correspondre à la signature de Transformers. **Retourne :** `list[int]` Identifiants de type de jeton selon le motif configuré. 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. #### decode[[transformers.MistralCommonBackend.decode]] ```python decode(token_ids: typing.Union[int, list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')], skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L475) **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 de jetons d'entrée tokenisés. Peut être obtenu à l'aide de la méthode `__call__`. skip_special_tokens (`bool`, *facultatif*, valeur par défaut `False`) : 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. Si `None`, la valeur par défaut est `self.clean_up_tokenization_spaces`. kwargs (arguments supplémentaires, *facultatifs*) : non pris en charge par `MistralCommonBackend.decode`. Une erreur sera levée s'ils sont utilisés. **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[[transformers.MistralCommonBackend.encode]] ```python encode(text: str | list[int], text_pair: None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, verbose: bool = True, return_offsets_mapping: typing.Literal[False] = False, split_special_tokens: typing.Literal[False] = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L378) **Paramètres :** text (`str` ou `list[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 par `MistralCommonBackend.encode`. Conservé pour correspondre à la signature de `PreTrainedTokenizerBase.encode`. add_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cette opération utilise la fonction sous-jacente `PretrainedTokenizerBase.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 jetons `bos` ou `eos`. Lorsque le Tokenizer est chargé en mode `finetuning`, il ajoute à la fois `bos` et `eos`. Sinon, en mode « test », il n'ajoute que `bos`. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes : - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes). truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, par défaut `False`) : Active et contrôle la troncature. Accepte les valeurs suivantes : - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'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 du modèle). max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est 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/remplissage à une longueur maximale sera désactivée. stride (`int`, *facultatif*, valeur par défaut 0) : Si défini avec une valeur numérique en plus de `max_length`, les jetons en dépassement renvoyés lorsque `return_overflowing_tokens=True` contiendront certains jetons de la fin de la séquence tronquée renvoyée, afin d'assurer un chevauchement entre les séquences tronquées et celles 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 sera rembourdie jusqu'à un multiple de la valeur fournie. Nécessite l'activation de `padding`. 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 sélectionné parmi ['right', 'left']. La valeur par défaut est choisie à partir de l'attribut de classe du même nom. return_tensors (`str` ou [TensorType](/docs/transformers/main/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - ****kwargs** : Non pris en charge par `MistralCommonBackend.encode`. Une erreur sera levée s'ils sont utilisés. **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[[transformers.MistralCommonBackend.from_pretrained]] ```python from_pretrained(pretrained_model_name_or_path: str | os.PathLike, *init_inputs, mode: str | ValidationMode = 'test', cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', model_max_length: int = 1000000000000000019884624838656, padding_side: str = 'left', truncation_side: str = 'right', model_input_names: list[str] | None = None, clean_up_tokenization_spaces: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1437) **Paramètres :** pretrained_model_name_or_path (`str` ou `os.PathLike`) : Peut être : - Une chaîne de caractères, l'*identifiant de modèle* d'un tokeniseur prédéfini hébergé dans un dépôt de modèles sur huggingface.co. - Un chemin vers un *répertoire* contenant la configuration du tokeniseur, par exemple sauvegardée à l'aide de la méthode `MistralCommonBackend.tokenization_mistral_common.save_pretrained`, par ex. `./my_model_directory/`. mode (`Union[str, ValidationMode]`, *facultatif*, valeur par défaut `ValidationMode.test`) : Mode de validation pour le tokenizer `MistralTokenizer`. Les valeurs possibles sont : - `"finetuning"` ou `ValidationMode.finetuning` : le mode de fine-tuning. - `"test"` ou `ValidationMode.test` : le mode de test. Cela modifie la manière dont le tokenizer valide l'entrée et prépare la requête envoyée au modèle. cache_dir (`str` ou `os.PathLike`, *facultatif*) : Chemin vers un répertoire dans lequel les fichiers de vocabulaire de tokeniseur 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*, valeur par défaut `False`) : Indique s'il faut forcer le (re-)téléchargement des fichiers de vocabulaire et remplacer les versions en cache si elles existent. token (`str` ou *bool*, *facultatif*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True`, utilise le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`). local_files_only (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut s'appuyer uniquement sur les fichiers locaux et ne pas tenter de télécharger de fichiers. revision (`str`, *facultatif*, valeur par défaut `"main"`) : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag 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 que `revision` peut être n'importe quel identifiant autorisé par git. max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est 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/remplissage à une longueur maximale sera désactivée. padding_side (`str`, *facultatif*, valeur 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*, valeur 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éfaut `False`) : Indique si le modèle doit nettoyer les espaces ajoutés lors de la division du texte d'entrée dans le processus de tokenisation. kwargs (arguments supplémentaires, *facultatifs*) : non pris en charge par `MistralCommonBackend.from_pretrained`. Une erreur sera levée s’ils sont utilisés. Instanciez un `MistralCommonBackend` à partir d'un tokenizer prédéfini. #### get_chat_template[[transformers.MistralCommonBackend.get_chat_template]] ```python get_chat_template(chat_template: str | None = None, tools: list[dict] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1713) `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[[transformers.MistralCommonBackend.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list, token_ids_1: None = None, already_has_special_tokens: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L691) **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*, valeur par défaut `False`) : 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 sur laquelle aucun jeton spécial n'a été ajouté. 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. #### get_vocab[[transformers.MistralCommonBackend.get_vocab]] ```python get_vocab() ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L352) **Retourne :** `Dict[str, int]` Le vocabulaire. 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[[transformers.MistralCommonBackend.num_special_tokens_to_add]] ```python num_special_tokens_to_add(pair: typing.Literal[False] = False) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1337) **Paramètres :** pair (`Literal[False]`, *facultatif*) : False, conservé pour correspondre à la signature de Transformer. **Retourne :** `int` Nombre de jetons spéciaux ajoutés aux séquences. Retourne le nombre de jetons ajoutés lors de l’encodage d’une séquence avec des jetons spéciaux. Cette opération encode une entrée factice et vérifie le nombre de jetons ajoutés, elle n’est donc pas efficace. Ne placez pas cette instruction dans votre boucle d’entraînement. #### prepare_for_model[[transformers.MistralCommonBackend.prepare_for_model]] ```python prepare_for_model(ids: list, pair_ids: None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_length: bool = False, verbose: bool = True, prepend_batch_axis: bool = False, return_offsets_mapping: typing.Literal[False] = False, split_special_tokens: typing.Literal[False] = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L844) **Paramètres :** ids (`list[int]`) : Identifiants des jetons de l'entrée tokenisée de la première séquence. pair_ids (`None`, *facultatif*) : Non pris en charge par `MistralCommonBackend`. Conservé pour correspondre à l'interface de `PreTrainedTokenizerBase`. add_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter des jetons spéciaux lors de l'encodage des séquences. Cette opération utilise la fonction sous-jacente `PretrainedTokenizerBase.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 jetons `bos` ou `eos`. Lorsque le Tokenizer est chargé en mode `finetuning`, il ajoute à la fois `bos` et `eos`. Sinon, en mode « test », il n'ajoute que `bos`. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `False`) : Active et contrôle le bourrage. Accepte les valeurs suivantes : - `True` ou `'longest'` : Bourrage jusqu'à la séquence la plus longue du lot (ou aucun bourrage si une seule séquence est fournie). - `'max_length'` : Bourrage jusqu'à une longueur maximale spécifiée avec l'argument `max_length` ou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'do_not_pad'` (par défaut) : Aucun bourrage (c'est-à-dire, peut produire un lot avec des séquences de longueurs différentes). truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, par défaut `False`) : Active et contrôle la troncature. Accepte les valeurs suivantes : - `True` ou `'longest_first'` : Tronque à une longueur maximale spécifiée avec l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. - `False` ou `'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 du modèle). max_length (`int`, *facultatif*) : Permet de contrôler la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage. S'il n'est pas défini ou s'il est 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/remplissage à une longueur maximale sera désactivée. stride (`int`, *facultatif*, valeur par défaut 0) : Si défini avec une valeur numérique en plus de `max_length`, les jetons en dépassement renvoyés lorsque `return_overflowing_tokens=True` contiendront certains jetons de la fin de la séquence tronquée renvoyée, afin d'assurer un chevauchement entre les séquences tronquées et celles 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 sera rembourdie jusqu'à un multiple de la valeur fournie. Nécessite l'activation de `padding`. 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 sélectionné parmi ['right', 'left']. La valeur par défaut est choisie à partir de l'attribut de classe du même nom. return_tensors (`str` ou [TensorType](/docs/transformers/main/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton. Pour `MistralCommonBackend`, renvoie une liste de zéros de la longueur de la séquence, car seule une séquence est prise en charge. [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-ids) 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'attribut `return_outputs`. [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non renvoyer 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 avec `truncation_strategy = longest_first` ou `True`, une erreur est levée au lieu de renvoyer les jetons en dépassement. return_special_tokens_mask (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner les informations du masque des jetons spéciaux. return_length (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut retourner les longueurs des entrées encodées. verbose (`bool`, *facultatif*, par défaut `True`) : 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 :** [BatchEncoding](/docs/transformers/main/fr/main_classes/tokenizer#transformers.BatchEncoding) Un [BatchEncoding](/docs/transformers/main/fr/main_classes/tokenizer#transformers.BatchEncoding) avec les champs suivants : - **input_ids** -- Liste des identifiants de jetons à fournir au modèle. [Qu'est-ce que les identifiants d'entrée ?](../glossary#input-ids) - **attention_mask** -- Liste d'indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque `return_attention_mask=True` ou si *"attention_mask"* est présent dans `self.model_input_names`). [Qu'est-ce que les masques d'attention ?](../glossary#attention-mask) - **overflowing_tokens** -- Liste des séquences de jetons en dépassement (lorsqu'une `max_length` est spécifiée et `return_overflowing_tokens=True`). - **num_truncated_tokens** -- Nombre de jetons tronqués (lorsqu'une `max_length` est spécifiée et `return_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=True` et `return_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[[transformers.MistralCommonBackend.save_chat_templates]] ```python save_chat_templates(save_directory: str | os.PathLike, tokenizer_config: dict, filename_prefix: str | None, save_jinja_files: bool) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1718) `MistralCommonBackend` n’implémente pas `save_chat_templates` par conception, car `mistral-common` n’utilise pas de modèles de discussion. #### save_pretrained[[transformers.MistralCommonBackend.save_pretrained]] ```python save_pretrained(save_directory: str | os.PathLike | pathlib.Path, push_to_hub: bool = False, token: str | bool | None = None, commit_message: str | None = None, repo_id: str | None = None, private: bool | None = None, save_format: str | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1552) **Paramètres :** save_directory (`str | os.PathLike | Path`) : Répertoire où le tokenizer sera enregistré. push_to_hub (`bool`, *facultatif*, valeur par défaut `False`) : Pousse vers le HF Hub après l'enregistrement. token (`str` ou `bool`, *facultatif*) : Jeton pour l'authentification sur le 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 — une erreur sera levée. **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. #### save_vocabulary[[transformers.MistralCommonBackend.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L1729) `MistralCommonBackend` n’implémente pas `save_vocabulary` par conception. Ceci est dû au fait que `mistral-common` est configuré par un seul fichier de tokenizer. Si vous souhaitez enregistrer le vocabulaire, veuillez plutôt utiliser la méthode `save_pretrained`. #### tokenize[[transformers.MistralCommonBackend.tokenize]] ```python tokenize(text: str, return_offsets_mapping: typing.Literal[False] = False, split_special_tokens: typing.Literal[False] = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L645) **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 par mot-clé supplémentaires) : non pris en charge par `MistralCommonBackend.tokenize`. Une erreur sera levée s'ils sont utilisés. **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[[transformers.MistralCommonBackend.truncate_sequences]] ```python truncate_sequences(ids: list, pair_ids: None = None, num_tokens_to_remove: int = 0, truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first', stride: int = 0, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_mistral_common.py#L974) **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éthodes `tokenize` et `convert_tokens_to_ids`. pair_ids (`None`, *facultatif*) : non pris en charge par `MistralCommonBackend`. Conservé pour correspondre à la signature de `PreTrainedTokenizerBase.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 (`str` ou [TruncationStrategy](/docs/transformers/main/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *facultatif*, par défaut `'longest_first'`) : La stratégie à suivre pour la troncature. Peut être : - `'longest_first'` : Tronquer à une longueur maximale spécifiée avec l'argument `max_length` ou à 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'est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d'entrée maximale admissible du 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. ## MistralModel[[transformers.MistralModel]] #### transformers.MistralModel[[transformers.MistralModel]] ```python transformers.MistralModel(config: MistralConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral/modeling_mistral.py#L309) **Paramètres :** config ([MistralConfig](/docs/transformers/main/fr/model_doc/mistral#transformers.MistralConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Mistral brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.MistralModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral/modeling_mistral.py#L326) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de 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]`. [Que sont les identifiants de position ?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`). **Retourne :** [BaseModelOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MistralConfig](/docs/transformers/main/fr/model_doc/mistral#transformers.MistralConfig)) et les entrées. La méthode forward de [MistralModel](/docs/transformers/main/fr/model_doc/mistral#transformers.MistralModel) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée. - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## MistralForCausalLM[[transformers.MistralForCausalLM]] #### transformers.MistralForCausalLM[[transformers.MistralForCausalLM]] ```python transformers.MistralForCausalLM(config: MistralConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral/modeling_mistral.py#L383) **Paramètres :** config ([MistralConfig](/docs/transformers/main/fr/model_doc/mistral#transformers.MistralConfig)) : 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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Mistral pour la modélisation de langage causale. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.MistralForCausalLM.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral/modeling_mistral.py#L398) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de 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]`. [Que sont les identifiants de position ?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`. use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`). logits_to_keep (`Union[int, torch.Tensor]`, *facultatif*, valeur par défaut `0`) : Si c'est un `int`, calcule les logits pour les `logits_to_keep` derniers jetons. Si c'est `0`, calcule les logits pour tous les `input_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 faire économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un `torch.Tensor`, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. C'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 :** [CausalLMOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)` Un [CausalLMOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MistralConfig](/docs/transformers/main/fr/model_doc/mistral#transformers.MistralConfig)) et les entrées. La méthode forward de [MistralForCausalLM](/docs/transformers/main/fr/model_doc/mistral#transformers.MistralForCausalLM) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant). - **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax). - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. Exemple : ```python >>> from transformers import AutoTokenizer, MistralForCausalLM >>> model = MistralForCausalLM.from_pretrained("meta-mistral/Mistral-2-7b-hf") >>> tokenizer = AutoTokenizer.from_pretrained("meta-mistral/Mistral-2-7b-hf") >>> 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." ``` ## MistralForSequenceClassification[[transformers.MistralForSequenceClassification]] #### transformers.MistralForSequenceClassification[[transformers.MistralForSequenceClassification]] ```python transformers.MistralForSequenceClassification(config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral/modeling_mistral.py#L460) #### forward[[transformers.MistralForSequenceClassification.forward]] ```python forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs]) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L128) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de 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]`. [Que sont les identifiants de position ?](../glossary#position-ids) 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. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, consultez notre [guide du cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux dont les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de 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]`. Si `config.num_labels == 1`, une perte de régression est calculée (perte du carré moyen). Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée). use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_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 `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. ## MistralForTokenClassification[[transformers.MistralForTokenClassification]] #### transformers.MistralForTokenClassification[[transformers.MistralForTokenClassification]] ```python transformers.MistralForTokenClassification(config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral/modeling_mistral.py#L456) #### forward[[transformers.MistralForTokenClassification.forward]] ```python forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, labels: torch.LongTensor | None = None, use_cache: bool | None = None, **kwargs: Unpack[TransformersKwargs]) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L275) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de 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]`. [Que sont les identifiants de position ?](../glossary#position-ids) 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. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, consultez notre [guide du cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux dont les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de 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 sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_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 `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. ## MistralForQuestionAnswering[[transformers.MistralForQuestionAnswering]] #### transformers.MistralForQuestionAnswering[[transformers.MistralForQuestionAnswering]] ```python transformers.MistralForQuestionAnswering(config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mistral/modeling_mistral.py#L464) #### forward[[transformers.MistralForQuestionAnswering.forward]] ```python forward(input_ids: torch.LongTensor | None = None, attention_mask: torch.Tensor | None = None, position_ids: torch.LongTensor | None = None, past_key_values: Cache | None = None, inputs_embeds: torch.Tensor | None = None, start_positions: torch.LongTensor | None = None, end_positions: torch.LongTensor | None = None, **kwargs: Unpack[TransformersKwargs]) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_layers.py#L208) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de 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]`. [Que sont les identifiants de position ?](../glossary#position-ids) 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. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, consultez notre [guide du cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux dont les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. start_positions (`torch.LongTensor` de 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 limité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.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour la position (index) de la fin de l'intervalle étiqueté, utilisées pour calculer la perte de classification de jetons. Les positions sont limité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 `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.