NLP

Augustin Chevallier

1 Introduction

1.1 Un peu d’histoire

1950 – 1980 : grammaires formelles (Chomsky)
1980 – 2010 : approches statistiques (n-grammes, Hidden Markov Models) → on apprend des probabilités à partir de corpus

“Every time I fire a linguist, the performance of the speech recognizer goes up.” — Frederick Jelinek (IBM, reconnaissance vocale)
2003 – 2017 : réseaux de neurones → embeddings, RNN / LSTM, seq2seq
2017 – … : révolution des Transformers (Attention Is All You Need) → BERT, GPT, puis ChatGPT (2022) et les LLM

2 Tokens & Vocabulaire

2.1 Token

Un token est une unité élémentaire de texte utilisée par un modèle.
C’est la plus petite partie du texte sur laquelle le modèle raisonne et prend des décisions.

Un token peut être :

un mot
un sous-mot (ex : “mang” + “er”)
un caractère
un symbole (ponctuation, espace, emoji…)

2.2 Vocabulaire

Ensemble de tous les tokens possibles (mots, symboles, sous-mots).
Chaque token reçoit un ID entier unique.
Définit ce que le modèle peut lire et peut prédire.
Taille du vocabulaire = nombre total de tokens utilisables.

2.3 Tokenizer

Rôle : transformer un texte en tokens

Un mot peut avoir plusieurs représentations

Mot : "unbelievable"
Vocabulaire :
["un", "b", "believ", "able", "elievable", "u", "n", "b", "e", "l", "i", "v", "a"]
Différentes façons de le découper :
1. ["un", "believ", "able"]
2. ["un", "b", "elievable"]
3. ["u", "n", "b", "e", "l", "i", "e", "v", "a", "b", "l", "e"]

2.4 Tokens spéciaux

Tokens ajoutés au vocabulaire pour gérer des cas particuliers.

Exemples courants :

\(<PAD>\) : remplir les séquences plus courtes
\(<EOS>\) : fin de séquence
\(<BOS>\) : début de séquence
\(<UNK>\) : token inconnu (mot non vu)
\(<MASK>\) : utilisé pour l’entraînement masqué (BERT, etc.)

3 Embedding/Projection & Decoding

3.1 Embedding

Chaque token est représenté par un vecteur de taille embedding_dim

Matrice entraînable : M = vocab_size × embedding_dim.
\(M[i,:]\) est la représentation du token ayant pour id \(i\)

Nombre de paramètres:

augmente avec la taille du vocabulaire
2 extrêmes :
- vocabulaire = dictionnaire de tous les mots entiers : facile à traiter pour le réseau, mais grand vocabulaire. Sensible aux typos !
- vocabulaire = liste des caractères : petit vocabulaire mais plus compliqué à traiter

3.2 En PyTorch : `nn.Embedding`

nn.Embedding(vocab_size, embedding_dim) :

contient la matrice \(M\) (attribut .weight), initialisée aléatoirement et entraînable
entrée : un tenseur d’entiers (les ids des tokens), de forme quelconque
sortie : les lignes correspondantes de \(M\), de shape (..., embedding_dim)

import torch
import torch.nn as nn

emb = nn.Embedding(num_embeddings=10, embedding_dim=3)  # M de taille 10 x 3
ids = torch.tensor([[1, 5, 5, 2]])   # 1 séquence de 4 tokens, shape (1, 4)

x = emb(ids)
print(x.shape)                              # torch.Size([1, 4, 3])
print(torch.equal(x[0, 0], emb.weight[1]))  # True : le token 1 donne la ligne 1 de M

3.3 Out projection / Head

Dans le cas de la génération de texte (i.e. prédiction du prochain token) :

la sortie est un token
c’est un problème de classification
chaque classe correspond à un token
la sortie est donc un vecteur de taille vocab_size
chaque élément du vecteur de sortie correspond au score associé à un token

Head layer:

on utilise une couche linéaire pour transformer la sortie de notre architecture (RNN, LSTM, Transformers, etc) vers la dimension souhaitée (vocab_size)

3.4 Interlude: Softmax

Softmax:

fonction de \(R^n\) dans \(R^n\): \[Softmax(y)_i = \frac{e^{y_i}}{\sum_{j=0}^n e^{y_j}}\]
Pour \(z = Softmax(y)\), \(z_i \in [0,1]\) et \(\sum_{i=1}^n z_i = 1\)
Peut être interprété comme une proba !

Temperature:

on associe souvent une température \(T\): \(z = Softmax(\frac{y}{T})\)
Si \(T \rightarrow 0\) alors: \(softmax(\frac{y}{T})_i = \delta_{i = argmax(y)}\)
Si \(T \rightarrow \infty\) alors: \(softmax(\frac{y}{T})_i = 1/\text{vocab_size}\)

3.5 Decoding

Pour une classification:

token = argmax(sortie)
déterministe!
On observe souvent des séquences de mots en boucle.

Pour les modèles de langage :

on passe le vecteur de sortie \(y\) dans la fonction softmax pour une température \(T\) : \[ z = softmax(\frac{y}{T}) \]
on interprète les \(z_i\) comme une probabilité sur chaque token.
on échantillonne \(z_i\).
choisir \(T = 0\) est équivalent à prendre l’argmax.
choisir \(T > 0\) “brise” les boucles.

NLP