Encodeurs-transformers

Modèles Transformer avec PyTorch

James Chapman

Curriculum Manager, DataCamp

Le transformer original

Architecture des transformers telle que présentée dans l'article universitaire « Attention Is All You Need ».

Le transformer original

Architecture du transformer original

Transformers à encodeur seulement

Architecture transformer à encodeur seulement

Corps du transformer : pile de N couches d'encodeur

Couche d'encodeur

Auto-attention multi-tête

Sous-couches à propagation directe

Normalisations de couche, abandons

Tête du transformer

Transformers à encodeur seulement

Architecture transformer à encodeur seulement

Corps du transformer : pile de N couches d'encodeur

Couche d'encodeur

Auto-attention multi-tête

Sous-couches à propagation directe

Normalisations de couche, abandons

Tête du transformer : traite les entrées encodées pour produire la prédiction de sortie

Tâche supervisée : classification, régression

Sous-couche à propagation directe dans les couches d'encodeur

Sous-couche à propagation directe après l'attention

class FeedForwardSubLayer(nn.Module):
    def __init__(self, d_model, d_ff):
        super().__init__()
        self.fc1 = nn.Linear(d_model, d_ff)
        self.fc2 = nn.Linear(d_ff, d_model)
        self.relu = nn.ReLU()


    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

2 x complètement connectée + activation ReLU

d_ff : dimension entre les couches linéaires
forward() : traite les sorties de l'attention pour capter des patrons complexes non linéaires

Couche d'encodeur

class EncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout):
        super().__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)
        self.ff_sublayer = FeedForwardSubLayer(d_model, d_ff)

        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)


    def forward(self, x, src_mask):
        attn_output = self.self_attn(x, x, x, src_mask)
        x = self.norm1(x + self.dropout(attn_output))
        ff_output = self.ff_sublayer(x)
        x = self.norm2(x + self.dropout(ff_output))
        return x

Couche d'encodeur

Auto-attention multi-tête
Sous-couche à propagation directe
Normalisations de couche et abandons

forward() :

mask évite de traiter les jetons de remplissage

Masquer le processus d'attention

Séquences remplies (padding)

Masque de remplissage en auto-attention

Corps de l'encodeur-transformer

class TransformerEncoder(nn.Module):
    def __init__(self, vocab_size, d_model, num_layers, num_heads, d_ff, dropout, max_seq_length):
        super().__init__()

        self.embedding = InputEmbeddings(vocab_size, d_model)

        self.positional_encoding = PositionalEncoding(d_model, max_seq_length)

        self.layers = nn.ModuleList(
          [EncoderLayer(d_model, num_heads, d_ff, dropout) for _ in range(num_layers)]
        )


    def forward(self, x, src_mask):
        x = self.embedding(x)
        x = self.positional_encoding(x)
        for layer in self.layers:
            x = layer(x, src_mask)
        return x

Tête d'encodeur-transformer

class ClassifierHead(nn.Module):
    def __init__(self, d_model, num_classes):
        super().__init__()
        self.fc = nn.Linear(d_model, num_classes)

    def forward(self, x):
        logits = self.fc(x)
        return F.log_softmax(logits, dim=-1)

class RegressionHead(nn.Module):
    def __init__(self, d_model, output_dim):
        super().__init__()
        self.fc = nn.Linear(d_model, output_dim)

    def forward(self, x):
        return self.fc(x)

Tête de classification

Tâches : classification de texte, analyse de sentiment, NER, QA extractive, etc.
fc : couche linéaire entièrement connectée
- Transforme les états cachés de l'encodeur en probabilités sur num_classes

Tête de régression

Tâches : estimer la lisibilité ou la complexité d'un texte, etc.
- output_dim vaut 1 pour prédire une seule valeur numérique

Passons à la pratique !

Modèles Transformer avec PyTorch