Comment est construit un transformateur et quels sont ses principaux blocs?

Un transformateur est une architecture de réseau neuronal largement utilisée pour traiter des séquences, comme du texte. L'idée principale du transformateur est d'utiliser un mécanisme d'attention pour pondérer l'importance des différentes parties des données d'entrée sans couches récurrentes ou convolutionnelles.

Les blocs principaux du transformateur :

1. Représentation d'entrée (Embedding) — convertit les tokens d'entrée en représentations vectorielles.

2. Codage positionnel (Positional Encoding) — ajoute des informations sur la position des tokens dans la séquence, car le mécanisme d'attention ne considère pas l'ordre.

3. Mécanisme d'attention (Self-Attention) — calcule des coefficients de poids pour chaque token par rapport à tous les autres, permettant au modèle de se concentrer sur les parties pertinentes de l'entrée.

4. Attention multi-tête (Multi-Head Attention) — applique parallèlement plusieurs mécanismes d'attention pour capturer différents aspects de la dépendance.

5. Normalisation et connexions résiduelles (Layer Normalization et Residual Connections) — aident à stabiliser l'apprentissage et à améliorer le flux de gradients.

6. Couches entièrement connectées (Feed-Forward Network) — sont appliquées à chaque élément de la séquence séparément pour une transformation non linéaire.

7. Couche de sortie — pour des tâches de génération ou de classification.

Exemple de structure simplifiée d'une couche de transformateur :

class TransformerLayer(nn.Module):
    def __init__(self, d_model, nhead):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(d_model, nhead)
        self.linear1 = nn.Linear(d_model, d_model*4)
        self.linear2 = nn.Linear(d_model*4, d_model)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)

    def forward(self, x):
        attn_output, _ = self.self_attn(x, x, x)
        x = self.norm1(x + attn_output)
        ff_output = self.linear2(F.relu(self.linear1(x)))
        x = self.norm2(x + ff_output)
        return x

Ainsi, le transformateur est construit à partir de couches répétées, ce qui permet de modéliser efficacement les dépendances dans les données.