# Utilitaires pour les tokenizers

Cette page répertorie toutes les fonctions utilitaires utilisées par les tokenizers, principalement la classe [PreTrainedTokenizerBase](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) qui implémente les méthodes communes entre [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).

La plupart de ces éléments ne sont utiles que si vous étudiez le code des tokenizers de la bibliothèque.

## PreTrainedTokenizerBase[[transformers.PreTrainedTokenizerBase]]

#### transformers.PreTrainedTokenizerBase[[transformers.PreTrainedTokenizerBase]]

```python
transformers.PreTrainedTokenizerBase(**kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L967)

**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 `<s>` est le `bos_token`, alors `tokenizer.tokenize("<s>") = ['<s>`]. Sinon, si `split_special_tokens=True`, alors `tokenizer.tokenize("<s>")` renverra `['<','s', '>']`.

Classe de base pour tous les backends de tokenizers.

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.PreTrainedTokenizerBase.__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_special_tokens[[transformers.PreTrainedTokenizerBase.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 `'</s>'`).

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": "<CLS>"}

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 == "<CLS>"
```

#### add_tokens[[transformers.PreTrainedTokenizerBase.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))
```

#### apply_chat_template[[transformers.PreTrainedTokenizerBase.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.PreTrainedTokenizerBase.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`.

#### clean_up_tokenization[[transformers.PreTrainedTokenizerBase.clean_up_tokenization]]

```python
clean_up_tokenization(text: str)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2203)

Nettoyer les espaces de tokenisation dans un texte donné. Cette méthode est principalement destinée à la prise en charge du code distant.

#### convert_ids_to_tokens[[transformers.PreTrainedTokenizerBase.convert_ids_to_tokens]]

```python
convert_ids_to_tokens(ids: int | list[int], skip_special_tokens: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1498)

**Paramètres :**

ids (`int` ou `list[int]`) : L'identifiant de jeton (ou les identifiants de jetons) à convertir en jetons.

skip_special_tokens (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut supprimer les jetons spéciaux lors du décodage.

**Retourne :** `str` ou `list[str]`

Le(s) jeton(s) décodé(s).

Convertit un index unique ou une séquence d’indices en un jeton ou une séquence de jetons, en utilisant le vocabulaire et les jetons ajoutés.

#### convert_tokens_to_ids[[transformers.PreTrainedTokenizerBase.convert_tokens_to_ids]]

```python
convert_tokens_to_ids(tokens: str | list[str])
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1482)

**Paramètres :**

tokens (`str` ou `list[str]`) : Un ou plusieurs jeton(s) à convertir en identifiant(s) de jeton.

**Retourne :** `int` ou `list[int]`

L'identifiant du jeton ou la liste des identifiants de jetons.

Convertit une chaîne de jetons (ou une séquence de jetons) en un identifiant entier unique (ou une séquence d'identifiants), en utilisant le vocabulaire.

#### convert_tokens_to_string[[transformers.PreTrainedTokenizerBase.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_base.py#L2871)

**Paramètres :**

tokens (`list[str]`) : Le jeton à concaténer dans une chaîne.

**Retourne :** `str`

Les jetons fusionnés.

Convertit une séquence de jetons en une seule chaîne de caractères. La méthode la plus simple est `" ".join(tokens)`, mais nous souhaitons souvent supprimer en même temps les artefacts de la tokenisation sous-mot.

#### decode[[transformers.PreTrainedTokenizerBase.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.PreTrainedTokenizerBase.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))`.

#### encode_message_with_chat_template[[transformers.PreTrainedTokenizerBase.encode_message_with_chat_template]]

```python
encode_message_with_chat_template(message: dict[str, str], conversation_history: list[dict[str, str]] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L3259)

**Paramètres :**

message (`dict`) : Un dictionnaire avec les clés "role" et "content", représentant le message à tokeniser.

conversation_history (`list[dict]`, *facultatif*) : une liste de dictionnaires avec les clés « role » et « content », représentant l’historique de la conversation jusqu’à présent. Si vous tokenisez les messages un par un, vous devez passer ici les messages précédents de la conversation.

- ****kwargs** : Autres arguments à passer à la méthode `apply_chat_template`.

**Retourne :** `list[int]`

Une liste d'identifiants de jetons représentant le message tokenisé.

Tokenise un message unique. Cette méthode est un wrapper pratique autour de `apply_chat_template` qui permet de tokeniser les messages un par un. Cela est utile pour des tâches telles que le streaming token par token. Cette méthode n’est pas garantie d’être parfaite. Pour certains modèles, il peut être impossible de tokeniser de manière robuste des messages uniques. Par exemple, si le chat template ajoute des tokens après chaque message, mais possède également un préfixe ajouté à l’ensemble de la conversation, il sera impossible de distinguer un chat-start-token d’un message-start-token. Dans ces cas, cette méthode fera de son mieux pour trouver la tokenisation correcte, mais elle peut ne pas être parfaite. **Remarque :** Cette méthode ne prend pas en charge `add_generation_prompt`. Si vous souhaitez ajouter un prompt de génération, vous devez le faire séparément après avoir tokenisé la conversation.

#### from_pretrained[[transformers.PreTrainedTokenizerBase.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike, *init_inputs, cache_dir: str | os.PathLike | None = None, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', trust_remote_code = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1514)

**Paramètres :**

pretrained_model_name_or_path (`str` ou `os.PathLike`) : Peut être :  - Une chaîne de caractères, l'*identifiant de modèle* d'un tokeniseur prédéfini hébergé dans un dépôt de modèles sur huggingface.co. - Un chemin vers un *dossier* contenant les fichiers de vocabulaire requis par le tokeniseur, par exemple sauvegardés à l'aide de la méthode [save_pretrained()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained), par ex. `./my_model_directory/`. - (**Déprécié**, ne s'applique pas à toutes les classes dérivées) un chemin vers un fichier de vocabulaire unique sauvegardé (si et seulement si le tokeniseur n'a besoin que d'un seul fichier de vocabulaire, comme Bert ou XLNet), par ex. `./my_model_directory/vocab.txt`.

cache_dir (`str` ou `os.PathLike`, *facultatif*) : Chemin vers un répertoire dans lequel les fichiers de vocabulaire de tokeniseur prédéfinis téléchargés doivent être mis en cache si le cache standard ne doit pas être utilisé.

force_download (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut forcer le (re-)téléchargement des fichiers de vocabulaire et remplacer les versions en cache si elles existent.

proxies (`dict[str, str]`, *facultatif*) : Un dictionnaire de serveurs proxy à utiliser par protocole ou point de terminaison, par exemple `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Les proxys sont utilisés pour chaque requête.

token (`str` ou *bool*, *facultatif*) : Jeton à utiliser comme autorisation HTTP bearer pour les fichiers distants. Si `True`, utilise le jeton généré lors de l'exécution de `hf auth login` (stocké dans `~/.huggingface`).

local_files_only (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut s'appuyer uniquement sur les fichiers locaux et ne pas tenter de télécharger de fichiers.

revision (`str`, *facultatif*, valeur par défaut `"main"`) : La version spécifique du modèle à utiliser. Il peut s'agir d'un nom de branche, d'un nom de tag ou d'un identifiant de commit, car nous utilisons un système basé sur git pour stocker les modèles et autres artefacts sur huggingface.co, de sorte que `revision` peut être n'importe quel identifiant autorisé par git.

subfolder (`str`, *facultatif*) : Si les fichiers pertinents se trouvent dans un sous-dossier du dépôt de modèle sur huggingface.co (par exemple pour facebook/rag-token-base), spécifiez-le ici.

inputs (arguments positionnels supplémentaires, *facultatifs*) : Seront transmis à la méthode `__init__` du Tokenizer.

trust_remote_code (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut autoriser les modèles personnalisés définis sur le Hub dans leurs propres fichiers de modélisation. Cette option ne doit être définie sur `True` que pour les dépôts de confiance dont vous avez lu le code, car cela exécutera le code présent sur le Hub sur votre machine locale.

kwargs (arguments supplémentaires, *facultatifs*) : Seront transmis à la méthode `__init__` du Tokenizer. Permet de définir des jetons spéciaux tels que `bos_token`, `eos_token`, `unk_token`, `sep_token`, `pad_token`, `cls_token`, `mask_token`, `extra_special_tokens`. Consultez les paramètres de `__init__` pour plus de détails.

Instanciez un [PreTrainedTokenizerBase](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase) (ou une classe dérivée) à partir d'un tokenizer prédéfini.

Passer `token=True` est obligatoire lorsque vous souhaitez utiliser un modèle privé.

Exemples :

```python
# We can't instantiate directly the base class *PreTrainedTokenizerBase* so let's show our examples on a derived class: BertTokenizer
# Download vocabulary from huggingface.co and cache.
tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")

# Download vocabulary from huggingface.co (user-uploaded) and cache.
tokenizer = BertTokenizer.from_pretrained("dbmdz/bert-base-german-cased")

# If vocabulary files are in a directory (e.g. tokenizer was saved using *save_pretrained('./test/saved_model/')*)
tokenizer = BertTokenizer.from_pretrained("./test/saved_model/")

# If the tokenizer uses a single vocabulary file, you can point directly to this file
tokenizer = BertTokenizer.from_pretrained("./test/saved_model/my_vocab.txt")

# You can link tokens to special vocabulary when instantiating
tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased", unk_token="<unk>")
# You should be sure '<unk>' is in the vocabulary when doing that.
# Otherwise use tokenizer.add_special_tokens({'unk_token': '<unk>'}) instead)
assert tokenizer.unk_token == "<unk>"
```

#### get_chat_template[[transformers.PreTrainedTokenizerBase.get_chat_template]]

```python
get_chat_template(chat_template: str | None = None, tools: list[dict] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L3319)

**Paramètres :**

chat_template (`str`, *facultatif*) : Un modèle Jinja ou le nom d'un modèle à 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.

tools (`list[Dict]`, *facultatif*) : Une liste d'outils (fonctions appelables) qui seront accessibles au modèle. Si le gabarit ne prend pas en charge l'appel de fonctions, cet argument n'aura aucun effet. Chaque outil doit être transmis sous forme de schéma JSON, indiquant le nom, la description et les types d'arguments de l'outil. Consultez notre [guide sur les gabarits de chat](https://huggingface.co/docs/transformers/main/en/chat_templating#automated-function-conversion-for-tool-use) pour plus d'informations.

**Retourne :** `str`

La chaîne de caractères du modèle de discussion.

Récupère la chaîne de gabarit de conversation utilisée pour la tokenisation des messages de chat. Ce gabarit est utilisé en interne par la méthode `apply_chat_template` et peut également être utilisé en externe pour récupérer le gabarit de conversation du modèle afin de mieux suivre la génération.

#### get_response_parser[[transformers.PreTrainedTokenizerBase.get_response_parser]]

```python
get_response_parser(response_template: dict | None = None, prefix: str | list[int] | np.ndarray | torch.Tensor | None = None, tools: list[dict | Callable] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L3516)

Retourne un `ResponseParser` avec état pour l’analyse incrémentale d’une réponse diffusée en continu. Utilise l’attribut `response_template` du tokeniseur, sauf en cas de remplacement.

`prefix` (une chaîne de caractères, une liste d’identifiants de jetons ou un tenseur 1D) est obligatoire : le flux est initialisé dans l’état implicite du contexte de la conversation (tronqué à droite au-delà de l’`start_anchor` de la spécification), de sorte que les fragments générés fournis via `stream.feed()` sont classés correctement, même lorsque le modèle de conversation a émis du contenu de tour d’assistant (par ex. `<think>\n`) que le modèle poursuit. S’il est omis, une exception est levée ; si le flux démarre réellement d’un tour d’assistant propre, passez `prefix=""` pour désactiver ce comportement.

`tools` (`list[Union[Dict, Callable]]`, *facultatif*) : outils disponibles pour le modèle, au même format que celui accepté par `apply_chat_template`. Lorsqu’ils sont définis, les arguments d’appel d’outil sont convertis en utilisant le schéma JSON de l’outil appelé à la fermeture de chaque région, de sorte que les événements de streaming `region_close` contiennent des arguments typés.

#### get_special_tokens_mask[[transformers.PreTrainedTokenizerBase.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list[int], token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1337)

**Paramètres :**

token_ids_0 : Liste des identifiants de la séquence (éventuellement déjà formatée).

token_ids_1 : Non utilisé lorsque `already_has_special_tokens=True`. Doit être None dans ce cas.

already_has_special_tokens : Indique si la séquence est déjà formatée avec des jetons spéciaux.

**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érer les identifiants de séquences à partir d'une liste de jetons à laquelle aucun jeton spécial n'a été ajouté.

Pour les tokenizers rapides, les data collators appellent cette fonction avec `already_has_special_tokens=True` afin de construire un masque sur une séquence déjà formatée. Dans ce cas, nous calculons le masque en vérifiant l’appartenance à `all_special_ids`.

#### get_vocab[[transformers.PreTrainedTokenizerBase.get_vocab]]

```python
get_vocab()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L1470)

**Retourne :** `dict[str, int]`

Le vocabulaire.

Retourne le vocabulaire sous forme de dictionnaire associant chaque jeton à son index.

`tokenizer.get_vocab()[token]` est équivalent à `tokenizer.convert_tokens_to_ids(token)` lorsque `token` est présent dans le vocabulaire.

#### pad[[transformers.PreTrainedTokenizerBase.pad]]

```python
pad(encoded_inputs: BatchEncoding | list[BatchEncoding] | dict[str, EncodedInput] | dict[str, list[EncodedInput]] | list[dict[str, EncodedInput]], padding: bool | str | PaddingStrategy = True, max_length: int | None = None, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_attention_mask: bool | None = None, return_tensors: str | TensorType | None = None, verbose: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2599)

**Paramètres :**

encoded_inputs ([BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding), liste de [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding), `dict[str, list[int]]`, `dict[str, list[list[int]]` ou `list[dict[str, list[int]]]`) : Entrées tokenisées. Peut représenter une seule entrée ([BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding) ou `dict[str, list[int]]`) ou un lot d'entrées tokenisées (liste de [BatchEncoding](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.BatchEncoding), *dict[str, list[list[int]]]* ou *list[dict[str, list[int]]]*), ce qui permet d'utiliser cette méthode aussi bien lors de la prétraitement que dans une fonction de collation de PyTorch Dataloader. À la place de `list[int]`, vous pouvez avoir des tenseurs (tableaux numpy ou tenseurs PyTorch), voir la note ci-dessus pour le type de retour.

padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/v5.23.0/fr/internal/file_utils#transformers.utils.PaddingStrategy), *facultatif*, par défaut `True`) : 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'` (par défaut) : 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'` : Aucun padding (c'est-à-dire, peut renvoyer un lot avec des séquences de longueurs différentes).

max_length (`int`, *facultatif*) : Longueur maximale de la liste renvoyée et, le cas échéant, longueur du bourrage (voir ci-dessus).

pad_to_multiple_of (`int`, *facultatif*) : Si défini, la séquence sera rembourdée 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.

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

verbose (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut afficher plus d'informations et d'avertissements.

Rembourrer une entrée encodée unique ou un lot d’entrées encodées jusqu’à une longueur prédéfinie ou jusqu’à la longueur de séquence maximale du lot.

Les identifiants de jetons de bourrage (côté gauche/droite) sont définis au niveau du tokeniseur (avec `self.padding_side`, `self.pad_token_id` et `self.pad_token_type_id`).

Veuillez noter qu’avec un tokenizer rapide, l’utilisation de la méthode `__call__` est plus rapide que l’utilisation d’une méthode pour encoder le texte suivie d’un appel à la méthode `pad` pour obtenir un encodage avec bourrage.

Si les `encoded_inputs` transmis sont un dictionnaire de tableaux numpy ou des tenseurs PyTorch, le résultat utilisera le même type, sauf si vous spécifiez un type de tenseur différent avec `return_tensors`. Dans le cas des tenseurs PyTorch, vous perdrez toutefois l’appareil spécifique de vos tenseurs.

#### parse_response[[transformers.PreTrainedTokenizerBase.parse_response]]

```python
parse_response(response: str | list[int] | list[str] | list[list[int]] | np.ndarray | torch.Tensor, schema: dict | None = None, prefix: str | list[int] | list[str] | list[list[int]] | np.ndarray | torch.Tensor | None = None, tools: list[dict | Callable] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L3431)

**Paramètres :**

response (`str`, identifiants de jetons, tenseur 1D/2D ou une liste de ces éléments) : La sortie générée par le modèle. Soit du texte décodé, soit des identifiants de jetons, sous forme d'une séquence unique (`str` / `list[int]` / tableau 1D / tenseur 1D) ou d'un lot (`list[str]` / `list[list[int]]` / tableau 2D / tenseur 2D). Notez que cette valeur doit contenir uniquement la sortie du modèle, et non le texte du prompt précédent (qui se trouve dans `prefix`).

schema (`dict`, *facultatif*) : Un modèle de réponse qui indique le format de sortie attendu et la manière dont l'analyse doit être effectuée. S'il n'est pas fourni, l'attribut `response_template` du tokenizer sera utilisé.

prefix (`str`, identifiants de jetons, tenseur 1D/2D, ou une liste de ces éléments) : le prompt qui précédait la génération. Cela est nécessaire car de nombreux modèles de chat pré-écrivent une partie du message, il faut donc voir le prompt pour l’analyser correctement. Pour une `response` par lot, passez soit un préfixe unique (diffusé à chaque élément), soit un préfixe par élément.

tools (`list[Union[Dict, Callable]]`, *facultatif*) : Outils disponibles pour le modèle, dans le même format que celui accepté par `apply_chat_template`. Lorsqu’ils sont transmis, les arguments d’appel d’outil sont convertis en utilisant le schéma JSON de l’outil appelé : `"7"` devient `7` pour un paramètre entier, mais reste `"7"` pour un paramètre de type chaîne.

**Retourne :**

Un message analysé sous forme de `dict` pour une séquence unique, ou une `list` de tels dicts pour un lot.

Convertit une chaîne de sortie créée par la génération de texte à partir d'un modèle en un dictionnaire de message analysé. Cette méthode est destinée à être utilisée avec des modèles de chat et lit l'attribut `response_template` du tokenizer pour contrôler l'analyse, sauf si un argument `schema` est passé directement.

Accepte soit une séquence unique, soit un lot. Une séquence unique (une chaîne de caractères, ou une séquence 1D d’identifiants de jetons) renvoie un `dict` de message analysé ; un lot (une liste de chaînes de caractères, une liste de séquences d’identifiants de jetons, ou un tenseur / tableau 2D) renvoie une `list` de dictionnaires de messages analysés, un par élément.

#### push_to_hub[[transformers.PreTrainedTokenizerBase.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")
```

#### register_for_auto_class[[transformers.PreTrainedTokenizerBase.register_for_auto_class]]

```python
register_for_auto_class(auto_class = 'AutoTokenizer')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L3000)

**Paramètres :**

auto_class (`str` ou `type`, *facultatif*, valeur par défaut `"AutoTokenizer"`) : La classe auto avec laquelle enregistrer ce nouveau tokenizer.

Enregistrez cette classe avec une classe auto donnée. Cette méthode ne doit être utilisée que pour les tokenizers personnalisés, car ceux de la bibliothèque sont déjà mappés avec `AutoTokenizer`.

#### save_chat_templates[[transformers.PreTrainedTokenizerBase.save_chat_templates]]

```python
save_chat_templates(save_directory: str | os.PathLike, tokenizer_config: dict, filename_prefix: str | None, save_jinja_files: bool)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L3373)

Écrit les gabarits de discussion dans le répertoire de sauvegarde si nous utilisons le nouveau format, et les supprime de la configuration du tokenizer s'ils y sont présents. Si nous utilisons le format hérité, il n'écrit aucun fichier et écrit à la place les gabarits dans la configuration du tokenizer au format approprié.

#### save_pretrained[[transformers.PreTrainedTokenizerBase.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, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2005)

**Paramètres :**

save_directory (`str` ou `os.PathLike`) : Le chemin vers un répertoire où le tokenizer sera enregistré.

legacy_format (`bool`, *facultatif*) : Ne s'applique qu'aux tokenizers rapides. Si non défini (par défaut), le tokenizer est enregistré au format JSON unifié ainsi qu'au format legacy s'il existe, c'est-à-dire avec le vocabulaire spécifique au tokenizer et un fichier added_tokens séparé. Si `False`, le tokenizer n'est enregistré qu'au format JSON unifié. Ce format est incompatible avec les tokenizers « lents » (non basés sur la bibliothèque *tokenizers*), de sorte que le tokenizer ne pourra pas être chargé dans le tokenizer « lent » correspondant. Si `True`, le tokenizer est enregistré au format legacy. Si le tokenizer « lent » n'existe pas, une value error est levée.

filename_prefix (`str`, *facultatif*) : Un préfixe à ajouter aux noms des fichiers enregistrés par le tokenizer.

push_to_hub (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut ou non publier votre modèle sur le Hugging Face model hub après l'avoir enregistré. Vous pouvez spécifier le dépôt de destination avec `repo_id` (par défaut, il s'agit du nom de `save_directory` dans votre espace de noms).

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.

Cette méthode s’assure que le tokenizer complet peut ensuite être rechargé à l’aide de la méthode de classe `~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`.

Warning,None Cela n'enregistrera pas les modifications que vous avez pu apporter au tokenizer après l'instantiation (par exemple, la modification de `tokenizer.do_lower_case` après la création).

#### save_vocabulary[[transformers.PreTrainedTokenizerBase.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_base.py#L2224)

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

Enregistrer uniquement le vocabulaire du tokenizer (vocabulaire + jetons ajoutés).

Cette méthode n'enregistre pas la configuration ni les correspondances des jetons spéciaux du tokenizer. Utilisez `_save_pretrained()` pour enregistrer l'état complet du tokenizer.

#### tokenize[[transformers.PreTrainedTokenizerBase.tokenize]]

```python
tokenize(text: str, pair: str | None = None, add_special_tokens: bool = False, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L2242)

**Paramètres :**

text (`str`) : La séquence à encoder.

pair (`str`, *facultatif*) : Une seconde séquence à encoder avec la première.

add_special_tokens (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ajouter les jetons spéciaux associés au modèle correspondant.

kwargs (arguments supplémentaires, *facultatifs*) : Seront transmis à la méthode d'encodage spécifique du modèle sous-jacent. Voir les détails dans [__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)

**Retourne :** `list[str]`

La liste de jetons.

Convertit une chaîne de caractères en une séquence de jetons, en remplaçant les jetons inconnus par `unk_token`.

## Énumérations et namedtuples[[transformers.tokenization_utils_base.TruncationStrategy]]

#### transformers.tokenization_utils_base.TruncationStrategy[[transformers.tokenization_utils_base.TruncationStrategy]]

```python
transformers.tokenization_utils_base.TruncationStrategy(value, names = None, module = None, qualname = None, type = None, start = 1, boundary = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L159)

Valeurs possibles pour l'argument `truncation` dans [PreTrainedTokenizerBase.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__). Utile pour l'achèvement automatique dans un IDE.

#### transformers.CharSpan[[transformers.CharSpan]]

```python
transformers.CharSpan(start: ForwardRef('int'), end: ForwardRef('int'))
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L171)

**Paramètres :**

start (`int`) : Index du premier caractère dans la chaîne d'origine.

end (`int`) : Index du caractère suivant le dernier caractère de la chaîne d'origine.

Portée des caractères dans la chaîne d'origine.

#### transformers.TokenSpan[[transformers.TokenSpan]]

```python
transformers.TokenSpan(start: ForwardRef('int'), end: ForwardRef('int'))
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/tokenization_utils_base.py#L184)

**Paramètres :**

start (`int`) : Index du premier jeton de la portée.

end (`int`) : Index du jeton suivant le dernier jeton de la portée.

Portée du jeton dans une chaîne encodée (liste de jetons).

