Découpage de jeton

Les modèles de langage ont des limites de jetons. Il ne faut pas dépasser la limite de jetons. Par conséquent, lors du découpage du texte en morceaux, il est préférable de calculer le nombre de jetons. Il existe de nombreux processeurs de jetons (tokenizers) disponibles. Lors du calcul du nombre de jetons dans le texte, le même processeur de jetons utilisé dans le modèle de langage doit être utilisé.

Ce chapitre présente comment LangChain utilise divers tokeniseurs de jetons pour découper le contenu du texte en fonction des jetons.

tiktoken

tiktoken est un tokenizeur BPE rapide open source développé par OpenAI.

Nous pouvons l'utiliser pour estimer le nombre de jetons utilisés. Il peut être plus précis pour les modèles OpenAI.

  1. Comment le texte est découpé : selon les caractères d'entrée.
  2. Comment la taille des morceaux est mesurée : en utilisant le tokenizer tiktoken.
%pip install --upgrade --quiet langchain-text-splitters tiktoken

with open("../../../state_of_the_union.txt") as f:
    state_of_the_union = f.read()
	
from langchain_text_splitters import CharacterTextSplitter

text_splitter = CharacterTextSplitter.from_tiktoken_encoder(
    chunk_size=100, chunk_overlap=0
)
texts = text_splitter.split_text(state_of_the_union)

print(texts[0])

Madame la Présidente, Madame la Vice-Présidente, notre Première Dame et Second Gentleman. Membres du Congrès et du Cabinet. Juges de la Cour Suprême. Mes chers compatriotes américains.

L'année dernière, la COVID-19 nous a séparés. Cette année, nous sommes enfin réunis.

Ce soir, nous nous retrouvons en tant que démocrates, républicains et indépendants. Mais surtout en tant qu'Américains.

Avec un devoir envers nous-mêmes, envers le peuple américain, envers la Constitution.

Nous pouvons également charger directement le découpeur tiktoken.

from langchain_text_splitters import TokenTextSplitter

text_splitter = TokenTextSplitter(chunk_size=10, chunk_overlap=0)

texts = text_splitter.split_text(state_of_the_union)
print(texts[0])

spaCy

spaCy est une bibliothèque de logiciels open source pour le traitement avancé du langage naturel écrite en Python et Cython.

Une autre alternative à l'utilisation de NLTK est d'utiliser le tokeniseur spaCy.

  1. Comment le texte est découpé : en utilisant le tokeniseur spaCy.
  2. Comment la taille des morceaux est mesurée : en comptant le nombre de caractères.
with open("../../../state_of_the_union.txt") as f:
    state_of_the_union = f.read()

from langchain_text_splitters import SpacyTextSplitter

text_splitter = SpacyTextSplitter(chunk_size=1000)

texts = text_splitter.split_text(state_of_the_union)
print(texts[0])

SentenceTransformers

SentenceTransformersTokenTextSplitter est un découpeur de texte conçu spécifiquement pour le modèle sentence-transformer. Son comportement par défaut est de découper le texte en blocs de taille de fenêtre de jetons adaptée au modèle sentence-transformer souhaité.

from langchain_text_splitters import SentenceTransformersTokenTextSplitter

splitter = SentenceTransformersTokenTextSplitter(chunk_overlap=0)
text = "Lorem "

count_start_and_stop_tokens = 2
text_token_count = splitter.count_tokens(text=text) - count_start_and_stop_tokens
print(text_token_count)

2

token_multiplier = splitter.maximum_tokens_per_chunk // text_token_count + 1

text_to_split = text * token_multiplier

print(f"jetons dans le texte à découper : {splitter.count_tokens(text=text_to_split)}")

jetons dans le texte à découper : 514

text_chunks = splitter.split_text(text=text_to_split)

print(text_chunks[1])

lorem

NLTK

Le kit d'outils de traitement du langage naturel, plus communément appelé NLTK, est un ensemble de bibliothèques et de programmes pour le traitement symbolique et statistique du langage naturel (NLP) écrit en langage de programmation Python, utilisé pour l'anglais.

Au lieu de simplement diviser le texte en se basant sur "\n\n", nous pouvons utiliser NLTK pour diviser en fonction du tokeniseur NLTK.

  1. Méthode de division du texte : en utilisant le tokeniseur NLTK.
  2. Mesure de la taille des blocs : mesurée par le nombre de caractères.
with open("../../../state_of_the_union.txt") as f:
    state_of_the_union = f.read()

from langchain_text_splitters import NLTKTextSplitter

text_splitter = NLTKTextSplitter(chunk_size=1000)

texts = text_splitter.split_text(state_of_the_union)
print(texts[0])

Hugging Face Tokenizer

Hugging Face propose de nombreux tokeniseurs.

Nous utilisons le GPT2TokenizerFast des tokeniseurs de Hugging Face pour calculer le nombre de jetons dans le texte.

  1. Comment le texte est segmenté : segmenté en fonction des caractères d'entrée.
  2. Comment la taille des blocs est calculée : mesurée par le nombre de jetons calculés par le tokeniseur de Hugging Face.
from transformers import GPT2TokenizerFast

tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")

with open("../../../state_of_the_union.txt") as f:
    state_of_the_union = f.read()

from langchain_text_splitters import CharacterTextSplitter

text_splitter = CharacterTextSplitter.from_huggingface_tokenizer(
    tokenizer, chunk_size=100, chunk_overlap=0
)
texts = text_splitter.split_text(state_of_the_union)

print(texts[0])