Autoattention multi-tête

Modèles Transformer avec PyTorch

James Chapman

Curriculum Manager, DataCamp

Attention multi-tête dans les transformers

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

Modèles Transformer avec PyTorch

Mécanisme d'autoattention

Anatomie du mécanisme d'autoattention

Modèles Transformer avec PyTorch

Mécanisme d'autoattention

Anatomie du mécanisme d'autoattention

  • Q : Indique ce que chaque jeton « cherche » chez les autres
  • K : Représente le contenu de chaque jeton
  • V : Contenu à agréger ou pondérer
Modèles Transformer avec PyTorch

Mécanisme d'autoattention

Anatomie du mécanisme d'autoattention

  • Q : Indique ce que chaque jeton « cherche » chez les autres
  • K : Représente le contenu de chaque jeton
  • V : Contenu à agréger ou pondérer

 

  • Scores d'attention : similarité Q‑K → produit scalaire
Modèles Transformer avec PyTorch

Mécanisme d'autoattention

Anatomie du mécanisme d'autoattention

  • Q : Indique ce que chaque jeton « cherche » chez les autres
  • K : Représente le contenu de chaque jeton
  • V : Contenu à agréger ou pondérer

 

  • Scores d'attention : similarité Q‑K → produit scalaire
  • Poids d'attention : mise à l'échelle softmax
Modèles Transformer avec PyTorch

Mécanisme d'autoattention

Anatomie du mécanisme d'autoattention

  • Scores d'attention : similarité Q‑K → produit scalaire
  • Poids d'attention : mise à l'échelle softmax

 

Orange is my favorite fruit
Requête : Orange
Poids d'attention : ,21 ,03 ,05 ,31 ,40
Modèles Transformer avec PyTorch

Mécanisme d'autoattention

Anatomie du mécanisme d'autoattention

  • Scores d'attention : similarité Q‑K → produit scalaire
  • Poids d'attention : mise à l'échelle softmax

 

Orange is my favorite fruit
Requête : Orange
Poids d'attention : ,21 ,03 ,05 ,31 ,40
Modèles Transformer avec PyTorch

Mécanisme d'autoattention

Anatomie du mécanisme d'autoattention

  • Scores d'attention : similarité Q‑K → produit scalaire
  • Poids d'attention : mise à l'échelle softmax

 

Orange is my favorite fruit
Requête : Orange
Poids d'attention : ,21 ,03 ,05 ,31 ,40
Modèles Transformer avec PyTorch

Attention multi-tête

Autoattention multi‑tête

Modèles Transformer avec PyTorch

Attention multi-tête

Autoattention multi‑tête

Modèles Transformer avec PyTorch

Attention multi-tête

Autoattention multi‑tête

Modèles Transformer avec PyTorch
import torch.nn as nn
import torch.nn.functional as F

class MultiHeadAttention(nn.Module):

    def __init__(self, d_model, num_heads):
        super().__init__()

        assert d_model % num_heads == 0, "d_model must be divisible by num_heads."

        self.num_heads = num_heads
        self.d_model = d_model
        self.head_dim = d_model // num_heads

        self.query_linear = nn.Linear(d_model, d_model, bias=False)
        self.key_linear = nn.Linear(d_model, d_model, bias=False)
        self.value_linear = nn.Linear(d_model, d_model, bias=False)

        self.output_linear = nn.Linear(d_model, d_model)
  • num_heads : nb de têtes d'attention, chacune traite des plongements de taille head_dim
  • bias=False : pas d'impact sur la performance tout en réduisant la complexité (entrées seulement)
Modèles Transformer avec PyTorch
    def split_heads(self, x, batch_size):

        seq_length = x.size(1)
        x = x.reshape(batch_size, seq_length, self.num_heads, self.head_dim)
        return x.permute(0, 2, 1, 3)


    def compute_attention(self, query, key, value, mask=None):

        scores = torch.matmul(query, key.transpose(-2, -1)) / (self.head_dim ** 0.5)

        if mask is not None:
            scores = scores.masked_fill(mask == 0, float('-inf'))

        attention_weights = F.softmax(scores, dim=-1)
        return torch.matmul(attention_weights, value)


    def combine_heads(self, x, batch_size):

        x = x.permute(0, 2, 1, 3).contiguous()
        return x.view(batch_size, -1, self.d_model)
  • compute_attention() : calcule les poids d'attention avec F.softmax()
  • torch.matmul(attention_weights, value) : somme pondérée des valeurs
Modèles Transformer avec PyTorch
    def forward(self, query, key, value, mask=None):
        batch_size = query.size(0)

        query = self.split_heads(self.query_linear(query), batch_size)
        key = self.split_heads(self.key_linear(key), batch_size)
        value = self.split_heads(self.value_linear(value), batch_size)

        attention_weights = self.compute_attention(query, key, value, mask)


        output = self.combine_heads(attention_weights, batch_size)

        return self.output_linear(output)
  • self.output_linear() : concatène et projette les sorties des têtes
Modèles Transformer avec PyTorch

Passons à la pratique !

Modèles Transformer avec PyTorch

Preparing Video For Download...