multi-head opmærksomhed
Multi-head opmærksomhed er en mekanisme i Transformer-arkitekturen, der udfører skalær dot-produkt opmærksomhed flere gange parallelt med forskellige lineære projektioner og sammenkæder resultaterne.
Kort fortalt
Det er en metode, hvor modellen ser på forskellige dele af inputtet fra flere 'vinkler' samtidig for at forstå sammenhænge bedre.
- Kategori
- arkitektur
- Niveau
- øvet
- Udtale
- [ˈmʌltiˌhɛd ʌbˈmɛʁksɔmˌheð]
Betydninger
1- 1
En opmærksomhedsmekanisme, der anvender flere parallelle opmærksomhedshoveder for at indfange information fra forskellige repræsentationsunderrum.
- Transformermodellen anvender multi-head opmærksomhed til at fange både lokale og globale afhængigheder i sætningen.
- I BERT bruges multi-head opmærksomhed til at lære kontekstuelle repræsentationer af ord.
Hvornår bruges det
Multi-head opmærksomhed anvendes primært i Transformer-baserede neurale netværk til opgaver som maskinoversættelse, tekstgenerering og billedbehandling. Det gør det muligt for modellen at fange forskellige former for afhængigheder i dataene ved at lære forskellige opmærksomhedsmønstre.
Formel
MultiHead(Q,K,V) = Concat(head_1, ..., head_h) W^O, where head_i = Attention(Q W_i^Q, K W_i^K, V W_i^V) and Attention(Q,K,V) = softmax(QK^T/√d_k)V.Kodeeksempel
import torch
import torch.nn as nn
class MultiHeadAttention(nn.Module):
def __init__(self, d_model, n_heads):
super().__init__()
assert d_model % n_heads == 0
self.d_k = d_model // n_heads
self.n_heads = n_heads
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, d_model)
self.W_v = nn.Linear(d_model, d_model)
self.W_o = nn.Linear(d_model, d_model)
def forward(self, Q, K, V, mask=None):
batch_size = Q.size(0)
Q = self.W_q(Q).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
K = self.W_k(K).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
V = self.W_v(V).view(batch_size, -1, self.n_heads, self.d_k).transpose(1, 2)
scores = torch.matmul(Q, K.transpose(-2, -1)) / (self.d_k ** 0.5)
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
attn = torch.softmax(scores, dim=-1)
context = torch.matmul(attn, V)
context = context.transpose(1, 2).contiguous().view(batch_size, -1, self.n_heads * self.d_k)
return self.W_o(context)En PyTorch-implementering af multi-head opmærksomhed med lineære projektioner og sammenkædning af hoveder.
Oprindelse
Udtrykket stammer fra artiklen 'Attention Is All You Need' (Vaswani et al., 2017), der introducerede Transformer-arkitekturen. 'Multi-head' refererer til brugen af flere uafhængige opmærksomhedshoveder.