multi-head self-attention

1. 1

   Opmærksomhedsmekanisme, hvor en sekvens af elementer (fx ord) hver især beregner opmærksomhed over alle andre elementer i sekvensen, opsplittet i flere parallelle 'hoveder' for at fange forskellige repræsentationsaspekter.

   • Multi-head self-attention gør det muligt for modellen samtidig at fokusere på både lokale og globale afhængigheder i sætningen. — Generelt eksempel
   • I transformerlaget efterfølges multi-head self-attention typisk af et feed-forward-netværk. — Vaswani et al., 2017
2. 2

   Specifik implementering af multi-head attention, hvor forespørgsler, nøgler og værdier alle stammer fra samme sekvens (self-attention). Dette er standard i koderdelen af transformere.

   • BERT anvender multi-head self-attention med 12 hoveder i sin base-version. — Devlin et al., 2019

Multi-head self-attention anvendes som en central byggesten i transformermodeller såsom BERT og GPT. Det bruges i hvert lag til at lade token-repræsentationer interagere og aggregere information på tværs af sekvensen. Flere hoveder gør det muligt at fange forskellige typer relationer, fx syntaktiske og semantiske.

MultiHead(Q,K,V) = Concat(head_1, ..., head_h)W^O, where head_i = Attention(QW_i^Q, KW_i^K, VW_i^V) and Attention(Q,K,V) = softmax(QK^T/√d_k)V.

import torch
import torch.nn as nn

class MultiHeadSelfAttention(nn.Module):
    def __init__(self, d_model, n_heads):
        super().__init__()
        self.n_heads = n_heads
        self.d_k = d_model // n_heads
        self.q_lin = nn.Linear(d_model, d_model)
        self.k_lin = nn.Linear(d_model, d_model)
        self.v_lin = nn.Linear(d_model, d_model)
        self.out_lin = nn.Linear(d_model, d_model)

    def forward(self, x):
        B, T, D = x.shape
        Q = self.q_lin(x).view(B, T, self.n_heads, self.d_k).transpose(1,2)
        K = self.k_lin(x).view(B, T, self.n_heads, self.d_k).transpose(1,2)
        V = self.v_lin(x).view(B, T, self.n_heads, self.d_k).transpose(1,2)
        attn = torch.softmax(Q @ K.transpose(-2,-1) / (self.d_k**0.5), dim=-1)
        out = (attn @ V).transpose(1,2).contiguous().view(B, T, D)
        return self.out_lin(out)

En forenklet PyTorch-implementering af multi-head self-attention med lineære projektioner.

Begrebet blev introduceret i artiklen 'Attention Is All You Need' af Vaswani et al. (2017). 'Multi-head' refererer til brugen af flere uafhængige opmærksomhedsmekanismer i parallel, og 'self-attention' betyder, at opmærksomheden beregnes over inputsekvensens egne elementer.

• Attention Is All You Need (Vaswani et al., 2017)
• BERT: Pre-training of Deep Bidirectional Transformers (Devlin et al., 2019)