Comment utiliser la bibliothèque Hugging Face Tokenizers pour prétraiter les données texte

Image par auteur

Si vous avez exploré le domaine du traitement du langage naturel (PNL), vous avez probablement rencontré le terme « tokenisation ». C’est une étape cruciale dans le prétraitement des données textuelles, où nous convertissons le texte en une forme compréhensible par les machines. Cela se fait en décomposant les phrases en unités plus petites appelées jetons. Ces jetons peuvent être des mots, des sous-mots ou même des caractères, selon l’algorithme de tokenisation utilisé. Dans cet article, nous allons découvrir comment utiliser la bibliothèque Hugging Face Tokenizers pour prétraiter nos données textuelles.

Configuration de la bibliothèque Hugging Face Tokenizers

Pour commencer à utiliser la bibliothèque Hugging Face Tokenizers, vous devez d’abord l’installer. Vous pouvez le faire en utilisant pip :

La bibliothèque Hugging Face prend en charge divers algorithmes de tokenisation, mais les trois principaux types sont :

• Encodage par paires d’octets (BPE) : Fusionne de manière itérative les paires de caractères ou de sous-mots les plus fréquentes, créant ainsi un vocabulaire compact. Utilisé par des modèles comme GPT-2.
• WordPiece : Semblable au BPE mais se concentre sur les fusions probabilistes, couramment utilisé par des modèles comme BERT.
• SentencePiece : Un tokenizer plus flexible qui peut gérer différents langages et scripts, souvent utilisé avec des modèles comme ALBERT, XLNet ou le framework Marian. Il traite les espaces comme des caractères plutôt que comme des séparateurs de mots.

La bibliothèque Hugging Face Transformers fournit une classe AutoTokenizer qui peut sélectionner automatiquement le meilleur tokenizer pour un modèle pré-entraîné donné. C’est un moyen pratique d’utiliser le tokenizer approprié pour un modèle spécifique et peut être importé depuis la bibliothèque transformers. Cependant, pour notre discussion sur la bibliothèque Tokenizers, nous ne suivrons pas cette approche.

Nous utiliserons le tokenizer pré-entraîné BERT-base-uncased. Ce tokenizer a été formé sur les mêmes données et en utilisant les mêmes techniques que le modèle BERT-base-uncased, ce qui signifie qu’il peut être utilisé pour prétraiter des données texte compatibles avec les modèles BERT :

# Import the necessary components

from tokenizers import Tokenizer

from transformers import BertTokenizer



# Load the pre-trained BERT-base-uncased tokenizer

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

Tokenisation d’une seule phrase

Encodons maintenant une phrase simple à l’aide de ce tokenizer :

# Tokenize a single sentence

encoded_input = tokenizer.encode_plus("This is sample text to test tokenization.")

print(encoded_input)

Sortie :

{'input_ids': [101, 2023, 2003, 7099, 3793, 2000, 3231, 19204, 3989, 1012, 102], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

Pour garantir l’exactitude, décodons l’entrée tokenisée :

tokenizer.decode(encoded_input["input_ids"])

Sortie :

[CLS] this is sample text to test tokenization. [SEP]

Dans cette sortie, vous pouvez voir deux jetons spéciaux. [CLS] marque le début de la séquence d’entrée, et [SEP] marque la fin, indiquant une seule séquence de texte.

Tokenisation par lots

Tokenisons maintenant un corpus de texte au lieu d’une seule phrase en utilisant batch_encode_plus :

corpus = [

    "Hello, how are you?",

    "I am learning how to use the Hugging Face Tokenizers library.",

    "Tokenization is a crucial step in NLP."

]

encoded_corpus = tokenizer.batch_encode_plus(corpus)

print(encoded_corpus)

Sortie :

{'input_ids': [[101, 7592, 1010, 2129, 2024, 2017, 1029, 102], [101, 1045, 2572, 4083, 2129, 2000, 2224, 1996, 17662, 2227, 19204, 17629, 2015, 3075, 1012, 102], [101, 19204, 3989, 2003, 1037, 10232, 3357, 1999, 17953, 2361, 1012, 102]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}

Pour une meilleure compréhension, décodons le corpus encodé par lots comme nous l’avons fait pour une seule phrase. Cela fournira les phrases originales, tokenisées de manière appropriée.

tokenizer.batch_decode(encoded_corpus["input_ids"])

Sortie :

['[CLS] hello, how are you? [SEP]',

 '[CLS] i am learning how to use the hugging face tokenizers library. [SEP]',

 '[CLS] tokenization is a crucial step in nlp. [SEP]']

Remplissage et troncature

Lors de la préparation des données pour des modèles d’apprentissage automatique, il est souvent nécessaire de s’assurer que toutes les séquences d’entrée ont la même longueur. Deux méthodes pour y parvenir sont :

1. Rembourrage

Le remplissage fonctionne en ajoutant le jeton spécial [PAD] à la fin des séquences les plus courtes pour correspondre à la longueur de la séquence la plus longue du lot ou à la longueur maximale prise en charge par le modèle si max_length est défini. Vous pouvez le faire en :

encoded_corpus_padded = tokenizer.batch_encode_plus(corpus, padding=True)

print(encoded_corpus_padded)

Sortie :

{'input_ids': [[101, 7592, 1010, 2129, 2024, 2017, 1029, 102, 0, 0, 0, 0, 0, 0, 0, 0], [101, 1045, 2572, 4083, 2129, 2000, 2224, 1996, 17662, 2227, 19204, 17629, 2015, 3075, 1012, 102], [101, 19204, 3989, 2003, 1037, 10232, 3357, 1999, 17953, 2361, 1012, 102, 0, 0, 0, 0]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]]}

Maintenant, vous pouvez voir que des 0 supplémentaires sont placés, mais pour une meilleure compréhension, décodons pour voir où le tokenizer a placé les jetons [PAD] :

tokenizer.batch_decode(encoded_corpus_padded["input_ids"], skip_special_tokens=False)

Sortie :

['[CLS] hello, how are you? [SEP] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD]',

 '[CLS] i am learning how to use the hugging face tokenizers library. [SEP]',

 '[CLS] tokenization is a crucial step in nlp. [SEP] [PAD] [PAD] [PAD] [PAD]']

2. Troncature

De nombreux modèles NLP ont une longueur maximale de séquence d’entrée, et la troncature fonctionne en coupant la fin de la séquence la plus longue pour respecter cette longueur maximale. Cela réduit l’utilisation de la mémoire et évite que le modèle soit submergé par de très grandes séquences d’entrée.

encoded_corpus_truncated = tokenizer.batch_encode_plus(corpus, truncation=True, max_length=5)

print(encoded_corpus_truncated)

Sortie :

{'input_ids': [[101, 7592, 1010, 2129, 102], [101, 1045, 2572, 4083, 102], [101, 19204, 3989, 2003, 102]], 'token_type_ids': [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]], 'attention_mask': [[1, 1, 1, 1, 1], [1, 1, 1, 1, 1], [1, 1, 1, 1, 1]]}

Vous pouvez également utiliser la méthode batch_decode, mais pour une meilleure compréhension, imprimons ces informations d’une manière différente :

for i, sentence in enumerate(corpus):

    print(f"Original sentence: {sentence}")

    print(f"Token IDs: {encoded_corpus_truncated['input_ids'][i]}")

    print(f"Tokens: {tokenizer.convert_ids_to_tokens(encoded_corpus_truncated['input_ids'][i])}")

    print()

Sortie :

Original sentence: Hello, how are you?

Token IDs: [101, 7592, 1010, 2129, 102]

Tokens: ['[CLS]', 'hello', ',', 'how', '[SEP]']



Original sentence: I am learning how to use the Hugging Face Tokenizers library.

Token IDs: [101, 1045, 2572, 4083, 102]

Tokens: ['[CLS]', 'i', 'am', 'learning', '[SEP]']



Original sentence: Tokenization is a crucial step in NLP.

Token IDs: [101, 19204, 3989, 2003, 102]

Tokens: ['[CLS]', 'token', '##ization', 'is', '[SEP]']

Cet article fait partie de notre série sur Hugging Face. Si vous souhaitez en savoir plus sur ce sujet, voici quelques références pour vous aider :

Source