# Tokenizer Un tokenizer est chargé de préparer les entrées d'un modèle. La bibliothèque contient des tokenizers pour tous les modèles. La plupart des tokenizers sont disponibles en deux versions : une implémentation Python complète et une implémentation « Fast » basée sur la bibliothèque Rust [🤗 Tokenizers](https://github.com/huggingface/tokenizers). Les implémentations « Fast » permettent : 1. un gain de vitesse significatif, en particulier lors de la tokenisation par lots et 2. méthodes supplémentaires pour effectuer la correspondance entre la chaîne de caractères d'origine (caractères et mots) et l'espace des jetons (par exemple, obtenir l'index du jeton contenant un caractère donné ou l'étendue des caractères correspondant à un jeton donné). Les classes de base [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend) et [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) implémentent les méthodes communes pour encoder les entrées de type chaîne en entrées de modèle (voir ci-dessous) et pour instancier/enregistrer des tokenizers Python et « Fast », que ce soit à partir d'un fichier ou d'un répertoire local, ou à partir d'un tokenizer préentraîné fourni par la bibliothèque (téléchargé depuis le dépôt AWS S3 de HuggingFace). Les deux reposent sur [PreTrainedTokenizerBase](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), qui contient les méthodes communes. [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend) et [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) implémentent donc les principales méthodes pour utiliser tous les tokenizers : - Tokenizing (découpage des chaînes en sous-mots), conversion des chaînes de jetons en identifiants et inversement, et encodage/décodage (c’est-à-dire tokenisation et conversion en entiers). - Ajout de nouveaux jetons au vocabulaire de manière indépendante de la structure sous-jacente (BPE, SentencePiece...). - Gestion des jetons spéciaux (comme mask, beginning-of-sentence, etc.) : les ajouter, leur attribuer des attributs dans le tokenizer pour un accès facile et s'assurer qu'ils ne sont pas fractionnés lors de la tokenization. [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding) contient la sortie des méthodes d’encodage de [PreTrainedTokenizerBase](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) (`__call__`, `encode_plus` et `batch_encode_plus`) et est dérivée d’un dictionnaire Python. Lorsque le tokenizer est un tokenizer Python pur, cette classe se comporte comme un dictionnaire Python standard et contient les différentes entrées du modèle calculées par ces méthodes (`input_ids`, `attention_mask`...). Lorsque le tokenizer est un tokenizer « Fast » (c’est-à-dire basé sur la bibliothèque [tokenizers](https://github.com/huggingface/tokenizers) de HuggingFace), cette classe fournit en outre plusieurs méthodes avancées d’alignement, qui permettent de passer entre la chaîne de caractères d’origine (caractères et mots) et l’espace des jetons (par exemple, obtenir l’index du jeton contenant un caractère donné, ou l’étendue de caractères correspondant à un jeton donné). ## Tokeniseur multimodal En dehors de cela, chaque tokenizer peut être un tokenizer « multimodal », ce qui signifie que le tokenizer conserve tous les jetons spéciaux pertinents en tant qu'attributs du tokenizer pour un accès plus facile. Par exemple, si le tokenizer est chargé depuis un modèle vision-langage comme LLaVA, vous pourrez accéder à `tokenizer.image_token_id` pour obtenir le jeton d'image spécial utilisé comme espace réservé. Pour activer des jetons spéciaux supplémentaires pour n’importe quel type de tokenizer, vous devez ajouter les lignes suivantes et enregistrer le tokenizer. Les jetons spéciaux supplémentaires n’ont pas à être liés à une modalité et peuvent être tout ce dont le modèle a souvent besoin. Dans le code ci-dessous, le tokenizer situé dans `output_dir` aura un accès direct à trois jetons spéciaux supplémentaires. ```python vision_tokenizer = AutoTokenizer.from_pretrained( "llava-hf/llava-1.5-7b-hf", extra_special_tokens={"image_token": "", "boi_token": "", "eoi_token": ""} ) print(vision_tokenizer.image_token, vision_tokenizer.image_token_id) ("", 32000) ``` ## PreTrainedTokenizer[[transformers.PythonBackend]] #### transformers.PythonBackend[[transformers.PythonBackend]] ```python transformers.PythonBackend(**kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L401) **Paramètres :** model_max_length (`int`, *facultatif*) : La longueur maximale (en nombre de jetons) des entrées pour le modèle transformer. Lorsque le tokeniseur est chargé avec [from_pretrained()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained), cette valeur est définie sur celle stockée pour le modèle associé dans `max_model_input_sizes` (voir ci-dessus). Si aucune valeur n'est fournie, la valeur par défaut est VERY_LARGE_INTEGER (`int(1e30)`). 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. truncation_side (`str`, *facultatif*) : Le côté sur lequel le modèle doit appliquer la troncature. Doit être sélectionné parmi ['right', 'left']. La valeur par défaut est choisie à partir de l'attribut de classe du même nom. chat_template (`str`, *facultatif*) : une chaîne de modèle Jinja utilisée pour formater les listes de messages de chat. Voir https://huggingface.co/docs/transformers/chat_templating pour une description complète. model_input_names (`list[string]`, *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. bos_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant le début d'une phrase. eos_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant la fin d'une phrase. unk_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant un jeton hors vocabulaire. sep_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial séparant deux phrases différentes dans la même entrée (utilisé par BERT, par exemple). pad_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Jeton spécial utilisé pour uniformiser la taille des tableaux de jetons dans le but de créer des lots. Il sera ensuite ignoré par les mécanismes d'attention ou le calcul de la perte. cls_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant la classe de l'entrée (utilisé par BERT, par exemple). mask_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant un jeton masqué (utilisé par les objectifs de pré-entraînement de modélisation de langage masqué, comme BERT). Sera associé à `self.mask_token` et `self.mask_token_id`. extra_special_tokens (liste de `str` ou `tokenizers.AddedToken`, *facultatif*) : une liste de jetons spéciaux supplémentaires spécifiques au modèle. Ajoutez-les ici pour vous assurer qu’ils sont ignorés lors du décodage lorsque `skip_special_tokens` est défini sur True. S’ils ne font pas partie du vocabulaire, ils seront ajoutés à la fin du vocabulaire. split_special_tokens (`bool`, *facultatif*, par défaut `False`) : Indique si les jetons spéciaux doivent être fractionnés lors du processus de tokenisation. La transmission de cette valeur affecte l'état interne du tokenizer. Le comportement par défaut est de ne pas fractionner les jetons spéciaux. Cela signifie que si `` est le `bos_token`, alors `tokenizer.tokenize("") = ['`]. Sinon, si `split_special_tokens=True`, alors `tokenizer.tokenize("")` renverra `['<','s', '>']`. Classe de base pour tous les tokeniseurs lents. Hérite de [PreTrainedTokenizerBase](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase). Gère toutes les méthodes partagées pour la tokenisation et les jetons spéciaux, ainsi que les méthodes de téléchargement, de mise en cache et de chargement des tokeniseurs pré-entraînés, et l’ajout de jetons au vocabulaire. Cette classe contient également les jetons ajoutés de manière unifiée au-dessus de tous les tokenizers, afin de ne pas avoir à gérer les méthodes spécifiques d’augmentation du vocabulaire des différentes structures de dictionnaire sous-jacentes (BPE, sentencepiece...). Attributs de classe (réécrits par les classes dérivées) - **vocab_files_names** (`dict[str, str]`) -- Un dictionnaire dont les clés sont les noms des mots-clés de `__init__` de chaque fichier de vocabulaire requis par le modèle, et dont les valeurs associées sont les noms de fichiers pour l’enregistrement du fichier correspondant (chaîne de caractères). - **pretrained_vocab_files_map** (`dict[str, dict[str, str]]`) -- Un dictionnaire de dictionnaires, dont les clés de haut niveau sont les noms de mots-clés `__init__` de chaque fichier de vocabulaire requis par le modèle, et les clés de bas niveau sont les `short-cut-names` des modèles pré-entraînés, avec, en valeurs associées, l'`url` du fichier de vocabulaire pré-entraîné correspondant. - **model_input_names** (`list[str]`) -- Une liste des entrées attendues lors de la passe avant du modèle. - **padding_side** (`str`) -- Valeur par défaut du côté sur lequel le modèle doit appliquer le bourrage. Doit être `'right'` ou `'left'`. - **truncation_side** (`str`) -- La valeur par défaut pour le côté sur lequel le modèle doit appliquer la troncature. Doit être `'right'` ou `'left'`. #### __appel__[[transformers.PythonBackend.__call__]] ```python __call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | 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_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2448) **Paramètres :** text (`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 les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l'ambiguïté avec un lot de séquences). text_pair (`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 les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l'ambiguïté avec un lot de séquences). text_target (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l’ambiguïté avec un lot de séquences). text_pair_target (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l’ambiguïté avec un lot de séquences). tokenizer_kwargs (`dict[str, Any]`, *facultatif*) : kwargs supplémentaires à passer au tokenizer. Ils seront fusionnés avec les paramètres explicites et les autres kwargs, les paramètres explicites ayant la priorité. 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`. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/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/v5.23.0/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 par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `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. is_split_into_words (`bool`, *facultatif*, valeur par défaut `False`) : Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini sur `True`, le tokenizer suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et procède à sa tokenisation. Cela est utile pour la NER ou la classification de tokens. 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/v5.23.0/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. - `'np'` : Renvoie des objets `np.ndarray` de Numpy. return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`. [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_offsets_mapping (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner `(char_start, char_end)` pour chaque jeton. Cette option n'est disponible que pour les tokenizers rapides héritant de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) ; si vous utilisez le tokenizer Python, cette méthode lèvera `NotImplementedError`. 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. - ****kwargs** : transmis à la méthode `self.tokenize()` **Retourne :** [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding) Un [BatchEncoding](/docs/transformers/v5.23.0/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) - **token_type_ids** -- Liste des identifiants de type de jeton à fournir au modèle (lorsque `return_token_type_ids=True` ou si *"token_type_ids"* est présent dans `self.model_input_names`). [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-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`) Méthode principale pour tokeniser et préparer pour le modèle une ou plusieurs séquences ou une ou plusieurs paires de séquences. #### add_tokens[[transformers.PythonBackend.add_tokens]] ```python add_tokens(new_tokens: str | AddedToken | Sequence[str | AddedToken], special_tokens: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1217) **Paramètres :** new_tokens (`str`, `tokenizers.AddedToken` ou une séquence de *str* ou `tokenizers.AddedToken`) : Les jetons ne sont ajoutés que s'ils ne figurent pas déjà dans le vocabulaire. `tokenizers.AddedToken` encapsule un jeton sous forme de chaîne de caractères afin de vous permettre de personnaliser son comportement : si ce jeton doit correspondre uniquement à un seul mot, s'il doit supprimer toutes les espaces potentielles sur le côté gauche, s'il doit supprimer toutes les espaces potentielles sur le côté droit, etc. special_tokens (`bool`, *facultatif*, par défaut `False`) : Indique si le jeton est spécial. Cela modifie principalement le comportement de normalisation. Voir les détails de `tokenizers.AddedToken` dans la bibliothèque HuggingFace tokenizers. **Retourne :** `int` Nombre de jetons ajoutés au vocabulaire. #TODO supprimer ceci d'ici ! PreTrainedTokenizerBase doit être agnostique vis-à-vis de AddedToken. Ajouter une liste de nouveaux jetons. Si les nouveaux jetons ne figurent pas dans le vocabulaire, ils sont ajoutés à la fin. Les jetons ajoutés et les jetons issus du vocabulaire de l’algorithme de tokenisation ne sont donc pas traités de la même manière. Les tokenizers rapides avec un pré-tokenizer `Metaspace` utilisant `prepend_scheme="always"` (par ex. NLLB) ajoutent `"▁"` au texte qui suit un token ajouté. Après `tokenizer.add_tokens(["abcd"])`, `"abcdgym"` est tokenizé en `["abcd", "▁gym"]` et décodé en `"abcd gym"`. Si les tokens ajoutés peuvent apparaître à l'intérieur de mots, changez le pré-tokenizer à `prepend_scheme="first"` pour que seul le début de l'entrée soit préfixé : ```python from tokenizers import pre_tokenizers pre_tokenizer = tokenizer.backend_tokenizer.pre_tokenizer tokenizer.backend_tokenizer.pre_tokenizer = pre_tokenizers.Metaspace( replacement=pre_tokenizer.replacement, prepend_scheme="first", split=pre_tokenizer.split ) ``` Exemples : ```python # Let's see how to increase the vocabulary of Bert model and tokenizer tokenizer = BertTokenizerFast.from_pretrained("google-bert/bert-base-uncased") model = BertModel.from_pretrained("google-bert/bert-base-uncased") num_added_toks = tokenizer.add_tokens(["new_tok1", "my_new-tok2"]) print("We have added", num_added_toks, "tokens") # Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer. model.resize_token_embeddings(len(tokenizer)) ``` #### add_special_tokens[[transformers.PythonBackend.add_special_tokens]] ```python add_special_tokens(special_tokens_dict: dict[str, str | AddedToken | Sequence[str | AddedToken]], replace_extra_special_tokens = True) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1112) **Paramètres :** special_tokens_dict (dictionnaire *str* vers *str*, `tokenizers.AddedToken` ou `Sequence[Union[str, AddedToken]]`) : les clés doivent figurer dans la liste des attributs spéciaux prédéfinis : [`bos_token`, `eos_token`, `unk_token`, `sep_token`, `pad_token`, `cls_token`, `mask_token`, `extra_special_tokens`]. Les jetons ne sont ajoutés que s’ils ne sont pas déjà présents dans le vocabulaire (vérifié en testant si le tokeniseur leur attribue l’index du `unk_token`). replace_extra_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Si `True`, la liste existante de jetons spéciaux supplémentaires sera remplacée par la liste fournie dans `special_tokens_dict`. Sinon, `extra_special_tokens` sera étendue. Dans le premier cas, les jetons ne seront PAS retirés du vocabulaire complet du tokeniseur - ils sont simplement marqués comme jetons non spéciaux. N'oubliez pas que cela n'affecte que les jetons ignorés lors du décodage, et non `added_tokens_encoder` et `added_tokens_decoder`. Cela signifie que les `extra_special_tokens` précédents restent des jetons ajoutés et ne seront pas fractionnés par le modèle. **Retourne :** `int` Nombre de jetons ajoutés au vocabulaire. Ajoute un dictionnaire de jetons spéciaux (eos, pad, cls, etc.) à l’encodeur et les associe aux attributs de classe. Si les jetons spéciaux ne figurent PAS dans le vocabulaire, ils y sont ajoutés (indexés à partir du dernier index du vocabulaire actuel). Lors de l’ajout de nouveaux jetons au vocabulaire, vous devez vous assurer de redimensionner également la matrice d’incorporation des jetons du modèle afin que sa matrice d’incorporation corresponde à celle du tokeniseur. Pour ce faire, veuillez utiliser la méthode [resize_token_embeddings()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.resize_token_embeddings). L'utilisation de `add_special_tokens` garantit que vos jetons spéciaux peuvent être utilisés de plusieurs manières : - Les jetons spéciaux peuvent être ignorés lors du décodage en utilisant `skip_special_tokens = True`. - Les jetons spéciaux sont soigneusement gérés par le tokeniseur (ils ne sont jamais fractionnés), de manière similaire à `AddedTokens`. - Vous pouvez facilement faire référence aux jetons spéciaux à l’aide des attributs de la classe tokenizer, comme `tokenizer.cls_token`. Cela facilite le développement de scripts d’entraînement et de fine-tuning indépendants du modèle. Lorsque c'est possible, les jetons spéciaux sont déjà enregistrés pour les modèles préentraînés fournis (par exemple, `cls_token` de [BertTokenizer](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.BertTokenizer) est déjà enregistré comme `'[CLS]'`, et celui de XLM est également enregistré comme `''`). Exemples : ```python # Let's see how to add a new classification token to GPT-2 tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2") model = GPT2Model.from_pretrained("openai-community/gpt2") special_tokens_dict = {"cls_token": ""} num_added_toks = tokenizer.add_special_tokens(special_tokens_dict) print("We have added", num_added_toks, "tokens") # Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer. model.resize_token_embeddings(len(tokenizer)) assert tokenizer.cls_token == "" ``` #### apply_chat_template[[transformers.PythonBackend.apply_chat_template]] ```python apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], tools: list[dict | Callable] | None = None, documents: list[dict[str, str]] | None = None, chat_template: str | None = None, add_generation_prompt: bool = False, continue_final_message: bool | str = False, tokenize: bool = True, sanitize_control_tokens: bool = False, padding: bool | str | PaddingStrategy = False, truncation: bool = False, max_length: int | None = None, return_tensors: str | TensorType | None = None, return_dict: bool = True, return_assistant_tokens_mask: bool = False, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L3020) **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 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 d'utilisation des outils](https://huggingface.co/docs/transformers/en/chat_extras#passing-tools) pour plus d'informations. documents (`list[dict[str, str]]`, *facultatif*) : Une liste de dictionnaires représentant des documents qui seront accessibles au modèle s'il effectue une RAG (génération augmentée par récupération). Si le modèle ne prend pas en charge la RAG, cet argument n'aura aucun effet. Nous recommandons que chaque document soit un dictionnaire contenant les clés "title" et "text". chat_template (`str`, *facultatif*) : Un modèle Jinja à utiliser pour cette conversion. Il n'est généralement pas nécessaire de passer quoi que ce soit à cet argument, car le modèle du modèle sera utilisé par défaut. add_generation_prompt (bool, *facultatif*) : Si ce paramètre est défini, un prompt contenant le ou les jetons indiquant le début d'un message d'assistant sera ajouté à la sortie formatée. Cela est utile lorsque vous souhaitez générer une réponse à partir du modèle. Notez que cet argument sera transmis au modèle de chat, et il doit donc être pris en charge par le modèle pour que cet argument ait un effet. continue_final_message (bool or str, *facultatif*) : Si cette option est définie, la conversation sera formatée de manière à ce que le dernier message de la conversation soit ouvert, sans aucun jeton 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. Si une chaîne de caractères est transmise, elle sera utilisée comme clé pour le champ à poursuivre (par ex. « reasoning_content »). 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. sanitize_control_tokens (`bool`, par défaut `False`) : Si défini, les jetons de contrôle apparaissant dans les messages, les outils, les documents ou les variables de modèle passées en tant que `**kwargs` sont encodés comme du texte ordinaire, de sorte que seuls les jetons de contrôle écrits par le modèle de discussion lui-même sont encodés en tant que jetons. Les jetons de contrôle sont les jetons spéciaux du tokeniseur, ainsi que les jetons ajoutés dans `tokenizer.chat_control_tokens`. Si cette variable n'est pas définie, les jetons de contrôle sont déduits des jetons ajoutés qui apparaissent dans le texte du modèle de discussion et les littéraux de chaîne. Seuls les jetons de contrôle entiers sont assainis, donc si le modèle de discussion assemble des chaînes de l'entrée en jetons de contrôle (comme `'<|' + message['role'] + '|>'`), ces chaînes doivent être validées séparément. Les clés de dictionnaire ne sont pas non plus assainies. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/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/v5.23.0/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. - `'np'` : Renvoie des objets `np.ndarray` de NumPy. return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un dictionnaire avec des sorties nommées. N'a aucun effet si tokenize est `False`. tokenizer_kwargs (`dict[str : Any]`, *facultatif*) : Arguments supplémentaires à passer au tokenizer. return_assistant_tokens_mask (`bool`, par défaut `False`) : Indique s'il faut retourner un masque des jetons générés par l'assistant. Pour les jetons générés par l'assistant, le masque contiendra 1. Pour les jetons utilisateur et système, le masque contiendra 0. Cette fonctionnalité n'est disponible que pour les modèles de chat qui la prennent en charge via le mot-clé `{% generation %}`. - ****kwargs** : kwargs supplémentaires à transmettre au renderer du template. Ils seront accessibles par le chat template. **Retourne :** `Union[list[int], Dict]` Une liste d’identifiants de jetons représentant 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()`. Si `return_dict` est défini, un dictionnaire de sorties du tokeniseur est renvoyé à la place. Convertit une liste de dictionnaires avec les clés `"role"` et `"content"` en une liste d'identifiants de jetons. Cette méthode est destinée à l'utilisation avec des modèles de chat et lit l'attribut chat_template du tokeniseur pour déterminer le format et les jetons de contrôle à utiliser lors de la conversion. #### batch_decode[[transformers.PythonBackend.batch_decode]] ```python batch_decode(sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2932) **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*) : Seront transmis à la méthode de décodage spécifique du modèle sous-jacent. **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`. #### decode[[transformers.PythonBackend.decode]] ```python decode(token_ids: int | list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2884) **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. kwargs (arguments supplémentaires, *facultatifs*) : Seront transmis à la méthode de décodage spécifique du modèle sous-jacent. **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 une chaîne de caractères, ou une liste de séquences en une liste de chaînes 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. Similaire à l'exécution de `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`. #### encode[[transformers.PythonBackend.encode]] ```python encode(text: TextInput | PreTokenizedInput | EncodedInput, text_pair: TextInput | PreTokenizedInput | EncodedInput | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, padding_side: str | None = None, return_tensors: str | TensorType | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2262) **Paramètres :** text (`str`, `list[str]` ou `list[int]`) : La première séquence à encoder. Il peut s'agir d'une chaîne de caractères, d'une liste de chaînes (chaîne tokenisée à l'aide de la méthode `tokenize`) ou d'une liste d'entiers (identifiants de chaînes tokenisées à l'aide de la méthode `convert_tokens_to_ids`). text_pair (`str`, `list[str]` ou `list[int]`, *facultatif*) : Deuxième séquence facultative à encoder. Il peut s'agir d'une chaîne de caractères, d'une liste de chaînes (chaîne tokenisée à l'aide de la méthode `tokenize`) ou d'une liste d'entiers (identifiants de tokens obtenus à l'aide de la méthode `convert_tokens_to_ids`). 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`. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/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/v5.23.0/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 par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `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. is_split_into_words (`bool`, *facultatif*, valeur par défaut `False`) : Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini sur `True`, le tokenizer suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et procède à sa tokenisation. Cela est utile pour la NER ou la classification de tokens. 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/v5.23.0/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. - `'np'` : Renvoie des objets `np.ndarray` de Numpy. - ****kwargs** : Transmis à la méthode `.tokenize()`. **Retourne :** `list[int]`, `torch.Tensor` ou `np.ndarray` 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. Identique à l'exécution de `self.convert_tokens_to_ids(self.tokenize(text))`. #### push_to_hub[[transformers.PythonBackend.push_to_hub]] ```python push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/hub.py#L822) **Paramètres :** repo_id (`str`) : Le nom du dépôt vers lequel vous souhaitez pousser votre tokenizer. Il doit contenir le nom de votre organisation lors d'une poussée vers une organisation donnée. commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. La valeur par défaut est `"Upload tokenizer"`. commit_description (`str`, *facultatif*) : La description du commit qui sera créé private (`bool`, *facultatif*) : Indique s'il faut rendre le dépôt privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l'organisation est privé. Cette valeur est ignorée si le dépôt existe déjà. token (`bool` ou `str`, *facultatif*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True` (par défaut), le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`) sera utilisé. revision (`str`, *facultatif*) : Branche vers laquelle pousser les fichiers téléversés. create_pr (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct. max_shard_size (`int` ou `str`, *facultatif*, valeur par défaut `"50GB"`) : Ne s'applique qu'aux modèles. Taille maximale d'un point de contrôle avant son fractionnement. Les points de contrôle fractionnés auront chacun une taille inférieure à cette valeur. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme `"5MB"`). tags (`list[str]`, *facultatif*) : Liste de tags à pousser sur le Hub. Téléversez les fichiers du tokenizer sur le 🤗 Model Hub. Exemples : ```python from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased") # Push the tokenizer to your namespace with the name "my-finetuned-bert". tokenizer.push_to_hub("my-finetuned-bert") # Push the tokenizer to an organization with the name "my-finetuned-bert". tokenizer.push_to_hub("huggingface/my-finetuned-bert") ``` #### build_inputs_with_special_tokens[[transformers.PythonBackend.build_inputs_with_special_tokens]] ```python build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L868) **Paramètres :** token_ids_0 (`list[int]`) : Liste d'identifiants auxquels les jetons spéciaux seront ajoutés. token_ids_1 (`list[int]`, *facultatif*) : Deuxième liste d'identifiants facultative pour les paires de séquences. **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 ou d'une paire de séquences en ajoutant des jetons spéciaux. Cette méthode construit dynamiquement les entrées en fonction de `special_tokens_pattern` du tokenizer : - `"none"` : aucun jeton spécial - `"cls_sep"` : [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] seq1 [SEP] - `"eos"` : seq0 [EOS] ou seq0 [EOS] seq1 [EOS] - `"bos"` : [BOS] seq0 ou [BOS] seq0 [BOS] seq1 - `"bos_eos"` : [BOS] seq0 [EOS] ou [BOS] seq0 [EOS] seq1 [EOS] - `"cls_double_sep"` : [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] [SEP] seq1 [SEP] - `"prefix_suffix"` : ` seq0 [seq1] ` (préfixe/suffixe personnalisé stocké sur le tokenizer) #### create_token_type_ids_from_sequences[[transformers.PythonBackend.create_token_type_ids_from_sequences]] ```python create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1301) **Paramètres :** token_ids_0 (`list[int]`) : Liste d'identifiants. token_ids_1 (`list[int]`, *facultatif*) : Deuxième liste d'identifiants facultative pour les paires de séquences. **Retourne :** `list[int]` Identifiants de type de jeton selon le motif configuré. Créez un masque à partir des deux séquences passées, à utiliser dans une tâche de classification de paires de séquences. Cette méthode construit dynamiquement les identifiants de type de jeton en fonction des attributs de configuration du tokeniseur : - `token_type_ids_pattern` : Motif à utiliser (« all_zeros » ou « bert_style ») - `token_type_ids_include_special_tokens` : Indique s'il faut prendre en compte les jetons spéciaux dans le calcul de la longueur Exemples : ```python # All zeros pattern (default, used by RoBERTa, BART, etc.) tokenizer.token_type_ids_pattern = "all_zeros" # Returns: [0, 0, 0, ...] for both sequences # BERT-style pattern (first sequence gets 0s, second gets 1s) tokenizer.token_type_ids_pattern = "bert_style" # Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs ``` #### get_added_vocab[[transformers.PythonBackend.get_added_vocab]] ```python get_added_vocab() ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L489) **Retourne :** `dict[str, int]` Les jetons ajoutés. Retourne les jetons ajoutés au vocabulaire sous forme d'un dictionnaire associant chaque jeton à son index. Les résultats peuvent différer de l'appel rapide, car pour l'instant nous ajoutons toujours les jetons, même s'ils sont déjà présents dans le vocabulaire. C'est un point à améliorer. #### get_special_tokens_mask[[transformers.PythonBackend.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list, token_ids_1: list | None = None, already_has_special_tokens: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L972) **Paramètres :** token_ids_0 (`list[int]`) : Liste des identifiants de la première séquence. token_ids_1 (`list[int]`, *facultatif*) : Liste des identifiants de la deuxième séquence. 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. Cette méthode construit dynamiquement le masque des jetons spéciaux en fonction de `special_tokens_pattern` du tokeniseur : - `"none"` : aucun jeton spécial (par défaut, renvoie des 0) - `"cls_sep"` : [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] seq1 [SEP] - `"eos"` : seq0 [EOS] ou seq0 [EOS] seq1 [EOS] - `"bos"` : [BOS] seq0 ou [BOS] seq0 [BOS] seq1 - `"bos_eos"` : [BOS] seq0 [EOS] ou [BOS] seq0 [EOS] seq1 [EOS] - `"cls_double_sep"` : [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] [SEP] seq1 [SEP] - `"prefix_suffix"`: ` seq0 [seq1] ` #### num_special_tokens_to_add[[transformers.PythonBackend.num_special_tokens_to_add]] ```python num_special_tokens_to_add(pair: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L603) **Paramètres :** pair (`bool`, *facultatif*, par défaut `False`) : Indique si le nombre de jetons ajoutés doit être calculé dans le cas d'une paire de séquences ou d'une séquence unique. **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.PythonBackend.prepare_for_model]] ```python prepare_for_model(ids: list[int], pair_ids: list[int] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = False, 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, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1124) **Paramètres :** ids : Identifiants d'entrée tokenisés de la première séquence. pair_ids : Identifiants d'entrée tokenisés de la deuxième séquence (facultatif). Prépare une séquence d'identifiants d'entrée afin qu'elle puisse être utilisée par le modèle. Ajoute des jetons spéciaux, tronque et remplit. #### prepare_for_tokenization[[transformers.PythonBackend.prepare_for_tokenization]] ```python prepare_for_tokenization(text: str, is_split_into_words: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L844) **Paramètres :** text (`str`) : Le texte à préparer. is_split_into_words (`bool`, *facultatif*, valeur par défaut `False`) : Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini sur `True`, le tokenizer suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et procède à sa tokenisation. Cela est utile pour la NER ou la classification de tokens. kwargs (`dict[str, Any]`, *facultatif*) : Arguments nommés à utiliser pour la tokenisation. **Retourne :** `tuple[str, dict[str, Any]]` Le texte préparé et les kwargs non utilisés. Effectue les transformations nécessaires avant la tokenization. Cette méthode doit extraire les arguments de `kwargs` et retourner également les `kwargs` restants. Nous vérifions les `kwargs` à la fin du processus d’encodage pour nous assurer que tous les arguments ont été utilisés. #### save_vocabulary[[transformers.PythonBackend.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1365) **Paramètres :** save_directory (`str`) : Le répertoire dans lequel enregistrer le vocabulaire. filename_prefix (`str`, *facultatif*) : Préfixe facultatif à ajouter au nom des fichiers enregistrés. **Retourne :** `tuple[str, ...]` Chemin des fichiers enregistrés, ou tuple vide si aucun fichier n'a été enregistré. Implémentation par défaut pour les motifs courants de sauvegarde du vocabulaire. Enregistre self.encoder/self.vocab au format JSON, éventuellement avec self.bpe_ranks en tant que fusions. Retourne un tuple vide si aucun vocabulaire n'existe. Écrasez cette méthode si votre tokenizer nécessite une logique de sauvegarde personnalisée (par exemple, des modèles SentencePiece, plusieurs fichiers de vocabulaire ou des formats de fichiers spéciaux). #### tokenize[[transformers.PythonBackend.tokenize]] ```python tokenize(text: str, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L626) **Paramètres :** text : La séquence à encoder. - ****kwargs** : Transmis à la méthode de prétraitement `prepare_for_tokenization` spécifique au modèle. **Retourne :** La liste de jetons. Convertit une chaîne de caractères en une séquence de jetons, en utilisant le tokeniseur. #### truncate_sequences[[transformers.PythonBackend.truncate_sequences]] ```python truncate_sequences(ids: list[int], pair_ids: list[int] | None = None, num_tokens_to_remove: int = 0, truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first', stride: int = 0) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1234) Tronque les séquences selon la stratégie spécifiée. ## PreTrainedTokenizerFast[[transformers.TokenizersBackend]] Le [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) dépend de la bibliothèque [tokenizers](https://huggingface.co/docs/tokenizers). Les tokenizers obtenus à partir de la bibliothèque 🤗 tokenizers peuvent être chargés très simplement dans 🤗 transformers. Consultez la page [Utiliser les tokenizers de 🤗 tokenizers](../fast_tokenizers) pour comprendre comment cela se fait. #### transformers.TokenizersBackend[[transformers.TokenizersBackend]] ```python transformers.TokenizersBackend(*args, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L87) **Paramètres :** model_max_length (`int`, *facultatif*) : La longueur maximale (en nombre de jetons) des entrées pour le modèle transformer. Lorsque le tokeniseur est chargé avec [from_pretrained()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained), cette valeur est définie sur celle stockée pour le modèle associé dans `max_model_input_sizes` (voir ci-dessus). Si aucune valeur n'est fournie, la valeur par défaut est VERY_LARGE_INTEGER (`int(1e30)`). 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. truncation_side (`str`, *facultatif*) : Le côté sur lequel le modèle doit appliquer la troncature. Doit être sélectionné parmi ['right', 'left']. La valeur par défaut est choisie à partir de l'attribut de classe du même nom. chat_template (`str`, *facultatif*) : une chaîne de modèle Jinja utilisée pour formater les listes de messages de chat. Voir https://huggingface.co/docs/transformers/chat_templating pour une description complète. model_input_names (`list[string]`, *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. bos_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant le début d'une phrase. eos_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant la fin d'une phrase. unk_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant un jeton hors vocabulaire. sep_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial séparant deux phrases différentes dans la même entrée (utilisé par BERT, par exemple). pad_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Jeton spécial utilisé pour uniformiser la taille des tableaux de jetons dans le but de créer des lots. Il sera ensuite ignoré par les mécanismes d'attention ou le calcul de la perte. cls_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant la classe de l'entrée (utilisé par BERT, par exemple). mask_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant un jeton masqué (utilisé par les objectifs de pré-entraînement de modélisation de langage masqué, comme BERT). Sera associé à `self.mask_token` et `self.mask_token_id`. extra_special_tokens (liste de `str` ou `tokenizers.AddedToken`, *facultatif*) : une liste de jetons spéciaux supplémentaires spécifiques au modèle. Ajoutez-les ici pour vous assurer qu’ils sont ignorés lors du décodage lorsque `skip_special_tokens` est défini sur True. S’ils ne font pas partie du vocabulaire, ils seront ajoutés à la fin du vocabulaire. split_special_tokens (`bool`, *facultatif*, par défaut `False`) : Indique si les jetons spéciaux doivent être fractionnés lors du processus de tokenisation. La transmission de cette valeur affecte l'état interne du tokenizer. Le comportement par défaut est de ne pas fractionner les jetons spéciaux. Cela signifie que si `` est le `bos_token`, alors `tokenizer.tokenize("") = ['`]. Sinon, si `split_special_tokens=True`, alors `tokenizer.tokenize("")` renverra `['<','s', '>']`. tokenizer_object (`tokenizers.Tokenizer`) : un objet `tokenizers.Tokenizer` de 🤗 tokenizers à partir duquel instancier. Voir [Utiliser des tokenizers de 🤗 tokenizers](../fast_tokenizers) pour plus d'informations. tokenizer_file (`str`) : Un chemin vers un fichier JSON local représentant un objet `tokenizers.Tokenizer` précédemment sérialisé de 🤗 tokenizers. Classe de base pour tous les tokenizers rapides (encapsulant la bibliothèque HuggingFace tokenizers). Hérite de [PreTrainedTokenizerBase](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase). Gère toutes les méthodes partagées pour la tokenisation et les jetons spéciaux, ainsi que les méthodes de téléchargement/mise en cache/chargement des tokeniseurs pré-entraînés, et l’ajout de jetons au vocabulaire. Cette classe contient également les jetons ajoutés de manière unifiée au-dessus de tous les tokenizers, afin de ne pas avoir à gérer les méthodes spécifiques d'augmentation du vocabulaire des différentes structures de dictionnaire sous-jacentes (BPE, sentencepiece...). Attributs de classe (réécrits par les classes dérivées) - **vocab_files_names** (`dict[str, str]`) -- Un dictionnaire dont les clés sont les noms des mots-clés de `__init__` de chaque fichier de vocabulaire requis par le modèle, et dont les valeurs associées sont les noms de fichiers pour l’enregistrement du fichier correspondant (chaîne de caractères). - **pretrained_vocab_files_map** (`dict[str, dict[str, str]]`) -- Un dictionnaire de dictionnaires, dont les clés de haut niveau sont les noms de mots-clés `__init__` de chaque fichier de vocabulaire requis par le modèle, et les clés de bas niveau sont les `short-cut-names` des modèles pré-entraînés, avec, en valeurs associées, l'`url` du fichier de vocabulaire pré-entraîné correspondant. - **model_input_names** (`list[str]`) -- Une liste des entrées attendues lors de la passe avant du modèle. - **padding_side** (`str`) -- Valeur par défaut du côté sur lequel le modèle doit appliquer le bourrage. Doit être `'right'` ou `'left'`. - **truncation_side** (`str`) -- La valeur par défaut pour le côté sur lequel le modèle doit appliquer la troncature. Doit être `'right'` ou `'left'`. #### __appel__[[transformers.TokenizersBackend.__call__]] ```python __call__(text: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, text_pair_target: TextInput | PreTokenizedInput | list[TextInput] | list[PreTokenizedInput] | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, is_split_into_words: bool = False, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | 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_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2448) **Paramètres :** text (`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 les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l'ambiguïté avec un lot de séquences). text_pair (`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 les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l'ambiguïté avec un lot de séquences). text_target (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l’ambiguïté avec un lot de séquences). text_pair_target (`str`, `list[str]`, `list[list[str]]`, *facultatif*) : La séquence ou le lot de séquences à encoder en tant que textes cibles. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si les séquences sont fournies sous forme de liste de chaînes de caractères (pré-tokenisées), vous devez définir `is_split_into_words=True` (pour lever l’ambiguïté avec un lot de séquences). tokenizer_kwargs (`dict[str, Any]`, *facultatif*) : kwargs supplémentaires à passer au tokenizer. Ils seront fusionnés avec les paramètres explicites et les autres kwargs, les paramètres explicites ayant la priorité. 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`. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/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/v5.23.0/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 par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `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. is_split_into_words (`bool`, *facultatif*, valeur par défaut `False`) : Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini sur `True`, le tokenizer suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et procède à sa tokenisation. Cela est utile pour la NER ou la classification de tokens. 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/v5.23.0/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. - `'np'` : Renvoie des objets `np.ndarray` de Numpy. return_token_type_ids (`bool`, *facultatif*) : Indique s'il faut renvoyer les identifiants de type de jeton. Si la valeur par défaut est conservée, les identifiants de type de jeton seront renvoyés selon la valeur par défaut du tokeniseur spécifique, définie par l'attribut `return_outputs`. [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_offsets_mapping (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non retourner `(char_start, char_end)` pour chaque jeton. Cette option n'est disponible que pour les tokenizers rapides héritant de [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) ; si vous utilisez le tokenizer Python, cette méthode lèvera `NotImplementedError`. 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. - ****kwargs** : transmis à la méthode `self.tokenize()` **Retourne :** [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding) Un [BatchEncoding](/docs/transformers/v5.23.0/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) - **token_type_ids** -- Liste des identifiants de type de jeton à fournir au modèle (lorsque `return_token_type_ids=True` ou si *"token_type_ids"* est présent dans `self.model_input_names`). [Qu'est-ce que les identifiants de type de jeton ?](../glossary#token-type-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`) Méthode principale pour tokeniser et préparer pour le modèle une ou plusieurs séquences ou une ou plusieurs paires de séquences. #### add_tokens[[transformers.TokenizersBackend.add_tokens]] ```python add_tokens(new_tokens: str | AddedToken | Sequence[str | AddedToken], special_tokens: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1217) **Paramètres :** new_tokens (`str`, `tokenizers.AddedToken` ou une séquence de *str* ou `tokenizers.AddedToken`) : Les jetons ne sont ajoutés que s'ils ne figurent pas déjà dans le vocabulaire. `tokenizers.AddedToken` encapsule un jeton sous forme de chaîne de caractères afin de vous permettre de personnaliser son comportement : si ce jeton doit correspondre uniquement à un seul mot, s'il doit supprimer toutes les espaces potentielles sur le côté gauche, s'il doit supprimer toutes les espaces potentielles sur le côté droit, etc. special_tokens (`bool`, *facultatif*, par défaut `False`) : Indique si le jeton est spécial. Cela modifie principalement le comportement de normalisation. Voir les détails de `tokenizers.AddedToken` dans la bibliothèque HuggingFace tokenizers. **Retourne :** `int` Nombre de jetons ajoutés au vocabulaire. #TODO supprimer ceci d'ici ! PreTrainedTokenizerBase doit être agnostique vis-à-vis de AddedToken. Ajouter une liste de nouveaux jetons. Si les nouveaux jetons ne figurent pas dans le vocabulaire, ils sont ajoutés à la fin. Les jetons ajoutés et les jetons issus du vocabulaire de l’algorithme de tokenisation ne sont donc pas traités de la même manière. Les tokenizers rapides avec un pré-tokenizer `Metaspace` utilisant `prepend_scheme="always"` (par ex. NLLB) ajoutent `"▁"` au texte qui suit un token ajouté. Après `tokenizer.add_tokens(["abcd"])`, `"abcdgym"` est tokenizé en `["abcd", "▁gym"]` et décodé en `"abcd gym"`. Si les tokens ajoutés peuvent apparaître à l'intérieur de mots, changez le pré-tokenizer à `prepend_scheme="first"` pour que seul le début de l'entrée soit préfixé : ```python from tokenizers import pre_tokenizers pre_tokenizer = tokenizer.backend_tokenizer.pre_tokenizer tokenizer.backend_tokenizer.pre_tokenizer = pre_tokenizers.Metaspace( replacement=pre_tokenizer.replacement, prepend_scheme="first", split=pre_tokenizer.split ) ``` Exemples : ```python # Let's see how to increase the vocabulary of Bert model and tokenizer tokenizer = BertTokenizerFast.from_pretrained("google-bert/bert-base-uncased") model = BertModel.from_pretrained("google-bert/bert-base-uncased") num_added_toks = tokenizer.add_tokens(["new_tok1", "my_new-tok2"]) print("We have added", num_added_toks, "tokens") # Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer. model.resize_token_embeddings(len(tokenizer)) ``` #### add_special_tokens[[transformers.TokenizersBackend.add_special_tokens]] ```python add_special_tokens(special_tokens_dict: dict[str, str | AddedToken | Sequence[str | AddedToken]], replace_extra_special_tokens = True) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1112) **Paramètres :** special_tokens_dict (dictionnaire *str* vers *str*, `tokenizers.AddedToken` ou `Sequence[Union[str, AddedToken]]`) : les clés doivent figurer dans la liste des attributs spéciaux prédéfinis : [`bos_token`, `eos_token`, `unk_token`, `sep_token`, `pad_token`, `cls_token`, `mask_token`, `extra_special_tokens`]. Les jetons ne sont ajoutés que s’ils ne sont pas déjà présents dans le vocabulaire (vérifié en testant si le tokeniseur leur attribue l’index du `unk_token`). replace_extra_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Si `True`, la liste existante de jetons spéciaux supplémentaires sera remplacée par la liste fournie dans `special_tokens_dict`. Sinon, `extra_special_tokens` sera étendue. Dans le premier cas, les jetons ne seront PAS retirés du vocabulaire complet du tokeniseur - ils sont simplement marqués comme jetons non spéciaux. N'oubliez pas que cela n'affecte que les jetons ignorés lors du décodage, et non `added_tokens_encoder` et `added_tokens_decoder`. Cela signifie que les `extra_special_tokens` précédents restent des jetons ajoutés et ne seront pas fractionnés par le modèle. **Retourne :** `int` Nombre de jetons ajoutés au vocabulaire. Ajoute un dictionnaire de jetons spéciaux (eos, pad, cls, etc.) à l’encodeur et les associe aux attributs de classe. Si les jetons spéciaux ne figurent PAS dans le vocabulaire, ils y sont ajoutés (indexés à partir du dernier index du vocabulaire actuel). Lors de l’ajout de nouveaux jetons au vocabulaire, vous devez vous assurer de redimensionner également la matrice d’incorporation des jetons du modèle afin que sa matrice d’incorporation corresponde à celle du tokeniseur. Pour ce faire, veuillez utiliser la méthode [resize_token_embeddings()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.resize_token_embeddings). L'utilisation de `add_special_tokens` garantit que vos jetons spéciaux peuvent être utilisés de plusieurs manières : - Les jetons spéciaux peuvent être ignorés lors du décodage en utilisant `skip_special_tokens = True`. - Les jetons spéciaux sont soigneusement gérés par le tokeniseur (ils ne sont jamais fractionnés), de manière similaire à `AddedTokens`. - Vous pouvez facilement faire référence aux jetons spéciaux à l’aide des attributs de la classe tokenizer, comme `tokenizer.cls_token`. Cela facilite le développement de scripts d’entraînement et de fine-tuning indépendants du modèle. Lorsque c'est possible, les jetons spéciaux sont déjà enregistrés pour les modèles préentraînés fournis (par exemple, `cls_token` de [BertTokenizer](/docs/transformers/v5.23.0/fr/model_doc/lxmert#transformers.BertTokenizer) est déjà enregistré comme `'[CLS]'`, et celui de XLM est également enregistré comme `''`). Exemples : ```python # Let's see how to add a new classification token to GPT-2 tokenizer = GPT2Tokenizer.from_pretrained("openai-community/gpt2") model = GPT2Model.from_pretrained("openai-community/gpt2") special_tokens_dict = {"cls_token": ""} num_added_toks = tokenizer.add_special_tokens(special_tokens_dict) print("We have added", num_added_toks, "tokens") # Notice: resize_token_embeddings expect to receive the full size of the new vocabulary, i.e., the length of the tokenizer. model.resize_token_embeddings(len(tokenizer)) assert tokenizer.cls_token == "" ``` #### apply_chat_template[[transformers.TokenizersBackend.apply_chat_template]] ```python apply_chat_template(conversation: list[dict[str, str]] | list[list[dict[str, str]]], tools: list[dict | Callable] | None = None, documents: list[dict[str, str]] | None = None, chat_template: str | None = None, add_generation_prompt: bool = False, continue_final_message: bool | str = False, tokenize: bool = True, sanitize_control_tokens: bool = False, padding: bool | str | PaddingStrategy = False, truncation: bool = False, max_length: int | None = None, return_tensors: str | TensorType | None = None, return_dict: bool = True, return_assistant_tokens_mask: bool = False, tokenizer_kwargs: dict[str, Any] | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L3020) **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 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 d'utilisation des outils](https://huggingface.co/docs/transformers/en/chat_extras#passing-tools) pour plus d'informations. documents (`list[dict[str, str]]`, *facultatif*) : Une liste de dictionnaires représentant des documents qui seront accessibles au modèle s'il effectue une RAG (génération augmentée par récupération). Si le modèle ne prend pas en charge la RAG, cet argument n'aura aucun effet. Nous recommandons que chaque document soit un dictionnaire contenant les clés "title" et "text". chat_template (`str`, *facultatif*) : Un modèle Jinja à utiliser pour cette conversion. Il n'est généralement pas nécessaire de passer quoi que ce soit à cet argument, car le modèle du modèle sera utilisé par défaut. add_generation_prompt (bool, *facultatif*) : Si ce paramètre est défini, un prompt contenant le ou les jetons indiquant le début d'un message d'assistant sera ajouté à la sortie formatée. Cela est utile lorsque vous souhaitez générer une réponse à partir du modèle. Notez que cet argument sera transmis au modèle de chat, et il doit donc être pris en charge par le modèle pour que cet argument ait un effet. continue_final_message (bool or str, *facultatif*) : Si cette option est définie, la conversation sera formatée de manière à ce que le dernier message de la conversation soit ouvert, sans aucun jeton 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. Si une chaîne de caractères est transmise, elle sera utilisée comme clé pour le champ à poursuivre (par ex. « reasoning_content »). 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. sanitize_control_tokens (`bool`, par défaut `False`) : Si défini, les jetons de contrôle apparaissant dans les messages, les outils, les documents ou les variables de modèle passées en tant que `**kwargs` sont encodés comme du texte ordinaire, de sorte que seuls les jetons de contrôle écrits par le modèle de discussion lui-même sont encodés en tant que jetons. Les jetons de contrôle sont les jetons spéciaux du tokeniseur, ainsi que les jetons ajoutés dans `tokenizer.chat_control_tokens`. Si cette variable n'est pas définie, les jetons de contrôle sont déduits des jetons ajoutés qui apparaissent dans le texte du modèle de discussion et les littéraux de chaîne. Seuls les jetons de contrôle entiers sont assainis, donc si le modèle de discussion assemble des chaînes de l'entrée en jetons de contrôle (comme `'<|' + message['role'] + '|>'`), ces chaînes doivent être validées séparément. Les clés de dictionnaire ne sont pas non plus assainies. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/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/v5.23.0/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. - `'np'` : Renvoie des objets `np.ndarray` de NumPy. return_dict (`bool`, par défaut `True`) : Indique s'il faut retourner un dictionnaire avec des sorties nommées. N'a aucun effet si tokenize est `False`. tokenizer_kwargs (`dict[str : Any]`, *facultatif*) : Arguments supplémentaires à passer au tokenizer. return_assistant_tokens_mask (`bool`, par défaut `False`) : Indique s'il faut retourner un masque des jetons générés par l'assistant. Pour les jetons générés par l'assistant, le masque contiendra 1. Pour les jetons utilisateur et système, le masque contiendra 0. Cette fonctionnalité n'est disponible que pour les modèles de chat qui la prennent en charge via le mot-clé `{% generation %}`. - ****kwargs** : kwargs supplémentaires à transmettre au renderer du template. Ils seront accessibles par le chat template. **Retourne :** `Union[list[int], Dict]` Une liste d’identifiants de jetons représentant 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()`. Si `return_dict` est défini, un dictionnaire de sorties du tokeniseur est renvoyé à la place. Convertit une liste de dictionnaires avec les clés `"role"` et `"content"` en une liste d'identifiants de jetons. Cette méthode est destinée à l'utilisation avec des modèles de chat et lit l'attribut chat_template du tokeniseur pour déterminer le format et les jetons de contrôle à utiliser lors de la conversion. #### batch_decode[[transformers.TokenizersBackend.batch_decode]] ```python batch_decode(sequences: list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, clean_up_tokenization_spaces: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2932) **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*) : Seront transmis à la méthode de décodage spécifique du modèle sous-jacent. **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`. #### decode[[transformers.TokenizersBackend.decode]] ```python decode(token_ids: int | list[int] | list[list[int]] | np.ndarray | torch.Tensor, skip_special_tokens: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2884) **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. kwargs (arguments supplémentaires, *facultatifs*) : Seront transmis à la méthode de décodage spécifique du modèle sous-jacent. **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 une chaîne de caractères, ou une liste de séquences en une liste de chaînes 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. Similaire à l'exécution de `self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))`. #### encode[[transformers.TokenizersBackend.encode]] ```python encode(text: TextInput | PreTokenizedInput | EncodedInput, text_pair: TextInput | PreTokenizedInput | EncodedInput | None = None, add_special_tokens: bool = True, padding: bool | str | PaddingStrategy = False, truncation: bool | str | TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, padding_side: str | None = None, return_tensors: str | TensorType | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2262) **Paramètres :** text (`str`, `list[str]` ou `list[int]`) : La première séquence à encoder. Il peut s'agir d'une chaîne de caractères, d'une liste de chaînes (chaîne tokenisée à l'aide de la méthode `tokenize`) ou d'une liste d'entiers (identifiants de chaînes tokenisées à l'aide de la méthode `convert_tokens_to_ids`). text_pair (`str`, `list[str]` ou `list[int]`, *facultatif*) : Deuxième séquence facultative à encoder. Il peut s'agir d'une chaîne de caractères, d'une liste de chaînes (chaîne tokenisée à l'aide de la méthode `tokenize`) ou d'une liste d'entiers (identifiants de tokens obtenus à l'aide de la méthode `convert_tokens_to_ids`). 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`. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/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/v5.23.0/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 par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela tronque jeton par jeton, en supprimant un jeton de la séquence la plus longue de la paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_first'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la première séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `'only_second'` : Tronque à une longueur maximale spécifiée par l'argument `max_length` ou à la longueur d'entrée maximale acceptable pour le modèle si cet argument n'est pas fourni. Cela ne tronque que la deuxième séquence d'une paire si une paire de séquences (ou un lot de paires) est fournie. - `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. is_split_into_words (`bool`, *facultatif*, valeur par défaut `False`) : Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini sur `True`, le tokenizer suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et procède à sa tokenisation. Cela est utile pour la NER ou la classification de tokens. 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/v5.23.0/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. - `'np'` : Renvoie des objets `np.ndarray` de Numpy. - ****kwargs** : Transmis à la méthode `.tokenize()`. **Retourne :** `list[int]`, `torch.Tensor` ou `np.ndarray` 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. Identique à l'exécution de `self.convert_tokens_to_ids(self.tokenize(text))`. #### push_to_hub[[transformers.TokenizersBackend.push_to_hub]] ```python push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/utils/hub.py#L822) **Paramètres :** repo_id (`str`) : Le nom du dépôt vers lequel vous souhaitez pousser votre tokenizer. Il doit contenir le nom de votre organisation lors d'une poussée vers une organisation donnée. commit_message (`str`, *facultatif*) : Message à commiter lors de la poussée. La valeur par défaut est `"Upload tokenizer"`. commit_description (`str`, *facultatif*) : La description du commit qui sera créé private (`bool`, *facultatif*) : Indique s'il faut rendre le dépôt privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le défaut de l'organisation est privé. Cette valeur est ignorée si le dépôt existe déjà. token (`bool` ou `str`, *facultatif*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True` (par défaut), le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`) sera utilisé. revision (`str`, *facultatif*) : Branche vers laquelle pousser les fichiers téléversés. create_pr (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut créer une PR avec les fichiers téléversés ou effectuer un commit direct. max_shard_size (`int` ou `str`, *facultatif*, valeur par défaut `"50GB"`) : Ne s'applique qu'aux modèles. Taille maximale d'un point de contrôle avant son fractionnement. Les points de contrôle fractionnés auront chacun une taille inférieure à cette valeur. S'il est exprimé sous forme de chaîne, il doit être composé de chiffres suivis d'une unité (comme `"5MB"`). tags (`list[str]`, *facultatif*) : Liste de tags à pousser sur le Hub. Téléversez les fichiers du tokenizer sur le 🤗 Model Hub. Exemples : ```python from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("google-bert/bert-base-cased") # Push the tokenizer to your namespace with the name "my-finetuned-bert". tokenizer.push_to_hub("my-finetuned-bert") # Push the tokenizer to an organization with the name "my-finetuned-bert". tokenizer.push_to_hub("huggingface/my-finetuned-bert") ``` #### convert_to_native_format[[transformers.TokenizersBackend.convert_to_native_format]] ```python convert_to_native_format(trust_remote_code = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L104) Construire un backend `tokenizers.Tokenizer` à partir des fichiers de sérialisation disponibles (tokenizer.json, modèles sentencepiece, tekken.json, vocab/merges). #### get_added_vocab[[transformers.TokenizersBackend.get_added_vocab]] ```python get_added_vocab() ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L741) **Retourne :** `dict[str, int]` Les jetons ajoutés. Retourne les jetons ajoutés au vocabulaire sous forme d'un dictionnaire associant chaque jeton à son index. #### num_special_tokens_to_add[[transformers.TokenizersBackend.num_special_tokens_to_add]] ```python num_special_tokens_to_add(pair: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L838) **Paramètres :** pair (`bool`, *facultatif*, par défaut `False`) : Indique si le nombre de jetons ajoutés doit être calculé dans le cas d'une paire de séquences ou d'une séquence unique. **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. #### save_pretrained[[transformers.TokenizersBackend.save_pretrained]] ```python save_pretrained(save_directory: str | os.PathLike, legacy_format: bool | None = None, filename_prefix: str | None = None, push_to_hub: bool = False, save_format: str | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L560) **Paramètres :** save_format (`str`, *facultatif*) : `"mistral"` pour enregistrer au format natif `tekken.json` en copiant le fichier d'origine (le fichier de vocabulaire tekken d'origine doit être disponible). Le nom est normalisé en `tekken.json` lors de l'enregistrement, et le tokenizer instancié doit toujours correspondre exactement à ce nom. `"hf"` ou `None` pour le format HuggingFace par défaut. kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires par mot-clé transmis à la méthode [push_to_hub()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub). **Retourne :** un tuple de `str` Les fichiers enregistrés. Enregistrer l'état complet du tokenizer. Étend [save_pretrained()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained) avec la prise en charge de `save_format`, pour les tokenizers convertis depuis un fichier de vocabulaire natif (par ex. `tekken.json` de Mistral). Consultez la méthode de base pour `legacy_format`, `filename_prefix` et `push_to_hub`. #### set_truncation_and_padding[[transformers.TokenizersBackend.set_truncation_and_padding]] ```python set_truncation_and_padding(padding_strategy: PaddingStrategy, truncation_strategy: TruncationStrategy, max_length: int, stride: int, pad_to_multiple_of: int | None, padding_side: str | None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L897) **Paramètres :** padding_strategy ([PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy)) : Le type de bourrage qui sera appliqué à l'entrée truncation_strategy ([TruncationStrategy](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)) : le type de troncature qui sera appliqué à l'entrée max_length (`int`) : La taille maximale d'une séquence. stride (`int`) : Pas à utiliser lors du traitement du dépassement. pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée (padding) jusqu'à un multiple de la valeur fournie. 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. Définir les stratégies de troncature et de bourrage pour les tokenizers rapides (fournis par la bibliothèque HuggingFace tokenizers) et restaurer les paramètres du tokenizer par la suite. Le tokenizer fourni n'a pas de stratégie de bourrage / troncature avant la section gérée. Si votre tokenizer avait défini une stratégie de bourrage / troncature auparavant, celle-ci sera réinitialisée à l'absence de bourrage / troncature lors de la sortie de la section gérée. #### train_new_from_iterator[[transformers.TokenizersBackend.train_new_from_iterator]] ```python train_new_from_iterator(text_iterator, vocab_size, length = None, new_special_tokens = None, special_tokens_map = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L1210) **Paramètres :** text_iterator (générateur de `list[str]`) : le corpus d'entraînement. Doit être un générateur de lots de textes, par exemple une liste de listes de textes si tout est en mémoire. vocab_size (`int`) : La taille du vocabulaire souhaité pour votre tokenizer. length (`int`, *facultatif*) : Le nombre total de séquences dans l'itérateur. Cela est utilisé pour fournir un suivi de progression significatif new_special_tokens (liste de `str` ou `AddedToken`, *facultatif*) : Une liste de nouveaux jetons spéciaux à ajouter au tokenizer que vous entraînez. special_tokens_map (`dict[str, str]`, *facultatif*) : Si vous souhaitez renommer certains des jetons spéciaux utilisés par ce tokenizer, transmettez dans cet argument un mapping du nom ancien du jeton spécial vers le nouveau nom. kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires passés au formateur par la bibliothèque 🤗 Tokenizers. **Retourne :** [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) Un nouveau tokenizer du même type que l'original, entraîné sur `text_iterator`. Entraîne un tokenizer sur un nouveau corpus avec les mêmes valeurs par défaut (en termes de jetons spéciaux ou de pipeline de tokenisation) que le tokenizer actuel. #### update_post_processor[[transformers.TokenizersBackend.update_post_processor]] ```python update_post_processor() ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L628) Met à jour le post-processeur sous-jacent avec les `bos_token` et `eos_token` actuels. ## PythonBackend[[transformers.PythonBackend]] #### transformers.PythonBackend[[transformers.PythonBackend]] ```python transformers.PythonBackend(**kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L401) **Paramètres :** model_max_length (`int`, *facultatif*) : La longueur maximale (en nombre de jetons) des entrées pour le modèle transformer. Lorsque le tokeniseur est chargé avec [from_pretrained()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained), cette valeur est définie sur celle stockée pour le modèle associé dans `max_model_input_sizes` (voir ci-dessus). Si aucune valeur n'est fournie, la valeur par défaut est VERY_LARGE_INTEGER (`int(1e30)`). 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. truncation_side (`str`, *facultatif*) : Le côté sur lequel le modèle doit appliquer la troncature. Doit être sélectionné parmi ['right', 'left']. La valeur par défaut est choisie à partir de l'attribut de classe du même nom. chat_template (`str`, *facultatif*) : une chaîne de modèle Jinja utilisée pour formater les listes de messages de chat. Voir https://huggingface.co/docs/transformers/chat_templating pour une description complète. model_input_names (`list[string]`, *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. bos_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant le début d'une phrase. eos_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant la fin d'une phrase. unk_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant un jeton hors vocabulaire. sep_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial séparant deux phrases différentes dans la même entrée (utilisé par BERT, par exemple). pad_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Jeton spécial utilisé pour uniformiser la taille des tableaux de jetons dans le but de créer des lots. Il sera ensuite ignoré par les mécanismes d'attention ou le calcul de la perte. cls_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant la classe de l'entrée (utilisé par BERT, par exemple). mask_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant un jeton masqué (utilisé par les objectifs de pré-entraînement de modélisation de langage masqué, comme BERT). Sera associé à `self.mask_token` et `self.mask_token_id`. extra_special_tokens (liste de `str` ou `tokenizers.AddedToken`, *facultatif*) : une liste de jetons spéciaux supplémentaires spécifiques au modèle. Ajoutez-les ici pour vous assurer qu’ils sont ignorés lors du décodage lorsque `skip_special_tokens` est défini sur True. S’ils ne font pas partie du vocabulaire, ils seront ajoutés à la fin du vocabulaire. split_special_tokens (`bool`, *facultatif*, par défaut `False`) : Indique si les jetons spéciaux doivent être fractionnés lors du processus de tokenisation. La transmission de cette valeur affecte l'état interne du tokenizer. Le comportement par défaut est de ne pas fractionner les jetons spéciaux. Cela signifie que si `` est le `bos_token`, alors `tokenizer.tokenize("") = ['`]. Sinon, si `split_special_tokens=True`, alors `tokenizer.tokenize("")` renverra `['<','s', '>']`. Classe de base pour tous les tokeniseurs lents. Hérite de [PreTrainedTokenizerBase](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase). Gère toutes les méthodes partagées pour la tokenisation et les jetons spéciaux, ainsi que les méthodes de téléchargement, de mise en cache et de chargement des tokeniseurs pré-entraînés, et l’ajout de jetons au vocabulaire. Cette classe contient également les jetons ajoutés de manière unifiée au-dessus de tous les tokenizers, afin de ne pas avoir à gérer les méthodes spécifiques d’augmentation du vocabulaire des différentes structures de dictionnaire sous-jacentes (BPE, sentencepiece...). Attributs de classe (réécrits par les classes dérivées) - **vocab_files_names** (`dict[str, str]`) -- Un dictionnaire dont les clés sont les noms des mots-clés de `__init__` de chaque fichier de vocabulaire requis par le modèle, et dont les valeurs associées sont les noms de fichiers pour l’enregistrement du fichier correspondant (chaîne de caractères). - **pretrained_vocab_files_map** (`dict[str, dict[str, str]]`) -- Un dictionnaire de dictionnaires, dont les clés de haut niveau sont les noms de mots-clés `__init__` de chaque fichier de vocabulaire requis par le modèle, et les clés de bas niveau sont les `short-cut-names` des modèles pré-entraînés, avec, en valeurs associées, l'`url` du fichier de vocabulaire pré-entraîné correspondant. - **model_input_names** (`list[str]`) -- Une liste des entrées attendues lors de la passe avant du modèle. - **padding_side** (`str`) -- Valeur par défaut du côté sur lequel le modèle doit appliquer le bourrage. Doit être `'right'` ou `'left'`. - **truncation_side** (`str`) -- La valeur par défaut pour le côté sur lequel le modèle doit appliquer la troncature. Doit être `'right'` ou `'left'`. #### build_inputs_with_special_tokens[[transformers.PythonBackend.build_inputs_with_special_tokens]] ```python build_inputs_with_special_tokens(token_ids_0: list[int], token_ids_1: list[int] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L868) **Paramètres :** token_ids_0 (`list[int]`) : Liste d'identifiants auxquels les jetons spéciaux seront ajoutés. token_ids_1 (`list[int]`, *facultatif*) : Deuxième liste d'identifiants facultative pour les paires de séquences. **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 ou d'une paire de séquences en ajoutant des jetons spéciaux. Cette méthode construit dynamiquement les entrées en fonction de `special_tokens_pattern` du tokenizer : - `"none"` : aucun jeton spécial - `"cls_sep"` : [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] seq1 [SEP] - `"eos"` : seq0 [EOS] ou seq0 [EOS] seq1 [EOS] - `"bos"` : [BOS] seq0 ou [BOS] seq0 [BOS] seq1 - `"bos_eos"` : [BOS] seq0 [EOS] ou [BOS] seq0 [EOS] seq1 [EOS] - `"cls_double_sep"` : [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] [SEP] seq1 [SEP] - `"prefix_suffix"` : ` seq0 [seq1] ` (préfixe/suffixe personnalisé stocké sur le tokenizer) #### create_token_type_ids_from_sequences[[transformers.PythonBackend.create_token_type_ids_from_sequences]] ```python create_token_type_ids_from_sequences(token_ids_0: list[int], token_ids_1: list[int] | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1301) **Paramètres :** token_ids_0 (`list[int]`) : Liste d'identifiants. token_ids_1 (`list[int]`, *facultatif*) : Deuxième liste d'identifiants facultative pour les paires de séquences. **Retourne :** `list[int]` Identifiants de type de jeton selon le motif configuré. Créez un masque à partir des deux séquences passées, à utiliser dans une tâche de classification de paires de séquences. Cette méthode construit dynamiquement les identifiants de type de jeton en fonction des attributs de configuration du tokeniseur : - `token_type_ids_pattern` : Motif à utiliser (« all_zeros » ou « bert_style ») - `token_type_ids_include_special_tokens` : Indique s'il faut prendre en compte les jetons spéciaux dans le calcul de la longueur Exemples : ```python # All zeros pattern (default, used by RoBERTa, BART, etc.) tokenizer.token_type_ids_pattern = "all_zeros" # Returns: [0, 0, 0, ...] for both sequences # BERT-style pattern (first sequence gets 0s, second gets 1s) tokenizer.token_type_ids_pattern = "bert_style" # Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs ``` #### get_added_vocab[[transformers.PythonBackend.get_added_vocab]] ```python get_added_vocab() ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L489) **Retourne :** `dict[str, int]` Les jetons ajoutés. Retourne les jetons ajoutés au vocabulaire sous forme d'un dictionnaire associant chaque jeton à son index. Les résultats peuvent différer de l'appel rapide, car pour l'instant nous ajoutons toujours les jetons, même s'ils sont déjà présents dans le vocabulaire. C'est un point à améliorer. #### get_special_tokens_mask[[transformers.PythonBackend.get_special_tokens_mask]] ```python get_special_tokens_mask(token_ids_0: list, token_ids_1: list | None = None, already_has_special_tokens: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L972) **Paramètres :** token_ids_0 (`list[int]`) : Liste des identifiants de la première séquence. token_ids_1 (`list[int]`, *facultatif*) : Liste des identifiants de la deuxième séquence. 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. Cette méthode construit dynamiquement le masque des jetons spéciaux en fonction de `special_tokens_pattern` du tokeniseur : - `"none"` : aucun jeton spécial (par défaut, renvoie des 0) - `"cls_sep"` : [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] seq1 [SEP] - `"eos"` : seq0 [EOS] ou seq0 [EOS] seq1 [EOS] - `"bos"` : [BOS] seq0 ou [BOS] seq0 [BOS] seq1 - `"bos_eos"` : [BOS] seq0 [EOS] ou [BOS] seq0 [EOS] seq1 [EOS] - `"cls_double_sep"` : [CLS] seq0 [SEP] ou [CLS] seq0 [SEP] [SEP] seq1 [SEP] - `"prefix_suffix"`: ` seq0 [seq1] ` #### num_special_tokens_to_add[[transformers.PythonBackend.num_special_tokens_to_add]] ```python num_special_tokens_to_add(pair: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L603) **Paramètres :** pair (`bool`, *facultatif*, par défaut `False`) : Indique si le nombre de jetons ajoutés doit être calculé dans le cas d'une paire de séquences ou d'une séquence unique. **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.PythonBackend.prepare_for_model]] ```python prepare_for_model(ids: list[int], pair_ids: list[int] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = False, 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, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1124) **Paramètres :** ids : Identifiants d'entrée tokenisés de la première séquence. pair_ids : Identifiants d'entrée tokenisés de la deuxième séquence (facultatif). Prépare une séquence d'identifiants d'entrée afin qu'elle puisse être utilisée par le modèle. Ajoute des jetons spéciaux, tronque et remplit. #### prepare_for_tokenization[[transformers.PythonBackend.prepare_for_tokenization]] ```python prepare_for_tokenization(text: str, is_split_into_words: bool = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L844) **Paramètres :** text (`str`) : Le texte à préparer. is_split_into_words (`bool`, *facultatif*, valeur par défaut `False`) : Indique si l'entrée est déjà pré-tokenisée (par exemple, découpée en mots). Si défini sur `True`, le tokenizer suppose que l'entrée est déjà découpée en mots (par exemple, en la séparant sur les espaces) et procède à sa tokenisation. Cela est utile pour la NER ou la classification de tokens. kwargs (`dict[str, Any]`, *facultatif*) : Arguments nommés à utiliser pour la tokenisation. **Retourne :** `tuple[str, dict[str, Any]]` Le texte préparé et les kwargs non utilisés. Effectue les transformations nécessaires avant la tokenization. Cette méthode doit extraire les arguments de `kwargs` et retourner également les `kwargs` restants. Nous vérifions les `kwargs` à la fin du processus d’encodage pour nous assurer que tous les arguments ont été utilisés. #### save_vocabulary[[transformers.PythonBackend.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1365) **Paramètres :** save_directory (`str`) : Le répertoire dans lequel enregistrer le vocabulaire. filename_prefix (`str`, *facultatif*) : Préfixe facultatif à ajouter au nom des fichiers enregistrés. **Retourne :** `tuple[str, ...]` Chemin des fichiers enregistrés, ou tuple vide si aucun fichier n'a été enregistré. Implémentation par défaut pour les motifs courants de sauvegarde du vocabulaire. Enregistre self.encoder/self.vocab au format JSON, éventuellement avec self.bpe_ranks en tant que fusions. Retourne un tuple vide si aucun vocabulaire n'existe. Écrasez cette méthode si votre tokenizer nécessite une logique de sauvegarde personnalisée (par exemple, des modèles SentencePiece, plusieurs fichiers de vocabulaire ou des formats de fichiers spéciaux). #### tokenize[[transformers.PythonBackend.tokenize]] ```python tokenize(text: str, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L626) **Paramètres :** text : La séquence à encoder. - ****kwargs** : Transmis à la méthode de prétraitement `prepare_for_tokenization` spécifique au modèle. **Retourne :** La liste de jetons. Convertit une chaîne de caractères en une séquence de jetons, en utilisant le tokeniseur. #### truncate_sequences[[transformers.PythonBackend.truncate_sequences]] ```python truncate_sequences(ids: list[int], pair_ids: list[int] | None = None, num_tokens_to_remove: int = 0, truncation_strategy: str | transformers.tokenization_utils_base.TruncationStrategy = 'longest_first', stride: int = 0) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_python.py#L1234) Tronque les séquences selon la stratégie spécifiée. ## TokenizersBackend[[transformers.TokenizersBackend]] #### transformers.TokenizersBackend[[transformers.TokenizersBackend]] ```python transformers.TokenizersBackend(*args, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L87) **Paramètres :** model_max_length (`int`, *facultatif*) : La longueur maximale (en nombre de jetons) des entrées pour le modèle transformer. Lorsque le tokeniseur est chargé avec [from_pretrained()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained), cette valeur est définie sur celle stockée pour le modèle associé dans `max_model_input_sizes` (voir ci-dessus). Si aucune valeur n'est fournie, la valeur par défaut est VERY_LARGE_INTEGER (`int(1e30)`). 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. truncation_side (`str`, *facultatif*) : Le côté sur lequel le modèle doit appliquer la troncature. Doit être sélectionné parmi ['right', 'left']. La valeur par défaut est choisie à partir de l'attribut de classe du même nom. chat_template (`str`, *facultatif*) : une chaîne de modèle Jinja utilisée pour formater les listes de messages de chat. Voir https://huggingface.co/docs/transformers/chat_templating pour une description complète. model_input_names (`list[string]`, *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. bos_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant le début d'une phrase. eos_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant la fin d'une phrase. unk_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant un jeton hors vocabulaire. sep_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial séparant deux phrases différentes dans la même entrée (utilisé par BERT, par exemple). pad_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Jeton spécial utilisé pour uniformiser la taille des tableaux de jetons dans le but de créer des lots. Il sera ensuite ignoré par les mécanismes d'attention ou le calcul de la perte. cls_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant la classe de l'entrée (utilisé par BERT, par exemple). mask_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant un jeton masqué (utilisé par les objectifs de pré-entraînement de modélisation de langage masqué, comme BERT). Sera associé à `self.mask_token` et `self.mask_token_id`. extra_special_tokens (liste de `str` ou `tokenizers.AddedToken`, *facultatif*) : une liste de jetons spéciaux supplémentaires spécifiques au modèle. Ajoutez-les ici pour vous assurer qu’ils sont ignorés lors du décodage lorsque `skip_special_tokens` est défini sur True. S’ils ne font pas partie du vocabulaire, ils seront ajoutés à la fin du vocabulaire. split_special_tokens (`bool`, *facultatif*, par défaut `False`) : Indique si les jetons spéciaux doivent être fractionnés lors du processus de tokenisation. La transmission de cette valeur affecte l'état interne du tokenizer. Le comportement par défaut est de ne pas fractionner les jetons spéciaux. Cela signifie que si `` est le `bos_token`, alors `tokenizer.tokenize("") = ['`]. Sinon, si `split_special_tokens=True`, alors `tokenizer.tokenize("")` renverra `['<','s', '>']`. tokenizer_object (`tokenizers.Tokenizer`) : un objet `tokenizers.Tokenizer` de 🤗 tokenizers à partir duquel instancier. Voir [Utiliser des tokenizers de 🤗 tokenizers](../fast_tokenizers) pour plus d'informations. tokenizer_file (`str`) : Un chemin vers un fichier JSON local représentant un objet `tokenizers.Tokenizer` précédemment sérialisé de 🤗 tokenizers. Classe de base pour tous les tokenizers rapides (encapsulant la bibliothèque HuggingFace tokenizers). Hérite de [PreTrainedTokenizerBase](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase). Gère toutes les méthodes partagées pour la tokenisation et les jetons spéciaux, ainsi que les méthodes de téléchargement/mise en cache/chargement des tokeniseurs pré-entraînés, et l’ajout de jetons au vocabulaire. Cette classe contient également les jetons ajoutés de manière unifiée au-dessus de tous les tokenizers, afin de ne pas avoir à gérer les méthodes spécifiques d'augmentation du vocabulaire des différentes structures de dictionnaire sous-jacentes (BPE, sentencepiece...). Attributs de classe (réécrits par les classes dérivées) - **vocab_files_names** (`dict[str, str]`) -- Un dictionnaire dont les clés sont les noms des mots-clés de `__init__` de chaque fichier de vocabulaire requis par le modèle, et dont les valeurs associées sont les noms de fichiers pour l’enregistrement du fichier correspondant (chaîne de caractères). - **pretrained_vocab_files_map** (`dict[str, dict[str, str]]`) -- Un dictionnaire de dictionnaires, dont les clés de haut niveau sont les noms de mots-clés `__init__` de chaque fichier de vocabulaire requis par le modèle, et les clés de bas niveau sont les `short-cut-names` des modèles pré-entraînés, avec, en valeurs associées, l'`url` du fichier de vocabulaire pré-entraîné correspondant. - **model_input_names** (`list[str]`) -- Une liste des entrées attendues lors de la passe avant du modèle. - **padding_side** (`str`) -- Valeur par défaut du côté sur lequel le modèle doit appliquer le bourrage. Doit être `'right'` ou `'left'`. - **truncation_side** (`str`) -- La valeur par défaut pour le côté sur lequel le modèle doit appliquer la troncature. Doit être `'right'` ou `'left'`. #### convert_to_native_format[[transformers.TokenizersBackend.convert_to_native_format]] ```python convert_to_native_format(trust_remote_code = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L104) Construire un backend `tokenizers.Tokenizer` à partir des fichiers de sérialisation disponibles (tokenizer.json, modèles sentencepiece, tekken.json, vocab/merges). #### get_added_vocab[[transformers.TokenizersBackend.get_added_vocab]] ```python get_added_vocab() ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L741) **Retourne :** `dict[str, int]` Les jetons ajoutés. Retourne les jetons ajoutés au vocabulaire sous forme d'un dictionnaire associant chaque jeton à son index. #### num_special_tokens_to_add[[transformers.TokenizersBackend.num_special_tokens_to_add]] ```python num_special_tokens_to_add(pair: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L838) **Paramètres :** pair (`bool`, *facultatif*, par défaut `False`) : Indique si le nombre de jetons ajoutés doit être calculé dans le cas d'une paire de séquences ou d'une séquence unique. **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. #### save_pretrained[[transformers.TokenizersBackend.save_pretrained]] ```python save_pretrained(save_directory: str | os.PathLike, legacy_format: bool | None = None, filename_prefix: str | None = None, push_to_hub: bool = False, save_format: str | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L560) **Paramètres :** save_format (`str`, *facultatif*) : `"mistral"` pour enregistrer au format natif `tekken.json` en copiant le fichier d'origine (le fichier de vocabulaire tekken d'origine doit être disponible). Le nom est normalisé en `tekken.json` lors de l'enregistrement, et le tokenizer instancié doit toujours correspondre exactement à ce nom. `"hf"` ou `None` pour le format HuggingFace par défaut. kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires par mot-clé transmis à la méthode [push_to_hub()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub). **Retourne :** un tuple de `str` Les fichiers enregistrés. Enregistrer l'état complet du tokenizer. Étend [save_pretrained()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained) avec la prise en charge de `save_format`, pour les tokenizers convertis depuis un fichier de vocabulaire natif (par ex. `tekken.json` de Mistral). Consultez la méthode de base pour `legacy_format`, `filename_prefix` et `push_to_hub`. #### set_truncation_and_padding[[transformers.TokenizersBackend.set_truncation_and_padding]] ```python set_truncation_and_padding(padding_strategy: PaddingStrategy, truncation_strategy: TruncationStrategy, max_length: int, stride: int, pad_to_multiple_of: int | None, padding_side: str | None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L897) **Paramètres :** padding_strategy ([PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy)) : Le type de bourrage qui sera appliqué à l'entrée truncation_strategy ([TruncationStrategy](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy)) : le type de troncature qui sera appliqué à l'entrée max_length (`int`) : La taille maximale d'une séquence. stride (`int`) : Pas à utiliser lors du traitement du dépassement. pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée (padding) jusqu'à un multiple de la valeur fournie. 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. Définir les stratégies de troncature et de bourrage pour les tokenizers rapides (fournis par la bibliothèque HuggingFace tokenizers) et restaurer les paramètres du tokenizer par la suite. Le tokenizer fourni n'a pas de stratégie de bourrage / troncature avant la section gérée. Si votre tokenizer avait défini une stratégie de bourrage / troncature auparavant, celle-ci sera réinitialisée à l'absence de bourrage / troncature lors de la sortie de la section gérée. #### train_new_from_iterator[[transformers.TokenizersBackend.train_new_from_iterator]] ```python train_new_from_iterator(text_iterator, vocab_size, length = None, new_special_tokens = None, special_tokens_map = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L1210) **Paramètres :** text_iterator (générateur de `list[str]`) : le corpus d'entraînement. Doit être un générateur de lots de textes, par exemple une liste de listes de textes si tout est en mémoire. vocab_size (`int`) : La taille du vocabulaire souhaité pour votre tokenizer. length (`int`, *facultatif*) : Le nombre total de séquences dans l'itérateur. Cela est utilisé pour fournir un suivi de progression significatif new_special_tokens (liste de `str` ou `AddedToken`, *facultatif*) : Une liste de nouveaux jetons spéciaux à ajouter au tokenizer que vous entraînez. special_tokens_map (`dict[str, str]`, *facultatif*) : Si vous souhaitez renommer certains des jetons spéciaux utilisés par ce tokenizer, transmettez dans cet argument un mapping du nom ancien du jeton spécial vers le nouveau nom. kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires passés au formateur par la bibliothèque 🤗 Tokenizers. **Retourne :** [PreTrainedTokenizerFast](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) Un nouveau tokenizer du même type que l'original, entraîné sur `text_iterator`. Entraîne un tokenizer sur un nouveau corpus avec les mêmes valeurs par défaut (en termes de jetons spéciaux ou de pipeline de tokenisation) que le tokenizer actuel. #### update_post_processor[[transformers.TokenizersBackend.update_post_processor]] ```python update_post_processor() ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_tokenizers.py#L628) Met à jour le post-processeur sous-jacent avec les `bos_token` et `eos_token` actuels. ## SentencePieceBackend[[transformers.SentencePieceBackend]] #### transformers.SentencePieceBackend[[transformers.SentencePieceBackend]] ```python transformers.SentencePieceBackend(**kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_sentencepiece.py#L45) **Paramètres :** model_max_length (`int`, *facultatif*) : La longueur maximale (en nombre de jetons) des entrées pour le modèle transformer. Lorsque le tokeniseur est chargé avec [from_pretrained()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.from_pretrained), cette valeur est définie sur celle stockée pour le modèle associé dans `max_model_input_sizes` (voir ci-dessus). Si aucune valeur n'est fournie, la valeur par défaut est VERY_LARGE_INTEGER (`int(1e30)`). 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. truncation_side (`str`, *facultatif*) : Le côté sur lequel le modèle doit appliquer la troncature. Doit être sélectionné parmi ['right', 'left']. La valeur par défaut est choisie à partir de l'attribut de classe du même nom. chat_template (`str`, *facultatif*) : une chaîne de modèle Jinja utilisée pour formater les listes de messages de chat. Voir https://huggingface.co/docs/transformers/chat_templating pour une description complète. model_input_names (`list[string]`, *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. bos_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant le début d'une phrase. eos_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant la fin d'une phrase. unk_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant un jeton hors vocabulaire. sep_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial séparant deux phrases différentes dans la même entrée (utilisé par BERT, par exemple). pad_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Jeton spécial utilisé pour uniformiser la taille des tableaux de jetons dans le but de créer des lots. Il sera ensuite ignoré par les mécanismes d'attention ou le calcul de la perte. cls_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant la classe de l'entrée (utilisé par BERT, par exemple). mask_token (`str` ou `tokenizers.AddedToken`, *facultatif*) : Un jeton spécial représentant un jeton masqué (utilisé par les objectifs de pré-entraînement de modélisation de langage masqué, comme BERT). Sera associé à `self.mask_token` et `self.mask_token_id`. extra_special_tokens (liste de `str` ou `tokenizers.AddedToken`, *facultatif*) : une liste de jetons spéciaux supplémentaires spécifiques au modèle. Ajoutez-les ici pour vous assurer qu’ils sont ignorés lors du décodage lorsque `skip_special_tokens` est défini sur True. S’ils ne font pas partie du vocabulaire, ils seront ajoutés à la fin du vocabulaire. split_special_tokens (`bool`, *facultatif*, par défaut `False`) : Indique si les jetons spéciaux doivent être fractionnés lors du processus de tokenisation. La transmission de cette valeur affecte l'état interne du tokenizer. Le comportement par défaut est de ne pas fractionner les jetons spéciaux. Cela signifie que si `` est le `bos_token`, alors `tokenizer.tokenize("") = ['`]. Sinon, si `split_special_tokens=True`, alors `tokenizer.tokenize("")` renverra `['<','s', '>']`. Classe de base pour les tokeniseurs basés sur SentencePiece qui chargent depuis des fichiers sentencepiece.model. Hérite de [PreTrainedTokenizer](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend). Gère toutes les méthodes partagées pour la tokenisation et les jetons spéciaux, ainsi que les méthodes de téléchargement, de mise en cache et de chargement des tokeniseurs pré-entraînés, et l’ajout de jetons au vocabulaire. Cette classe contient également les jetons ajoutés de manière unifiée au-dessus de tous les tokenizers, afin de ne pas avoir à gérer les méthodes spécifiques d’augmentation du vocabulaire des différentes structures de dictionnaire sous-jacentes (BPE, sentencepiece...). Attributs de classe (réécrits par les classes dérivées) - **vocab_files_names** (`dict[str, str]`) -- Un dictionnaire dont les clés sont les noms des mots-clés de `__init__` de chaque fichier de vocabulaire requis par le modèle, et dont les valeurs associées sont les noms de fichiers pour l’enregistrement du fichier correspondant (chaîne de caractères). - **pretrained_vocab_files_map** (`dict[str, dict[str, str]]`) -- Un dictionnaire de dictionnaires, dont les clés de haut niveau sont les noms de mots-clés `__init__` de chaque fichier de vocabulaire requis par le modèle, et les clés de bas niveau sont les `short-cut-names` des modèles pré-entraînés, avec, en valeurs associées, l'`url` du fichier de vocabulaire pré-entraîné correspondant. - **model_input_names** (`list[str]`) -- Une liste des entrées attendues lors de la passe avant du modèle. - **padding_side** (`str`) -- Valeur par défaut du côté sur lequel le modèle doit appliquer le bourrage. Doit être `'right'` ou `'left'`. - **truncation_side** (`str`) -- La valeur par défaut pour le côté sur lequel le modèle doit appliquer la troncature. Doit être `'right'` ou `'left'`. #### convert_tokens_to_string[[transformers.SentencePieceBackend.convert_tokens_to_string]] ```python convert_tokens_to_string(tokens: list[str]) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_sentencepiece.py#L232) Convertit une séquence de jetons (chaîne de caractères) en une seule chaîne. #### get_vocab[[transformers.SentencePieceBackend.get_vocab]] ```python get_vocab() ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_sentencepiece.py#L104) Retourne le vocabulaire sous forme de dictionnaire #### save_vocabulary[[transformers.SentencePieceBackend.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_sentencepiece.py#L237) **Paramètres :** save_directory (`str`) : Le répertoire dans lequel enregistrer le vocabulaire. filename_prefix (`str`, *facultatif*) : Préfixe facultatif à ajouter au nom des fichiers enregistrés. **Retourne :** `tuple(str)` Chemin des fichiers enregistrés. Enregistrez le vocabulaire sentencepiece (copie du fichier d'origine) dans un répertoire. ## BatchEncoding[[transformers.BatchEncoding]] #### transformers.BatchEncoding[[transformers.BatchEncoding]] ```python transformers.BatchEncoding(data: dict[str, Any] | None = None, encoding: EncodingFast | Sequence[EncodingFast] | None = None, tensor_type: None | str | TensorType = None, prepend_batch_axis: bool = False, n_sequences: int | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L200) **Paramètres :** data (`dict`, *facultatif*) : Dictionnaire de listes/tableaux/tenseurs renvoyé par les méthodes `__call__`/`encode_plus`/`batch_encode_plus` ('input_ids', 'attention_mask', etc.). encoding (`tokenizers.Encoding` ou `Sequence[tokenizers.Encoding]`, *facultatif*) : si le tokenizer est un fast tokenizer qui fournit des informations supplémentaires, telles que le mapping de l'espace des mots/caractères vers l'espace des tokens, l'instance `tokenizers.Encoding` ou la liste d'instances (pour les lots) contient ces informations. tensor_type (`Union[None, str, TensorType]`, *facultatif*) : Vous pouvez indiquer un tensor_type ici pour convertir les listes d'entiers en Tensors PyTorch/Numpy lors de l'initialisation. prepend_batch_axis (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ou non ajouter un axe de lot lors de la conversion en tenseurs (voir `tensor_type` ci-dessus). Notez que ce paramètre a un effet si le paramètre `tensor_type` est défini, *sans quoi il n'a aucun effet*. n_sequences (`Optional[int]`, *facultatif*) : Le nombre de séquences d'entrée représentées par chaque encodage (`None` pour inconnu, `1` pour une seule séquence et `2` pour une paire de séquences). Contient la sortie des méthodes [__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__), `~tokenization_utils_base.PreTrainedTokenizerBase.encode_plus` et `~tokenization_utils_base.PreTrainedTokenizerBase.batch_encode_plus` (jetons, attention_masks, etc.). Cette classe est dérivée d'un dictionnaire Python et peut être utilisée comme tel. En outre, cette classe expose des méthodes utilitaires permettant de passer de l'espace des mots/caractères à l'espace des jetons. #### char_to_token[[transformers.BatchEncoding.char_to_token]] ```python char_to_token(batch_or_char_index: int, char_index: int | None = None, sequence_index: int = 0) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L546) **Paramètres :** batch_or_char_index (`int`) : Index de la séquence dans le lot. Si le lot ne comprend qu'une seule séquence, il peut s'agir de l'index du caractère dans la séquence char_index (`int`, *facultatif*) : Si un index de lot est fourni dans *batch_or_char_index*, il peut s'agir de l'index du caractère dans la séquence. sequence_index (`int`, *facultatif*, valeur par défaut 0) : si une paire de séquences est encodée dans le lot, ce paramètre permet de spécifier à quelle séquence de la paire (0 ou 1) appartient l'index de caractère fourni. **Retourne :** `int` Index du jeton, ou None si l'index du caractère correspond à un jeton composé uniquement d'espaces et que les espaces sont supprimés avec `trim_offsets=True`. Obtenir l'index du jeton dans la sortie encodée qui comprend un caractère de la chaîne d'origine pour une séquence du lot. Peut être appelé de la manière suivante : - `self.char_to_token(char_index)` si la taille du lot est de 1 - `self.char_to_token(batch_index, char_index)` si la taille du lot est supérieure ou égale à 1 Cette méthode est particulièrement adaptée lorsque les séquences d’entrée sont fournies sous forme de séquences pré-tokenisées (c’est-à-dire que les mots sont définis par l’utilisateur). Dans ce cas, elle permet d’associer facilement les jetons encodés aux mots tokenisés fournis. #### char_to_word[[transformers.BatchEncoding.char_to_word]] ```python char_to_word(batch_or_char_index: int, char_index: int | None = None, sequence_index: int = 0) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L631) **Paramètres :** batch_or_char_index (`int`) : Index de la séquence dans le lot. Si le lot ne contient qu'une seule séquence, il peut s'agir de l'index du caractère dans la chaîne d'origine. char_index (`int`, *facultatif*) : Si un index de lot est fourni dans *batch_or_char_index*, il peut s'agir de l'index du caractère dans la chaîne d'origine. sequence_index (`int`, *facultatif*, valeur par défaut 0) : si une paire de séquences est encodée dans le lot, ce paramètre permet de spécifier à quelle séquence de la paire (0 ou 1) appartient l'index de caractère fourni. **Retourne :** `int` Index du mot contenant le caractère. Obtenir le mot de la chaîne d'origine correspondant à un caractère de la chaîne d'origine d'une séquence du lot. Peut être appelé de la manière suivante : - `self.char_to_word(char_index)` si la taille du lot est de 1 - `self.char_to_word(batch_index, char_index)` si la taille du lot est supérieure à 1 Cette méthode est particulièrement adaptée lorsque les séquences d’entrée sont fournies sous forme de séquences pré-tokenisées (c’est-à-dire que les mots sont définis par l’utilisateur). Dans ce cas, elle permet d’associer facilement les jetons encodés aux mots tokenisés fournis. #### convert_to_tensors[[transformers.BatchEncoding.convert_to_tensors]] ```python convert_to_tensors(tensor_type: str | TensorType | None = None, prepend_batch_axis: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L670) **Paramètres :** tensor_type (`str` ou [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Le type de tenseurs à utiliser. Si `str`, doit être l'une des valeurs de l'enum [TensorType](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.TensorType). Si `None`, aucune modification n'est effectuée. prepend_batch_axis (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ajouter la dimension de lot lors de la conversion. Convertir le contenu interne en tenseurs. #### sequence_ids[[transformers.BatchEncoding.sequence_ids]] ```python sequence_ids(batch_index: int = 0) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L340) **Paramètres :** batch_index (`int`, *facultatif*, valeur par défaut 0) : L'indice à accéder dans le lot. **Retourne :** `list[Optional[int]]` Une liste indiquant l'identifiant de séquence correspondant à chaque jeton. Les jetons spéciaux ajoutés par le tokeniseur sont mappés sur `None` et les autres jetons sont mappés sur l'index de leur séquence correspondante. Retourne une liste associant les jetons à l'identifiant de leurs phrases d'origine : - `None` pour les jetons spéciaux ajoutés autour ou entre les séquences, - `0` pour les jetons correspondant aux mots de la première séquence, - `1` pour les jetons correspondant aux mots de la deuxième séquence lorsqu'une paire de séquences a été encodée conjointement. #### vers[[transformers.BatchEncoding.to]] ```python to(device: str | torch.device | int, non_blocking: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L764) **Paramètres :** device (`str` ou `torch.device` ou `int`) : L'appareil sur lequel placer les tenseurs. non_blocking (`bool`) : Indique s'il faut effectuer la copie de manière asynchrone. **Retourne :** [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding) La même instance après modification. Envoyez toutes les valeurs vers l'appareil en appelant `v.to(device, non_blocking=non_blocking)` (PyTorch uniquement). #### token_to_chars[[transformers.BatchEncoding.token_to_chars]] ```python token_to_chars(batch_or_token_index: int, token_index: int | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L507) **Paramètres :** batch_or_token_index (`int`) : Index de la séquence dans le lot. Si le lot ne comprend qu'une seule séquence, il peut s'agir de l'index du jeton dans la séquence. token_index (`int`, *facultatif*) : Si un index de lot est fourni dans *batch_or_token_index*, il peut s'agir de l'index du ou des jetons dans la séquence. **Retourne :** [CharSpan](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.CharSpan) Portée des caractères dans la chaîne d'origine, ou None, si le jeton (par ex. , ) ne correspond à aucun caractère de la chaîne d'origine. Obtenir l'étendue de caractères correspondant à un jeton encodé dans une séquence du lot. Les portées de caractères sont renvoyées sous forme de [CharSpan](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.CharSpan) avec : - **start** -- Index du premier caractère de la chaîne d'origine associé au jeton. - **end** -- Index du caractère suivant le dernier caractère de la chaîne d'origine associée au jeton. Peut être appelé de la manière suivante : - `self.token_to_chars(token_index)` si la taille du lot est de 1 - `self.token_to_chars(batch_index, token_index)` si la taille du lot est supérieure ou égale à 1 #### token_to_sequence[[transformers.BatchEncoding.token_to_sequence]] ```python token_to_sequence(batch_or_token_index: int, token_index: int | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L377) **Paramètres :** batch_or_token_index (`int`) : Index de la séquence dans le lot. Si le lot ne comprend qu'une seule séquence, il peut s'agir de l'index du jeton dans la séquence. token_index (`int`, *facultatif*) : Si un index de lot est fourni dans *batch_or_token_index*, il peut s’agir de l’index du jeton dans la séquence. **Retourne :** `int` Index de la séquence d'entrée contenant le jeton (`0` pour la première séquence ou `1` pour la deuxième séquence d'une paire). Obtient l'index de la séquence représentée par le jeton donné. Dans le cas d'utilisation général, cette méthode renvoie `0` pour une séquence unique ou la première séquence d'une paire, et `1` pour la deuxième séquence d'une paire Peut être appelé de la manière suivante : - `self.token_to_sequence(token_index)` si la taille du lot est de 1 - `self.token_to_sequence(batch_index, token_index)` si la taille du lot est supérieure à 1 Cette méthode est particulièrement adaptée lorsque les séquences d’entrée sont fournies sous forme de séquences pré-tokenisées (c’est-à-dire que les mots sont définis par l’utilisateur). Dans ce cas, elle permet d’associer facilement les jetons encodés aux mots tokenisés fournis. #### token_to_word[[transformers.BatchEncoding.token_to_word]] ```python token_to_word(batch_or_token_index: int, token_index: int | None = None) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L416) **Paramètres :** batch_or_token_index (`int`) : Index de la séquence dans le lot. Si le lot ne comprend qu'une seule séquence, il peut s'agir de l'index du jeton dans la séquence. token_index (`int`, *facultatif*) : Si un index de lot est fourni dans *batch_or_token_index*, il peut s’agir de l’index du jeton dans la séquence. **Retourne :** `int` Index du mot dans la séquence d'entrée. Obtenir l'index du mot correspondant (c'est-à-dire contenant) à un jeton encodé dans une séquence du lot. Peut être appelé de la manière suivante : - `self.token_to_word(token_index)` si la taille du lot est de 1 - `self.token_to_word(batch_index, token_index)` si la taille du lot est supérieure à 1 Cette méthode est particulièrement adaptée lorsque les séquences d’entrée sont fournies sous forme de séquences pré-tokenisées (c’est-à-dire que les mots sont définis par l’utilisateur). Dans ce cas, elle permet d’associer facilement les jetons encodés aux mots tokenisés fournis. #### tokens[[transformers.BatchEncoding.tokens]] ```python tokens(batch_index: int = 0) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L325) **Paramètres :** batch_index (`int`, *facultatif*, valeur par défaut 0) : L'indice à accéder dans le lot. **Retourne :** `list[str]` La liste de jetons à cet index. Retourne la liste des jetons (sous-parties des chaînes d’entrée après le fractionnement en mots/sous-mots et avant la conversion en indices entiers) à un index de lot donné (fonctionne uniquement pour la sortie d’un tokeniseur rapide). #### word_ids[[transformers.BatchEncoding.word_ids]] ```python word_ids(batch_index: int = 0) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L361) **Paramètres :** batch_index (`int`, *facultatif*, valeur par défaut 0) : L'indice à accéder dans le lot. **Retourne :** `list[Optional[int]]` Une liste indiquant le mot correspondant à chaque jeton. Les jetons spéciaux ajoutés par le tokeniseur sont mappés sur `None` et les autres jetons sont mappés sur l'index de leur mot correspondant (plusieurs jetons seront mappés sur le même index de mot s'ils en sont des parties). Retourne une liste associant les jetons à leur mot réel dans la phrase initiale pour un tokenizer rapide. #### word_to_chars[[transformers.BatchEncoding.word_to_chars]] ```python word_to_chars(batch_or_word_index: int, word_index: int | None = None, sequence_index: int = 0) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L586) **Paramètres :** batch_or_word_index (`int`) : Index de la séquence dans le lot. Si le lot ne comprend qu'une seule séquence, il peut s'agir de l'index du mot dans la séquence word_index (`int`, *facultatif*) : si un index de lot est fourni dans *batch_or_word_index*, il peut s'agir de l'index du mot dans la séquence. sequence_index (`int`, *facultatif*, valeur par défaut 0) : si une paire de séquences est encodée dans le lot, ce paramètre permet de spécifier à quelle séquence de la paire (0 ou 1) appartient l'index de mot fourni. **Retourne :** `CharSpan` Portée du ou des caractères associés dans la chaîne. CharSpan est un NamedTuple avec : - start : index du premier caractère associé au mot dans la chaîne d'origine - end : index du caractère suivant le dernier caractère associé au mot dans la chaîne d'origine Obtenir l'étendue de caractères dans la chaîne d'origine correspondant au mot donné dans une séquence du lot. Les portées de caractères sont renvoyées sous forme de NamedTuple CharSpan avec : - start : index du premier caractère dans la chaîne d'origine - end : index du caractère suivant le dernier caractère de la chaîne d'origine Peut être appelé de la manière suivante : - `self.word_to_chars(word_index)` si la taille du lot est de 1 - `self.word_to_chars(batch_index, word_index)` si la taille du lot est supérieure ou égale à 1 #### word_to_tokens[[transformers.BatchEncoding.word_to_tokens]] ```python word_to_tokens(batch_or_word_index: int, word_index: int | None = None, sequence_index: int = 0) ``` [Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L454) **Paramètres :** batch_or_word_index (`int`) : Index de la séquence dans le lot. Si le lot ne comprend qu'une seule séquence, il peut s'agir de l'index du mot dans la séquence. word_index (`int`, *facultatif*) : si un index de lot est fourni dans *batch_or_word_index*, il peut s'agir de l'index du mot dans la séquence. sequence_index (`int`, *facultatif*, valeur par défaut 0) : si une paire de séquences est encodée dans le lot, ce paramètre permet de spécifier à quelle séquence de la paire (0 ou 1) appartient l'index de mot fourni. **Retourne :** ([TokenSpan](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.TokenSpan), *optionnel*) Portée des jetons dans la séquence encodée. Retourne `None` si aucun jeton ne correspond au mot. Cela peut se produire en particulier lorsque le jeton est un jeton spécial utilisé pour formater la tokenisation. Par exemple, lorsque nous ajoutons un jeton de classe au tout début de la tokenisation. Obtenir l'étendue de jetons encodés correspondant à un mot dans une séquence du lot. Les plages de jetons sont renvoyées sous forme de [TokenSpan](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.TokenSpan) avec : - **start** -- Index du premier jeton. - **end** -- Index du jeton suivant le dernier jeton. Peut être appelé de la manière suivante : - `self.word_to_tokens(word_index, sequence_index: int = 0)` si la taille du lot est de 1 - `self.word_to_tokens(batch_index, word_index, sequence_index: int = 0)` si la taille du lot est supérieure ou égale à 1 Cette méthode est particulièrement adaptée lorsque les séquences d’entrée sont fournies sous forme de séquences pré-tokenisées (c’est-à-dire que les mots sont définis par l’utilisateur). Dans ce cas, elle permet d’associer facilement les jetons encodés aux mots tokenisés fournis.