Batch- och layernormalisering

Ett normaliseringslager tar aktiveringarna, drar bort medelvärdet och delar med standardavvikelsen — och lär sig sedan två parametrar (γ, β) som får skala och flytta tillbaka om det behövs.

Batchnorm normaliserar över batchen för varje feature. Behöver alltså en batch, och beter sig olika under träning (batchens statistik) och inferens (löpande medelvärden). Standard i CNN.

Layernorm normaliserar över features inom varje exempel. Oberoende av batchstorlek, identisk under träning och inferens. Standard i transformers — bland annat därför att sekvenser har olika längd och batchstatistik blir opålitlig.

Effekten: stabilare träning, högre inlärningstakt går att använda, mindre känslighet för initiering.

import torch, torch.nn as nn

x = torch.randn(32, 64)                    # (batch, features)

bn = nn.BatchNorm1d(64)
ln = nn.LayerNorm(64)

print(bn(x).mean(dim=0)[:3].round(decimals=4))   # ≈ 0 per feature (över batchen)
print(ln(x).mean(dim=1)[:3].round(decimals=4))   # ≈ 0 per exempel (över features)

# Batchnorm beter sig olika i eval:
bn.eval()
print(bn(x).mean().item())      # använder löpande statistik, inte batchens

# Transformerblock: layernorm före attention (pre-norm) är standard i dag
class Block(nn.Module):
    def __init__(self, d):
        super().__init__()
        self.ln1, self.ln2 = nn.LayerNorm(d), nn.LayerNorm(d)
        self.attn, self.mlp = nn.MultiheadAttention(d, 8, batch_first=True), nn.Sequential(nn.Linear(d, 4*d), nn.GELU(), nn.Linear(4*d, d))
    def forward(self, x):
        h = self.ln1(x); x = x + self.attn(h, h, h, need_weights=False)[0]
        return x + self.mlp(self.ln2(x))

Fällan: batchnorm med batchstorlek 1 eller 2 ger meningslös statistik och kan förstöra träningen helt. Använd layernorm eller GroupNorm när batchen måste vara liten.