Transformers documentation
Pixtral
Ce modèle a été publié dans HF papers le 2024-10-09 et contribué à Hugging Face Transformers le 2024-09-14.
Pixtral
Pixtral 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.
Pixtral architecture. Taken from the blog post. Vous pouvez trouver tous les points de contrôle originaux de Pixtral sous l'organisation Mistral AI.
Ce modèle a été contribué par amyeroberts et ArthurZ. Cliquez sur les modèles Pixtral dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer Pixtral à différentes tâches de vision et de langage.
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 pour plus d'informations sur les backends de quantification disponibles.
L'exemple ci-dessous utilise bitsandbytes pour quantifier le modèle en 4 bits.
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 comme encodeur visuel et MistralForCausalLM pour son décodeur de langage.
Le modèle remplace en interne les jetons de remplacement
[IMG]par des plongements d'image."<s>[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_templatepour gérer ces jetons à votre place.
PixtralVisionConfig
classe transformers.PixtralVisionConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024intermediate_size: int = 4096num_hidden_layers: int = 24num_attention_heads: int = 16num_channels: int = 3image_size: int | list[int] | tuple[int, int] = 1024patch_size: int | list[int] | tuple[int, int] = 16hidden_act: str = 'gelu'attention_dropout: float | int = 0.0rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneinitializer_range: float = 0.02 )
Paramètres
- hidden_size (
int, facultatif, par défaut1024) — Dimension des représentations cachées. - intermediate_size (
int, facultatif, par défaut4096) — Dimension des représentations du MLP. - num_hidden_layers (
int, facultatif, par défaut24) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_channels (
int, facultatif, par défaut3) — Le nombre de canaux d'entrée. - image_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut1024) — La taille (résolution) de chaque image. - patch_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut16) — La taille (résolution) de chaque patch. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.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 pourrope_thetaet, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec desmax_position_embeddingsplus longs. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
Ceci est 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, 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 mistral-labs/pixtral-12b
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 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.configMistralCommonBackend
classe transformers.MistralCommonBackend
< source >( tokenizer_path: str | os.PathLike | pathlib.Pathmode: str | ValidationMode = 'test'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )
Classe destinée à encapsuler les tokenizers de mistral-common.
mistral-common est la bibliothèque de tokenisation officielle pour les modèles Mistral AI. Pour l’utiliser, vous devez l’installer avec :
pip install transformers[mistral-common]
Sinon, le tokenizer bascule sur l'implémentation du tokenizer de Transformers.
Pour plus d'informations sur mistral-common, consultez mistral-common.
Cette classe est un wrapper autour d’un mistral_common.tokens.tokenizers.mistral.MistralTokenizer.
Elle fournit une interface compatible Hugging Face pour la tokenisation à l’aide du tokeniseur officiel mistral-common et hérite de la classe PreTrainedTokenizerBase.
Voici les principales différences de comportement par rapport à la classe PythonBackend :
- Les paires de séquences ne sont pas prises en charge. La signature a été conservée pour des raisons de compatibilité, mais tous les arguments liés aux paires de séquences sont ignorés. Les valeurs de retour pour les paires sont renvoyées sous forme de
None. - L'argument
is_split_into_wordsn'est pas pris en charge. - Il n'est pas possible d'ajouter de nouveaux jetons au tokenizer. Les jetons spéciaux sont gérés différemment par rapport à Transformers. Dans
mistral-common, les jetons spéciaux ne sont jamais encodés directement. Cela signifie que :tokenizer.encode("<s>")ne renverra pas l'ID du jeton<s>. En revanche, il renverra une liste d'IDs correspondant à la tokenisation de la chaîne"<s>". Pour plus d'informations, consultez la documentation de mistral-common.
Si vous avez des suggestions pour améliorer cette classe, veuillez ouvrir un ticket sur le dépôt GitHub mistral-common si cela concerne le tokenizer, ou sur le dépôt GitHub Transformers si cela concerne l’interface Hugging Face.
add_special_tokens
< source >( special_tokens_dict: dictreplace_extra_special_tokens: bool = True )
MistralCommonBackend n’implémente pas add_special_tokens par conception.
Si vous souhaitez que ce comportement soit implémenté, veuillez ouvrir un ticket dans les dépôts Transformers ou mistral-common pour le demander.
MistralCommonBackend n’implémente pas add_special_tokens par conception.
Si vous souhaitez que ce comportement soit implémenté, veuillez ouvrir un ticket dans les dépôts Transformers ou mistral-common pour le demander.
apply_chat_template
< source >( conversation: list[dict[str, str]] | list[list[dict[str, str]]]tools: list[dict | collections.abc.Callable] | None = Noneadd_generation_prompt: bool = Falsecontinue_final_message: bool = Falsetokenize: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool = Falsemax_length: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_dict: bool = Truereasoning_effort: ReasoningEffort | None = None**kwargs ) → Union[str, list[int], list[str], list[list[int]], BatchEncoding]
Paramètres
- conversation (Union[List[Dict[str, str]], List[List[Dict[str, str]]]]) — A list of dicts with “role” and “content” keys, representing the chat history so far.
- tools (
List[Union[Dict, Callable]], facultatif) — Une liste d’outils (fonctions appelables) qui seront accessibles au modèle. Si le modèle de dialogue ne prend pas en charge l’appel de fonctions, cet argument n’aura aucun effet. Chaque outil doit être transmis sous forme de schéma JSON, indiquant le nom, la description et les types d’arguments de l’outil. Consultez notre guide sur les modèles de dialogue pour plus d’informations. - add_generation_prompt (
bool, facultatif) — Cet argument est ignoré parMistralCommonBackend. Cependant, il ne peut pas être utilisé en même temps quecontinue_final_messageafin de conserver la cohérence de l’API. Si une conversation se termine par un message de l’assistant, une erreur sera levée. Dans ce cas, utilisez plutôtcontinue_final_message. - continue_final_message (bool, facultatif) —
Si ce paramètre est défini, la conversation sera formatée de manière à ce que le dernier message de la conversation soit ouvert, sans jetons EOS. Le modèle poursuivra ce message au lieu d’en démarrer un nouveau. Cela permet de « préremplir » une partie de la réponse du modèle. Ne peut pas être utilisé en même temps que
add_generation_prompt. - tokenize (
bool, par défautTrue) — Indique s'il faut tokeniser la sortie. SiFalse, la sortie sera une chaîne de caractères. - padding (
bool,strou PaddingStrategy, facultatif, défaut :False) — Sélectionne une stratégie pour mettre en place le padding des séquences renvoyées (selon le côté de padding et l'index de padding du modèle) parmi les options suivantes :Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
- truncation (
bool, par défautFalse) — Indique s'il faut tronquer les séquences à la longueur maximale. N'a aucun effet si tokenize estFalse. - max_length (
int, facultatif) — Longueur maximale (en jetons) à utiliser pour le bourrage ou la troncature. N’a aucun effet si tokenize estFalse. Si non spécifié, l’attributmax_lengthdu tokeniseur sera utilisé par défaut. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. N'a aucun effet si tokenize estFalse. Valeurs acceptables :'pt': Renvoie des objetstorch.Tensorde PyTorch.
- return_dict (
bool, par défautFalse) — Indique s'il faut retourner un dictionnaire avec des sorties nommées. N'a aucun effet si tokenize estFalse. Si au moins une conversation contient une image, ses valeurs de pixels seront retournées dans la clépixel_valueset les dimensions des images dans la cléimage_sizes. - reasoning_effort (
ReasoningEffort, facultatif) — L'effort de raisonnement à utiliser pour la complétion de chat pour les modèles qui le prennent en charge. Les valeurs possibles sont :ReasoningEffort.none: le modèle ne raisonne pas.ReasoningEffort.high: le modèle utilisera une approche de raisonnement. Si non spécifié, l'effort de raisonnement par défaut sera utilisé.
- kwargs (arguments supplémentaires par mot-clé, facultatif) —
Arguments supplémentaires transmis à la méthode
ChatCompletionRequest.from_openaide mistral-common.
Retourne
Union[str, list[int], list[str], list[list[int]], BatchEncoding]
La conversation tokenisée jusqu’à présent, y compris les jetons de contrôle. Cette sortie est prête à être transmise au modèle, soit directement, soit via des méthodes telles que generate().
Convertit une liste de dictionnaires avec les clés "role" et "content" en une liste d'identifiants de jetons.
batch_decode
< source >( sequences: typing.Union[list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → list[str]
Paramètres
- sequences (
Union[list[int], list[list[int]], np.ndarray, torch.Tensor]) — Liste des identifiants d’entrée tokenisés. Peut être obtenue à l’aide de la méthode__call__. - skip_special_tokens (
bool, facultatif, valeur par défautFalse) — Indique s'il faut supprimer les jetons spéciaux lors du décodage. - clean_up_tokenization_spaces (
bool, facultatif) — Indique s'il faut nettoyer les espaces de tokenisation. SiNone, la valeur par défaut estself.clean_up_tokenization_spaces. - kwargs (arguments supplémentaires par mot-clé, facultatif) —
Non pris en charge par
MistralCommonBackend.batch_decode. Levera une erreur s'il est utilisé.
Retourne
list[str]
La liste des phrases décodées.
Convertir une liste de listes d'identifiants de jetons en une liste de chaînes en appelant decode.
Cette méthode est fournie pour la compatibilité ascendante. La méthode decode gère désormais nativement les entrées par lots,
vous pouvez donc utiliser directement decode au lieu de batch_decode.
build_inputs_with_special_tokens
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
Construire les entrées du modèle à partir d'une séquence en ajoutant des jetons spéciaux.
Cette méthode construit dynamiquement les entrées en fonction du mode du tokenizer :
"test": seq0 [EOS]"finetuning": [BOS] seq0
convert_added_tokens
< source >( obj: tokenizers.AddedToken | typing.Anysave: bool = Falseadd_type_field: bool = True )
MistralCommonBackend n’implémente pas convert_added_tokens par conception.
Si vous souhaitez que ce comportement soit implémenté, veuillez ouvrir un ticket dans les dépôts Transformers ou mistral-common pour le demander.
create_token_type_ids_from_sequences
< source >( token_ids_0: listtoken_ids_1: None = None ) → list[int]
Créez un masque de zéros à partir des identifiants de jetons avec les jetons spéciaux ajoutés.
Conservé pour correspondre à l'implémentation de Transformers.
décoder
< source >( token_ids: typing.Union[int, list[int], list[list[int]], numpy.ndarray, ForwardRef('torch.Tensor')]skip_special_tokens: bool = Falseclean_up_tokenization_spaces: bool | None = None**kwargs ) → Union[str, list[str]]
Paramètres
- token_ids (
Union[int, list[int], list[list[int]], np.ndarray, torch.Tensor]) — Une séquence unique ou un lot (liste de séquences) d’identifiants d’entrée tokenisés. Peut être obtenu à l’aide de la méthode__call__. - skip_special_tokens (
bool, facultatif, valeur par défautFalse) — Indique s'il faut supprimer les jetons spéciaux lors du décodage. - clean_up_tokenization_spaces (
bool, facultatif) — Indique s'il faut nettoyer les espaces de tokenisation. SiNone, la valeur par défaut estself.clean_up_tokenization_spaces. - kwargs (arguments supplémentaires par mot-clé, facultatif) —
Non pris en charge par
MistralCommonBackend.decode. Levera une erreur s'il est utilisé.
Retourne
Union[str, list[str]]
La chaîne décodée pour une séquence unique, ou une liste de chaînes décodées pour un lot de séquences.
Convertit une séquence d'identifiants en chaîne de caractères, en utilisant le tokenizer et le vocabulaire, avec des options pour supprimer les jetons spéciaux et nettoyer les espaces de tokenization.
encode
< source >( text: str | list[int]text_pair: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Noneverbose: bool = Truereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[int], torch.Tensor
Paramètres
- text (
stroulist[int]) — La première séquence à encoder. Il peut s’agir d’une chaîne de caractères ou d’une liste d’entiers (identifiants de jetons d’une chaîne tokenisée). - text_pair (
None, facultatif) — Non pris en charge parMistralCommonBackend.encode. Conservé pour correspondre à la signature dePreTrainedTokenizerBase.encode. - add_special_tokens (
bool, facultatif, par défautTrue) — Indique s'il faut ou non ajouter des jetons spéciaux lors de l'encodage des séquences. Cela utilise la fonction sous-jacentePretrainedTokenizerBase.build_inputs_with_special_tokens, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetonsbosoueos. Lorsque le Tokenizer est chargé en modefinetuning, il ajoute à la foisboseteos. Sinon, en mode « test », il n'ajoute quebos. - padding (
bool,strou PaddingStrategy, facultatif, défaut :False) — Active et contrôle le padding. Accepte les valeurs suivantes :Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
- truncation (
bool,strou TruncationStrategy, facultatif, défaut :False) — Active et contrôle la troncature. Accepte les valeurs suivantes :Trueou'longest_first': Tronquer à une longueur maximale spécifiée avec l’argumentmax_lengthou à la longueur d’entrée maximale acceptable pour le modèle si cet argument n’est pas fourni.Falseou'do_not_truncate'(par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).
- max_length (
int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.Si non défini ou défini sur
None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé. - stride (
int, facultatif, valeur par défaut 0) — Si défini à un nombre avecmax_length, les jetons en dépassement renvoyés lorsquereturn_overflowing_tokens=Truecontiendront certains jetons de la fin de la séquence tronquée renvoyée afin de fournir un chevauchement entre les séquences tronquées et les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement. - pad_to_multiple_of (
int, facultatif) — Si défini, la séquence est rembourrée jusqu'à un multiple de la valeur fournie. Nécessite l'activation depadding. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul>= 7.5(Volta). - padding_side (
str, facultatif) — Le côté sur lequel le modèle doit appliquer le bourrage. Doit être choisi parmi [‘right’, ‘left’]. La valeur par défaut est choisie à partir de l’attribut de classe du même nom. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.
- **kwargs — Non pris en charge par
MistralCommonBackend.encode. Levera une erreur s'il est utilisé.
Retourne
list[int], torch.Tensor
Les identifiants tokenisés du texte.
Convertit une chaîne de caractères en une séquence d'identifiants (entiers), en utilisant le tokenizer et le vocabulaire.
from_pretrained
< source >( pretrained_model_name_or_path: str | os.PathLike*init_inputsmode: str | ValidationMode = 'test'cache_dir: str | os.PathLike | None = Noneforce_download: bool = Falselocal_files_only: bool = Falsetoken: str | bool | None = Nonerevision: str = 'main'model_max_length: int = 1000000000000000019884624838656padding_side: str = 'left'truncation_side: str = 'right'model_input_names: list[str] | None = Noneclean_up_tokenization_spaces: bool = False**kwargs )
Paramètres
- pretrained_model_name_or_path (
strouos.PathLike) — Peut être soit :- Une chaîne de caractères, l'identifiant du modèle d'un tokeniseur prédéfini hébergé dans un dépôt de modèles sur huggingface.co.
- Chemin vers un dossier contenant la configuration du tokenizer, par exemple sauvegardée à l’aide de la méthode
MistralCommonBackend.tokenization_mistral_common.save_pretrained, par exemple./my_model_directory/.
- mode (
Union[str, ValidationMode], facultatif, défaut surValidationMode.test) — Mode de validation pour leMistralTokenizertokenizer. Les valeurs possibles sont :"finetuning"ouValidationMode.finetuning: le mode de fine-tuning."test"ouValidationMode.test: le mode test. Il modifie la manière dont le tokenizer valide l'entrée et prépare la requête destinée au modèle.
- cache_dir (
strouos.PathLike, facultatif) — Chemin vers un répertoire dans lequel les fichiers de vocabulaire de tokenizer prédéfinis téléchargés doivent être mis en cache si le cache standard ne doit pas être utilisé. - force_download (
bool, facultatif, par défautFalse) — Indique s'il faut forcer le (re)téléchargement des fichiers de vocabulaire et remplacer les versions en cache si elles existent. - token (
strou bool, facultatif) — Le jeton à utiliser comme autorisation bearer HTTP pour les fichiers distants. SiTrue, utilise le jeton généré lors de l’exécution dehf auth login(stocké dans~/.huggingface). - local_files_only (
bool, facultatif, valeur par défautFalse) — Indique s'il faut s'appuyer uniquement sur les fichiers locaux et ne pas tenter de télécharger de fichiers. - revision (
str, facultatif, par défaut"main") — La version spécifique du modèle à utiliser. Il peut s’agir du nom d’une branche, du nom d’une étiquette ou d’un identifiant de commit, car nous utilisons un système basé sur git pour stocker les modèles et autres artefacts sur huggingface.co, de sorte querevisionpeut être n’importe quel identifiant autorisé par git. - max_length (
int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.Si non défini ou défini sur
None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé. - padding_side (
str, facultatif, par défaut"left") — Le côté sur lequel le modèle doit appliquer le bourrage. Doit être sélectionné parmi [‘right’, ‘left’]. La valeur par défaut est choisie à partir de l’attribut de classe du même nom. - truncation_side (
str, facultatif, par défaut"right") — Le côté sur lequel le modèle doit appliquer la troncature. Doit être sélectionné parmi [‘right’, ‘left’]. - model_input_names (
List[str], facultatif) — La liste des entrées acceptées par le passage avant du modèle (comme"token_type_ids"ou"attention_mask"). La valeur par défaut est choisie à partir de l'attribut de classe du même nom. - clean_up_tokenization_spaces (
bool, facultatif, valeur par défautFalse) — Indique si le modèle doit nettoyer les espaces ajoutés lors de la division du texte d’entrée pendant le processus de tokenisation. - kwargs (arguments supplémentaires par mot-clé, facultatif) —
Non pris en charge par
MistralCommonBackend.from_pretrained. Levera une erreur s'il est utilisé.
Instanciez un MistralCommonBackend à partir d'un
tokeniseur prédéfini.
MistralCommonBackend n’implémente pas get_chat_template par conception, car mistral-common n’utilise pas de modèles de discussion.
get_special_tokens_mask
< source >( token_ids_0: listtoken_ids_1: None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]
Paramètres
- token_ids_0 (
list[int]) — Liste des identifiants de la séquence. - token_ids_1 (
None, facultatif) — None, conservé pour correspondre à l’implémentation de Transformers. - already_has_special_tokens (
bool, facultatif, par défautFalse) — Indique si la liste de jetons est déjà formatée avec les jetons spéciaux du modèle.
Retourne
Une liste d'entiers dans l'intervalle [0, 1]
1 pour un jeton spécial, 0 pour un jeton de séquence.
Récupère les identifiants de séquences à partir d'une liste de jetons qui ne contient pas de jetons spéciaux ajoutés. Cette méthode est appelée lors de l'ajout de jetons spéciaux à l'aide des méthodes prepare_for_model ou encode_plus du tokenizer.
Retourne le vocabulaire sous forme de dictionnaire associant chaque jeton à son index.
Il s'agit d'une conversion avec perte. Plusieurs identifiants de jetons peuvent se décoder en la même chaîne en raison de séquences d'octets UTF-8 partielles converties en �.
num_special_tokens_to_add
< source >( pair: typing.Literal[False] = False ) → int
Retourne le nombre de jetons ajoutés lors de l’encodage d’une séquence avec des jetons spéciaux.
Cela encode une entrée factice et vérifie le nombre de jetons ajoutés, ce qui n'est donc pas efficace. Ne placez pas cela dans votre boucle d'entraînement.
prepare_for_model
< source >( ids: listpair_ids: None = Noneadd_special_tokens: bool = Truepadding: bool | str | transformers.utils.generic.PaddingStrategy = Falsetruncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = Nonemax_length: int | None = Nonestride: int = 0pad_to_multiple_of: int | None = Nonepadding_side: str | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_token_type_ids: bool | None = Nonereturn_attention_mask: bool | None = Nonereturn_overflowing_tokens: bool = Falsereturn_special_tokens_mask: bool = Falsereturn_length: bool = Falseverbose: bool = Trueprepend_batch_axis: bool = Falsereturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → BatchEncoding
Paramètres
- ids (
list[int]) — Identifiants des jetons d'entrée de la première séquence. - pair_ids (
None, facultatif) — Non pris en charge parMistralCommonBackend. Conservé pour correspondre à l’interface dePreTrainedTokenizerBase. - add_special_tokens (
bool, facultatif, par défautTrue) — Indique s'il faut ou non ajouter des jetons spéciaux lors de l'encodage des séquences. Cela utilise la fonction sous-jacentePretrainedTokenizerBase.build_inputs_with_special_tokens, qui définit les jetons ajoutés automatiquement aux identifiants d'entrée. Cela est utile si vous souhaitez ajouter automatiquement des jetonsbosoueos. Lorsque le Tokenizer est chargé en modefinetuning, il ajoute à la foisboseteos. Sinon, en mode « test », il n'ajoute quebos. - padding (
bool,strou PaddingStrategy, facultatif, défaut :False) — Active et contrôle le padding. Accepte les valeurs suivantes :Trueou'longest': Ajuster à la séquence la plus longue du lot (ou aucun ajustement si une seule séquence est fournie).'max_length': Remplir jusqu'à une longueur maximale spécifiée par l'argumentmax_lengthou jusqu'à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.Falseou'do_not_pad'(par défaut) : aucun padding (c’est-à-dire, peut produire un lot avec des séquences de longueurs différentes).
- truncation (
bool,strou TruncationStrategy, facultatif, défaut :False) — Active et contrôle la troncature. Accepte les valeurs suivantes :Trueou'longest_first': Tronquer à une longueur maximale spécifiée avec l’argumentmax_lengthou à la longueur d’entrée maximale acceptable pour le modèle si cet argument n’est pas fourni.Falseou'do_not_truncate'(par défaut) : aucune troncature (c’est-à-dire, peut produire un lot avec des longueurs de séquences supérieures à la taille d’entrée maximale admissible par le modèle).
- max_length (
int, facultatif) — Contrôle la longueur maximale à utiliser par l'un des paramètres de troncature/remplissage.Si non défini ou défini sur
None, la longueur maximale prédéfinie du modèle sera utilisée si l'un des paramètres de troncature/remplissage exige une longueur maximale. Si le modèle n'a pas de longueur d'entrée maximale spécifique (comme XLNet), la troncature/le remplissage à une longueur maximale sera désactivé. - stride (
int, facultatif, valeur par défaut 0) — Si défini à un nombre avecmax_length, les jetons en dépassement renvoyés lorsquereturn_overflowing_tokens=Truecontiendront certains jetons de la fin de la séquence tronquée renvoyée afin de fournir un chevauchement entre les séquences tronquées et les séquences en dépassement. La valeur de cet argument définit le nombre de jetons en chevauchement. - pad_to_multiple_of (
int, facultatif) — Si défini, la séquence est rembourrée jusqu'à un multiple de la valeur fournie. Nécessite l'activation depadding. Cela est particulièrement utile pour permettre l'utilisation des Tensor Cores sur le matériel NVIDIA avec une capacité de calcul>= 7.5(Volta). - padding_side (
str, facultatif) — Le côté sur lequel le modèle doit appliquer le bourrage. Doit être choisi parmi [‘right’, ‘left’]. La valeur par défaut est choisie à partir de l’attribut de classe du même nom. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs au lieu d'une liste d'entiers Python. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.
- return_token_type_ids (
bool, facultatif) — Indique s'il faut renvoyer les identifiants de type de jeton. PourMistralCommonBackend, il renvoie une liste de zéros de la longueur de la séquence, car seule une séquence est prise en charge. - return_attention_mask (
bool, facultatif) — Indique s'il faut retourner le masque d'attention. Si la valeur par défaut est conservée, le masque d'attention est retourné selon la valeur par défaut du tokenizer spécifique, définie par l'attributreturn_outputs. - return_overflowing_tokens (
bool, facultatif, par défautFalse) — Indique s'il faut ou non retourner les séquences de jetons en dépassement. Si une paire de séquences d'identifiants d'entrée (ou un lot de paires) est fournie avectruncation_strategy = longest_firstouTrue, une erreur est levée au lieu de retourner les jetons en dépassement. - return_special_tokens_mask (
bool, facultatif, par défautFalse) — Indique s'il faut ou non retourner les informations du masque des jetons spéciaux. - return_length (
bool, facultatif, par défautFalse) — Indique s'il faut retourner les longueurs des entrées encodées. - verbose (
bool, facultatif, par défautTrue) — Indique s'il faut afficher plus d'informations et d'avertissements. - return_offsets_mapping (
Literal[False], facultatif) — False, conservé pour correspondre à la signature de Transformers. - split_special_tokens (
Literal[False], facultatif) — False, conservé pour correspondre à la signature de Transformers. - **kwargs — transmis à la méthode
self.tokenize()
Retourne
Un BatchEncoding avec les champs suivants :
-
input_ids — Liste des identifiants de jetons à fournir à un modèle.
-
attention_mask — Liste d’indices spécifiant les jetons auxquels le modèle doit prêter attention (lorsque
return_attention_mask=Trueou si “attention_mask” est présent dansself.model_input_names). -
overflowing_tokens — Liste des séquences de jetons en dépassement (lorsqu'une
max_lengthest spécifiée etreturn_overflowing_tokens=True). -
num_truncated_tokens — Nombre de jetons tronqués (lorsqu'une
max_lengthest spécifiée etreturn_overflowing_tokens=True). -
special_tokens_mask — Liste de 0 et de 1, où 1 indique les jetons spéciaux ajoutés et 0 indique les jetons de séquence réguliers (lorsque
add_special_tokens=Trueetreturn_special_tokens_mask=True). -
length — La longueur des entrées (lorsque
return_length=True)
Prépare une séquence d’identifiants d’entrée afin qu’elle puisse être utilisée par le modèle. Il ajoute des jetons spéciaux, tronque les séquences en cas de dépassement en tenant compte des jetons spéciaux et gère une fenêtre glissante (avec un pas défini par l’utilisateur) pour les jetons en dépassement.
save_chat_templates
< source >( save_directory: str | os.PathLiketokenizer_config: dictfilename_prefix: str | Nonesave_jinja_files: bool )
MistralCommonBackend n’implémente pas save_chat_templates par conception, car mistral-common n’utilise pas de modèles de discussion.
save_pretrained
< source >( save_directory: str | os.PathLike | pathlib.Pathpush_to_hub: bool = Falsetoken: str | bool | None = Nonecommit_message: str | None = Nonerepo_id: str | None = Noneprivate: bool | None = Nonesave_format: str | None = None**kwargs ) → tuple[str, ...]
Paramètres
- save_directory (
str | os.PathLike | Path) — Répertoire où le tokenizer sera enregistré. - push_to_hub (
bool, facultatif, par défautFalse) — Pousse vers le HF Hub après l'enregistrement. - token (
stroubool, facultatif) — Jeton pour l’authentification au Hub. - commit_message (
str, facultatif) — Message de commit lors de la poussée. - repo_id (
str, facultatif) — Identifiant du dépôt sur le Hub. - private (
bool, facultatif) — Indique si le dépôt est privé. - save_format (
str, facultatif) —"mistral"pour enregistrer au format tekken natif,"hf"pour le format HuggingFace. None conserve le format d'origine. - kwargs (
dict, facultatif) — Non pris en charge — lève une erreur.
Retourne
tuple[str, ...]
Chemin des fichiers enregistrés.
Enregistrer l'état complet du tokenizer.
Lorsque save_format est "mistral" (ou None pour un tokenizer tekken),
le fichier de tokenizer d'origine (par ex. tekken.json) est écrit dans save_directory. Lorsque save_format est "hf", des fichiers au format HF
(tokenizer.json + tokenizer_config.json) sont produits à la place.
MistralCommonBackend n’implémente pas save_vocabulary par conception.
Cela est dû au fait que mistral-common est configuré par un seul fichier de tokenizer. Si vous souhaitez enregistrer le vocabulaire, veuillez envisager d'utiliser la méthode save_pretrained à la place.
tokenize
< source >( text: strreturn_offsets_mapping: typing.Literal[False] = Falsesplit_special_tokens: typing.Literal[False] = False**kwargs ) → list[str]
Paramètres
- text (
str) — La séquence à encoder. - return_offsets_mapping (
Literal[False], facultatif) — False, conservé pour correspondre à la signature de Transformers. - split_special_tokens (
Literal[False], facultatif) — False, conservé pour correspondre à la signature de Transformers. - **kwargs (arguments supplémentaires par mot-clé) —
Non pris en charge par
MistralCommonBackend.tokenize. Levera une erreur s'il est utilisé.
Retourne
list[str]
La liste de jetons.
Convertit une chaîne de caractères en une séquence de jetons, en utilisant le tokeniseur.
Découpe en mots pour les vocabulaires basés sur les mots ou en sous-mots pour les vocabulaires basés sur les sous-mots.
truncate_sequences
< source >( ids: listpair_ids: None = Nonenum_tokens_to_remove: int = 0truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first'stride: int = 0**kwargs ) → Tuple[list[int], None, list[int]]
Paramètres
- ids (
list[int]) — Identifiants d’entrée tokenisés. Ils peuvent être obtenus à partir d’une chaîne en enchaînant les méthodestokenizeetconvert_tokens_to_ids. - pair_ids (
None, facultatif) — Non pris en charge parMistralCommonBackend. Conservé pour correspondre à la signature dePreTrainedTokenizerBase.truncate_sequences. - num_tokens_to_remove (
int, facultatif, valeur par défaut 0) — Nombre de jetons à supprimer en utilisant la stratégie de troncature. - truncation_strategy (
strou TruncationStrategy, facultatif, défaut :'longest_first') — La stratégie à suivre pour la troncature. Peut être :'longest_first': Tronque à une longueur maximale spécifiée avec l'argumentmax_lengthou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni.'do_not_truncate'(par défaut) : aucune troncature (c.-à-d. peut produire un lot dont les longueurs de séquences dépassent la taille d’entrée maximale admissible par le modèle).
- stride (
int, facultatif, valeur par défaut 0) — Si défini sur un nombre positif, les jetons en dépassement renvoyés contiendront certains jetons de la séquence principale renvoyée. La valeur de cet argument définit le nombre de jetons supplémentaires.
Retourne
Tuple[list[int], None, list[int]]
Les ids tronqués et la liste des
jetons en dépassement. None est retourné pour correspondre à la signature de Transformers.
Tronque une paire de séquences sur place selon la stratégie.
PixtralVisionModel
classe transformers.PixtralVisionModel
< source >( config: PixtralVisionConfig )
Paramètres
- config (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() 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. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( pixel_values: Tensorimage_sizes: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde 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.Tensorde forme(batch_size, 2), facultatif) — Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.
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 (PixtralVisionConfig) et des entrées.
La méthode forward du modèle 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
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.pooler_output (
torch.Tensorde 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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
PixtralImageProcessor
classe transformers.PixtralImageProcessor
< source >( **kwargs: *<class 'transformers.models.pixtral.image_processing_pixtral.PixtralImageProcessorKwargs'> )
Paramètres
- do_convert_rgb (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif, valeur par défautTrue) — 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éfinit les dimensions d'entrée maximales pour le modèle. - default_to_square (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, 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 decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut3) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif, valeur par défaut0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif, valeur par défautTrue) — 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 sido_normalizeest défini surTrue. - 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 sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut appliquer un bourrage (padding) à l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage 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 les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_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) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- 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) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne 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 est 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
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.pixtral.image_processing_pixtral.PixtralImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature
Paramètres
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_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éfinit les dimensions maximales des entrées du modèle. - default_to_square (
bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en 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 decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image sido_rescaleest défini surTrue. - 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 sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage 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 les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_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) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- 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) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne 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 est 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
classe transformers.PixtralImageProcessorPil
< source >( **kwargs: *<class 'transformers.models.pixtral.image_processing_pil_pixtral.PixtralImageProcessorKwargs'> )
Paramètres
- do_convert_rgb (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif, valeur par défautTrue) — 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éfinit les dimensions d'entrée maximales pour le modèle. - default_to_square (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, 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 decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut3) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif, par défautTrue) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif, valeur par défaut0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif, valeur par défautTrue) — 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 sido_normalizeest défini surTrue. - 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 sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif, valeur par défautTrue) — Indique s'il faut appliquer un bourrage (padding) à l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage 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 les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_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) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- 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) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne 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 est 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
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.pixtral.image_processing_pil_pixtral.PixtralImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature
Paramètres
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_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éfinit les dimensions maximales des entrées du modèle. - default_to_square (
bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en 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 decenter_crop. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image sido_rescaleest défini surTrue. - 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 sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - do_pad (
bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage 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 les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Sipad_sizen'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsquedo_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) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour 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"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- 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) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne 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 est 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
classe transformers.PixtralProcessor
< source >( image_processor = Nonetokenizer = Nonepatch_size: int = 16spatial_merge_size: int = 1chat_template = Noneimage_token = '[IMG]'image_break_token = '[IMG_BREAK]'image_end_token = '[IMG_END]'**kwargs )
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 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, par défaut"[IMG]") — Jeton spécial utilisé pour indiquer l'emplacement de l'image. - image_break_token (
str, facultatif, 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, 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 offre toutes les fonctionnalités de PixtralImageProcessor et de MistralCommonBackend. Consultez ~PixtralImageProcessor et ~MistralCommonBackend pour plus d’informations.
__call__
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: 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] = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> )
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. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_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 de caractères (chaînes pré-tokenisées). Si vous passez une entrée pré-tokenisée, définissezis_split_into_words=Truepour é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 vont de 0 à 255. Si vous passez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_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/tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur d’échantillonnage de l’audio. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets NumPynp.ndarray.
- **kwargs (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.