Comment un modèle de langage lit un texte
La tokenisation découpe un texte en morceaux appelés jetons, et l’encodage par paires d’octets (BPE, byte-pair encoding) est la façon habituelle de choisir ces morceaux. Chaque phrase tapée dans un agent conversationnel est découpée ainsi avant que le modèle la voie.
Ces morceaux décident de la quantité de texte qui tient, du sort des mots rares et de ce que le modèle sait épeler.
À la fin de cette leçon
Remarque
Je peux découper un court texte en jetons par fusions de paires.
Mots-clés
| Mot | Ce que ça veut dire | Exemple |
|---|---|---|
| Jeton | un morceau de texte que le modèle traite d’un bloc | ami |
| Vocabulaire | la liste de tous les jetons que le modèle connaît | |
| Paire | deux jetons placés côte à côte | m i |
| Fusion | coller une paire pour en faire un nouveau jeton | |
| Encodage par paires | construire les jetons en fusionnant sans cesse la paire la plus fréquente | |
| Identifiant de jeton | le nombre qui remplace un jeton |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Des mots ou des caractères : deux découpages simples
Le module sur le traitement automatique des langues découpait le texte en mots. Un modèle de langage a besoin d’un vocabulaire fixe, et les mots compliquent cela. Un mot nouveau, comme un nom propre ou une faute de frappe, est tout simplement inconnu.
Les caractères règlent ce problème, car quelques dizaines suffisent pour écrire n’importe quel mot. Mais une phrase devient très longue, et une longue entrée coûte plus de calcul.
Exemple travaillé : un texte, deux découpages
| Découpage | Jetons dans « ami amie mie amie ami » | Vocabulaire | Peut-il écrire « amis » ? |
|---|---|---|---|
| Mots | 5 | 3 : ami, amie, mie | Non, le mot est inconnu |
| Caractères | 17 | 4 : a, m, i, e | Seulement avec une lettre nouvelle, s |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Compter les deux sortes de jetons
texte = "ami amie mie amie ami"
mots = texte.split()
caracteres = []
for mot in mots:
for c in mot:
caracteres.append(c)
vocab_mots = []
for mot in mots:
if mot not in vocab_mots:
vocab_mots.append(mot)
vocab_car = []
for c in caracteres:
if c not in vocab_car:
vocab_car.append(c)
print("jetons-mots :", len(mots), "vocabulaire :", vocab_mots)
print("jetons-caractères :", len(caracteres), "vocabulaire :", vocab_car)
print("amis est-il un mot connu ?", "amis" in vocab_mots)
# Ajoutez le mot amis au texte, puis cliquez sur Exécuter.
# Quel vocabulaire grandit, et de combien ?
Fusionner la paire la plus fréquente
L’encodage par paires d’octets se place entre les mots et les caractères. On part des caractères. On compte chaque paire de jetons voisins à l’intérieur d’un mot. On fusionne la paire la plus fréquente en un nouveau jeton, ajouté au vocabulaire.
Puis on recompte et on fusionne encore. Chaque fusion raccourcit les mots fréquents. Les mots rares restent en petits morceaux, donc rien n’est jamais inconnu.
Exemple travaillé : compter les paires
| Paire | Où elle apparaît | Compte |
|---|---|---|
| m i | ami, amie, mie, amie, ami | 5 |
| a m | ami, amie, amie, ami | 4 |
| i e | amie, mie, amie | 3 |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Compter les paires dans le labo
docker exec jupyter python3 -c "from collections import Counter; mots = 'ami amie mie amie ami'.split(); print(Counter(m[i:i + 2] for m in mots for i in range(len(m) - 1)).most_common(3))"Affichée ici, non exécutée. Créez un compte gratuit pour appuyer sur Exécuter et la saisir dans le terminal de votre propre labo.
Exemple travaillé : trois fusions
| Fusion | Nouveau jeton | ami | amie | mie |
|---|---|---|---|---|
| Départ | aucun | a m i | a m i e | m i e |
| 1 : m i (5) | mi | a mi | a mi e | mi e |
| 2 : a mi (4) | ami | ami | ami e | mi e |
| 3 : ami e (2) | amie | ami | amie | mi e |
Les cellules que les étudiants remplissent restent vides dans cet aperçu.
Faire la première fusion
texte = "ami amie mie amie ami"
mots = []
for mot in texte.split():
mots.append(list(mot))
gauche = "m"
droite = "i"
fusionnes = []
for jetons in mots:
sortie = []
i = 0
while i < len(jetons):
# On colle la paire en un seul jeton, puis on saute les deux.
if i + 1 < len(jetons) and jetons[i] == gauche and jetons[i + 1] == droite:
sortie.append(gauche + droite)
i = i + 2
else:
sortie.append(jetons[i])
i = i + 1
fusionnes.append(sortie)
print(fusionnes)
# Remplacez la paire par "a" et "m", puis cliquez sur Exécuter.
# Combien de jetons le mot mie a-t-il maintenant ?
Une erreur fréquente
Attention
Beaucoup pensent qu’un jeton est un mot. Avec l’encodage par paires, un mot fréquent fait un jeton, mais un mot rare en fait plusieurs. Comptez donc les jetons, pas les mots, quand vous demandez combien de texte tient dans un modèle.
Chaque jeton devient un nombre
Le modèle ne voit jamais de lettres. Chaque jeton du vocabulaire reçoit un identifiant, sa place dans la liste. Après les trois fusions, le vocabulaire est a, m, i, e, mi, ami et amie, numérotés de 0 à 6.
Ainsi « amie mie ami » devient amie, mi, e, ami, soit les identifiants 6, 4, 3, 5. Quatre jetons au lieu de dix caractères.
Changer les jetons en identifiants
docker exec jupyter python3 -c "vocab = ['a', 'm', 'i', 'e', 'mi', 'ami', 'amie']; print([vocab.index(j) for j in ['amie', 'mi', 'e', 'ami']])"Affichée ici, non exécutée. Créez un compte gratuit pour appuyer sur Exécuter et la saisir dans le terminal de votre propre labo.