Transformers documentation

Personalización de tokenizadores

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Personalización de tokenizadores

Los tokenizers están desacoplados de sus vocabularios aprendidos. Esto permite inicializar un tokenizer vacío para el entrenamiento o crear uno directamente con su propio vocabulario. El pipeline de tokenización subyacente permanece igual (normalizador, pretokenizador, algoritmo de tokenización), por lo que no es necesario recrearlo desde cero.

Esta guía muestra cómo entrenar y crear un tokenizador personalizado.

Agent prompt

Ayuda al usuario a elegir cómo crear o adaptar un tokenizador de Transformers. Primero, averigua si necesita entrenar un nuevo vocabulario, definir un vocabulario personalizado o modificar el pipeline de tokenización. Usa esta guía para elegir el enfoque adecuado.

  1. Pide el idioma o dominio, la fuente y el tamaño del corpus, el tokenizador inicial, el tamaño de vocabulario deseado, el modelo previsto y el uso previsto. Haz preguntas de seguimiento solo cuando los detalles faltantes afecten la elección, y etiqueta tus suposiciones.
  2. Elija el flujo de trabajo correspondiente. Para agregar tokens a un tokenizador existente, use add_tokens para tokens regulares o add_special_tokens cuando necesiten el comportamiento de token especial. Si agrega tokens a un tokenizador emparejado con un modelo, redimensione las incrustaciones de tokens del modelo con resize_token_embeddings(len(tokenizer)). Para un vocabulario nuevo que mantenga un pipeline de tokenizador existente, use train_new_from_iterator con lotes de texto representativos. Para un vocabulario y reglas de fusión proporcionados, verifique si el tokenizador admite esas entradas. Use un backend personalizado solo cuando el pipeline existente no pueda expresar el comportamiento requerido.
  3. Compruebe la compatibilidad con el modelo previsto. Un vocabulario nuevo puede cambiar los IDs de tokens, por lo que no asuma que coincide con las incrustaciones de un modelo preentrenado. Explique si el modelo necesita incrustaciones coincidentes o un entrenamiento adicional.
  4. Valide el resultado. Guarde y recargue el tokenizador, luego pruebe la codificación y decodificación con texto representativo del dominio y tokens especiales. Informe los archivos creados, el tokenizador inicial, el tamaño del vocabulario, los resultados de las pruebas y las preguntas de compatibilidad sin resolver.

Entrenar un tokenizador

Un tokenizador entrenable vacío reemplaza el vocabulario con un nuevo vocabulario objetivo. Esto resulta útil para adaptarse a un nuevo dominio, como finanzas, un idioma con pocos recursos o código.

Cree un tokenizador vacío y cargue un conjunto de datos.

from datasets import load_dataset
from transformers import GemmaTokenizer

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

Use el método TokenizersBackend.train_new_from_iterator() para entrenar el tokenizador. Este método acepta una función generadora para devolver fragmentos de texto del conjunto de datos en lugar de cargar todo en la memoria a la vez. El argumento vocab_size establece el tamaño del vocabulario de los tokenizadores.

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]

Agregue nuevos tokens especiales con el argumento new_special_tokens o use special_tokens_map para renombrar los tokens especiales antiguos a los nuevos tokens especiales.

Guarde el nuevo tokenizador de finanzas con save_pretrained() o guárdelo y súbelo al Hub con push_to_hub(). Esto crea un archivo tokenizer.json que captura el vocabulario recién entrenado, las reglas de fusión y la configuración completa del pipeline.

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

Vocabulario personalizado

Un tokenizador vacío admite un vocabulario personalizado con los argumentos vocab y merges.

  • vocab es el conjunto completo de tokens que un tokenizador conoce y cada entrada asocia un token con su id de entrada.
  • merges define cómo el algoritmo BPE debe combinar tokens adyacentes.
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"])

Subclase de TokenizersBackend

Tokenizers admite cuatro backends diferentes. En general, debes usar TokenizersBackend para definir un tokenizador nuevo, ya que es más rápido.

El PythonBackend es un tokenizador en Python puro que no depende de backends como Rust, SentencePiece o mistral-common. Solo debe usar PythonBackend si está construyendo un tokenizador muy especializado que no puede expresarse con el backend de Rust.

  1. Subclase de TokenizersBackend con atributos de clase como el lado de relleno y el algoritmo de tokenización a utilizar.
  2. Defina el pipeline de tokenización en __init__. Esto incluye el algoritmo de tokenización a utilizar, cómo dividir el texto crudo antes del algoritmo y cómo decodificar los tokens de vuelta a texto.
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,
        )

Entrena o guarda el nuevo tokenizador vacío.

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")
Update on GitHub