Qu’est-ce que l’encodage positionnel ?

L’encodage positionnel est une technique qui injecte des informations sur la position des mots dans une séquence dans les architectures de Transformers.

L’ordre des mots joue un rôle fondamental dans la compréhension de la signification sémantique d’une phrase. Par exemple, « Jean promène chien » et « Chien promène Jean » ont des significations totalement différentes, même s’ils ont les mêmes mots ou tokens. Lors de la mise en œuvre d’applications de traitement automatique du langage naturel (NLP) à l’aide de l’apprentissage profond et des réseaux de neurones, nous devons créer un mécanisme par lequel les machines peuvent conserver les ordres de mots dans une phrase pour produire un résultat logique.

Traditionnellement, les modèles tels que les réseaux de neurones récurrents (RNN), ou la mémoire à long et à court terme (LSTM), disposent d’un mécanisme intégré qui gère l’ordre des mots. Les RNN et les LSTM traitent les entrées de manière séquentielle, un token à la fois, en mémorisant toutes les positions des mots en séquence. En d’autres termes, le vecteur à n dimensions, également appelé « vecteur d’entrée », est traité séquentiellement, ce qui permet d’intégrer l’information d’ordre. En revanche, d’autres architectures qui profitent des réseaux de neurones convolutifs ou des Transformers (Vaswani et al. 2017) ne conservent pas l’ordre des mots et traitent les tokens en parallèle. En conséquence, nous devons mettre en place un mécanisme capable de représenter explicitement l’ordre des mots dans une séquence, une technique connue sous le nom d’encodage positionnel. L’encodage positionnel permet au Transformer de conserver les informations de l’ordre des mots, ce qui autorise une parallélisation et un entraînement efficace des modèles. Vous pouvez souvent trouver des implémentations d’encodage positionnel sur GitHub.

Newsletter sectorielle

Les dernières tendances en matière d’IA, vues par des experts

Obtenez des informations sur les actualités les plus importantes et les plus intrigantes en matière d’intelligence artificielle. Abonnez-vous à notre newsletter hebdomadaire Think. Lire la Déclaration de confidentialité d’IBM.

Pourquoi l’encodage positionnel est-il important ?

L’ordre des mots dans une phrase ou une séquence dicte le sens inhérent à la phrase dans les langues naturelles. De plus, pour le machine learning, l’encodage de l’ordre des mots nous donne un répertoire sur l’endroit où chaque mot doit se trouver. Ces informations sont conservées et peuvent se généraliser tout au long de l’entraînement des modèles de transformeurs, ce qui permet la parallélisation et devance les RNN et les LSTM pour l’efficacité d’entraînement.

Reprenons l’exemple :

« Jean promène chien »
« Chien promène Jean »

Ces deux phrases avec les trois mêmes tokens ont des significations totalement différentes à cause de l’ordre des mots. Les Transformers, qui s’appuient sur l’auto-attention et le mécanisme d’attention multi-tête, n’ont pas de représentation inhérente des ordres de mots et traiteraient le mot individuel dans une séquence de manière identique si nous n’avions pas d’informations positionnelles explicites. Nous voulons que le modèle comprenne qui promène et qui est promené, ce qui dépend entièrement des positions.

Nous atteignons cet objectif en traitant d’abord chaque mot comme un vecteur qui représente sa signification. Par exemple, « chien » sera encodé dans une matrice de grande dimension qui encode son concept. En termes techniques, chaque mot ou sous-mot est mappé à un plongement d’entrée de longueurs variables. Cependant, à lui seul, le vecteur de signification ne nous indique pas où « chien » apparaît dans la phrase. L’encodage positionnel ajoute un deuxième vecteur, qui encode l’index de position, tel que le « premier mot » ou le « deuxième mot », et ainsi de suite. Les deux vecteurs sont ensuite ajoutés pour représenter le mot et où il se trouve. Ce vecteur résultant est souvent appelé vecteur d’encodage positionnel.

Il existe plusieurs manières de créer un encodage positionnel. Dans cet article, nous découvrons l’exemple le plus connu d’utilisation d’une fonction sinusoïdale introduit par les auteurs dans Attention is all you need¹ pour créer un encodage positionnel.

Mixture of Experts | 12 décembre, épisode 85

Décryptage de l’IA : Tour d’horizon hebdomadaire

Rejoignez notre panel d’ingénieurs, de chercheurs, de chefs de produits et autres spécialistes de premier plan pour connaître l’essentiel de l’actualité et des dernières tendances dans le domaine de l’IA.

Regardez tous les épisodes de Mixture of Experts

Encodage positionnel dans les Transformers

Dans l’article original présenté par Vaswani et al. 2017, l’idée clé est de générer un encodage fixe et déterministe pour chaque position d’une séquence en utilisant une fonction sinusoïdale, en particulier la fonction sinus $s i n (x)$ et cosinus $c o s (x)$ .

Qu’est-ce qu’une fonction sinusoïdale ?

Les fonctions sinus sont un concept mathématique fondamental qui produit un schéma de longueur d’onde lisse. Les fonctions cosinus et sinus sont notamment utilisées par les auteurs dans les fonctions de transformation originales pour faciliter l’encodage positionnel.

Si nous comptons $s i n (x)$ et $c o s (x)$ , nous verrons une courbe qui monte et tombe entre − 1 et 1 selon un motif périodique répétitif.

Voici quelques propriétés de la fonction sinus qui la rendent puissante pour l’encodage positionnel :

Elle est périodique : elle se répète régulièrement sur des intervalles, ce qui est utile pour représenter des schémas répétés.
Elle est lisse et continue : de petites modifications dans l’entrée entraînent de petites modifications dans la production, ce qui nous permet de représenter des positions dans un espace différentiable.
En faisant varier la fréquence des longueurs d’onde dans les différentes dimensions, nous pouvons créer une représentation riche et multi-échelle de la position.

Nous allons tracer les ondes sinus et cosinus pour comprendre visuellement à quoi elles ressemblent :

import numpy as np 
import matplotlib.pyplot as plt 

# Create an array of 100 x values evenly spaced from 0 to 2π (approx 6.28)
x = np.linspace(0, 2 * np.pi, 100) 

# Compute the sine and cosine of each x value 
sin_values = np.sin(x) 

# Create the plot 
plt.figure(figsize=(5, 2)) 
plt.plot(x, sin_values, label='sin(x)', color='blue') 

# Customize the plot 
plt.title('Sine Function') 
plt.xlabel('x') 
plt.ylabel('Function value') 
plt.axhline(0, color='black', linewidth=0.5) # horizontal line at y=0 
plt.axvline(0, color='black', linewidth=0.5) # vertical line at x=0 
#plt.grid(True, linestyle='--', alpha=0.5) 
plt.legend() 
plt.tight_layout() 

# Show the plot 
plt.show()

La fonction sinus

Voyons maintenant comment représenter la fonction cosinus :

#apply the cosine function to the same array, x
cosine = np.cos(x) 

plt.figure(figsize = (5,2)) 
plt.plot(x, cosine, label = 'cos(x)', color = 'blue') 
plt.title('The Cosine Function') 
plt.xlabel('x') 
plt.ylabel('Function value') 
plt.axhline(0, color='black', linewidth=0.5) # horizontal line at y=0 
plt.axvline(0, color='black', linewidth=0.5) # vertical line at x=0 
#plt.grid(True, linestyle='--', alpha=0.5) 
plt.legend() 
plt.tight_layout()

Graphique de la fonction cosinus qui illustre sa nature périodique et ses caractéristiques clés.

Les formules d’encodage de position sinusoïdale, définies par les auteurs de l’article original Transformers (Vaswani et al. 2017), sont présentées comme suit :

Pour les positions paires :

$P E_{p o s, 2 i} = \sin (\frac{p o s}{10000^{2 i / d_{m o d e l}}})$

Pour les positions impaires :

$P E_{p o s, 2 i + 1} = \cos (\frac{p o s}{10000^{2 i / d_{m o d e l}}})$

$k$ : la position du mot dans la phrase (par exemple, 0 pour le premier mot, 1 pour le deuxième, etc.)

$i$ : l’index de dimension du vecteur de plongement mappe à l’index de colonne. 2i indiquera une position paire et 2i+1 indiquera une position imparfaite

$d_{m o d e l}$ : la dimensionnalité prédéfinie des plongements de token (par exemple, 512)

$n$ : valeur scalaire définie par l’utilisateur (par exemple, 10 000)

$P E$ : fonction de position pour le mappage de la position k dans la séquence d’entrée pour obtenir le mappage positionnel

Avec cette formule, chaque mot, à la position k, aura une valeur de plongement basée sur la position du mot. Reprenons l’exemple que nous avons utilisé, « Jean promène chien ». Nous pouvons calculer le plongement positionnel pour chaque mot :

– $k_{1}$ = « Jean »

– $k_{2}$ = « promène »

– $k_{3}$ = « chien »

Écrivons une fonction Python simple pour calculer la valeur de $P E (k)$ :

importer numpy en tant que np 

importer Matplotlib.pyplot en tant que plt 

 

 # créer la fonction d’encodage positionnel en utilisant la formule ci-dessus 

def getPositionEncoding(seq_len, d, n=10000) : 

    # instancier un tableau de 0 comme point de départ 

 P = np.zeros((seq_len, d)) # itérer sur les positions de chaque mot pour k dans range(seq_len) : #calculer l’encodage positionnel pour les positions paires et impaires de chaque mot pour i dans np.arange(int(d/2)) : dénominateur = np .power(n, 2*i/d) P[k, 2*i] = np.sin(k/dénominateur) 

            P[k, 2*i+1] = np.cos(k/dénominateur) 
    retour P

Une fois que nous avons appelé la fonction et entré la valeur correspondante dans notre exemple, où la longueur de la séquence est de 3, avec une dimension simplifiée de $d = 4$ , et $n = 10000$

P = getPositionEncoding(seq_len=3, d=4, n=10000) 

print(P)

Nous obtenons la matrice d’encodage suivante (également appelée tenseur) :

[[ 0. 1. 0. 1. ]

[ 0.84147098 0.54030231 0.09983342 0.99500417]

[ 0.90929743 -0.41614684 0.19866933 0.98006658]]

Pour représenter ce résultat plus concrètement, nous obtenons

Position du mot	Dim 0 sin(pos ÷ 10000^(0 ÷ 4))	Dim 1 cos(pos ÷ 10000^(0 ÷ 4))	Dim 2 sin(pos ÷ 10000^(2 ÷ 4))	Dim 3 cos(pos ÷ 10000^(2 ÷ 4))
« Jean » k = 0	0,0000	0,0000	0,0000	1.0000
« promène » k = 1	0,841471	0,540302	0,010000	0,999950
« chien » k = 2	0,909297	− 0,416147	0,020000	0,999800

Ici, nous pouvons voir la valeur concrète de chaque mot et la valeur de plongement correspondante. Cependant, nous ne pouvons pas utiliser ces plongements de mots directement pour interpréter l’ordre des mots. La valeur calculée ici est utilisée pour injecter des informations sur la position dans un vecteur d’entrée du Transformer. Étant donné que les entrées de $s i n (x)$ et $c o s (x)$ sont différentes, chaque position $k$ répondra à une fonction sinusoïdale différente. La position correspondante des différentes fonctions sinusoïdales nous donne des informations sur la position absolue et la position relative du mot dans « Jean promène chien ». En d’autres termes, ces informations peuvent être utilisées par le modèle afin d’apprendre à associer ces schémas à l’ordre, à l’espacement et à la structure.

Implémentons maintenant une fonction python pour visualiser la matrice positionnelle

import numpy as np 

import matplotlib.pyplot as plt 

  

def get_position_encoding(seq_len, d_model, n=10000): 

    P = np.zeros((seq_len, d_model)) 

    for pos in range(seq_len): 

        for i in range(d_model): 

            angle = pos / np.power(n, (2 * (i // 2)) / d_model) 

            P[pos, i] = np.sin(angle) if i % 2 == 0 else np.cos(angle) 

    return P 

  

# Parameters 

seq_len = 100   # Number of tokens 

d_model = 512   # Embedding dimensions 

  

# Generate positional encoding 

P = get_position_encoding(seq_len, d_model) 

  

# Plot 

plt.figure(figsize=(10, 6)) 

cax = plt.matshow(P, cmap='viridis', aspect='auto') 

plt.title("Sinusoidal Positional Encoding Heatmap") 

plt.xlabel("Embedding Dimension") 

plt.ylabel("Token Position") 

plt.colorbar(cax) 

plt.tight_layout() 

plt.show()

Dernières réflexions

Comme nous pouvons le voir avec les différentes fréquences basées sur les valeurs de x, chaque position correspondante du mot d’entrée k sera différente sur une échelle de $[- 1.1]$ , la gamme de la fonction $s i n (x)$ . De là, notre modèle de Transformer basé sur l’encodeur-décodeur apprendra et préservera l’encodage positionnel de chaque mot, ce qui permettra de conserver les informations pour l’entraînement. Le vecteur de position encodé reste statique pendant l’entraînement, ce qui permet un calcul en parallèle.

Libérez la puissance de l’IA générative et du ML

Découvrez comment intégrer en toute confiance l’IA générative et le machine learning dans votre entreprise.

Ressources

Les bases des réseaux neuronaux

Acquérez une compréhension approfondie des réseaux neuronaux, de leurs fonctions de base et des principes fondamentaux de leur construction.

Découvrir IBM Granite

IBM Granite est notre famille de modèles d’IA ouverts, performants et fiables, conçus pour les entreprises et optimisés pour dimensionner vos applications d’IA. Explorez les options de langage, de code, de séries temporelles et de garde-fous.

L’IA en action 2024

Nous avons interrogé 2 000 entreprises à propos de leurs initiatives d’IA pour découvrir ce qui fonctionne, ce qui ne fonctionne pas et comment progresser.

Libérez la puissance de l’IA générative et du ML

Découvrez comment intégrer en toute confiance l’IA générative et le machine learning dans votre entreprise.

Choisir le bon modèle de fondation

Découvrez comment choisir le modèle de fondation d’IA le mieux adapté à votre cas d’utilisation.

Le guide du PDG sur l’IA générative

Découvrez comment les PDG peuvent trouver un équilibre entre la valeur que l’IA générative peut créer, l’investissement qu’elle exige et les risques qu’elle introduit.

Mettre l’IA au travail : mise en place d'un retour sur investissement grâce à l'IA générative

Vous voulez obtenir un meilleur retour sur vos investissements dans l’IA ? Découvrez comment la mise à l’échelle de l’IA générative dans des domaines clés favorise le changement en aidant vos meilleurs éléments à créer et à fournir de nouvelles solutions innovantes.

Solutions connexes

IBM watsonx.ai

Entraînez, validez, réglez et déployez une IA générative, des modèles de fondation et des capacités de machine learning avec IBM watsonx.ai, un studio d’entreprise nouvelle génération pour les générateurs d’IA. Créez des applications d’IA en peu de temps et avec moins de données.

Découvrir watsonx.ai

Solutions d’intelligence artificielle

Mettez l’IA au service de votre entreprise en vous appuyant sur l’expertise de pointe d’IBM dans le domaine de l’IA et sur son portefeuille de solutions.

Découvrir les solutions d’IA

Conseils et services en matière d’IA

Réinventez les workflows et les opérations critiques en ajoutant l’IA pour optimiser les expériences, la prise de décision et la valeur métier en temps réel.

Découvrir les services d’IA

Passez à l’étape suivante

Bénéficiez d’un accès centralisé aux fonctionnalités couvrant le cycle de développement de l’IA. Produisez des solutions IA puissantes offrant des interfaces conviviales, des workflows et un accès à des API et SDK conformes aux normes du secteur.

Découvrir watsonx.ai

Réserver une démo en direct

Notes de bas de page

1. « Attention Is All You Need », Ashish Vaswani et al., Proceedings of the 31st International Conference on Neural Information Processing Systems, arXiv:1706.03762v7, révisé le 2 août 2023.

2. « Long Short-Term Memories », Sepp Hochreiter et Jürgen Schmidhuber. 1997. Long Short-Term Memory. Neural Comput. 9, 8 (15 novembre 1997), 1735 – 1780.,

3.« Foundations of Recurrent Neural Networks (RNNs) and Long Short-Term Memories », Alex Shertinsky et al., journal Elsevier « Physica D: Nonlinear Phenomena », volume 404, mars 2020 : édition spéciale sur le machine learning et les systèmes dynamiques

Qu’est-ce que l’encodage positionnel ?