On va commencer par entraîner le modèle. Les couches neuronales seront au début des structures de données aléatoires, et fur et à mesure des répétitions, ces structures seront mises à jour, pour produire des réponses de plus en plus éclairées.
On comprend que le jeu de données utilisé pour le modèle est fondamental car c'est grâce à des corrections successives que le modèle apprend. Les grands modèles de langage comme chatGPT utilisent des centaines de gigabits de données pour leur entraînement, qu'ils doivent nettoyer au préalable. Une fois qu'on a obtenu une grande quantité de texte de bonne qualité, on va découper le texte en dizaines de milliers de morceaux, souvent appelés tokens. Chaque token représente une chaîne de caractère spécifique à laquelle on peut attribuer un sens et un identifiant numérique. Parfois ce sont de mots entiers comme "manger", mais parfois ce sont uniquement des fragments de mots. Puis on va lui donner un certain nombre de tokens, et la réponse à prédire sera le token suivant. On définit ainsi la taille du "vocabulaire" comme le total de tokens uniques dans notre ensemble de données.
On peut utiliser divers algorithmes pour déterminer comment choisir quels caractères composent les tokens. Le plus classique, le byte pair encoding (BPE) est constitué des étapes suivantes :
Cela permet de capturer à la fois des mots fréquents et des sous-mots ou segments de mots moins fréquents.
Voici quelques exemples de tokens :
imaginer␣aireLivreprocon␣␣able␣tionmentcieldanseNoter que dans ce modèle les majuscules et minuscules sont distinguées et que l’espace est pris en compte pour signifier que le token est un début ou une fin de mot.
Les tokens servent à transformer une suite de mots en une liste de nombres.
Par exemple la phrase :
le soleil brille
se transforme en la liste de tokens :
[le, so␣, ␣leil, brille]
qui à son tour se transforme en une liste d’entiers (les tokens id) :
[4321, 9876, 1234, 5678]
Il s’agit d’un encodage sans perte d’information car à partir de la liste des identifiants on peut retrouver les tokens et donc la phrase originale.
Chaque mot fréquemment utilisé sera codé par un unique token, alors que les mots plus rares sont découpés en deux tokens ou plus.
Les tokens facilitent un apprentissage logique des termes, par exemple en séparant la racine d’un mot et sa terminaison :
On imagine maintenant ℝⁿ, un espace vectoriel de dimension N, muni d'une base canonique notée eᵢ pour i ∈ ℕ. Ainsi, e₂ est par exemple le vecteur qui a un 1 en position deux, et des zéros partout.
On met maintenant en correspondance les identifiants des tokens avec les vecteurs de la base canonique de ℝⁿ. Par exemple, le token "le" va être associé à l'identifiant 4321, puis au vecteur e₄₃₂₁.
La valeur approximative d'un mot en tokens dépend de la langue et de la complexité du mot. En général, pour le français, un mot correspond en moyenne à 1,3 tokens. Voici quelques points pour mieux comprendre :
Mots simples
Les mots courts et courants, comme le, chat, ou est, comptent souvent comme un seul token.
Mots complexes
Les mots plus longs ou composés, comme incroyable ou transformation, peuvent être décomposés en plusieurs tokens. Par exemple, incroyable pourrait être décomposé en in, croy, able (3 tokens).
Langues avec mots longs
Certaines langues, comme l'allemand, où les mots composés sont courants, peuvent voir une plus grande décomposition en tokens pour un seul mot.
Estimations générales
En moyenne, pour une estimation rapide :
Un mot = environ 1,3 tokens.
Il existe plusieurs processus permettant de choisir les tokens dans un corpus. Ce sont des petits programmes itératifs permettant d'extraire les mots ou sous-mots les plus répétitifs dans un corpus. L'un d'entre eux est le Byte Pair Encoding (BPE) présenté ci-dessous.
L'algorithme commence par compter l'occurrence de chaque caractère et continue en fusionnant les caractères. C'est un processus glouton qui considère soigneusement toutes les combinaisons possibles pour identifier l'ensemble optimal de mots/sous-mots couvrant le jeu de données avec le moins de tokens requis.
L'étape suivante consistera à créer le vocabulaire pour notre modèle, qui se compose d'un dictionnaire complet comprenant les tokens les plus fréquents extraits par BPE (ou une autre technique de votre choix) à partir du jeu de données. Un dictionnaire est une structure de données qui contient une paire clé-valeur pour chaque ligne. Dans notre scénario particulier, chaque point de données se voit attribuer une clé représentée par un index commençant à 0, tandis que la valeur correspondante est un token.
Étant donné que les réseaux neuronaux n'acceptent que des entrées numériques, nous utilisons le vocabulaire lui-même comme une table de correspondance entre les tokens et leurs ID correspondants. Lorsque nous faisons cela, nous devons sauvegarder le vocabulaire pour des cas d'utilisation futurs afin de pouvoir toujours décoder la sortie du modèle des ID vers les mots. Ceci est connu sous le nom de vocabulaire pré-entraîné, un composant essentiel accompagnant les modèles pré-entraînés publiés. Sans le vocabulaire, comprendre la sortie du modèle (les ID) serait impossible. Pour des modèles comme GPT-4o, il peut s'étendre jusqu'à 50 000 tokens.
La prochaine étape est d'associer le vecteur de la base canonique à un nouveau vecteur appelé vecteur token, vecteur d’embedding, vecteur de plongement, vecteur d'état, vecteur d'état caché, vecteur d'intégration, ou encore hidden state vector.
On note φ la fonction de plongement, qui va d'un espace de dimension N dans un espace de dimension n, avec N > n. À titre d'exemple, pour chatGPT4, N = 1048576 et n = 12288. On appelle n la dimension de plongement.
Les images vᵢ = φ(eᵢ) ∈ ℝⁿ sont donc obtenues par plongement pour chaque token.
.webp)
Le but du plongement va être de regrouper les mots par catégories sémantiques. Par exemple, les mots décrivant des couleurs vont se retrouver regroupés, et ainsi de suite. Mathématiquement, cela correspond à une application linéaire :
φ : ℝᴺ → ℝⁿ
eᵢ ↦ vᵢ
Or, la théorie des espaces vectoriels nous dit que toute application linéaire de N dans n peut être représentée sous la forme d'une matrice ayant n lignes et N colonnes. Ainsi, φ peut être représentée par la matrice A telle que la i-ème colonne de la matrice est exactement le vecteur vᵢ. Cette matrice s’appelle la matrice de plongement. Ainsi, en termes de vecteurs, nous avons donc simplement :
vᵢ = A eᵢ.
Une fois calculés tous les vecteurs tokens, on va introduire la notion de similarité entre deux vecteurs en fonction de la valeur de la distance cosinus entre deux vecteurs.
La distance cosinus, ou similarité cosinus, entre deux vecteurs a et b, est donnée par :
s_C(a, b) = (a ⋅ b) / (||a|| × ||b||)
où a ⋅ b est le produit scalaire des vecteurs et ||a|| est la norme de a.
.webp)
La similarité cosinus va nous fournir un angle, qui correspond à la distance logique entre deux vecteurs.
Les vecteurs ont aussi une norme, c'est-à-dire une taille par rapport à l'origine du repère. Plus la norme est grande et plus la force du vecteur est marquée, c'est-à-dire que la confiance dans le calcul de similarité est grande. Par exemple, imaginons un espace ℝ⁴ avec les dimensions suivantes : oracle, aventurier, jeune, mythologie.
Dans cet espace de coordonnées (oracle, aventurier, jeune, mythologie), considérons trois mots (sage, héros, divinité) représentés par les vecteurs V₁, V₂ et V₃.
Si dans une phrase, nous rencontrons les mots "prophétie", "divination", et "prédiction" (qui appartiennent à la symbolique du mot oracle) ainsi que les mots "panthéon" (symbole de l'olympe) et "épopée" (symbole de mythologie), nous allons associer à ce texte le vecteur W = [3, 0, 1, 1] en comptant les occurrences de chaque catégorie.
On a donc les vecteurs Vᵢ suivants :
V₁ = [1, 0, 0, 0]
V₂ = [0, 1, 0, 1]
V₃ = [1, 0, 1, 1]
Calculons chaque similarité cosinus entre W et les Vᵢ :
cos(θ₁) = (W ⋅ V₁) / (||W|| × ||V₁||) = (3×1 + 0×0 + 1×0 + 1×0) / (√(3² + 0² + 1² + 1²) × √(1² + 0² + 0² + 0²)) ≈ 0.90
cos(θ₂) = (W ⋅ V₂) / (||W|| × ||V₂||) = (3×0 + 0×1 + 1×0 + 1×1) / (√(3² + 0² + 1² + 1²) × √(0² + 1² + 0² + 1²)) ≈ 0.15
cos(θ₃) = (W ⋅ V₃) / (||W|| × ||V₃||) = (3×1 + 0×0 + 1×1 + 1×1) / (√(3² + 0² + 1² + 1²) × √(1² + 0² + 1² + 1²)) ≈ 0.87
Le vecteur le plus proche de W est donc V₁ avec une similarité cosinus de 0.90, mais le vecteur V₃ arrive juste après. De plus, on remarque que le vecteur V₃ a une norme plus élevée que V₁, ce qui fait qu'il a un taux de confiance plus élevé, donc selon la politique de configuration, il pourrait être préféré à V₁. Cet exemple illustre bien les arbitrages subtils que l'on doit parfois effectuer dans la mise en place de ce type de modèle.
On va ainsi pouvoir calculer les embeddings de phrase en concaténant les embeddings des vecteurs des mots.
.png)
