Transformers — arkitekturen

Ett transformerblock gör två saker med varje token: låter den samla information från andra tokens (attention) och sedan bearbeta den för sig själv (ett litet neuronnät, MLP). Runt båda ligger en residual-koppling (lägg till indatan igen, så inget går förlorat) och layernorm (håll talen i rimlig skala).

Stapla 12, 32 eller 96 sådana block, så har du GPT-, Llama- eller Qwen-familjen.

För tokenrepresentationer X (n×d):

X ← X + MultiHeadAttention(LayerNorm(X)) X ← X + MLP(LayerNorm(X))

Multi-head: h parallella attention-huvuden med d/h dimensioner var, resultaten konkateneras — olika huvuden kan lära sig olika slags relationer.

Attention är permutationsinvariant — den vet inte ordningen. Därför adderas positionell kodning till embeddingarna (sinusfunktioner i originalet, inlärda eller roterande (RoPE) i moderna modeller).

Decoder-only (GPT-stil): kausal mask så token t bara ser 1…t. Sista lagret ger logits över ordförrådet → softmax → sannolikhet för nästa token. Generering: dra en token, lägg till den, kör igen. En token i taget, därför är generering långsam och KV-cache (spara K och V för tidigare tokens) är avgörande för hastighet.

import torch.nn as nn

class Block(nn.Module):
    def __init__(self, d, heads):
        super().__init__()
        self.ln1, self.ln2 = nn.LayerNorm(d), nn.LayerNorm(d)
        self.attn = nn.MultiheadAttention(d, heads, batch_first=True)
        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(), nn.Linear(4 * d, d))

    def forward(self, x, mask):
        h = self.ln1(x)
        x = x + self.attn(h, h, h, attn_mask=mask)[0]
        return x + self.mlp(self.ln2(x))

mask är en n×n övre triangulär matris med −inf ovanför diagonalen: den kausala masken.