MLP-blocket: GELU, SwiGLU

Varje transformerblock har två delar: attention (flyttar information mellan positioner) och MLP (bearbetar varje position för sig).

Klassiskt MLP-block: $\text{MLP}(x) = W_2\,\text{GELU}(W_1 x)$ med en expansion på 4× i mitten: 4096 → 16384 → 4096.

MLP:n står för ungefär två tredjedelar av parametrarna i en transformer — den är där det mesta av «kunskapen» sitter, medan attention sköter dirigeringen.

Gated Linear Units (Shazeer 2020) lägger till en grind: $\text{SwiGLU}(x) = \big(\text{Swish}(W_{\text{gate}}x)\odot W_{\text{up}}x\big)W_{\text{down}}$

Där $\text{Swish}(z) = z\cdot\sigma(z)$ (även kallad SiLU). Grinden låter nätet multiplikativt dämpa eller släppa fram varje kanal beroende på indata — en form av innehållsberoende filtrering som en vanlig MLP inte kan uttrycka lika lätt.

Tre matriser i stället för två betyder fler parametrar vid samma bredd. Därför justeras expansionsfaktorn från 4× till ungefär $\tfrac{8}{3}\approx 2{,}67\times$, så att parameterantalet blir jämförbart:

Vid jämförbart parameterantal presterar SwiGLU konsekvent något bättre — därför används den i Llama, Mistral, Qwen och PaLM.

Llamas märkliga dolda dimension 11 008 är just $\tfrac{8}{3}\cdot 4096 = 10922$ avrundat uppåt till en multipel av 256 (för effektiv matrismultiplikation).

import torch, torch.nn as nn, torch.nn.functional as F

class SwiGLU(nn.Module):
    def __init__(self, d, dold=None, multipel=256):
        super().__init__()
        dold = dold or int(((8 / 3) * d + multipel - 1) // multipel * multipel)
        self.gate = nn.Linear(d, dold, bias=False)
        self.up   = nn.Linear(d, dold, bias=False)
        self.down = nn.Linear(dold, d, bias=False)
        self.dold = dold
    def forward(self, x):
        return self.down(F.silu(self.gate(x)) * self.up(x))

class GeluMLP(nn.Module):
    def __init__(self, d, dold=None):
        super().__init__()
        dold = dold or 4 * d
        self.upp = nn.Linear(d, dold, bias=False)
        self.ner = nn.Linear(dold, d, bias=False)
    def forward(self, x):
        return self.ner(F.gelu(self.upp(x)))

for namn, m in (("GELU-MLP", GeluMLP(4096)), ("SwiGLU", SwiGLU(4096))):
    print(f"{namn:9s} parametrar {sum(p.numel() for p in m.parameters()):,}")
# GELU-MLP  parametrar 134,217,728
# SwiGLU    parametrar 135,266,304   ← jämförbart tack vare 8/3-justeringen