Jetons et plongements

Leçon 15
50 min
Module 5 : Représenter les séquences et le sens

Leçon 15 sur 23 · L'apprentissage profond et les transformeurs expliquésJetons et plongements

Aperçu du cours

1. Ce qu'est un réseau de neurones

2. Les tenseurs et PyTorch

3. Comment les réseaux de neurones apprennent

4. Diagnostiquer les problèmes d'entraînement

5. Représenter les séquences et le sens

6. Assembler un transformeur

7. Utiliser des modèles préentraînés

8. Sous le capot : les mathématiquesFacultatif

9. Études de cas

Ce que vous saurez faire

Donnez au réseau une façon utile de lire les mots. Vous transformez le texte en identifiants de jetons et donnez à chaque jeton une ligne de nombres appris. Ensuite, vous vérifiez ce que ces nombres ont appris, et ce qu’ils n’ont pas appris.

Carnet JupyterJetons, plongements et mots les plus proches, dans un carnetColab · Kaggle · GitHub · en anglais

Le carnet (notebook) Jupyter transforme les billets de soutien en identifiants de jetons et récupère les lignes de plongement. Il entraîne le réseau à moyenne de plongements sur les billets et trouve les mots les plus proches. L’entraînement prend environ une minute sur un processeur gratuit de Colab. Ses vérifications indiquent si votre réponse est correcte, sans la montrer. Environ 30 minutes.

Ouvrir dans Colab Ouvrir dans Kaggle Voir sur GitHub

Le carnet est en anglais. Colab et Kaggle ouvrent votre propre copie. Il faut un compte Google ou Kaggle gratuit. Vous êtes bloqué ? Consultez le carnet de solution.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 50 minutes

Ce que vous devez savoir

Le vocabulaire et le sac de mots, vus dans La propagation avant : chaque jeton présent au moins deux fois dans les billets d’entraînement reçoit une position. Un billet devient une ligne de fréquences.
L’entraînement avec des mini-lots, des époques et des données de validation, vu dans Lots, époques et validation.
La similarité cosinus : à quel point deux vecteurs pointent dans la même direction, de 1 (même direction) à −1 (directions opposées). Cette notion vient de Similarité et distance, dans le cours de mathématiques.

Ce qu’il vous faut sur votre ordinateur

Un navigateur. Le carnet s’ouvre dans Colab ou Kaggle, où PyTorch est déjà installé.
Pour l’option locale : le dossier ticket-router avec son environnement .venv actif, ticketnet.py et data/, présentés dans Installer PyTorch : option 2.

Tous les nombres proviennent des exécutions enregistrées du cours.

Une liste de noms et une carte

Regardez une liste alphabétique de villes. « Bath » vient juste après « Barnsley », mais les deux villes sont éloignées. « Bath » et « Bristol » sont voisines, mais beaucoup de noms les séparent dans la liste. La position dans une liste ne dit rien sur l’emplacement d’une ville.

Une carte fonctionne autrement. Chaque ville reçoit deux nombres, ses coordonnées. Les villes proches sur le terrain reçoivent des nombres proches. Vous pouvez donc mesurer la distance entre elles. Cette leçon donne à chaque mot sa propre « position sur la carte » et laisse le réseau choisir les positions.

Du texte aux identifiants de jetons

Un réseau calcule avec des nombres. La première étape consiste donc toujours à découper le texte en morceaux et à les numéroter. Ces morceaux s’appellent des jetons (tokens). Ce cours utilise les jetons les plus simples : mots en minuscules, nombres et signes de ponctuation individuels. La fonction tokenize du fichier ticketnet.py du cours effectue ce découpage avec une seule expression régulière.

Chaque jeton reçoit ensuite son identifiant de jeton : son numéro de ligne dans le vocabulaire. Vous avez construit le vocabulaire dans La propagation avant. Il contient chaque jeton présent au moins deux fois dans les billets d’entraînement. Le vocabulaire de Larkfield compte 2 864 entrées. L’identifiant 0 correspond à <pad> (remplissage), qui complète les billets courts dans un lot. L’identifiant 1 correspond à <unk> (inconnu), pour tout jeton absent du vocabulaire.

from ticketnet import Vocab, load_split, tokenize

train_rows = load_split("data/train.csv")
valid_rows = load_split("data/valid.csv")
vocab = Vocab([r["text"] for r in train_rows])

text = "Ugh, need to change trampoline delivery slot. Order LK-640933"
print(tokenize(text))
print(vocab.encode(text))
print(len(vocab), "entries;", vocab.itos[:2], "; ID of 'delivery':", vocab.stoi["delivery"])

La sortie :

['ugh', ',', 'need', 'to', 'change', 'trampoline', 'delivery', 'slot', '.', 'order', 'lk', '-', '640933']
[2653, 8, 1664, 2591, 618, 2620, 832, 2338, 10, 1749, 1486, 9, 1]
2864 entries; ['<pad>', '<unk>'] ; ID of 'delivery': 832

Il s’agit du véritable billet de validation T-64715, qui contient 13 jetons. Le numéro de commande 640933 n’apparaît dans aucun billet d’entraînement. Il devient donc l’identifiant 1, <unk>. Environ 1,2 % des jetons de validation sont <unk>, surtout des numéros de commande comme celui-ci.

Pourquoi des jetons de mots simples? Les grands modèles de langage découpent le texte en morceaux plus petits et fréquents. Ainsi, ils ne rencontrent jamais de mot inconnu. La leçon Du texte aux jetons du cours sur les modèles de langage montre comment. Ces outils de segmentation apprennent à partir de milliards de mots. Larkfield n’a qu’environ 4 700 billets d’entraînement. Les jetons de mots sont aussi faciles à lire. Dans L’attention étape par étape, chaque jeton dans le réseau est un mot que vous connaissez. Le prix à payer est le jeton <unk> : une faute comme « delivry » perd complètement son sens.

Le problème : un identifiant ne dit rien sur le sens

Les identifiants de jetons ressemblent à la liste alphabétique de villes. « refund » (remboursement) et « refunded » (remboursé) reçoivent des identifiants voisins seulement parce que leur orthographe se ressemble. « parcel » (colis) et « courier » (service de messagerie) sont éloignés dans la liste. Pourtant, ils apparaissent dans le même type de billet. Le réseau ne peut donc pas utiliser l’identifiant comme une quantité. L’identifiant 2 000 n’est pas « plus » que l’identifiant 1 000 dans un sens utile.

Tomás a quand même essayé : il a donné au réseau les identifiants de jetons de chaque billet comme de simples nombres. Le réseau n’a acheminé correctement que 29,0 % des billets de validation. C’est presque aussi bon que de toujours répondre « delivery » (livraison), soit 27,5 %. Le cas d’échec ci-dessous donne les détails.

Le sac de mots du module 2 évite ce problème. En pratique, chaque jeton devient un vecteur à codage unitaire : 2 864 nombres, tous à 0 sauf un seul 1 à l’identifiant du jeton. Le sac de mots d’un billet est la somme des vecteurs à codage unitaire de ses jetons. Cela fonctionne, mais ces vecteurs ont deux problèmes :

Ils sont longs. Chaque jeton utilise 2 864 nombres, dont un seul n’est pas 0.
Toutes les paires de mots sont aussi différentes. Les vecteurs à codage unitaire de « refund » et « refunded » n’ont aucune position commune. Leur produit scalaire est donc 0, et leur similarité cosinus aussi. C’est également vrai pour « refund » et « trampoline ». Le réseau doit apprendre chaque mot séparément, à partir des billets qui le contiennent.

L’idée : une ligne de nombres appris pour chaque jeton

Donnez plutôt à chaque jeton une courte ligne de nombres, par exemple 64 nombres. Placez les lignes dans une table, avec une ligne par identifiant de jeton : 2 864 lignes × 64 nombres. Pour lire un jeton, prenez sa ligne. Puis laissez l’entraînement modifier les nombres, comme tous les autres poids.

La ligne d’un jeton s’appelle son plongement (embedding), et la table est la table de plongements. Le nom vient des mathématiques : vous « plongez » les mots dans un espace de nombres. C’est comme une carte qui place des villes sur une feuille plane avec deux coordonnées. Ici, l’espace a 64 directions plutôt que deux.

Pourquoi ces lignes apprendraient-elles quelque chose d’utile? L’entraînement modifie chaque nombre pour réduire la perte. Les mots qui orientent un billet vers la même équipe reçoivent des lignes pointant dans une direction semblable. C’est le cas de « charged » (facturé) et « twice » (deux fois). Des lignes semblables mènent à la même prédiction correcte. Personne ne dit au réseau quels mots sont semblables. Il trouve les lignes qui l’aident à acheminer les billets.

Voici un petit exemple détaillé. Prenez un vocabulaire de quatre jetons et seulement 2 nombres par ligne :

Identifiant	jeton	ligne de plongement
0	`<pad>`	(0, 0)
1	`parcel`	(0,9, 0,1)
2	`courier`	(0,8, 0,3)
3	`refund`	(−0,2, 0,9)

Le texte « courier parcel » a les identifiants 2 et 1. La recherche retourne les lignes (0,8, 0,3) et (0,9, 0,1), dont la moyenne est (0,85, 0,2). La similarité cosinus de « parcel » et « courier » est (0,9 × 0,8 + 0,1 × 0,3) ÷ (0,906 × 0,854) = 0,97. Ils pointent presque dans la même direction. Pour « parcel » et « refund », elle vaut (−0,18 + 0,09) ÷ (0,906 × 0,922) = −0,11. Dans un vrai réseau, l’entraînement détermine ces nombres.

La recherche donne le même résultat que la multiplication d’un vecteur à codage unitaire par la table. Le seul 1 sélectionne une ligne. PyTorch évite la multiplication et lit directement la ligne, ce qui est beaucoup plus rapide. Le schéma montre le parcours complet du véritable billet.

Cinq étapes. 1, le texte du billet T-64715. 2, treize jetons. 3, treize identifiants de jetons : ugh 2653, delivery 832, et 640933 devient 1, inconnu. 4, la table de plongements : la ligne 1 pour inconnu commence par −0,46, 1,36; la ligne 832 pour delivery commence par −0,32, −1,94; la ligne 2653 pour ugh commence par 1,67, −1,01. 5, treize lignes de 64 nombres, de forme (1, 13, 64), puis leur moyenne, de forme (1, 64), puis 5 scores d'équipe : delivery 99,3 %. — Du texte aux vecteurs de plongement : une recherche dans une table. Les identifiants et les nombres sont réels. Ils proviennent du réseau à moyenne de plongements entraîné du cours.

Dans PyTorch, la table de plongements est nn.Embedding(number_of_tokens, numbers_per_row). Elle commence avec des nombres aléatoires. padding_idx=0 garde la ligne <pad> à zéro et ne l’entraîne jamais.

import torch
from torch import nn

torch.manual_seed(0)
embed = nn.Embedding(len(vocab), 64, padding_idx=0)   # 2,864 rows of 64 random numbers, to be learned
ids = torch.tensor([vocab.encode(text)])              # one ticket: shape (1, 13)
vectors = embed(ids)                                  # look up one row per token
print(ids.shape, "->", vectors.shape)
print(torch.equal(vectors[0, 6], embed.weight[832]))  # token 7 is 'delivery', ID 832
print(embed.weight.shape, embed.weight.numel(), "numbers to learn")

La sortie :

torch.Size([1, 13]) -> torch.Size([1, 13, 64])
True
torch.Size([2864, 64]) 183296 numbers to learn

Lisez les formes. Un billet avec 13 identifiants de jetons entre dans le réseau. Il en sort une ligne de 64 nombres par jeton : (1, 13, 64). La nouvelle dernière dimension est le plongement. Le vecteur du septième jeton est exactement la ligne 832 de la table.

Le réseau à moyenne de plongements sur les billets

Acheminez maintenant les billets avec des plongements. Le réseau le plus simple qui les utilise est AverageEmbeddingNet, fourni dans le cours. Il récupère la ligne de chaque jeton, calcule la moyenne des lignes et l’envoie dans une couche de sortie. Cette couche produit 5 scores d’équipe. La moyenne transforme un billet de n’importe quelle longueur en une ligne de 64 nombres. Le réseau ignore les jetons <pad>, donc le remplissage ne change pas la moyenne d’un billet.

from ticketnet import AverageEmbeddingNet, count_parameters, labels, set_seed, token_ids, train

ids_train, ids_valid = token_ids(train_rows, vocab), token_ids(valid_rows, vocab)
print(ids_train.shape, ids_valid.shape)
set_seed(0)
model = AverageEmbeddingNet(len(vocab))
print(count_parameters(model), "parameters")
history = train(model, ids_train, labels(train_rows), ids_valid, labels(valid_rows), epochs=30, lr=0.01, log=None)
best = min(history, key=lambda h: h["valid_loss"])
print("best:", best)
print("last:", history[-1])

La sortie :

torch.Size([4696, 120]) torch.Size([600, 120])
183621 parameters
best: {'epoch': 7, 'train_loss': 0.034, 'train_acc': 0.9934, 'valid_loss': 0.0704, 'valid_acc': 0.98}
last: {'epoch': 30, 'train_loss': 0.0009, 'train_acc': 1.0, 'valid_loss': 0.0959, 'valid_acc': 0.9683}

token_ids complète chaque billet avec des zéros jusqu’à la longueur du plus long, avec un maximum de 120 jetons. Le réseau compte 183 621 paramètres : 183 296 dans la table de plongements et 325 dans la couche de sortie. Ces derniers comprennent 64 × 5 poids + 5 biais. À sa meilleure époque, la 7e, il achemine correctement 98,0 % des billets de validation. Ensuite, il fait du surapprentissage : après 30 époques, le résultat est de 96,8 %.

Comparez ce résultat aux systèmes d’acheminement précédents. Le réseau à sac de mots a atteint 98,3 % à sa meilleure époque. Le modèle linéaire du cours d’apprentissage automatique a atteint 98,8 %. Les plongements n’acheminent donc pas mieux les billets. Ce n’est pas surprenant : une moyenne, comme une fréquence, élimine l’ordre des mots. La prochaine leçon montre ce que cela coûte.

Ce que les plongements ont appris

Les plongements sont maintenant entraînés. Vous pouvez donc demander : quels mots ont des lignes qui pointent dans la même direction? Ramenez chaque ligne à une longueur de 1. Le produit scalaire de deux lignes est alors leur similarité cosinus. Pour un mot, calculez-la avec les 2 864 lignes et gardez les valeurs les plus élevées.

W = model.embed.weight.detach()
W = W / W.norm(dim=1, keepdim=True).clamp(min=1e-8)   # every row to length 1 (the <pad> row stays 0)

def nearest(word, k=5):
    sims = W @ W[vocab.stoi[word]]                    # cosine similarity with every word
    top = sims.topk(k + 1).indices.tolist()
    return [(vocab.itos[i], round(sims[i].item(), 2)) for i in top if vocab.itos[i] != word][:k]

for word in ("return", "refund", "cracked"):
    print(word, nearest(word))
print("refund / refunded:", round((W[vocab.stoi["refund"]] @ W[vocab.stoi["refunded"]]).item(), 2))

La sortie :

return [('collection', 0.76), ('sale', 0.75), ('back', 0.73), ('balcony', 0.73), ('returned', 0.7)]
refund [('twice', 0.57), ('bank', 0.56), ('paperwork', 0.56), ('payments', 0.55), ('statement', 0.54)]
cracked [('where', 0.61), ('along', 0.57), ('here', 0.56), ('lamp', 0.56), ('doorstep', 0.55)]
refund / refunded: -0.28

Lisez ces listes honnêtement. Elles sont en partie pertinentes et en partie du bruit.

« return » (retour) est proche de « collection » (collecte), « back » (retour) et « returned » (retourné) : les mots des billets de retour. « sale » (vente) et « balcony » (balcon) y figurent aussi. C’est seulement parce qu’ils apparaissent surtout dans les billets de retour de ces données, respectivement 98 % et 64 % du temps.
« refund » est proche des mots de paiement : « bank » (banque), « payments » (paiements), « statement » (relevé). Cela correspond à la politique de Grace : un remboursement confirmé mais non reçu est un problème de paiement. Mais il n’est pas proche de « refunded » (−0,28), qui apparaît seulement 28 fois dans tous les billets d’entraînement.
« cracked » (fissuré) est proche de « where » (où), « along » (le long de) et « here » (ici). Ces mots n’ont aucun sens commun avec lui. Dans les données d’entraînement, « cracked » apparaît presque autant dans les billets de garantie (51 %) que de livraison (46 %, bris à l’arrivée). Sa ligne ne peut pas pointer vers une seule équipe. Ses voisins sont donc d’autres mots qui ne pointent vers aucune équipe.

La carte montre la même chose en image. Elle part de 43 mots choisis : mots de paiement, de livraison, de garantie et quelques mots courants. Leurs 64 nombres sont réduits à 2 avec la PCA (analyse en composantes principales). Cette méthode garde les deux directions où ces lignes diffèrent le plus. La carte montre 18 des 43 mots. Les autres sont si proches que leurs étiquettes se chevaucheraient. Les mots qui orientent vers la même équipe forment des groupes. Les mots courants comme « the » (le, la ou les) restent près du centre, car ils n’orientent vers aucune équipe.

surtout dans les billets de livraison
surtout dans les billets de paiement
surtout dans les billets de garantie
mots courants

The learned embeddings of 18 words, pressed from 64 numbers to 2 with PCA (computed on 43 chosen words). The two directions keep 51% of the differences between those rows, so the map is a flat shadow, not the whole picture. Each word has the colour of the team whose training tickets use it most.

Description textuelle du graphique

Un nuage de points de 18 mots. Les mots de paiement charged et statement sont à gauche, sous le centre. Les mots de garantie guarantee, stopped, repair et snapped sont en bas à droite. Les mots de livraison tracking, arrived, box, porch, damaged, missing et late sont en haut. Les mots courants the et my sont près du centre. Trois mots occupent des positions surprenantes. Driver, un mot de livraison, se trouve en haut à gauche, du côté paiement de la carte. Il est loin des autres mots de livraison. Cracked, un mot de garantie, se trouve à droite, entre les groupes de livraison et de garantie. Doorstep, un mot de livraison, se trouve au bord droit, entre ces deux mêmes groupes. Les deux directions représentées conservent environ la moitié des différences entre les 43 lignes choisies.

Regardez aussi les surprises. « driver » (chauffeur) apparaît surtout dans les billets de livraison. Mais sa ligne se situe du côté paiement et oriente un billet vers le paiement. « cracked » se situe entre les groupes de garantie et de livraison, et oriente vers la livraison. Ces lignes ont appris ce qui aidait à acheminer 4 696 billets, rien de plus.

Quand utiliser les plongements, et ce qu’ils coûtent

Utilisez une table de plongements chaque fois qu’un réseau lit des jetons. Tous les réseaux de la suite du cours commencent par une telle table, comme tous les modèles de langage. Comparé à un vecteur à codage unitaire, un plongement est court : 64 nombres au lieu de 2 864. Il peut aussi apprendre que deux mots jouent un rôle semblable.

Connaissez leurs limites :

Semblable ne veut pas dire de même sens. Les lignes sont proches quand les mots aident à faire la même prédiction. « charged » et « twice » sont proches (0,75), mais ne veulent pas dire la même chose.
Ils reflètent seulement ces données. Ces lignes ont appris à partir de 4 696 billets et d’une seule tâche : l’acheminement. Elles ne connaissent rien de l’anglais en dehors des billets, et les mots rares reçoivent des lignes bruitées.
Ils coûtent des paramètres et des données. La table contient 183 296 nombres, soit presque tous les poids de ce réseau. Chaque ligne apprend seulement à partir des billets qui contiennent son mot.
Une moyenne oublie l’ordre. Les plongements décrivent les mots, pas les phrases. La façon dont les mots se combinent est le sujet des deux prochaines leçons.

Les plongements appris à partir d’une énorme quantité de texte, dans un modèle préentraîné, connaissent beaucoup mieux l’anglais. Le module 7 utilise un tel modèle.

Exercice guidé : les mots les plus proches dans le carnet

Ouvrez le carnet et exécutez les cellules de configuration. Elles téléchargent les billets et ticketnet.py.
Exécutez la section « Tokens and IDs » (jetons et identifiants). Vérifiez que le billet T-64715 contient 13 jetons et que 640933 devient l’identifiant 1.
Exécutez la section « Train the average-embedding network » (entraîner le réseau à moyenne de plongements). Cela prend environ une minute.
Exécutez nearest("password") et nearest("charged").
Pour chaque liste, notez quels voisins sont pertinents pour les équipes de Grace et lesquels ressemblent à du bruit.

Sortie attendue à l’étape 4 :

password [('associated', 0.57), ('cannot', 0.56), ('recognised', 0.56), ('service', 0.53), ('unable', 0.5)]
charged [('twice', 0.75), ('total', 0.74), ('charges', 0.71), ('identical', 0.68), ('bank', 0.67)]

Afficher un exemple de réponse

password : « cannot » (ne pas pouvoir), « recognised » (reconnu), « unable » (incapable) et « associated » (associé) viennent de problèmes de connexion. Par exemple : « my password is not recognised » (mon mot de passe n’est pas reconnu), « I cannot log in » (je ne peux pas me connecter), « the email associated with my account » (le courriel associé à mon compte). Ils décrivent les billets de l’équipe des comptes, pas le sens de « password » (mot de passe). « service » ressemble à du bruit.

charged : « twice », « total », « charges » (frais), « identical » (identique) et « bank » viennent tous de billets de paiement. Ces billets portent sur des frais en double et des totaux erronés. Cette liste est la plus pertinente, car « charged » apparaît presque seulement dans les billets de paiement (87 % du temps).

Plus un mot appartient à une seule équipe, plus ses voisins sont pertinents. Les mots présents dans plusieurs équipes, comme « cracked », reçoivent des voisins bruités.

À vous de jouer : deux mots qui se ressemblent

Avant toute exécution, faites une prédiction : la similarité cosinus de « refund » et « refunded » est-elle élevée, proche de 0 ou négative? Et celle de « cracked » et « broken » (cassé)? Utilisez ensuite le carnet pour vérifier les deux.

Afficher la réponse

« refund » et « refunded » : −0,28. « cracked » et « broken » : 0,49. Une personne voit deux formes du même mot dans la première paire. Le réseau voit deux façons différentes de les utiliser. « refund » apparaît 1 358 fois, dans les billets des cinq équipes. « refunded » apparaît seulement 28 fois, donc sa ligne a appris à partir de très peu de billets. Rien dans l’entraînement n’a rapproché les deux lignes. Les plongements mesurent « utilisés de façon semblable pour cette tâche », pas « de même sens ».

Cas d’échec : utiliser les identifiants de jetons comme des nombres

Erreur courante

Identifiants de jetons fournis au réseau comme de simples nombres

Symptôme : Tomás n’utilise pas la table de plongements. Il ajoute du remplissage aux identifiants de jetons de chaque billet de soutien pour en obtenir 120. Il les divise par 2 864 pour qu’ils soient entre 0 et 1. Il entraîne ensuite un réseau avec une couche cachée (120 → 64 → 5). Après 20 époques, le réseau achemine correctement seulement 29,0 % des billets de validation. Répondre toujours « delivery » (livraison) donne 27,5 %.

Cause : un identifiant est un nom, pas une quantité. Le réseau traite l’identifiant 2 000 comme « deux fois plus » que l’identifiant 1 000. Il traite aussi la première position de chaque billet comme une caractéristique. Le même mot reçoit une entrée différente à chaque position. Deux mots sans lien dont les identifiants sont proches semblent presque identiques.

Solution : ne fournissez jamais les identifiants comme des nombres. Transformez d’abord chaque identifiant en vecteur : un vecteur à encodage disjonctif (le sac de mots) ou une ligne de plongement (nn.Embedding). Affichez ensuite la forme après la recherche dans la table : une ligne par jeton, (lot, jetons, 64).

Vérification des connaissances

Vérifiez votre compréhension

Dans vos mots : qu'est-ce qu'un plongement, et pourquoi est-il plus utile au réseau que l'identifiant du jeton?

Afficher la réponse

Un plongement est une ligne de nombres appris pour un jeton, par exemple 64 nombres. Le réseau la trouve dans la table de plongements grâce à l’identifiant du jeton, comme un numéro de ligne. L’identifiant lui-même n’est qu’un nom : un identifiant plus grand ne représente pas « plus » de quelque chose. Des identifiants proches ne désignent pas nécessairement des mots semblables. L’entraînement modifie les lignes de plongement. Les mots qui aident à faire la même prédiction peuvent donc obtenir des lignes qui pointent dans la même direction. Le réseau peut alors les comparer.

Vérifiez votre compréhension

Les mots les plus proches du plongement entraîné de « cracked » sont « where », « along » et « here ». Tomás dit que les plongements fonctionnent mal. Que lui répondez-vous?

Afficher la réponse

Les plongements fonctionnent bien; ils ont appris ce qu’il fallait pour l’acheminement à partir de 4 696 billets. « cracked » (fissuré) apparaît presque aussi souvent dans les billets de garantie que dans les billets de livraison. Sa ligne ne peut donc pas pointer vers une seule équipe. Ses voisins sont d’autres mots qui ne pointent vers aucune équipe. Les plongements montrent quels mots ont servi de façon semblable pour cette tâche, dans ces données. Ce ne sont pas un dictionnaire de sens.

Vérifiez votre compréhension

Prédisez : une table de plongements contient 2 864 lignes de 64 nombres. Quelle forme renvoie-t-elle pour un lot de 8 billets complétés à 120 jetons par remplissage? Combien de nombres contient-elle?

Afficher la réponse

L’entrée contient des identifiants de jetons de forme (8, 120). La recherche ajoute une dimension de 64 nombres pour chaque jeton. La sortie a donc la forme (8, 120, 64). La table contient 2 864 × 64 = 183 296 nombres. L’entraînement les modifie tous, sauf ceux de la ligne <pad> (remplissage) quand padding_idx=0 est défini.

Récapitulatif

Le texte devient des jetons (ici : mots en minuscules, nombres, ponctuation). Chaque jeton reçoit un identifiant de jeton du vocabulaire de 2 864 entrées. Les jetons inconnus, comme les numéros de commande, deviennent <unk> (inconnu).
Un identifiant est un nom, pas une quantité. Un vecteur à encodage disjonctif contient 2 864 nombres et rend toute paire de mots également différente.
Un plongement est une ligne de nombres appris pour chaque jeton, trouvée par une recherche dans une table : (lot, jetons) → (lot, jetons, 64). Les mots qui aident à faire la même prédiction obtiennent des lignes semblables.
À sa meilleure époque, le réseau utilisant la moyenne des plongements achemine correctement 98,0 % des billets de validation. Ce n’est pas mieux que le sac de mots (98,3 %) ou le modèle linéaire (98,8 %). Une moyenne oublie l’ordre des mots.
Les mots les plus proches sont parfois pertinents (« charged » → « twice », « total » : facturé → deux fois, total). D’autres relèvent du bruit (« cracked » → « where », « along » : fissuré → où, le long de). Les plongements reflètent une tâche et 4 696 billets.

Voyez ensuite exactement où le comptage et la moyenne des mots échouent : les billets dont l’équipe dépend de l’ordre des mots.

Leçon suivante : Pourquoi l'ordre des mots et le contexte comptent