🧙 Maestro Yoda Cap. 19 · Architetture

Puntata 209

Puntata 209 — Norm, attivazioni, residui

Livello: 🧙 Maestro Yoda · Capitolo 19 · Architetture

L’attention è quella che fa notizia. La differenza fra un modello che impara e uno che esplode al passo 3.000 sta in 30 righe di residui e normalizzazione.

blocco transformer “esploso” con frecce che indicano i residui (input bypassa il blocco e si somma in uscita), un riquadro per la LayerNorm, uno per la GELU/SwiGLU. Tag: “il vero lavoro sporco”

I tre amici silenziosi

Ogni blocco transformer è composto da:

  1. Self-attention
  2. Feed-forward network (FFN/MLP)
  3. Tre “amici” che li fanno funzionare:
    • Residual connections (skip)
    • Layer normalization
    • Funzioni di attivazione

Senza i tre amici, training su modelli profondi (>10 layer) è instabile: i gradienti collassano, la loss esplode, i pesi divergono. Con loro, scali a 100 layer e oltre.

Residual connection (skip connection)

L’idea, ereditata da ResNet (He et al., 2015): a ogni blocco, somma l’input al suo output.

y = x + Block(x)

Block(x) può essere l’attention o il FFN. La somma con x è il “residuo”.

Perché funziona:

  1. Gradient highway: il gradiente fluisce dall’output verso l’input senza ostacoli passando per la somma identità. I gradienti non si attenuano esponenzialmente con la profondità.
  2. Inductive bias verso l’identità: il blocco impara una perturbazione di x, non x da zero. Più facile da ottimizzare.
  3. Interpretabilità: lo “stream residuale” è il canale principale di comunicazione fra layer. Ogni blocco vi scrive dentro la sua aggiunta, e i layer successivi possono leggerlo. È una metafora centrale nell’interpretability moderna (transformer-circuits.pub).

Tutti i transformer moderni hanno residui. Senza, non scali. Punto.

Layer Normalization

La self-attention e il FFN producono output con scala e statistica imprevedibili. Senza una normalizzazione, dopo qualche layer la magnitudine esplode o collassa.

LayerNorm (Ba et al., 2016) normalizza lungo la dimensione delle feature, per ogni token indipendentemente:

y = γ · (x - μ) / √(σ² + ε) + β

dove μ, σ sono media e varianza calcolate sui d_model valori del singolo token. γ, β sono parametri appresi (scale and shift).

Tre proprietà rispetto a BatchNorm:

  • Indipendente dal batch size (cruciale per varia-length).
  • Compatibile con autoregressive decoding (non hai statistiche di “batch” in inferenza single-stream).
  • Stesso comportamento train/eval.

Pre-norm vs Post-norm

Differenza non-banale che ha tormentato i ricercatori:

Post-norm (originale 2017):

y = LN(x + Block(x))

La norm è alla fine, sul residuo. Funziona per modelli piccoli, ma per modelli profondi è instabile: serve warmup di learning rate molto attento.

Pre-norm (oggi standard):

y = x + Block(LN(x))

La norm è all’inizio del blocco, sull’input. Lo stream residuale resta puro. Più stabile in training, scala a 100+ layer.

Tutti i modelli grandi moderni usano pre-norm. Un piccolo dettaglio architetturale che, in retrospettiva, ha sbloccato lo scaling oltre i 10-20 layer.

RMSNorm: la versione “leggera”

Root Mean Square Layer Normalization (Zhang & Sennrich, 2019):

y = γ · x / √(mean(x²) + ε)

Niente media da sottrarre, niente bias β. Solo normalizza per la magnitudine.

  • Più semplice, ~10% più veloce della LayerNorm.
  • Quality equivalente (in pratica).
  • Adottato da: Llama (tutti), Mistral, Gemma, DeepSeek, Qwen, Phi.

Nel 2026 RMSNorm è il default de facto nei nuovi LLM. La LayerNorm classica resta in BERT/RoBERTa/T5 e poco altro.

Funzioni di attivazione nel FFN

Il FFN (feed-forward network) di ogni blocco transformer è uno schema fisso:

FFN(x) = W_2 · activation( W_1 · x )

con W_1: d_model → d_ff (tipicamente d_ff = 4 × d_model), e W_2: d_ff → d_model.

La scelta di activation è cambiata nel tempo:

ReLU (originale)

ReLU(x) = max(0, x)

Semplice, veloce. Soffre il problema dei “dead neurons” (input <0 produce gradiente 0).

GELU (Gaussian Error Linear Unit, Hendrycks & Gimpel 2016)

GELU(x) ≈ 0.5 · x · (1 + tanh(√(2/π) (x + 0.044715 x³)))

Smooth, niente zone morte, performa meglio di ReLU su transformer. Default in BERT, GPT-2, GPT-3.

SwiGLU (Shazeer 2020, vincitore moderno)

Gated activation: separa il FFN in due rami e li moltiplica.

FFN_SwiGLU(x) = W_2 · (Swish(W_1 x) ⊙ W_3 x)

dove Swish(x) = x · sigmoid(x). Aggiunge una matrice in più (W_3) ma migliora consistentemente la qualità.

Adottato da: PaLM, Llama (tutti), Mistral, Gemma, DeepSeek, Qwen, Mixtral.

GeGLU

Variante con GELU al posto di Swish. Equivalente in pratica, marginalmente meno usata.

Tendenza 2026: SwiGLU domina. Se vedi un FFN moderno, è quasi sicuro che sia gated.

Dropout: la grande assenza

Nei modelli pre-2020 si usava dropout in attention e FFN. Nei LLM moderni grandi (GPT-3+, Llama, ecc.) il dropout è stato eliminato durante il pretraining: con corpora enormi e single-epoch, il rischio di overfitting è trascurabile e il dropout introduce solo rumore.

Resta in: fine-tuning su dataset piccoli, modelli “vecchi”, task specifici. Per il pretraining a scala, è morto.

Composizione: come arrivano questi pezzi in un blocco

Blocco Llama-3 style (semplificato):

def transformer_block(x):
    # Attention sub-block
    h = x + Attention(RMSNorm(x))
    # FFN sub-block
    out = h + SwiGLU_FFN(RMSNorm(h))
    return out

Stessa identica struttura, ripetuta 32 / 64 / 96 / 128 volte. Tutto il “deep learning” del transformer è quella ricetta replicata.

Glossario lampo

  • Skip connection — residual, somma input-output.
  • Pre-norm / Post-norm — posizione della normalizzazione (prima o dopo il blocco).
  • RMSNorm — variante semplificata di LayerNorm, oggi standard.
  • Gated activation — funzione che moltiplica due rami, uno usato come “gate” sull’altro.
  • Dead neurons — neuroni che restano sempre a 0 perché ReLU spegne i loro input.

TEST hands-on

  1. Implementa RMSNorm in 5 righe di PyTorch. Verifica numericamente che, dato un tensore di shape (B, n, d), normalizzi sull’ultima dim. Confronta con la PyTorch ufficiale (torch.nn.RMSNorm dal 2024).
  2. Allena un mini-transformer di 6 layer (d_model=128, h=4) su un task giocattolo (es. predire il prossimo carattere su Shakespeare). Esegui due training run:
    • uno senza residui
    • uno con residui Confronta le curve di loss. Senza residui vedrai esplosioni o piateau dopo poche centinaia di step.
  3. Sostituisci la SwiGLU con una ReLU. Riallena. Aspettati ~2-5% di perplexity in più a parità di compute.
  4. Bonus: carica meta-llama/Llama-3.2-1B e ispeziona la struttura: print(model). Identifica visivamente RMSNorm, SwiGLU, e il pattern pre-norm. Conta i layer.

Take-away

Tutto il talento del transformer vive nell’attention. Tutta la sua stabilità in training vive in residui, normalizzazione e attivazioni gated. Sono dettagli che non finiscono nei comunicati stampa, ma se mancano il modello non impara. Lo sa chi ha tentato di trainare un transformer “by the book” del 2017 nel 2026 e ha visto la loss salire al cielo dopo 800 step.

➡️ Prossima puntata: Context window estesa — come si arriva a 1M+ token.