# Personnalisation des tokenizers

Les Tokenizers sont découplés de leurs vocabulaires appris. Cela vous permet d'initialiser un tokenizer vide pour l'entraînement ou d'en créer un directement avec votre propre vocabulaire. Le pipeline de tokenisation sous-jacent reste le même (normaliseur, pré-tokeniseur, algorithme de tokenisation), vous n'avez donc pas besoin de le recréer de zéro.

Ce guide montre comment entraîner et créer un tokeniseur personnalisé.

> [!AgentPrompt]
> Aidez l'utilisateur à choisir comment créer ou adapter un tokenizer Transformers. Commencez par déterminer s'il doit entraîner un nouveau vocabulaire, définir un vocabulaire personnalisé ou modifier le pipeline de tokenisation. Utilisez ce guide pour sélectionner l'approche correspondante.
>
> 1. Demander la langue ou le domaine, la source et la taille du corpus, le tokenizer de départ, la taille de vocabulaire souhaitée, le modèle cible et l’usage prévu. Poser des questions complémentaires uniquement si les détails manquants influencent le choix, et formuler clairement les hypothèses. 2. Choisir le flux de travail adapté. Pour ajouter des jetons à un tokenizer existant, utiliser `add_tokens` pour les jetons réguliers ou `add_special_tokens` s’ils nécessitent un comportement de jeton spécial. Si des jetons sont ajoutés à un tokenizer associé à un modèle, redimensionner les embeddings de jetons du modèle avec `resize_token_embeddings(len(tokenizer))`. Pour un nouveau vocabulaire qui conserve le pipeline d’un tokenizer existant, utiliser `train_new_from_iterator` avec des lots de texte représentatifs. Pour un vocabulaire et des règles de fusion fournis, vérifier si le tokenizer prend en charge ces entrées. N’utiliser un backend personnalisé que si le pipeline existant ne peut pas exprimer le comportement requis. 3. Vérifier la compatibilité avec le modèle cible. Un nouveau vocabulaire peut modifier les identifiants de jetons, il ne faut donc pas supposer qu’il correspond aux embeddings d’un modèle pré-entraîné. Expliquer si le modèle nécessite des embeddings correspondants ou une formation supplémentaire. 4. Valider le résultat. Enregistrer puis recharger le tokenizer, puis tester l’encodage et le décodage sur un texte de domaine représentatif et des jetons spéciaux. Signaler les fichiers créés, le tokenizer de départ, la taille du vocabulaire, les résultats des tests et les questions de compatibilité non résolues.

## Entraîner un tokenizer

Un tokenizer entraînable vide remplace le vocabulaire par un nouveau vocabulaire cible. Cela est utile pour s'adapter à un nouveau domaine comme la finance, une langue à faibles ressources, ou le code.

Créez un tokenizer vide et chargez un jeu de données.

```py
from datasets import load_dataset
from transformers import GemmaTokenizer

tokenizer = GemmaTokenizer()
dataset = load_dataset("Josephgflowers/Finance-Instruct-500k", split="train")
```

Utilisez la méthode [TokenizersBackend.train_new_from_iterator()](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend.train_new_from_iterator) pour entraîner le tokeniseur. Cette méthode accepte une fonction génératrice pour retourner des blocs de texte depuis le jeu de données, au lieu de tout charger en mémoire d'un coup. L'argument `vocab_size` définit la taille du vocabulaire des tokeniseurs.

```py
def batch_iterator(batch_size=1000):
    for i in range(0, len(dataset), batch_size):
        yield dataset[i : i + batch_size]["assistant"]

trained_tokenizer = tokenizer.train_new_from_iterator(
    batch_iterator(),
    vocab_size=32000,
)
encoded = trained_tokenizer("The stock market rallied today.")
print(encoded["input_ids"])
[5866, 11503, 98, 5885, 8617, 13381, 30]
```

Ajoutez de nouveaux jetons spéciaux avec l’argument `new_special_tokens` ou utilisez `special_tokens_map` pour renommer les anciens jetons spéciaux en nouveaux jetons spéciaux.

Enregistrez le nouveau finance tokenizer avec [save_pretrained()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.save_pretrained) ou enregistrez-le et téléchargez-le sur le Hub avec [push_to_hub()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub). Cela crée un fichier `tokenizer.json` qui capture le vocabulaire nouvellement entraîné, les règles de fusion et la configuration complète du pipeline.

```py
trained_tokenizer.save_pretrained("./finance-gemma-tokenizer")
trained_tokenizer.push_to_hub("finance-gemma-tokenizer")
```

## Vocabulaire personnalisé

Un tokenizer vide prend en charge un vocabulaire personnalisé grâce aux arguments `vocab` et `merges`.

- `vocab` est l'ensemble complet des jetons que le tokeniseur connaît et chaque entrée associe un jeton à son identifiant d'entrée.
- `merges` définit la manière dont l'algorithme BPE doit combiner les jetons adjacents.

```py
from transformers import GemmaTokenizer

vocab={
    "<pad>": 0,
    "</s>": 1,
    "<s>": 2,
    "<unk>": 3,
    "<mask>": 4,
    "▁the": 5,
    "▁stock": 6,
    "▁market": 7,
    "▁": 8,
    "r": 9,
    "a": 10,
    "l": 11,
    "i": 12,
    "e": 13,
    "d": 14,
    "ra": 15,
    "li": 16,
    "lie": 17,
    "lied": 18,
    "ral": 19,
    "ralli": 20,
    "rallie": 21,
    "rallied": 22,
}
merges=[
    ("r", "a"),       # r + a → ra
    ("l", "i"),       # l + i → li
    ("li", "e"),      # li + e → lie
    ("lie", "d"),     # lie + d → lied
    ("ra", "l"),      # ra + l → ral
    ("ral", "li"),    # ral + li → ralli
    ("ralli", "e"),   # ralli + e → rallie
    ("rallie", "d"),  # rallie + d → rallied
]

tokenizer = GemmaTokenizer(vocab=vocab, merges=merges)
encoded = tokenizer("the stock market rallied")
print(encoded["input_ids"])
```

## Sous-classer TokenizersBackend

Tokenizers prend en charge quatre [backends](./fast_tokenizers#backends) différents. En général, vous devez utiliser [TokenizersBackend](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) pour définir un nouveau tokenizer, car il est plus rapide.

> [!TIP]
> Le [PythonBackend](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend) est un tokeniseur en Python pur qui ne s’appuie pas sur des backends tels que Rust, SentencePiece ou mistral-common. Vous ne devriez utiliser [PythonBackend](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.PythonBackend) que si vous développez un tokeniseur très spécialisé qui ne peut pas être exprimé par le backend Rust.

1. Sous-classez [TokenizersBackend](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) avec des attributs de classe tels que le côté de bourrage et l'algorithme de tokenisation à utiliser.
2. Définissez le pipeline de tokenisation dans le `__init__`. Cela inclut l'algorithme de tokenisation à utiliser, la manière de découper le texte brut avant l'algorithme, et la manière de décoder les jetons pour revenir au texte.

```py
from tokenizers import Tokenizer, decoders, pre_tokenizers
from tokenizers.models import BPE
from transformers import TokenizersBackend

class NewTokenizer(TokenizersBackend):
    padding_side = "left"
    model = BPE

    def __init__(
        self,
        vocab=None,
        merges=None,
        unk_token="<unk>",
        bos_token="<s>",
        eos_token="</s>",
        pad_token="<pad>",
    ):
        self._vocab = vocab or {
            str(unk_token): 0,
            str(bos_token): 1,
            str(eos_token): 2,
            str(pad_token): 3,
        }
        self._merges = merges or []

        self._tokenizer = Tokenizer(
            BPE(vocab=self._vocab, merges=self._merges, fuse_unk=True)
        )
        self._tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=False)
        self._tokenizer.decoder = decoders.ByteLevel()

        super().__init__(
            unk_token=unk_token,
            bos_token=bos_token,
            eos_token=eos_token,
            pad_token=pad_token,
        )
```

Entraînez ou enregistrez le nouveau tokenizer vide.

```py
tokenizer = NewTokenizer()

# train on new corpus
corpus = ["The stock market rallied today.", "Bond yields fell sharply."]
trained_tokenizer = tokenizer.train_new_from_iterator(corpus, vocab_size=32000)
# save tokenizer
trained_tokenizer.save_pretrained("./new-tokenizer")
```

