Une brève introduction au mécanisme de l'attention

Le mécanisme de l'attention est une technique importante dans le domaine de l'apprentissage en profondeur, en particulier dans les tâches de traitement du langage naturel (TAL), qui a obtenu des résultats remarquables. Cet article présentera les concepts et principes de base du mécanisme d'attention et comment appliquer le mécanisme d'attention dans le modèle de réseau de neurones.

Quel est le mécanisme de l'attention

Dans l'apprentissage en profondeur, le mécanisme d'attention est une méthode qui imite le principe d'allocation de l'attention humaine. Il aide les réseaux de neurones à apprendre automatiquement à pondérer et à concentrer les informations clés lors du traitement des séquences d'entrée. De cette manière, les réseaux de neurones peuvent capturer plus efficacement les dépendances à longue portée dans les séquences d'entrée.

Le mécanisme de l'attention est issu du modèle séquence à séquence (Seq2Seq), qui est excellent dans le traitement des tâches de séquence (telles que la traduction automatique, la reconnaissance vocale, etc.). Cependant, les modèles Seq2Seq traditionnels sont confrontés au problème de la perte d'informations lorsqu'ils traitent de longues séquences. Les mécanismes d'attention traitent efficacement ce problème en pondérant différentes parties de la séquence d'entrée.

Comment fonctionne le mécanisme d'attention

L'idée centrale du mécanisme d'attention est d'attribuer une valeur de poids à chaque élément de la séquence d'entrée, et ces valeurs de poids détermineront le degré d'attention du modèle lors du traitement de la séquence d'entrée. Les valeurs de poids sont calculées par une fonction apprenable, généralement un réseau de neurones.

Lors du calcul des poids d'attention, nous devons considérer deux vecteurs :

Vecteur de requête : généralement dérivé de l'état caché de la position de la séquence cible actuellement traitée.
Vecteur clé : provient de l'état caché de chaque élément dans la séquence d'entrée.

Le vecteur de requête et le vecteur clé sont calculés via une fonction de notation, produisant un score d'attention brut. Ensuite, ces scores sont normalisés à des valeurs de probabilité, c'est-à-dire des poids d'attention. Enfin, le poids d'attention est multiplié par le vecteur de valeur de la séquence d'entrée pour obtenir une somme pondérée comme sortie du mécanisme d'attention.
Plus précisément, le mécanisme d'attention fonctionne comme suit :

Vecteur de requête : Le vecteur de requête est généralement un état caché par rapport à la position de la séquence cible actuellement traitée. Il capture les informations de la position actuelle dans la séquence cible, qui sont utilisées pour décider quelles positions dans la séquence d'entrée le modèle devrait recevoir plus d'attention.
Vecteur clé : Le vecteur clé est dérivé de l'état caché de chaque élément dans la séquence d'entrée. Il contient des informations sur chaque position dans la séquence d'entrée.
Fonction de notation : La fonction de notation compare le vecteur de requête au vecteur clé pour produire un score d'attention brut. La fonction de notation peut être mise en œuvre de différentes manières, telles que l'attention au produit scalaire, l'attention additive, etc.
Poids d'attention : Les poids d'attention sont obtenus en normalisant les scores d'attention bruts. La normalisation utilise généralement une fonction softmax telle que les pondérations d'attention totalisent 1 et représentent l'importance de chaque emplacement dans le modèle.
Somme pondérée : Le poids de l'attention est multiplié par le vecteur de valeur de la séquence d'entrée, et les résultats sont pondérés et additionnés pour obtenir la sortie finale du mécanisme d'attention. Cette somme pondérée est appelée vecteur de contexte (vecteur de contexte), qui fusionne les informations de chaque position dans la séquence d'entrée et les fournit au modèle pour un traitement ultérieur.

Le mécanisme d'attention pondère les informations de différentes positions dans la séquence d'entrée pendant le processus de calcul, de sorte que le modèle puisse mieux se concentrer sur la position d'entrée liée à la cible actuelle, extraire les informations clés et les utiliser dans le processus de prédiction et de génération ultérieur. Ce mécanisme permet au modèle d'avoir de meilleures performances et une meilleure flexibilité lorsqu'il traite des données de séquence.

Types de mécanismes d'attention

Le mécanisme d'attention peut être divisé en types suivants selon sa méthode de calcul des poids :

Attention additive : Aussi connu sous le nom d'attention de Bahdanau, un réseau de neurones à anticipation est utilisé pour calculer la somme du vecteur de requête et du vecteur clé.
Attention du produit scalaire : Aussi connu sous le nom d'attention de Luong, le score d'attention est obtenu en calculant le produit scalaire du vecteur requête et du vecteur clé.
Attention mise à l'échelle du produit scalaire (Attention mise à l'échelle du produit scalaire) : Basé sur l'attention du produit scalaire, un facteur de mise à l'échelle est introduit pour éviter le problème de disparition du gradient causé par une valeur de produit scalaire trop grande.
Attention multi-tête : Divisez les vecteurs de requête, de clé et de valeur en plusieurs sous-vecteurs, puis calculez l'attention de chaque sous-vecteur séparément, et enfin assemblez les résultats. Cette approche permet au modèle de se concentrer sur de nombreux éléments d'information différents.

Application des mécanismes d'attention aux réseaux de neurones

Pour appliquer l'attention dans un réseau de neurones, nous devons introduire une couche d'attention dans l'architecture du modèle. Voici un exemple simplifié montrant comment appliquer l'attention dans une structure Encodeur-Décodeur :

import torch
import torch.nn as nn
import torch.nn.functional as F

class Encoder(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super(Encoder, self).__init__()
        self.hidden_dim = hidden_dim
        self.lstm = nn.LSTM(input_dim, hidden_dim)

    def forward(self, input_seq):
        outputs, hidden = self.lstm(input_seq)
        return outputs, hidden

class Attention(nn.Module):
    def __init__(self, hidden_dim):
        super(Attention, self).__init__()
        self.attn = nn.Linear(hidden_dim * 2, hidden_dim)
        self.v = nn.Linear(hidden_dim, 1, bias=False)

    def forward(self, hidden, encoder_outputs):
        attn_weights = self.v(torch.tanh(self.attn(torch.cat((hidden, encoder_outputs), dim=2))))
        attn_weights = F.softmax(attn_weights, dim=1)
        return attn_weights

class Decoder(nn.Module):
    def __init__(self, output_dim, hidden_dim):
        super(Decoder, self).__init__()
        self.output_dim = output_dim
        self.hidden_dim = hidden_dim
        self.lstm = nn.LSTM(hidden_dim, hidden_dim)
        self.attention = Attention(hidden_dim)
        self.out = nn.Linear(hidden_dim, output_dim)

    def forward(self, input, hidden, encoder_outputs):
        attn_weights = self.attention(hidden, encoder_outputs)
        context = torch.bmm(attn_weights.transpose(1, 2), encoder_outputs)
        lstm_output, hidden = self.lstm(input, hidden)
        output = torch.cat((lstm_output, context), dim=2)
        output = self.out(output)
        return output, hidden, attn_weights

class Seq2Seq(nn.Module):
    def __init__(self, encoder, decoder):
        super(Seq2Seq, self).__init__()
        self.encoder = encoder
        self.decoder = decoder

    def forward(self, input_seq, target_seq):
        encoder_outputs, hidden = self.encoder(input_seq)
        decoder_outputs = []
        for i in range(target_seq.size(1)):
            decoder_output, hidden, attn_weights = self.decoder(target_seq[:, i].unsqueeze(1), hidden, encoder_outputs)
            decoder_outputs.append(decoder_output)
        return torch.cat(decoder_outputs, dim=1)

Exemple : traduction automatique utilisant des mécanismes d'attention

Dans cet exemple, nous allons construire un modèle de traduction automatique simple utilisant un mécanisme d'attention. Tout d'abord, les données textuelles doivent être prétraitées dans un format d'entrée adapté au modèle. Ensuite, un modèle est construit en utilisant une structure encodeur-décodeur et un mécanisme d'attention. Enfin, entraînez le modèle et évaluez les performances.

Prétraitement des données : chargez les données textuelles, effectuez la segmentation des mots, construisez le vocabulaire et convertissez le texte en représentation numérique.
Création de modèles : utilisez les exemples de code ci-dessus pour créer l'encodeur, la couche d'attention et le décodeur.
Entraînez le modèle : passez la séquence d'entrée à l'encodeur, obtenez la sortie de l'encodeur et l'état caché. Transmettez ces informations au décodeur pour générer la séquence cible. Calculez la fonction de perte et optimisez-la.
Évaluer les performances : testez les performances du modèle sur l'ensemble de test et calculez les métriques d'évaluation telles que BLEU.

Résumer

Ce didacticiel présente les concepts et principes de base du mécanisme d'attention et comment appliquer le mécanisme d'attention dans le modèle de réseau neuronal. Le mécanisme d'attention est devenu l'une des technologies clés dans le domaine de l'apprentissage profond et du traitement du langage naturel. En appliquant un mécanisme d'attention, les performances du modèle peuvent être améliorées pour le rendre plus efficace dans le traitement des tâches séquentielles.