Hugging Face's logo

Transformers documentation

Mistral 3

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Ce modèle a été contribué à Hugging Face Transformers le 2025-03-18.

PyTorch

Mistral 3

Mistral 3 est un modèle optimisé pour la latence, doté de beaucoup moins de couches afin de réduire le temps par passe avant. Ce modèle ajoute la compréhension visuelle et prend en charge des longueurs de contexte allant jusqu'à 128K jetons sans compromettre les performances.

Vous pouvez trouver les points de contrôle originaux de Mistral 3 sous l'organisation Mistral AI.

Ce modèle a été contribué par cyrilvallez et yonigozlan. Cliquez sur les modèles Mistral3 dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer Mistral3 à différentes tâches.

Définissez use_kernels=True dans from_pretrained() pour remplacer les couches prises en charge par des noyaux optimisés du Hub. Consultez Chargement des noyaux pour en savoir plus.

L'exemple ci-dessous montre comment générer du texte pour une image avec Pipeline et la classe AutoModel.

Pipeline
AutoModel
from transformers import pipeline


messages = [
    {"role": "user",
        "content":[
            {"type": "image",
            "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",},
            {"type": "text", "text": "Describe this image."}
        ,]
    ,}
,]

pipeline = pipeline(
    task="image-text-to-text",
    model="mistralai/Mistral-Small-3.1-24B-Instruct-2503",
    device=0
)
outputs = pipeline(text=messages, max_new_tokens=50, return_full_text=False)

outputs[0]["generated_text"]
'The image depicts a vibrant and lush garden scene featuring a variety of wildflowers and plants. The central focus is on a large, pinkish-purple flower, likely a Greater Celandine (Chelidonium majus), with a'

Notes

  • Mistral 3 prend en charge la génération de texte uniquement.
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = ".mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

SYSTEM_PROMPT = "You are a conversational agent that always answers straight to the point, always end your accurate response with an ASCII drawing of a cat."
user_prompt = "Give me 5 non-formal ways to say 'See you later' in French."

messages = [
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": user_prompt},
]

text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = processor(text=text, return_tensors="pt").to(0)
generate_ids = model.generate(**inputs, max_new_tokens=50, do_sample=False)
decoded_output = processor.batch_decode(generate_ids[:, inputs["input_ids"].shape[1] :], skip_special_tokens=True)[0]

print(decoded_output)
"1. À plus tard!
 2. Salut, à plus!
 3. À toute!
 4. À la prochaine!
 5. Je me casse, à plus!

/_/\ ( o.o )

^ <

  • Mistral 3 accepte des entrées d'images et de texte par lots.
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

messages = [
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                 {"type": "text", "text": "Write a haiku for this image"},
             ],
         },
     ],
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://www.ilankelman.org/stopsigns/australia.jpg"},
                 {"type": "text", "text": "Describe this image"},
             ],
         },
     ],
 ]


 inputs = processor.apply_chat_template(messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

 output = model.generate(**inputs, max_new_tokens=25)

 decoded_outputs = processor.batch_decode(output, skip_special_tokens=True)
 decoded_outputs
["Write a haiku for this imageCalm waters reflect\nWhispers of the forest's breath\nPeace on wooden path"
, "Describe this imageThe image depicts a vibrant street scene in what appears to be a Chinatown district. The focal point is a traditional Chinese"]
  • Mistral 3 prenait également en charge des entrées d’images et de texte par lots, avec un nombre d’images différent pour chaque texte. L’exemple ci-dessous quantise le modèle avec bitsandbytes.
import torch
from transformers import AutoProcessor, AutoModelForImageTextToText, BitsAndBytesConfig

model_checkpoint = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
processor = AutoProcessor.from_pretrained(model_checkpoint)
quantization_config = BitsAndBytesConfig(load_in_4bit=True)
model = AutoModelForImageTextToText.from_pretrained(
     model_checkpoint, quantization_config=quantization_config
 device_map="auto")

messages = [
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/llava_view.jpg"},
                 {"type": "text", "text": "Write a haiku for this image"},
             ],
         },
     ],
     [
         {
             "role": "user",
             "content": [
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/statue_of_liberty.jpg"},
                 {"type": "image", "url": "https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/dreamstime_golden_gate_flowers.jpg"},
                 {"type": "text", "text": "These images depict two different landmarks. Can you identify them?"},
             ],
         },
     ],
 ]

 inputs = processor.apply_chat_template(messages, padding=True, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)

 output = model.generate(**inputs, max_new_tokens=25)

 decoded_outputs = processor.batch_decode(output, skip_special_tokens=True)
 decoded_outputs
["Write a haiku for this imageSure, here is a haiku inspired by the image:\n\nCalm lake's wooden path\nSilent forest stands guard\n", "These images depict two different landmarks. Can you identify them? Certainly! The images depict two iconic landmarks:\n\n1. The first image shows the Statue of Liberty in New York City."]

Mistral3Config

classe transformers.Mistral3Config

< >

( 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 = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_index: int = 10projector_hidden_act: str = 'gelu'vision_feature_layer: int | list[int] = -1multimodal_projector_bias: bool = Falsespatial_merge_size: int = 2tie_word_embeddings: bool = True )

Paramètres

  • vision_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone visuel.
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte.
  • image_token_index (int, facultatif, par défaut 10) — L’index du jeton d’image utilisé comme espace réservé pour les images d’entrée.
  • projector_hidden_act (str, facultatif, par défaut gelu) — La fonction d'activation utilisée par le projecteur multimodal.
  • vision_feature_layer (Union[int, list[int]], facultatif, par défaut -1) — L'indice de la couche à partir de laquelle extraire les caractéristiques visuelles. Si plusieurs indices sont fournis, les caractéristiques visuelles des indices correspondants sont concaténées pour former les caractéristiques visuelles.
  • multimodal_projector_bias (bool, facultatif, valeur par défaut False) — Indique s'il faut utiliser un biais dans le projecteur multimodal.
  • spatial_merge_size (int, facultatif, par défaut 2) — La taille de la fenêtre de fusion spatiale utilisée pour réduire le nombre de jetons visuels en fusionnant les patches voisins.
  • tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un Mistral3Model. Elle est utilisée pour instancier un modèle Mistral3 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/Mistral-Small-3.1-24B-Instruct-2503

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 Mistral3ForConditionalGeneration, Mistral3Config, PixtralVisionConfig, MistralConfig

>>> # Initializing a Pixtral-vision config
>>> vision_config = PixtralVisionConfig()

>>> # Initializing a Mistral config
>>> text_config = MistralConfig()

>>> # Initializing a Mistral3 configuration
>>> configuration = Mistral3Config(vision_config, text_config)

>>> # Initializing a model from the mistral3.1 configuration
>>> model = Mistral3ForConditionalGeneration(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

MistralCommonBackend

classe transformers.MistralCommonBackend

< >

( 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_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("<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

< >

( 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.

add_tokens

< >

( 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.

apply_chat_template

< >

( 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é par MistralCommonBackend. Cependant, il ne peut pas être utilisé en même temps que continue_final_message afin 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ôt continue_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é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, 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 :
    • True ou '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'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 produire 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. N'a aucun 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, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. N'a aucun effet si tokenize est False. Valeurs acceptables :
    • '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 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_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

< >

( 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é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 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

< >

( token_ids_0: listtoken_ids_1: None = None ) → list[int]

Paramètres

  • token_ids_0 (list[int]) — Liste des ID 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

< >

( 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

< >

( token_ids_0: listtoken_ids_1: None = None ) → list[int]

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.

décoder

< >

( 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é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 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

< >

( 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 (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, par défaut True) — Indique s'il faut ou non ajouter des jetons spéciaux lors de l'encodage des séquences. Cela 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, facultatif, défaut : False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou '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'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 produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif, défaut : False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou '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.
    • 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 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 avec 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 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 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 choisi 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, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :
    • 'pt' : Renvoie des objets torch.Tensor de 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

< >

( 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 (str ou os.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 sur ValidationMode.test) — Mode de validation pour le MistralTokenizer tokenizer. Les valeurs possibles sont :
    • "finetuning" ou ValidationMode.finetuning : le mode de fine-tuning.
    • "test" ou ValidationMode.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 (str ou os.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é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) — Le jeton à utiliser comme autorisation bearer HTTP 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, 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 que revision peut ê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éfaut False) — 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.

get_chat_template

< >

( chat_template: str | None = Nonetools: list[dict] | None = None )

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

< >

( 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é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 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.

get_vocab

< >

( ) → Dict[str, int]

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

< >

( pair: typing.Literal[False] = False ) → int

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.

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

< >

( 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 par MistralCommonBackend. Conservé pour correspondre à l’interface de PreTrainedTokenizerBase.
  • add_special_tokens (bool, facultatif, par défaut True) — Indique s'il faut ou non ajouter des jetons spéciaux lors de l'encodage des séquences. Cela 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, facultatif, défaut : False) — Active et contrôle le padding. Accepte les valeurs suivantes :
    • True ou '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'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 produire un lot avec des séquences de longueurs différentes).
  • truncation (bool, str ou TruncationStrategy, facultatif, défaut : False) — Active et contrôle la troncature. Accepte les valeurs suivantes :
    • True ou '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.
    • 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 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 avec 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 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 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 choisi 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, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées 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 , il 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 ?

  • 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 ?

  • return_overflowing_tokens (bool, facultatif, par défaut False) — 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 avec truncation_strategy = longest_first ou True, une erreur est levée au lieu de retourner les jetons en dépassement.
  • return_special_tokens_mask (bool, facultatif, 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

Un BatchEncoding avec les champs suivants :

  • input_ids — Liste des identifiants de jetons à fournir à un modèle.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 ?

  • 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

< >

( 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

< >

( 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éfaut False) — Pousse vers le HF Hub après l'enregistrement.
  • token (str ou bool, 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.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

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

< >

( 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

< >

( 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é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, 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'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.-à-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.

Mistral3Model

classe transformers.Mistral3Model

< >

( config: Mistral3Config )

Paramètres

  • config (Mistral3Config) — 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 Mistral3, qui se compose d'un backbone de vision et d'un modèle de langage, sans tête de modélisation du langage.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonevision_feature_layer: int | list[int] | None = Noneuse_cache: bool | None = Noneimage_sizes: typing.Optional[torch.Tensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Mistral3ModelOutputWithPast or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de PixtralImageProcessor. Voir PixtralImageProcessor.call() pour plus de détails (PixtralProcessor utilise PixtralImageProcessor pour le traitement des images).
  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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].

    Qu'est-ce que les identifiants de position ?

  • 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 la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'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_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 n’ont pas été 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 que la matrice de recherche d’intégration interne du modèle.
  • vision_feature_layer (Union[int, list[int]], facultatif) — L'indice de la couche à partir de laquelle extraire la caractéristique visuelle. Si plusieurs indices sont fournis, les caractéristiques visuelles des indices correspondants sont concaténées pour former les caractéristiques visuelles.
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).
  • image_sizes (torch.Tensor de forme (batch_size, 2), facultatif) — Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], facultatif) — Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (pooler_output, facultatif : last_hidden_states, facultatif : hidden_states, facultatif : attentions) pooler_output de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.

Retourne

Mistral3ModelOutputWithPast ou tuple(torch.Tensor)

Un Mistral3ModelOutputWithPast 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 (Mistral3Config) et des entrées.

La méthode forward du modèle Mistral3Model 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. 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é 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).

    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.

  • image_hidden_states (torch.Tensor, facultatif) — Un torch.Tensor de taille (batch_size, num_images, sequence_length, hidden_size). image_hidden_states du modèle produit par l’encodeur visuel et après projection de l’état caché final.

get_image_features

< >

( pixel_values: Tensorimage_sizes: Tensorvision_feature_layer: int | list[int] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de PixtralImageProcessor. Voir PixtralImageProcessor.call() pour plus de détails (PixtralProcessor utilise PixtralImageProcessor pour le traitement des images).
  • image_sizes (torch.Tensor de forme (batch_size, 2)) — Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.
  • vision_feature_layer (Union[int, list[int]], facultatif) — L'indice de la couche à partir de laquelle extraire la caractéristique visuelle. Si plusieurs indices sont fournis, les caractéristiques visuelles des indices correspondants sont concaténées pour former les caractéristiques visuelles.

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Un BaseModelOutputWithPooling 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 (Mistral3Config) et des entrées.

Obtient les derniers états cachés de l'image depuis la tour de vision et applique la projection multimodale.

  • 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.

  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • 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).

    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.

get_placeholder_mask

< >

( input_ids: LongTensorinputs_embeds: Tensorimage_features: Tensor )

Obtient le masque de jetons multimodaux à partir de input_ids ou de inputs_embeds, et vérifie que le nombre de jetons correspond à la longueur des fonctionnalités multimodales. Si les longueurs diffèrent, une erreur est levée.

Mistral3ForConditionalGeneration

classe transformers.Mistral3ForConditionalGeneration

< >

( config: Mistral3Config )

Paramètres

  • config (Mistral3Config) — 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 MISTRAL3, qui se compose d'un backbone de vision et d'un modèle de langage.

Ce modèle hérite de PreTrainedModel. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)

Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0image_sizes: typing.Optional[torch.Tensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Mistral3CausalLMOutputWithPast or tuple(torch.Tensor)

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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de PixtralImageProcessor. Voir PixtralImageProcessor.call() pour plus de détails (PixtralProcessor utilise PixtralImageProcessor pour le traitement des images).
  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • 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].

    Qu'est-ce que les identifiants de position ?

  • 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 la past_key_values retournée 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 est autorisée en entrée, consultez notre guide du cache kv. Si aucun past_key_values n'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_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 n’ont pas été 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 que 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 dans [0, ..., config.vocab_size] ou -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 dans [0, ..., config.vocab_size].
  • use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur 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 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 é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. 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).
  • image_sizes (torch.Tensor de forme (batch_size, 2), facultatif) — Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], facultatif) — Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (pooler_output, facultatif : last_hidden_states, facultatif : hidden_states, facultatif : attentions) pooler_output de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.

Retourne

Mistral3CausalLMOutputWithPast ou tuple(torch.Tensor)

Un Mistral3CausalLMOutputWithPast 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 (Mistral3Config) et des entrées.

La méthode forward de Mistral3ForConditionalGeneration remplace 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. 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é 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).

    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.

  • image_hidden_states (torch.Tensor, facultatif) — Un torch.Tensor de taille (batch_size, num_images, sequence_length, hidden_size). image_hidden_states du modèle produit par l’encodeur visuel et après projection de l’état caché final.

Exemple :

>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, Mistral3ForConditionalGeneration

>>> model = Mistral3ForConditionalGeneration.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> processor = AutoProcessor.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")

>>> prompt = "<s>[INST][IMG]What is the image?[/INST]"
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> inputs = processor(images=image, text=prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(**inputs, max_new_tokens=15)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is the image?The image depicts two cats lying on a pink blanket."

get_image_features

< >

( pixel_values: Tensorimage_sizes: Tensorvision_feature_layer: int | list[int] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de PixtralImageProcessor. Voir PixtralImageProcessor.call() pour plus de détails (PixtralProcessor utilise PixtralImageProcessor pour le traitement des images).
  • image_sizes (torch.Tensor de forme (batch_size, 2)) — Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.
  • vision_feature_layer (Union[int, list[int]], facultatif) — L'indice de la couche à partir de laquelle extraire la caractéristique visuelle. Si plusieurs indices sont fournis, les caractéristiques visuelles des indices correspondants sont concaténées pour former les caractéristiques visuelles.

Retourne

BaseModelOutputWithPooling ou tuple(torch.Tensor)

Un BaseModelOutputWithPooling 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 (Mistral3Config) et des entrées.

  • 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.

  • pooler_output (torch.Tensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • 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).

    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 PIL import Image
>>> from transformers import AutoProcessor, Mistral3ForConditionalGeneration

>>> model = Mistral3ForConditionalGeneration.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> processor = AutoProcessor.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
Update on GitHub

←Mistral Large 4 Mistral4→