Architetture neurali — CNN, RNN, Transformer

Perché servono architetture diverse

Una MLP fully-connected è un approssimatore universale: in teoria può rappresentare qualsiasi funzione. In pratica, applicarla brutalmente a un'immagine 256×256 RGB è un disastro. Vediamo perché.

Un'immagine 256×256×3 ha 196.608 pixel. Un primo layer fully-connected da 1000 unità avrebbe quasi 200 milioni di parametri. Per un dataset di 60.000 immagini, è assicurato che il modello memorizzerà perfettamente i dati senza imparare nulla di generale. Inoltre, la MLP non sa nulla della struttura spaziale dell'immagine — per lei il pixel (12,45) e il pixel (200,150) sono input scorrelati, tanto quanto i pixel adiacenti (12,45) e (12,46). Tutto ciò che “sa” un essere umano sulla visione (località, traslazione, invarianza di scala) la rete dovrebbe impararlo da capo, dai dati, sprecando capacità rappresentativa.

Le architetture specializzate codificano dentro la struttura della rete delle assunzioni a priori (inductive bias) sui dati. La CNN assume che la struttura sia locale e invariante per traslazione. La RNN assume che la struttura sia sequenziale e temporale. Il Transformer assume che ogni elemento possa essere rilevante per ogni altro, e lascia all'attention scoprire quali. Ognuna di queste scelte ha conseguenze enormi su come la rete impara e cosa può rappresentare.

Analogia: pensa a tre tipi di artigiani. Un orologiaio (CNN) lavora con strumenti specializzati per pezzi piccoli e ravvicinati; assume che il dettaglio sia tutto e il contesto distante non lo riguardi. Un musicista (RNN) suona una nota alla volta, ricordando quelle precedenti, costruendo la melodia in sequenza. Un direttore d'orchestra (Transformer) vede l'intero pezzo dall'alto, decide a ogni istante a quale strumento prestare attenzione, può collegare il finale all'introduzione. Le tre prospettive servono a problemi diversi.

CNN — Convolutional Neural Networks

L'idea base della convoluzione è far scorrere un piccolo “filtro” (una matrice di pesi, tipicamente 3×3 o 5×5) su tutta l'immagine, calcolando in ogni posizione un prodotto scalare. Il filtro impara a rispondere a un certo pattern locale — un bordo verticale, una texture, un colore — e produce in output una feature map che indica dove quel pattern compare nell'immagine.

Tre proprietà chiave della convoluzione:

1. Località: ogni unità di output guarda solo una piccola regione dell'input (campo recettivo). Inductive bias: feature significative sono locali.

2. Parameter sharing: lo stesso filtro è applicato in tutte le posizioni. Inductive bias: ciò che è utile in alto a sinistra è utile anche in basso a destra (invarianza per traslazione). Conseguenza enorme: una conv con 32 filtri 3×3 su un'immagine RGB ha 3×3×3×32 = 864 parametri, indipendentemente dalle dimensioni dell'immagine. La stessa cosa con una MLP fully-connected ne avrebbe milioni.

3. Composizione gerarchica: impilando layer convoluzionali, ogni layer combina feature di più basso livello in feature di più alto livello. Layer 1: bordi e angoli. Layer 5: parti di oggetti. Layer 10: oggetti interi. Layer 15: scene composite.

Pooling — ridurre dimensione, mantenere essenza

Tra layer convoluzionali si inseriscono operazioni di pooling che riducono la dimensione spaziale. Il max pooling 2×2 divide la feature map in quadrati 2×2 e tiene solo il massimo. Riduce dimensione 4x, mantiene la feature più forte di ogni quadrato, è robusto a piccole traslazioni. Average pooling è un'alternativa più smooth. Global average pooling riduce ogni feature map a un singolo numero ed è lo standard moderno prima del classifier finale.

# CNN base in PyTorch
import torch.nn as nn

cnn = nn.Sequential(
    nn.Conv2d(3, 32, kernel_size=3, padding=1),   # 3→32 canali, conv 3×3
    nn.ReLU(),
    nn.MaxPool2d(2),                              # 32×32 → 16×16

    nn.Conv2d(32, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),                              # 16×16 → 8×8

    nn.AdaptiveAvgPool2d(1),                       # global avg pool → 1×1
    nn.Flatten(),
    nn.Linear(64, 10),                            # classifier 10 classi
)

Le architetture CNN che hanno fatto la storia

ResNet e le skip connection

La rivoluzione di ResNet (Microsoft Research Asia, 2015) sembra banale. Ogni blocco di una rete ResNet calcola:

Dove F è una sequenza di conv-BN-ReLU-conv-BN e x è l'input del blocco stesso, sommato a fine blocco (skip connection, anche detto residual connection). Sembra una decorazione, ma cambia tutto. Il gradiente che fluisce all'indietro può sempre passare attraverso la skip connection: ∂(F(x)+x)/∂x = ∂F/∂x + I, dove I è l'identità. Anche se ∂F/∂x è minuscolo, l'+I garantisce gradiente non nullo. Vanishing gradient risolto.

Pratico effetto: prima di ResNet le CNN si fermavano a ~20 layer, perché più profonde non addestravano. Dopo ResNet, 152 layer addestrabili senza problemi, 1000 layer con qualche accorgimento. Le skip connection sono uno degli inventi di design più importanti del deep learning: oggi sono dappertutto, inclusi i Transformer (che hanno residual connection in ogni layer).

RNN — Reti Ricorrenti

Le immagini hanno struttura spaziale. Testo, audio, serie temporali hanno struttura sequenziale: l'ordine conta, e ogni elemento dipende dai precedenti. Per processare sequenze servono reti che mantengono memoria.

L'idea della RNN è semplice e bella: a ogni timestep t, la rete riceve l'input corrente x_t e uno stato nascosto h_t−1 ereditato dal timestep precedente, e produce un nuovo stato h_t e un output y_t:

L'eleganza: una RNN può processare sequenze di qualunque lunghezza con un numero fisso di parametri. Tre architetture canoniche per task diversi:

Il problema della RNN vanilla: la memoria si dimentica

Le RNN puramente vanilla (Elman, 1990) hanno un problema strutturale grave: la memoria svanisce rapidamente. Per propagare l'errore di un output al timestep 50 fino al peso che ha influenzato il timestep 1, il gradiente attraversa 50 moltiplicazioni per W_hh. Se i valori di W_hh sono in media < 1, il gradiente si annulla — vanishing gradient nel tempo. Se sono > 1, esplode. In pratica le RNN vanilla riescono a tenere memoria di circa 5–10 timestep, oltre i quali dimenticano. Inutile per traduzione di frasi lunghe o per generazione di testo coerente.

LSTM e GRU — la memoria gated

LSTM (Long Short-Term Memory, Hochreiter & Schmidhuber 1997) risolve il problema introducendo un cell state c_t che fluisce attraverso il tempo con poche trasformazioni, modulato da tre gate (forget, input, output) controllati dalla rete stessa:

Il punto cruciale: il cell state c_t è aggiornato in modo additivo (c_t = f · c_t−1 + i · c˜), non moltiplicativo. Esattamente come le skip connection di ResNet risolvono il vanishing gradient nello spazio, le LSTM lo risolvono nel tempo. Possono mantenere memoria di centinaia di timestep.

La GRU (Cho et al. 2014) è una versione semplificata con due gate invece di tre. Performance simili a LSTM in molti task, con meno parametri.

Dal 2014 al 2017 LSTM e GRU sono lo standard NLP: traduzione, sentiment analysis, named entity recognition, summarization. Google Translate gira su LSTM dal 2016 al 2017. Poi arriva il Transformer.

Transformer — Attention is All You Need

Nel giugno 2017 otto ricercatori Google Brain (Vaswani, Shazeer, Parmar, Uszkoreit, Jones, Gomez, Kaiser, Polosukhin) pubblicano “Attention Is All You Need”. Propongono un'architettura per la traduzione automatica che elimina completamente la ricorrenza e si basa solo su un meccanismo di attention. Sui benchmark di traduzione i risultati sono superiori, ma il vero impatto è un altro: il Transformer è parallelizzabile.

Una LSTM addestra un timestep alla volta: t₂ deve aspettare t₁, t₃ deve aspettare t₂, etc. Su una sequenza di 1000 token sono 1000 step seriali. Il Transformer processa tutta la sequenza in parallelo grazie all'attention: ogni token guarda tutti gli altri simultaneamente. Su GPU questo significa addestramento 10–100x più veloce. La porta dello scaling è spalancata: nascono BERT, GPT, e tutti i grandi LLM moderni.

Self-attention — il cuore del Transformer

Ogni token della sequenza produce tre vettori: Query, Key, Value. L'attention score di un token i verso un token j è il prodotto scalare della query di i con la key di j:

L'interpretazione: per ogni token i, calcoli quanto attentamente deve guardare ogni altro token j (i punteggi softmax sommano a 1), e poi prendi la media pesata dei value di tutti i token. Il risultato è una nuova rappresentazione di i che integra contesto da tutta la sequenza.

Tre dettagli importanti. Primo, la divisione per √d_k è una scalatura che impedisce ai prodotti scalari di diventare troppo grandi e mandare il softmax in saturazione. Secondo, la multi-head attention esegue questo calcolo h volte in parallelo (tipico h=8 o 16), ognuna su uno spazio proiettato diverso, e concatena i risultati. Ogni testa può specializzarsi su relazioni diverse (sintassi, coreference, dipendenze semantiche). Terzo, l'attention è permutation-invariant: senza ulteriori accorgimenti, “cane morde uomo” e “uomo morde cane” sarebbero indistinguibili. Per dare ordine si aggiungono positional encoding agli embedding di input (sinusoidali nel paper originale, learned o RoPE nei modelli moderni).

Encoder, decoder, encoder-decoder

Il Transformer originale ha due metà: un encoder che processa la sequenza di input in parallelo, e un decoder che genera la sequenza di output un token alla volta. Da questi due blocchi è nata l'intera tassonomia degli LLM moderni.

Anatomia di un blocco Transformer

Un blocco Transformer ha una struttura abbastanza fissa che si ripete N volte (N=12 in BERT-base, N=96 in GPT-3, N=80 in Llama 3 70B):

Quattro componenti per blocco: (1) multi-head self-attention; (2) un MLP a due strati (di solito con espansione 4x: in 768, hidden 3072, out 768 in BERT-base) con attivazione GELU; (3) due skip connection che aggirano sia attention che MLP; (4) due LayerNorm, applicate prima (Pre-LN, lo standard moderno) o dopo (Post-LN, il paper originale) ogni sub-blocco. Pre-LN è più stabile in training e ha sostituito Post-LN nei modelli moderni.

Perché il Transformer ha cambiato tutto

Tre ragioni convergono.

1. Parallelizzazione. Tutta la sequenza processata in parallelo → sfrutta perfettamente GPU/TPU → modelli più grandi addestrabili in tempi ragionevoli → emerge la scala.

2. Long-range dependencies. L'attention permette a ogni token di guardare direttamente qualsiasi altro token, indipendentemente dalla distanza. Nessun decadimento di memoria come nelle RNN. Modelli moderni gestiscono contesti di 200.000+ token (Claude, Gemini 1.5 Pro arrivano a 1M+).

3. Generalità dell'architettura. Lo stesso Transformer (con minimi adattamenti) funziona su testo, immagini (Vision Transformer), audio (Whisper), proteine (AlphaFold), codice (Codex), grafici (Graph Transformer), serie temporali. Un'unica architettura per molte modalità: prima ogni dominio aveva la sua architettura specializzata.

Varianti moderne — MoE, State Space, Multimodale

Mixture of Experts

Nei Transformer standard, ogni token attraversa tutti i parametri del MLP. Idea MoE: invece di un singolo MLP per layer, hai N esperti (ognuno un MLP separato) e un piccolo router che decide quale esperto attivare per ogni token. Solo k=1 o k=2 esperti per token vengono effettivamente eseguiti.

Vantaggio: hai un modello con miliardi di parametri totali ma costo computazionale di un modello molto più piccolo (perché usi solo gli esperti attivi). Mixtral 8x7B (Mistral, 2023) ha 46.7B parametri totali ma usa solo 12.9B per token. GPT-4 è quasi certamente un MoE (le stime parlano di ~1.8T parametri totali, ~280B attivi). DeepSeek V3 (2024), Llama 4 (2025), Claude 3.5 hanno tutti architetture MoE.

State Space Models (Mamba)

Famiglia di modelli (S4, S5, Mamba) che ripropone l'idea ricorrente in chiave moderna, con un meccanismo selettivo per ricordare/dimenticare. Costo computazionale lineare nella lunghezza della sequenza (vs quadratico per Transformer self-attention), il che li rende interessanti per sequenze molto lunghe (audio lungo, DNA, sensor data). Performance competitiva con Transformer su linguaggio, ma non hanno ancora sostituito i Transformer in production a grande scala.

Architetture multimodali

I modelli di frontiera moderni (GPT-4o, Gemini 2.0, Claude 3.5) accettano e producono modalità multiple: testo, immagini, audio, video. Due approcci principali. Late fusion: encoder separati per ogni modalità (CLIP-style: un text encoder e un image encoder che producono embedding nello stesso spazio), poi un Transformer combina i risultati. Native multimodal: token di modalità diverse mescolati nella stessa sequenza, un unico Transformer che processa tutto omogeneamente. Quest'ultimo è l'approccio di GPT-4o e Gemini 2.0, ed è quello che permette comportamenti più integrati (es. ragionamento congiunto su immagine + testo).

Pre-training & fine-tuning — il paradigma moderno

Fino al 2017 lo standard era: per ogni nuovo task addestrare una nuova rete da zero. Dal 2018 in poi (BERT) il paradigma cambia radicalmente: pre-training su tantissimi dati generici, fine-tuning su pochi dati specifici.

Pre-training: il modello viene addestrato su un task self-supervised (non richiede etichette umane) su un corpus enorme. Tipici task self-supervised:

• Masked Language Modeling (BERT): maschera il 15% dei token, predici quelli mancanti dato il contesto.
• Causal Language Modeling (GPT): predici il prossimo token dato il contesto precedente.
• Span corruption (T5): rimuovi span di token, generali in ordine.
• Contrastive learning (CLIP, SimCLR): porta vicini nello spazio gli embedding di coppie correlate, lontani quelli scorrelati.
• Next sentence prediction (BERT, abbandonato in RoBERTa): predici se due frasi si seguono o no.

Il bello del self-supervised: non servono annotatori umani. Il dataset è il web stesso. GPT-3 è addestrato su ~500 miliardi di token; GPT-4 si stima su trilioni; Llama 3 su 15 trilioni. Quantità di dati impensabili per qualsiasi annotazione manuale.

Fine-tuning: il modello pre-addestrato viene affinato su un task specifico con dati etichettati (sentiment analysis, summarization specifica per il tuo dominio, ecc.). Servono ordini di magnitudo meno dati rispetto a un training from-scratch: spesso bastano qualche migliaio di esempi etichettati. È una forma di transfer learning: le conoscenze generali apprese in pre-training si trasferiscono al task specifico.

Da fine-tuning a RLHF e instruction-tuning

Per i modelli generativi (GPT-3 in poi) il fine-tuning ha preso una forma particolare: l'allineamento. Tre stadi tipici dopo il pre-training:

1. SFT (Supervised Fine-Tuning): dimostrazioni umane di buone risposte. Insegnano al modello lo stile e il formato.
2. Reward Modeling: annotatori umani confrontano coppie di risposte (“quale è meglio?”). Si addestra un Reward Model che imita queste preferenze.
3. RLHF (Reinforcement Learning from Human Feedback): il modello viene addestrato con Reinforcement Learning per massimizzare il reward predetto, spesso con PPO (Proximal Policy Optimization).

Varianti moderne: DPO (Direct Preference Optimization, 2023) salta il Reward Model e ottimizza direttamente sulle preferenze, più semplice e stabile. Constitutional AI (Anthropic) usa un modello AI per generare il feedback invece di umani, scalabile.

PEFT — Parameter Efficient Fine-Tuning

Fine-tunare 70 miliardi di parametri costa centinaia di migliaia di dollari di GPU. LoRA (Low-Rank Adaptation, 2021) e varianti freeze il modello base e addestrano solo piccole matrici di adattamento (1% dei parametri totali). Risultati comparabili al full fine-tuning a costo 100x inferiore. QLoRA aggiunge quantizzazione a 4-bit: puoi fine-tunare Llama-70B su una singola GPU consumer da 24GB.

Scaling laws — quanto più grande, quanto migliore

Una delle scoperte più importanti dell'era LLM è che le performance dei modelli sono prevedibili in funzione di tre risorse: parametri, dati, compute. Si chiamano scaling laws.

Il paper seminale è Kaplan et al. (OpenAI, 2020): mostra che la loss del modello scala come una power law in ognuno dei tre. Se aumenti i parametri di 10x, la loss scende di X. Niente saturazione (almeno fino alle scale testate).

Nel 2022 il paper Chinchilla (DeepMind) rivede le scaling laws con un risultato pratico cruciale: i modelli LLM contemporanei (incluso GPT-3) erano under-trained. Per un budget computazionale fissato, la performance ottimale richiede più dati e meno parametri di quanto si pensasse. La regola Chinchilla: 20 token di training per parametro. Un modello da 70B parametri vuole 1.4T token. Llama 3 (15T token per 70B parametri) usa addirittura ~200 token per parametro — oltre Chinchilla, ma motivato dal fatto che modelli più piccoli con più dati sono più economici in inferenza.

Capacità emergenti

Le scaling laws predicono la loss. Quello che non predicono è quando emergono capacità qualitative specifiche. Esempi documentati: l'abilità di fare aritmetica a più cifre emerge attorno ai 70B parametri; il chain-of-thought reasoning emerge attorno ai 100B; il code-switching tra lingue affidabile attorno a quei livelli. Sotto soglia: il modello fallisce. Sopra: funziona quasi perfettamente. La transizione è netta, non graduale.

È un fenomeno controverso. Schaeffer et al. (2023) hanno mostrato che molte “emergenze” sono artefatti delle metriche discrete: con metriche più smooth, le capacità migliorano gradualmente. Ma in pratica, dal punto di vista dell'utente, una capacità che funziona allo 0% è assente, e una che funziona al 90% è presente. La discontinuità percepita è reale anche se quella sottostante non lo è.

Quale architettura per quale problema (cheat sheet)

Cosa portarsi a casa

Tre principi che si sono dimostrati robusti attraverso le diverse architetture.

1. L'inductive bias dell'architettura conta. CNN per immagini, RNN/Transformer per sequenze, GNN per grafi: scegliere l'architettura adatta riduce la quantità di dati necessaria di ordini di magnitudo. Con abbastanza dati, anche un'architettura sub-ottimale (es. Transformer su immagini) può vincere, ma il prezzo è lo scaling.

2. La residual connection è il pattern di design più importante del decennio. ResNet (2015), LSTM (1997), Transformer (2017) — tutti risolvono i loro problemi di gradient flow con qualche forma di skip connection o gate. Se progetti reti profonde da zero, mettile.

3. Il pre-training cambia l'economia. Per molti task pratici, il momento del “addestra da zero” è finito. Prendi un modello pre-addestrato, fai fine-tuning con LoRA su pochi dati specifici, ottieni risultati che dieci anni fa avrebbero richiesto un team accademico di anni. Questa è la rivoluzione vera della pratica del 2023–2026, prima ancora che le capacità emergenti facciano notizia.

Continua il percorso

Hai completato il giro teorico sui fondamenti del deep learning. Ora puoi:

• Approfondire come questi modelli rappresentano il testo — Token e Modelli AI (panoramica LLM moderni)
• Vedere come la teoria diventa codice nei case study didattici — nove progetti Python che attraversano scikit-learn, PyTorch da zero, ResNet con transfer learning, Hugging Face Transformers, OpenAI API, LangChain
• Passare alle tecniche applicative moderne: RAG, GraphRAG, MCP, Orchestrazione di agenti, Prompt Engineering
• Riprendere la storia dell'AI per inquadrare dove ci porterà il prossimo decennio