Transformer-blok

1. 1

   Den basale enhed i Transformer-arkitekturen, der består af et multi-head attention-lag, et feed-forward lag, residualforbindelser og layer normalization. Anvendes i både encoder og decoder.

   • Vi stabler 12 Transformer-blokke for at opbygge en BERT-basemodel. — Faglig diskussion, 2023
   • Hver Transformer-blok i decoder indeholder et maskeret multi-head attention-lag for at forhindre kigge fremad. — Originalartikel, 2017

Transformer-blokke bruges som byggesten i stort set alle moderne sprogmodeller som GPT, BERT og T5. De stables i et antal (f.eks. 12 eller 24) for at danne en komplet model. Hver blok behandler sekvensen uafhængigt og trinvis, hvilket muliggør parallelisering.

import torch.nn as nn

class TransformerBlock(nn.Module):
    def __init__(self, d_model, n_heads, d_ff, dropout=0.1):
        super().__init__()
        self.attention = nn.MultiheadAttention(d_model, n_heads, dropout=dropout)
        self.norm1 = nn.LayerNorm(d_model)
        self.ff = nn.Sequential(
            nn.Linear(d_model, d_ff),
            nn.ReLU(),
            nn.Linear(d_ff, d_model)
        )
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        attn_out, _ = self.attention(x, x, x)
        x = self.norm1(x + self.dropout(attn_out))
        ff_out = self.ff(x)
        x = self.norm2(x + self.dropout(ff_out))
        return x

En simpel PyTorch-implementering af en Transformer-blok med multi-head attention og feed-forward lag med residualforbindelser og layer normalization.

Betegnelsen 'Transformer' kommer fra artiklen 'Attention Is All You Need' (2017), hvor arkitekturen blev introduceret. 'Blok' refererer til den modulære, gentagne struktur.

• Attention Is All You Need (2017)