Architetture LLM

Le architetture dei modelli linguistici di grandi dimensioni (LLM) sono i principi fondamentali e le strutture che determinano come i grandi modelli linguistici vengono costruiti, addestrati e funzionano. Gli LLM moderni, capaci di comprendere e generare il linguaggio umano, si basano quasi interamente sull'architettura Transformer, ma includono numerosi miglioramenti e approcci diversi volti ad aumentare l'efficienza, la scalabilità e le capacità.

Famiglie di architetture LLM (transformer)

I moderni modelli linguistici di grandi dimensioni si basano sull'architettura transformer, ma la utilizzano in modi diversi a seconda dell'obiettivo: comprendere il testo, generare una continuazione o trasformare un testo in un altro. In pratica si distinguono tre famiglie, mantenendo i principi di base del transformer.

1. Encoder‑only (solo codificatore, solo encoder)

Il modello utilizza solo lo stack degli encoder e considera l'intero testo in ingresso in modo bidirezionale. Il pre-addestramento è solitamente strutturato come masked‑language modeling (MLM, modellazione linguistica con mascheramento): una parte dei token viene nascosta e il modello impara a ripristinarli dal contesto circostante. Grazie al contesto bidirezionale, questi modelli eccellono nei compiti di comprensione e scoring: classificazione, riconoscimento di entità, re-ranking di documenti e QA estrattivo. Non sono progettati per la generazione autoregressiva "da zero".

In pratica vengono applicati anche obiettivi di pre-addestramento alternativi per la famiglia encoder‑only: replaced token detection (RTD) in ELECTRA (il modello discriminatore riconosce i token sostituiti) e apprendimento contrastivo di bi-encoder per la ricerca semantica/retrieval (InfoNCE/softmax‑loss su coppie «query-documento», come in Dense Passage Retrieval). Quando utilizzati in RAG, gli encoder‑only fungono da bi-encoder (codifica separata di query e documento per una rapida ricerca ANN) oppure da cross-encoder (codifica congiunta della coppia per un re-ranking preciso).

Vantaggi:

• Elevata qualità di comprensione del testo grazie al contesto bidirezionale: classificazione, NER, estrazione di fatti, re-ranking, QA estrattivo.
• Elaborazione parallela e alta velocità di throughput: un singolo passaggio diretto senza auto-regressione; comodo per il batching di scoring massivo.
• Integrazione naturale con la ricerca e RAG: nel ruolo di bi-encoder — ricerca semantica rapida; nel ruolo di cross-encoder — re-ranking preciso.
• Adattamento efficiente: varianti relativamente compatte (≈100–300 milioni di parametri; BERT‑base ≈110 milioni) forniscono alta qualità dopo il fine-tuning mirato.
• Latenza stabile, indipendente dalla lunghezza della risposta generata (nessuna decodifica passo-passo); adatti per lo scoring offline di grandi collezioni.
• Possibilità di aumentare la finestra di contesto degli encoder tramite posizioni relative/rotazionali e/o attention sparse locale (es. Longformer/BigBird), utile per documenti lunghi.

Svantaggi:

• Nessuna capacità generativa propria: per dialoghi e risposte articolate è necessario un decoder o un modulo generativo esterno.
• Limitazioni negli scenari interattivi: nessuna generazione graduale con mantenimento dello stato.
• Disallineamento tra l'obiettivo di pre-addestramento e i compiti di generazione libera: MLM si allinea peggio alla generazione rispetto alla modellazione causale.
• Finestra di contesto storicamente limitata (spesso 512 token nelle configurazioni base con posizioni assolute); l'estensione richiede schemi speciali di posizione/attention e/o fine-tuning.
• Per i compiti di retrieval è necessario un fine-tuning contrastivo separato del bi-encoder e/o cross-encoder; senza di esso la qualità di ricerca/re-ranking è di solito inferiore rispetto ai modelli appositamente addestrati.

Modelli rappresentativi: BERT e derivati, nonché RoBERTa e DeBERTa (varianti estese encoder‑only); tra gli obiettivi di pre-addestramento alternativi — ELECTRA (RTD).

2. Decoder‑only (solo decodificatore, solo decoder)

Viene utilizzato solo lo stack dei decoder con attention causale (da sinistra a destra): il modello predice il token successivo dato un prefisso già fornito. Questa modalità di addestramento — causal language modeling (CLM) — rende questi modelli la scelta naturale per la generazione: dialoghi, risposte articolate, testo creativo, codice sorgente. Il compromesso è l'aumento della latenza e della dimensione della KV-cache con prompt lunghi. In pratica, per gli encoder decoder‑only vengono ampiamente utilizzate tecniche ingegneristiche: riduzione della KV-cache tramite MQA e GQA, accelerazione dell'inferenza tramite decodifica speculativa e ottimizzazioni server (PagedAttention/vLLM, continuous batching, chunked prefill).

Vantaggi:

• Generazione naturale di testo (CLM): forti capacità zero‑shot e few‑shot; scala bene.
• Versatilità di applicazione: un singolo modello risolve numerosi compiti tramite istruzioni ed esempi nel prompt; si combina naturalmente con RAG e il richiamo di strumenti (tool use).
• Ecosistema maturo: pratiche di fine-tuning per istruzioni e allineamento del comportamento (RLHF, DPO); disponibili implementazioni open source e commerciali.
• Ampio stack di ottimizzazioni per l'inferenza: MQA/GQA riducono la dimensione della KV-cache e aumentano il throughput; la decodifica speculativa accelera l'inferenza senza modificare la distribuzione; PagedAttention/vLLM con continuous batching e chunked prefill aumentano l'utilizzo complessivo della GPU.
• Supporto per la generazione strutturata per formati di risposta rigidi (JSON/SQL/DSL), che semplifica l'integrazione con sistemi informativi e API.

Svantaggi:

• Maggiore latenza di generazione: inferenza sequenziale; il costo di un nuovo token cresce con la lunghezza del contesto già «letto» (KV-cache).
• Meno vantaggioso nel profilo «input lungo – output corto» (riassunto, traduzione) rispetto all'encoder–decoder, dove l'input viene codificato una sola volta.
• Limitazione al contesto unidirezionale: nei compiti di comprensione risulta talvolta inferiore ai modelli con rappresentazione bidirezionale (encoder‑only / encoder–decoder).
• La memoria per la KV-cache può diventare un "collo di bottiglia" con prompt lunghi e batch grandi;
• La quantizzazione delle attivazioni/KV (INT8/FP8) accelera l'inferenza ma può peggiorare la qualità su contesti lunghi/codice; richiede una validazione accurata (specialmente con SLA rigidi).

Modelli rappresentativi: GPT‑3, GPT‑4 (i dettagli dell'architettura e del dataset non sono resi pubblici), LLaMA e Llama 3 (8B/70B, 2024).

3. Encoder–decoder (codificatore–decodificatore, encoder-decoder)

L'architettura combina entrambi i componenti. L'encoder funziona in modalità bidirezionale, mentre il decoder funziona in modo causale. L'encoder analizza l'input una sola volta e forma la sua rappresentazione; il decoder genera l'output facendo riferimento a questa rappresentazione tramite cross‑attention. Questo approccio separato è particolarmente utile quando è necessario trasformare un lungo testo in input in un output breve: traduzione automatica, riassunto, risposte basate su documenti. Sebbene il metodo richieda maggiori costi computazionali complessivi (due stack e cross-attention), il suo vantaggio è una generazione controllata basata sull'analisi completa del testo sorgente; la codifica viene eseguita una sola volta e riutilizzata durante l'intero processo di inferenza.

Vantaggi:

• Generazione condizionale: il decoder utilizza la cross-attention sulla rappresentazione dell'input.
• Efficiente nello scenario «input lungo → output breve»: l'input viene codificato una sola volta.
• Comodo per il formato «text‑to‑text» e l'inferenza controllata (prefissi di compito, istruzioni speciali).
• Stabilità ed efficienza con sorgenti lunghe: nella fase di decodifica cresce solo la self-attention sull'output, mentre la cross-attention riutilizza chiavi/valori fissi dall'encoder (l'input non viene «riletto» ad ogni passo).

Svantaggi:

• Due stack aumentano i requisiti di memoria e calcolo durante l'addestramento e l'utilizzo.
• Su sequenze molto lunghe la latenza totale è comparabile al decoder‑only; l'auto-regressione rimane il collo di bottiglia.
• Meno modelli chat universali rispetto al decoder‑only; utilizzati più spesso come motore seq2seq di alta qualità per compiti specifici.
• Con input molto lunghi aumenta la memoria per le chiavi/valori di cross-attention in ogni layer del decoder (su tutta la sorgente), il che richiede un'attenta pianificazione del serving.

Modelli rappresentativi: T5 (inclusi T5 v1.1 e la pratica del fine-tuning per istruzioni in FLAN‑T5) e BART.

Transformer densi (dense)

L'architettura LLM classica e più diffusa: nell'elaborazione di ogni token partecipa praticamente l'intero insieme dei parametri del modello. A differenza degli approcci sparsi (ad esempio, Mixture‑of‑Experts), non c'è attivazione selettiva delle sotto-reti — ogni blocco funziona per ogni token.

Principio di funzionamento e architettura

Struttura di base. Il modello è uno stack di N blocchi transformer identici. Ogni blocco include:

1. Attenzione multi-testa (Multi‑Head Self‑Attention). Per ogni token vengono calcolati tre vettori: Q (query), K (key), V (value); l'attenzione è definita come $\mathrm{softmax}\left(\frac{Q{K}^{\mathrm{\top }}+M}{\sqrt{d_k}}\right)\cdot V$, dove $M$ è la maschera (causale e/o di padding) che esclude le posizioni non ammissibili. Diverse «teste» di attenzione considerano parallelamente aspetti diversi del contesto (H teste, solitamente $d_{\mathrm{h}\mathrm{e}\mathrm{a}\mathrm{d}}=\frac{d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}}{H}$); il loro numero cresce con la scala del modello.
2. Rete fully-connected (Feed‑Forward Network, FFN). Due layer lineari con non-linearità tra di essi (solitamente GELU/SiLU; in alcuni modelli moderni — SwiGLU). La dimensione intermedia è solitamente $\approx 4d_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}$; quando si usa SwiGLU spesso si prende $\approx \frac{8}{3}{d}_{\mathrm{m}\mathrm{o}\mathrm{d}\mathrm{e}\mathrm{l}}$ per mantenere un numero comparabile di parametri. La FFN contiene una quota significativa dei parametri.

Componenti aggiuntivi. Vengono utilizzate connessioni residuali e normalizzazione dei layer; nei moderni LLM viene più spesso applicato Pre‑LN (normalizzazione prima dei sotto-blocchi) — questo migliora la stabilità dell'addestramento su grandi profondità. Oltre alla classica LayerNorm viene sempre più utilizzata RMSNorm (riduce i costi computazionali e funziona bene nei modelli grandi); in alcune famiglie viene applicata anche la normalizzazione nello spazio dell'attenzione (es. normalizzazione Q/K prima del softmax). Le rappresentazioni posizionali possono essere assolute o relative; per i contesti lunghi RoPE è diventato lo standard de facto.

Esempi di modelli e scala

• BERT‑Large: 24 layer, dimensione 1024, 16 teste di attenzione, ≈340 milioni di parametri.
• GPT‑3 (175B): 96 layer, dimensione 12288, 96 teste di attenzione, ≈175 miliardi di parametri.
• LLaMA‑65B: 80 layer, dimensione 8192, 64 teste di attenzione, ≈65 miliardi di parametri.
• PaLM‑540B: 118 layer, dimensione dell'ordine di 18432, ≈540 miliardi di parametri.

Vantaggi

• Blocchi uniformi, modalità di addestramento ben studiate e comportamento prevedibile nella scalabilità.
• La qualità migliora in modo power-law con la crescita dei parametri e dei dati; il regime compute-optimal prevede l'incremento congiunto della dimensione del modello e del volume dei token di addestramento.
• La stessa architettura dopo il fine-tuning copre un ampio spettro di compiti senza modifiche a livello di layer.

Svantaggi

• La self-attention completa ha complessità quadratica rispetto alla lunghezza della sequenza ($O(n^2)$), il che limita la finestra di contesto.
• Attivazione completa dei parametri al passo di generazione: nel decoder senza MoE il costo dell'inferenza per token cresce approssimativamente in proporzione al numero di parametri.
• Collo di bottiglia — larghezza di banda della memoria (memory‑bound): il caricamento dei pesi dalla HBM spesso limita la velocità di inferenza.

Limitazioni di scalabilità e contesto

• La memoria per i parametri cresce linearmente con la dimensione del modello; la memoria di addestramento aumenta a causa dei gradienti e degli stati dell'ottimizzatore.
• Le configurazioni base erano storicamente limitate a 2–4 mila token. I moderni schemi posizionali (RoPE) e le tecniche di estensione (Position Interpolation, YaRN, ecc.) consentono di aumentare la finestra di un ordine di grandezza e oltre, ma al costo di un carico computazionale/di memoria aggiuntivo.

Ottimizzazioni moderne

• FlashAttention. Attenzione esatta con considerazione della gerarchia di memoria della GPU; riduce i costi di memoria e accelera l'addestramento/inferenza su sequenze lunghe.
• Riduzione e gestione della KV-cache. Multi‑Query Attention e Grouped‑Query Attention riducono la dimensione della cache e il traffico di memoria; a livello server PagedAttention (vLLM) aumenta il throughput tramite la gestione paginata della cache.
• Decodifica speculativa. Un modello bozza (draft) propone una continuazione e il modello principale la verifica rapidamente; si ottiene un'accelerazione senza modificare la distribuzione dell'output.

Modelli sparsi (Sparse Models) e Mixture‑of‑Experts (MoE)

MoE è un modo per aumentare la capacità del modello senza una crescita proporzionale dei calcoli per token. Invece di un unico grande blocco FFN nel layer, viene utilizzato un insieme di «esperti» paralleli (diversi FFN indipendenti), e una rete di routing apprendibile (gating network) per ogni token seleziona i top‑k esperti più rilevanti (solitamente k=1–2; in alcuni modelli k=4). Vengono attivati solo gli esperti selezionati; i loro output vengono pesati e sommati. Così il numero totale di parametri può essere centinaia di miliardi e persino trilioni, ma ad ogni passo viene utilizzata solo una piccola frazione.

Esempi di modelli e scala

• Switch Transformer (Google): fino a ~1.6T parametri; routing top‑1 (un esperto per token). Ha dimostrato che MoE consente di aumentare drasticamente la capacità con costi per token comparabili.
• GLaM (Google): 1.2T parametri, 64 esperti per layer, top‑2; per ogni token vengono attivati ≈96.6B parametri (≈8%).
• Mixtral 8×7B (Mistral AI): ~46.7B parametri totali, ≈12.9B attivi per token, top‑2.
• Mixtral 8×22B: ~141B parametri totali, ≈39B attivi per token, top‑2.
• DBRX (Databricks): 132B parametri totali, ≈36B attivi per token; 16 esperti e routing top‑4 (fine‑grained MoE).

Vantaggi

• Il costo computazionale è determinato dal numero di esperti attivi k, non dal numero totale di parametri: è possibile addestrare e utilizzare modelli su scala trilionaria con costi comparabili a modelli densi di dimensioni notevolmente inferiori.
• Specializzazione: gli esperti si «adattano» automaticamente a lingue/domini/pattern, migliorando la qualità nei compiti multi-dominio.
• Distribuzione flessibile: è possibile mantenere in memoria gli esperti usati frequentemente e caricare quelli rari (con l'infrastruttura appropriata).

Limitazioni

• Bilanciamento del carico: senza regolarizzazione il router può «bloccarsi» su alcuni esperti (router collapse). Sono necessarie auxiliary losses (load‑balancing) e schemi di routing migliorati.
• Complessità del calcolo distribuito: richiede expert parallelism e scambi all‑to‑all; i costi di comunicazione e la gestione della memoria diventano il collo di bottiglia.
• Stabilità dell'addestramento: importanti le impostazioni del router e dei vincoli di capacità (capacity), altrimenti sono possibili degradazioni della qualità/convergenza.

Miglioramenti moderni

• Expert‑Choice routing: gli esperti «scelgono» i token, migliorando il bilanciamento e la convergenza con costi comparabili.
• Fine‑grained MoE: un maggior numero di esperti più piccoli (come in DBRX) fornisce una granularità fine della specializzazione.
• Sparse Upcycling: la conversione di un modello denso in MoE dal suo checkpoint consente di migliorare significativamente la qualità con costi moderati.

Opportunità di applicazione di MoE

• Assistenti multi-dominio su larga scala con budget computazionale limitato.
• Addestramento su corpus estesi, dove la specializzazione porta vantaggi.
• Scenari con infrastruttura distribuita avanzata (molte GPU/TPU e reti veloci).

Quando sono preferibili i modelli densi: infrastruttura limitata (1–2 GPU), requisiti rigidi di latenza prevedibile e semplicità di distribuzione.

Retrieval‑Augmented Generation (RAG)

RAG è un pattern architetturale di sistema attorno all'LLM, non un'architettura interna del modello stesso. Combina un LLM (componente generativo) con una base di conoscenza esterna (componente di recupero), il che consente di compensare i limiti della «memoria parametrica» del modello.

• Principio di funzionamento: Prima della generazione, l'LLM recupera documenti rilevanti da una fonte esterna (wiki, knowledge base aziendale, web) e si basa su di essi per formulare la risposta.
• Vantaggi:
  • Riduzione delle allucinazioni e miglioramento dell'accuratezza fattuale.
  • Aggiornamento senza il riaddestramento completo del modello.
  • Citabilità e tracciabilità delle risposte.
• Applicazione: Standard de facto per assistenti aziendali e sistemi in cui sono richiesti fatti verificabili e lavoro con dati privati/altamente specializzati.

Meccanismi di attenzione e gestione del contesto

La self-attention di base ha complessità quadratica rispetto alla lunghezza della sequenza ($O(n^2)$), pertanto sono state sviluppate ottimizzazioni.

• Attenzione sparsa (Sparse Attention): Limitazione dell'attenzione a finestre/pattern locali. Esempi: Longformer, BigBird.
• FlashAttention: Ristrutturazione dell'ordine dei calcoli tenendo conto della gerarchia di memoria della GPU; fornisce un significativo guadagno in termini di tempo e memoria ed è diventata lo standard de facto nell'addestramento di LLM con contesto lungo.
• MQA/GQA (accelerazione della decodifica): Multi‑Query Attention (chiavi/valori condivisi per tutte le teste) riduce il traffico della KV-cache. Grouped‑Query Attention bilancia qualità/velocità.
• Rappresentazioni posizionali migliorate:
  • ALiBi (Attention with Linear Biases): Bias lineari ai punteggi di attenzione migliorano la generalizzazione a lunghezze maggiori.
  • RoPE (Rotary Position Embeddings): Informazioni posizionali relative tramite rotazione di Q/K; ampiamente utilizzato nei modelli moderni (es. LLaMA).
  • Estensione del contesto per modelli RoPE: Position Interpolation , YaRN , nonché le modifiche NTK-aware consentono di aumentare efficacemente la finestra di contesto senza modificare l'architettura.

• Altri approcci per sequenze lunghe:
  • Transformer‑XL: memoria ricorrente tra segmenti per la modellazione di dipendenze a lungo raggio.
  • Reformer: LSH‑attention e blocchi residuali reversibili per il risparmio di memoria.
  • Performer: approssimazione lineare della softmax‑attention (FAVOR+).
  • Linformer: approssimazione a basso rango della matrice di attenzione.

Ottimizzazioni dei modelli e infrastruttura di addestramento

Per l'addestramento e il deployment degli LLM vengono utilizzate tecniche e framework specializzati.

• Quantizzazione (Quantization): La riduzione della precisione dei pesi diminuisce la memoria e accelera l'inferenza. QLoRA consente il fine-tuning efficiente di modelli a 4 bit (inclusi 65B) con una qualità vicina alla piena precisione.
• Distillazione della conoscenza (Knowledge Distillation): Addestramento Teacher→Student per modelli compatti; esempio — DistilBERT.
• Addestramento distribuito:
  • DeepSpeed e ZeRO — distribuzione di parametri/gradienti/stati dell'ottimizzatore per l'addestramento di modelli trilionari.
  • Megatron‑LM — parallelismo tensoriale e a pipeline per transformer di grandi dimensioni.
• Ecosistema e strumenti: Hugging Face Transformers e Accelerate forniscono implementazioni standard dei modelli e integrazione con DeepSpeed/FSDP per addestramento e inferenza.

Leggi di scalabilità e addestramento compute‑optimal

Le leggi di scalabilità empiriche mostrano che l'errore di cross-entropia diminuisce secondo una legge di potenza con la crescita dei parametri, dei dati e dei calcoli. Il lavoro Chinchilla ha precisato i regimi compute‑optimal: per un'efficienza ottimale, la dimensione del modello e il numero di token di addestramento devono essere scalati congiuntamente (esempio — un modello da 70B addestrato su ~1.4T token supera modelli più grandi ma sotto-addestrati).

Modelli con spazio degli stati (State Space Models, SSM)

State Space Models (SSM) sono un'architettura alternativa ai transformer per lavorare con sequenze lunghe. Prende in prestito idee dalla teoria del controllo e dall'elaborazione digitale dei segnali e risolve il problema principale della self-attention: la crescita quadratica dei calcoli all'aumentare della lunghezza del testo.

Problema principale e soluzione

Il problema dei transformer. Il problema principale dei transformer tradizionali è la complessità quadratica dell'attenzione: un testo 10 volte più lungo richiede circa 100 volte più calcoli.

L'approccio SSM. Invece di «prestare attenzione a tutte le parole contemporaneamente», il modello percorre il testo in modo sequenziale e mantiene un compatto stato di memoria interno che viene aggiornato ad ogni passo. Di conseguenza il tempo e il consumo di memoria crescono approssimativamente in modo lineare con la lunghezza del testo. L'addestramento può essere eseguito in parallelo — tramite la rappresentazione convoluzionale del kernel (alta velocità di throughput su sequenze lunghe).

Principio di funzionamento

Un SSM discreto è descritto dalle equazioni di stato e di uscita:

$x_t=A{x}_{t-1}+B{u}_t,y_t=C{x}_t+D{u}_t$

dove $x_t$ è lo stato di memoria, $u_t$ è l'input (token), $y_t$ è l'output. Negli SSM profondi le matrici $A,B,C,D$ vengono parametrizzate in modo da garantire stabilità e calcoli efficienti su sequenze lunghe. Lo stesso layer può essere considerato:

• ricorrente (scansione passo per passo) — inferenza efficiente in memoria senza KV-cache;
• convoluzionale — addestramento parallelo con kernel pre-calcolato.

Architetture principali e ibridi

• S4 (Structured State Spaces). Linea di base SSM con parametrizzazione stabile della matrice di stato; dimostra efficienza su sequenze molto lunghe.
• Mamba. SSM selettivi: le regole di aggiornamento della memoria dipendono dall'input corrente (il modello decide autonomamente cosa «tenere in memoria» e cosa «dimenticare»). L'implementazione è orientata alla gerarchia di memoria della GPU; secondo gli autori, si ottiene un multiplo aumento del throughput di inferenza con complessità lineare rispetto alla lunghezza.
• RetNet. Meccanismo di retention con tre modalità: addestramento parallelo, inferenza ricorrente e block-ricorrente. L'obiettivo è combinare addestramento rapido (come nei transformer) con un flusso economico in inferenza (memoria O(1) per token).
• Ibridi Attention+SSM. Esempio — Jamba (alternanza di layer Transformer e Mamba più MoE): riporta il supporto di contesti dell'ordine di ~256 K token con un requisito di memoria significativamente inferiore rispetto a modelli puramente transformer di classe simile.

Vantaggi

• Complessità lineare e risparmio di memoria in inferenza. Nessuna self-attention globale e KV-cache; viene conservato solo uno stato compatto.
• Addestramento parallelo su sequenze lunghe. La modalità convoluzionale aumenta il throughput di addestramento.
• Efficienza hardware. Le implementazioni sono orientate alla moderna gerarchia di memoria (HBM/SRAM).
• Contesti lunghi e streaming. Gli ibridi SSM+Attention sono pratici per centinaia di migliaia di token con risorse moderate.

Limitazioni e pratica corrente

• Maturità dell'ecosistema. Gli strumenti e le «ricette» di scalabilità (istruzioni, RLHF/DPO) sono ancora inferiori allo stack dei transformer.
• Qualità e stabilità. In alcuni compiti gli ibridi (Attention+SSM) mostrano un compromesso «qualità/velocità/memoria» più stabile rispetto agli SSM «puri».

Confronto degli approcci (sommario)

Caratteristica	Transformer	SSM	Ibridi (Attention+SSM)
Complessità rispetto alla lunghezza	Quadratica (self‑attention)	Lineare (scan/convoluzione)	Vicina alla lineare
Memoria per token (inferenza)	KV-cache cresce con il contesto	Stato O(1)	Crescita moderata
Contesti lunghi	Richiedono ottimizzazioni speciali	Supporto naturale	Pratici fino a ~256 K
Maturità dell'ecosistema	Alta	In sviluppo	In sviluppo

Applicazioni pratiche

• Analisi di documenti molto lunghi (libri, report, rassegne scientifiche).
• Elaborazione in streaming e scenari chat con lunga cronologia senza aumento dei costi di memoria.
• Ambienti con risorse limitate (dispositivi mobili/edge).
• Serie temporali e altri dati sequenziali.

Modelli rappresentativi: S4, Mamba, RetNet; ibridi Attention+SSM (Jamba).

Evoluzione delle architetture

• 2017 — pubblicato l'articolo «Attention Is All You Need». Presentata l'architettura transformer: la self-attention multi-testa e le codifiche posizionali consentono di addestrare modelli senza ricorrenza e convoluzioni; tuttavia l'attenzione ha complessità quadratica rispetto alla lunghezza del contesto.

• 2018 — presentati GPT‑1 e BERT. GPT‑1 utilizza uno stack solo decoder con attention causale per la generazione e il successivo fine-tuning; BERT introduce un encoder bidirezionale e il pre-addestramento MLM per i compiti di comprensione del testo.

• 2019 — proposti metodi per lavorare con sequenze lunghe e scalato il decoder-only. Transformer‑XL aggiunge «memoria» e posizioni relative per superare la finestra fissa; GPT‑2 mostra la crescita delle capacità zero-shot con l'aumento della scala; BART dimostra l'efficacia del pre-addestramento con denoising per seq2seq.

• 2020 — unificato il formato «text‑to‑text» e mostrati metodi per documenti lunghi. T5 formula un approccio unificato encoder–decoder per diversi compiti; Longformer e BigBird utilizzano l'attention sparsa/strutturata per testi lunghi; GPT‑3 conferma l'efficacia della scalabilità del decoder‑only denso.

• 2021 — migliorate le rappresentazioni posizionali e mostrata la sparsità dei parametri (MoE). RoPE e ALiBi migliorano la generalizzazione su lunghezze maggiori; Switch Transformer e GLaM attivano solo una parte degli esperti per token, aumentando la capacità senza un aumento proporzionale del costo di inferenza.

• 2022 — precisato il regime compute‑optimal e accelerata l'inferenza su prompt lunghi. Chinchilla mostra il vantaggio di un maggiore numero di token di addestramento con una dimensione del modello moderata; PaLM con Multi‑Query Attention riduce la dimensione della KV-cache; FlashAttention accelera l'attenzione sulla GPU.

• 2023 — aumentate le finestre di contesto senza modificare i layer e migliorato il serving. La famiglia LLaMA consolida le pratiche (RMSNorm, SwiGLU, RoPE); Position Interpolation e YaRN estendono il contesto; vLLM/PagedAttention gestisce più efficacemente la KV-cache.

• 2023 — GPT‑4 e Gemini mostrano elaborazione e generazione in più modalità all'interno di una stessa famiglia di modelli.

• 2023 — proposti modelli con spazio degli stati (SSM). Mamba e RetNet reintroducono l'elaborazione sequenziale con stato compatto al posto della KV-cache e pongono le basi per architetture ibride.

• 2024 — pubblicati modelli MoE open source e ibridi Attention+SSM; accelerata l'attenzione sulle nuove GPU. Mixtral 8×7B/8×22B e DBRX confermano la praticità di MoE; Jamba combina Transformer e Mamba per contesti molto lunghi; FlashAttention‑3 aumenta il throughput.

Riferimenti

• https://jalammar.github.io/illustrated-transformer/ The Illustrated Transformer — spiegazione visiva

Bibliografia

• Vaswani, A. et al. (2017). Attention Is All You Need. NIPS. https://arxiv.org/abs/1706.03762
• Devlin, J. et al. (2019). BERT. NAACL. https://arxiv.org/abs/1810.04805
• Brown, T. et al. (2020). Language Models are Few‑Shot Learners. NeurIPS. https://arxiv.org/abs/2005.14165
• Raffel, C. et al. (2020). Exploring the Limits of Transfer Learning with a Unified Text‑to‑Text Transformer (T5). JMLR. https://jmlr.org/papers/volume21/20-074/20-074.pdf
• Lewis, M. et al. (2019). BART: Denoising Sequence‑to‑Sequence Pre‑training. https://arxiv.org/abs/1910.13461
• Touvron, H. et al. (2023). LLaMA. https://arxiv.org/abs/2302.13971
• Chowdhery, A. et al. (2022). PaLM: Scaling Language Modeling with Pathways. https://arxiv.org/abs/2204.02311
• Dao, T. et al. (2022–2024). FlashAttention (1/2/3). https://arxiv.org/abs/2205.14135 ; https://arxiv.org/abs/2307.08691 ; https://arxiv.org/abs/2407.08608
• Shazeer, N. (2019). MQA. https://arxiv.org/abs/1911.02150
• Ainslie, J. et al. (2023). GQA. https://arxiv.org/abs/2305.13245
• Kwon, W. et al. (2023). PagedAttention / vLLM. https://arxiv.org/abs/2309.06180
• Leviathan, Y. et al. (2023). Speculative Decoding. https://arxiv.org/abs/2211.17192
• Fedus, W.; Zoph, B.; Shazeer, N. (2021/2022). Switch Transformers. https://arxiv.org/abs/2101.03961
• Du, N. et al. (2022). GLaM. https://proceedings.mlr.press/v162/du22c/du22c.pdf
• Jiang, A.Q. et al. (2024). Mixtral of Experts. https://arxiv.org/abs/2401.04088
• Databricks (2024). Introducing DBRX. https://www.databricks.com/blog/introducing-dbrx-new-state-art-open-llm
• NVIDIA (2024). Applying Mixture of Experts in LLM Architectures. https://developer.nvidia.com/blog/applying-mixture-of-experts-in-llm-architectures/
• Zhou, Y. et al. (2022). Expert Choice Routing. https://arxiv.org/abs/2202.09368
• Komatsuzaki, A. et al. (2022). Sparse Upcycling. https://arxiv.org/abs/2212.05055
• Lewis, P. et al. (2020). RAG. https://arxiv.org/abs/2005.11401
• Beltagy, I. et al. (2020). Longformer. https://arxiv.org/abs/2004.05150
• Zaheer, M. et al. (2020). BigBird. https://arxiv.org/abs/2007.14062
• Press, O. et al. (2022). ALiBi. https://arxiv.org/abs/2108.12409
• Su, J. et al. (2021). RoFormer (RoPE). https://arxiv.org/abs/2104.09864
• Chen, S. et al. (2023). Position Interpolation. https://arxiv.org/abs/2306.15595
• Peng, B. et al. (2023). YaRN. https://arxiv.org/abs/2309.00071
• Dettmers, T. et al. (2023). QLoRA. https://arxiv.org/abs/2305.14314
• Rajbhandari, S. et al. (2020). ZeRO. https://www.microsoft.com/en-us/research/publication/zero-memory-optimizations-toward-training-trillion-parameter-models/
• Shoeybi, M. et al. (2019). Megatron‑LM. https://arxiv.org/abs/1909.08053
• Kaplan, J. et al. (2020). Scaling Laws. https://arxiv.org/abs/2001.08361
• Hoffmann, J. et al. (2022). Chinchilla / Compute‑Optimal. https://arxiv.org/abs/2203.15556
• Gemini Team (2023). Gemini. https://arxiv.org/abs/2312.11805
• Bai, Y. et al. (2022). Constitutional AI. https://arxiv.org/abs/2212.08073
• OpenAI (2023). GPT‑4 Technical Report. https://arxiv.org/abs/2303.08774
• OpenAI (2023). DevDay: GPT‑4 Turbo 128k. https://openai.com/index/new-models-and-developer-products-announced-at-devday/
• Zhang, B.; Sennrich, R. (2019). RMSNorm. https://arxiv.org/abs/1910.07467
• Shazeer, N. (2020). GLU Variants / SwiGLU. https://arxiv.org/abs/2002.05202
• Gu, A.; Goel, K.; Ré, C. (2021). S4: Structured State Spaces. https://arxiv.org/abs/2111.00396
• Gu, A.; Dao, T. (2023/2024). Mamba: Selective State Spaces. https://arxiv.org/abs/2312.00752
• Sun, Y. et al. (2023). RetNet. https://arxiv.org/abs/2307.08621
• Lieber, O. et al. (2024). Jamba: Hybrid Transformer‑Mamba. https://arxiv.org/abs/2403.19887
• Dai, Z. et al. (2019). Transformer‑XL. https://arxiv.org/abs/1901.02860
• Kitaev, N.; Kaiser, L.; Levskaya, A. (2020). Reformer. https://arxiv.org/abs/2001.04451
• Choromanski, K. et al. (2021). Performer. https://arxiv.org/abs/2009.14794
• Wang, S. et al. (2020). Linformer. https://arxiv.org/abs/2006.04768