# Pixtral [Pixtral](https://huggingface.co/papers/2410.07073) est un modèle multimodal entraîné pour comprendre des images naturelles et des documents. Il accepte les images dans leur résolution et leur ratio d’aspect naturels, sans redimensionnement ni bourrage, grâce à ses embeddings 2D RoPE. De plus, Pixtral dispose d’une fenêtre de contexte longue de 128K jetons pour traiter un grand nombre d’images. Pixtral associe un encodeur visuel de 400M à un décodeur Mistral Nemo de 12B. drawing Architecture de Pixtral. Issue de l'article de blog. Vous pouvez trouver tous les points de contrôle originaux de Pixtral sous l'organisation [Mistral AI](https://huggingface.co/mistralai/models?search=pixtral). > [!TIP] > Ce modèle a été contribué par [amyeroberts](https://huggingface.co/amyeroberts) et [ArthurZ](https://huggingface.co/ArthurZ). Cliquez sur les modèles Pixtral dans la barre latérale droite pour plus d’exemples d’application de Pixtral à différentes tâches de vision et de langage. ```python import torch from transformers import AutoProcessor, LlavaForConditionalGeneration model_id = "mistral-community/pixtral-12b" model = LlavaForConditionalGeneration.from_pretrained(model_id, device_map="auto") processor = AutoProcessor.from_pretrained(model_id) url_dog = "https://picsum.photos/id/237/200/300" url_mountain = "https://picsum.photos/seed/picsum/200/300" chat = [ { "role": "user", "content": [ {"type": "text", "content": "Can this animal"}, {"type": "image", "url": url_dog}, {"type": "text", "content": "live here?"}, {"type": "image", "url" : url_mountain} ] } ] inputs = processor.apply_chat_template(chat, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device) generate_ids = model.generate(**inputs, max_new_tokens=500) output = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] ``` 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 quantifier le modèle en 4 bits. ```python import requests import torch from PIL import Image from transformers import AutoProcessor, BitsAndBytesConfig, LlavaForConditionalGeneration model_id = "mistral-community/pixtral-12b" quantization_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16 ) model = LlavaForConditionalGeneration.from_pretrained( model_id, quantization_config=quantization_config, device_map="auto" ) processor = AutoProcessor.from_pretrained(model_id) dog_url = "https://picsum.photos/id/237/200/300" mountain_url = "https://picsum.photos/seed/picsum/200/300" dog_image = Image.open(requests.get(dog_url, stream=True).raw) mountain_image = Image.open(requests.get(mountain_url, stream=True).raw) chat = [ { "role": "user", "content": [ {"type": "text", "text": "Can this animal"}, {"type": "image"}, {"type": "text", "text": "live here?"}, {"type": "image"} ] } ] prompt = processor.apply_chat_template(chat, tokenize=False, add_generation_prompt=True) inputs = processor(text=prompt, images=[dog_image, mountain_image], return_tensors="pt").to(model.device) inputs["pixel_values"] = inputs["pixel_values"].to(model.dtype) inputs = {k: v.to(model.device) for k, v in inputs.items()} generate_ids = model.generate(**inputs, max_new_tokens=100) output = processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False) print(output) ``` ## Notes - Pixtral utilise [PixtralVisionModel](/docs/transformers/main/fr/model_doc/pixtral#transformers.PixtralVisionModel) comme encodeur visuel et [MistralForCausalLM](/docs/transformers/main/fr/model_doc/mistral#transformers.MistralForCausalLM) pour son décodeur de langage. - Le modèle remplace en interne les jetons de remplacement `[IMG]` par des plongements d'image. ```py "[INST][IMG]\nWhat are the things I should be cautious about when I visit this place?[/INST]" ``` Les jetons `[IMG]` sont remplacés par un nombre de jetons `[IMG]` qui dépend de la hauteur et de la largeur de chaque image. Chaque ligne de l'image est séparée par un jeton `[IMG_BREAK]` et chaque image est séparée par un jeton `[IMG_END]`. Utilisez la méthode `~Processor.apply_chat_template` pour gérer ces jetons à votre place. ## PixtralVisionConfig[[transformers.PixtralVisionConfig]] #### transformers.PixtralVisionConfig[[transformers.PixtralVisionConfig]] ```python transformers.PixtralVisionConfig(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, hidden_size: int = 1024, intermediate_size: int = 4096, num_hidden_layers: int = 24, num_attention_heads: int = 16, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 1024, patch_size: int | list[int] | tuple[int, int] = 16, hidden_act: str = 'gelu', attention_dropout: float | int = 0.0, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, initializer_range: float = 0.02) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/configuration_pixtral.py#L24) **Paramètres :** hidden_size (`int`, *facultatif*, valeur par défaut `1024`) : Dimension des représentations cachées. intermediate_size (`int`, *facultatif*, valeur par défaut `4096`) : Dimension des représentations MLP. num_hidden_layers (`int`, *facultatif*, valeur par défaut `24`) : Nombre de couches cachées dans le décodeur Transformer. num_attention_heads (`int`, *facultatif*, valeur par défaut `16`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée. image_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `1024`) : La taille (résolution) de chaque image. patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `16`) : La taille (résolution) de chaque patch. hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. 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. 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. Il s'agit de la classe de configuration destinée à stocker la configuration d'un PixtralVisionModel. Elle est utilisée pour instancier un modèle Pixtral 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 [mistral-labs/pixtral-12b](https://huggingface.co/mistral-labs/pixtral-12b) 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 PixtralVisionModel, PixtralVisionConfig >>> # Initializing a Pixtral-12B style configuration >>> config = PixtralVisionConfig() >>> # Initializing a model (with randomly initialized weights) from the configuration >>> model = PixtralVisionModel(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. ## PixtralVisionModel[[transformers.PixtralVisionModel]] #### transformers.PixtralVisionModel[[transformers.PixtralVisionModel]] ```python transformers.PixtralVisionModel(config: PixtralVisionConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/modeling_pixtral.py#L379) **Paramètres :** config ([PixtralVisionConfig](/docs/transformers/main/fr/model_doc/pixtral#transformers.PixtralVisionConfig)) : 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 Pixtral 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.PixtralVisionModel.forward]] ```python forward(pixel_values: Tensor, image_sizes: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/modeling_pixtral.py#L402) **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](/docs/transformers/main/fr/model_doc/pixtral#transformers.PixtralImageProcessor). Consultez [PixtralImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([PixtralProcessor](/docs/transformers/main/fr/model_doc/pixtral#transformers.PixtralProcessor) utilise [PixtralImageProcessor](/docs/transformers/main/fr/model_doc/pixtral#transformers.PixtralImageProcessor) pour le traitement des images). image_sizes (`torch.Tensor` de forme `(batch_size, 2)`, *facultatif*) : Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image. **Retourne :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([PixtralVisionConfig](/docs/transformers/main/fr/model_doc/pixtral#transformers.PixtralVisionConfig)) et les entrées. La méthode forward du modèle [PixtralVisionModel](/docs/transformers/main/fr/model_doc/pixtral#transformers.PixtralVisionModel) 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. - **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)`. 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. ## PixtralImageProcessor[[transformers.PixtralImageProcessor]] #### transformers.PixtralImageProcessor[[transformers.PixtralImageProcessor]] ```python transformers.PixtralImageProcessor(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/image_processing_pixtral.py#L99) **Paramètres :** do_convert_rgb (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'longest_edge' : 1024}`) : Décris les dimensions d'entrée maximales pour le modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `3`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir de l'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.48145466, 0.4578275, 0.40821073]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.26862954, 0.26130258, 0.27577711]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. patch_size (`Union[dict[str, *kwargs*, int], int]` *facultatif*, par défaut `{"height" : 16, "width": 16}`) : Taille des patches dans le modèle, utilisée pour calculer la taille de l'image de sortie. Construit un processeur d’images PixtralImageProcessor. #### prétraiter[[transformers.PixtralImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/image_processing_pixtral.py#L118) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. patch_size (`Union[dict[str, *kwargs*, int], int]` *facultatif*, par défaut `{"height" : 16, "width": 16}`) : Taille des patches dans le modèle, utilisée pour calculer la taille de l'image de sortie. **Retourne :** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.). - **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation. ## PixtralImageProcessorPil[[transformers.PixtralImageProcessorPil]] #### transformers.PixtralImageProcessorPil[[transformers.PixtralImageProcessorPil]] ```python transformers.PixtralImageProcessorPil(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/image_processing_pil_pixtral.py#L107) **Paramètres :** do_convert_rgb (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'longest_edge' : 1024}`) : Décris les dimensions d'entrée maximales pour le modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `3`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir de l'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.48145466, 0.4578275, 0.40821073]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.26862954, 0.26130258, 0.27577711]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. patch_size (`Union[dict[str, *kwargs*, int], int]` *facultatif*, par défaut `{"height" : 16, "width": 16}`) : Taille des patches dans le modèle, utilisée pour calculer la taille de l'image de sortie. Construit un processeur d’images PixtralImageProcessor. #### prétraiter[[transformers.PixtralImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/image_processing_pil_pixtral.py#L126) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. patch_size (`Union[dict[str, *kwargs*, int], int]` *facultatif*, par défaut `{"height" : 16, "width": 16}`) : Taille des patches dans le modèle, utilisée pour calculer la taille de l'image de sortie. **Retourne :** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.). - **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation. ## PixtralProcessor[[transformers.PixtralProcessor]] #### transformers.PixtralProcessor[[transformers.PixtralProcessor]] ```python transformers.PixtralProcessor(image_processor = None, tokenizer = None, patch_size: int = 16, spatial_merge_size: int = 1, chat_template = None, image_token = '[IMG]', image_break_token = '[IMG_BREAK]', image_end_token = '[IMG_END]', **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/pixtral/processing_pixtral.py#L50) **Paramètres :** image_processor (`PixtralImageProcessor`) : le processeur d'images est une entrée obligatoire. tokenizer (`MistralCommonBackend`) : le tokenizer est une entrée obligatoire. patch_size (`int`, *facultatif*, valeur par défaut 16) : Taille du patch issue de la tour visuelle. spatial_merge_size (`int`, *facultatif*, valeur par défaut : 1) : Facteur de sous-échantillonnage pour l'opération de fusion spatiale. chat_template (`str`) : Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable. image_token (`str`, *facultatif*, valeur par défaut `"[IMG]"`) : Jeton spécial utilisé pour indiquer l'emplacement d'une image. image_break_token (`str`, *facultatif*, valeur par défaut `"[IMG_BREAK]"`) : Jeton spécial utilisé pour indiquer la fin d'une ligne de pixels dans une image. image_end_token (`str`, *facultatif*, valeur par défaut `"[IMG_END]"`) : Jeton spécial utilisé pour indiquer la fin d'une entrée d'image. Construit un PixtralProcessor qui encapsule un processeur d’images et un tokeniseur en un seul processeur. [PixtralProcessor](/docs/transformers/main/fr/model_doc/pixtral#transformers.PixtralProcessor) offre toutes les fonctionnalités de [PixtralImageProcessor](/docs/transformers/main/fr/model_doc/pixtral#transformers.PixtralImageProcessor) et de [MistralCommonBackend](/docs/transformers/main/fr/model_doc/mistral#transformers.MistralCommonBackend). Consultez [~PixtralImageProcessor](/docs/transformers/main/fr/model_doc/pixtral#transformers.PixtralImageProcessor) et [~MistralCommonBackend](/docs/transformers/main/fr/model_doc/mistral#transformers.MistralCommonBackend) pour plus d’informations. #### __appel__[[transformers.PixtralProcessor.__call__]] ```python __call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L659) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *facultatif*) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. text (`Union[str, list[str], list[list[str]]]`, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes (chaîne pré-tokenisée). Si vous transmettez une entrée pré-tokenisée, définissez `is_split_into_words=True` pour éviter toute ambiguïté avec les entrées en lot. videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *facultatif*) : Vidéo à prétraiter. S'attend à une vidéo unique ou à un lot de vidéos dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *facultatif*) : L'audio ou le lot d'audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d'un tableau NumPy/d'un tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur en échantillons de l'audio. 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. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/fr/main_classes/processors#transformers.ProcessingKwargs), *facultatif*) : Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.