Come Funziona un LLM

🎯 Il gioco fondamentale: "predici la prossima parola"

Dai al modello "Il gatto sale sul..." e lui produce una probabilità per ogni parola possibile: tetto 41%, tavolo 22%, divano 12%, ... frigorifero 0.3%. Ne sceglie una, la attacca alla frase, e ripete. Questo è tutto il meccanismo di base. Sembra poco? Per indovinare bene il finale di milioni di frasi diverse, il modello è costretto a costruirsi al suo interno una rappresentazione di grammatica, fatti, stili, logica e perfino un po' di "buon senso". Imparare a predire bene = imparare a modellare il mondo descritto dal testo.

🧸 Le 4 cose che devi tenere a mente per tutta la guida

✂️ Cosa è un token

Un token è un pezzo di testo: a volte una parola intera (casa), spesso un pezzo di parola (intelligen + za), a volte un singolo carattere o uno spazio. In media 1 token ≈ 4 caratteri ≈ 0,75 parole in inglese (un po' meno efficiente in italiano). Il vocabolario di un modello moderno ha tipicamente da 50.000 a 200.000+ token distinti. La tecnica più usata per costruirlo si chiama BPE (Byte-Pair Encoding): parte dai singoli byte e fonde via via le coppie più frequenti.

# "Lo svogliato programma di notte"  →  token  →  ID numerici

["Lo", " svog", "liato", " programma", " di", " notte"]
   ↓       ↓        ↓          ↓          ↓       ↓
[ 3304,    78521,    9982,      27114,      357,    49183 ]

# Nota: "svogliato" si spezza in pezzi (parola rara),
# "programma" resta intero (parola comune). Lo spazio fa parte del token.

pip install tiktoken

import tiktoken
enc = tiktoken.get_encoding("cl100k_base")   # un tokenizzatore reale
ids = enc.encode("Lo svogliato programma di notte")
print(ids)                 # → lista di interi
print(len(ids))            # quanti token = quanto "costa"
print([enc.decode([i]) for i in ids])  # i pezzi a ritroso

📏 Da ID a vettore

L'embedding è una grande tabella di consultazione (una matrice): vocabolario × dimensioni. Per il token 49183 il modello pesca la riga 49183 e ottiene il suo vettore. Questi numeri non sono scritti a mano: vengono imparati durante l'addestramento, esattamente come tutti gli altri pesi.

import numpy as np

# vettori-giocattolo a 4 dimensioni (i veri ne hanno migliaia)
gatto  = np.array([ 0.9,  0.8, -0.1,  0.2])
cane   = np.array([ 0.8,  0.7,  0.0,  0.3])
banana = np.array([-0.6,  0.1,  0.9, -0.4])

def simil(a, b):                 # 1 = identici, 0 = scorrelati
    return a @ b / (np.linalg.norm(a) * np.linalg.norm(b))

print(simil(gatto, cane))     # ≈ 0.99  (stesso quartiere)
print(simil(gatto, banana))   # ≈ 0.10  (lontani)

📍 E l'ordine delle parole? Positional encoding

"Il cane morde l'uomo" e "L'uomo morde il cane" hanno gli stessi token ma significati opposti. Gli embedding da soli non sanno l'ordine. Per questo si aggiunge un positional encoding: un'informazione sulla posizione di ogni token nella sequenza (oggi spesso col metodo RoPE, rotary). Così il modello sa non solo quali token ci sono, ma in che ordine.

⚙️ Il neurone artificiale: una somma pesata

L'unità di base è banale: prende dei numeri in ingresso, li moltiplica ciascuno per un peso, somma tutto, aggiunge un bias e passa il risultato attraverso una funzione non lineare (attivazione). Fine. Un LLM è questa operazione ripetuta miliardi di volte, organizzata in strati.

import numpy as np

ingressi = np.array([0.5, -0.2, 0.8])      # dati in input
pesi     = np.array([0.9,  0.4, -0.7])      # IMPARATI nel training
bias     = 0.1                              # anch'esso imparato

z = ingressi @ pesi + bias                  # somma pesata
uscita = np.maximum(0, z)                    # attivazione ReLU = max(0, z)
print(uscita)

# I "pesi" sono SOLO questi numeri. Addestrare = trovarli giusti.
# Un layer fa la stessa cosa per migliaia di neuroni in parallelo
# → diventa una moltiplicazione tra matrici (per questo servono le GPU).

🏔️ Strati, profondità e scala

I neuroni sono organizzati in layer (decine, a volte centinaia). L'uscita di uno entra nel successivo. Più layer = più capacità di catturare pattern astratti. La "magia" degli LLM è in gran parte una questione di scala: tanti parametri + tanti dati + tanto calcolo → capacità che nei modelli piccoli non c'erano (le cosiddette abilità emergenti).

🔍 Query, Key, Value in pratica

Da ogni embedding il modello ricava tre vettori — Query, Key, Value — moltiplicandolo per tre matrici di pesi (anch'esse imparate). L'attenzione di un token verso un altro è il prodotto della sua Query con la Key dell'altro: più sono allineati, più alto il punteggio. I punteggi si normalizzano con un softmax (diventano percentuali che sommano a 1) e si usano per fare una media pesata dei Value.

import numpy as np
def softmax(x):
    e = np.exp(x - x.max(axis=-1, keepdims=True))
    return e / e.sum(axis=-1, keepdims=True)

def attention(Q, K, V):
    d = Q.shape[-1]
    punteggi = Q @ K.T / np.sqrt(d)      # quanto ogni token guarda gli altri
    pesi = softmax(punteggi)             # → percentuali che sommano a 1
    return pesi @ V                       # media pesata dei contenuti

# Attention(Q,K,V) = softmax(Q·Kᵀ / √d) · V   — tutto qui.

🏗️ Come si impila un blocco transformer

Un LLM è una pila di blocchi identici, ognuno con due parti: l'attention (i token si scambiano informazioni) e una rete feed-forward (ogni token elabora ciò che ha raccolto). Con in più due trucchi che rendono possibile impilarne tanti senza che l'addestramento esploda: le connessioni residue (scorciatoie che saltano il blocco) e la normalizzazione.

📚 Il compito: indovinare la parola nascosta

Si prende una valanga di testo (web, libri, codice, articoli: migliaia di miliardi di token) e si gioca a un gioco automatico: si mostra al modello una frase troncata e gli si chiede il token successivo. La risposta giusta è già nel testo (la parola che veniva davvero dopo), quindi non serve nessun umano a etichettare: è auto-supervisionato. È il motivo per cui si può fare su scala planetaria.

📉 Loss, backpropagation, gradient descent

Tre parole che spaventano, tre idee semplici:

• Loss (errore) — un numero che dice quanto la predizione è sbagliata. Se il modello dava al token giusto solo il 3% di probabilità, la loss è alta; se gli dava l'80%, è bassa. La formula tipica si chiama cross-entropy.
• Backpropagation — la procedura che calcola, per ogni singolo peso, "se ti muovo di un pelo in su o in giù, la loss sale o scende?". È la regola della catena delle derivate, applicata a ritroso dall'uscita verso l'ingresso.
• Gradient descent — si spostano tutti i pesi di un passettino nella direzione che riduce la loss. Ripeti. È come scendere da una montagna nella nebbia: senti la pendenza sotto i piedi e fai un passo in discesa.

for batch in dati:                       # miliardi di pezzi di testo
    pred = modello(batch.input)         # 1. predici il prossimo token
    loss = cross_entropy(pred, batch.target)  # 2. quanto hai sbagliato?
    gradienti = loss.backward()         # 3. backprop: colpa di quali pesi?
    pesi = pesi - lr * gradienti        # 4. correggi (lr = learning rate)
    # ...ripeti per settimane su migliaia di GPU...

# Aggiornamento di un peso:  w := w - (passo) × (pendenza della loss su w)

💰 Perché costa così tanto

Moltiplica: miliardi di parametri × migliaia di miliardi di token × molti passaggi. Sono 10²³ – 10²⁵ operazioni, settimane o mesi su migliaia di GPU/acceleratori, per milioni di dollari di elettricità e hardware. Per questo i modelli base li allenano in pochi (grandi laboratori), e tu li scarichi già addestrati. Il risultato di questa fase è un base model: sa completare testo in modo impressionante, ma non sa ancora chattare né seguire istruzioni. Se gli scrivi "Qual è la capitale della Francia?" potrebbe continuare con "Qual è la capitale della Spagna?" — perché sta completando un elenco di domande, non rispondendo.

🎓 Instruction tuning

Si prende il base model e lo si continua ad addestrare — stesso meccanismo (predici il prossimo token, loss, backprop) — ma su un dataset molto più piccolo e curato di esempi conversazionali: coppie istruzione → risposta ideale scritte o selezionate da umani. Decine/centinaia di migliaia di esempi del tipo "domanda dell'utente / risposta utile, ben formattata, educata".

{
  "utente":    "Spiega cos'è un firewall a un bambino di 10 anni.",
  "assistente": "Immagina un buttafuori all'ingresso di una festa: \
                controlla chi può entrare e chi no. Un firewall fa \
                lo stesso con i dati che arrivano dal tuo computer..."
}
# Migliaia di esempi come questo insegnano il FORMATO "assistente":
# rispondere, non continuare; essere chiari; seguire l'istruzione.

Dopo l'SFT, alla domanda sulla capitale della Francia il modello risponde "Parigi" invece di continuare l'elenco. Non ha imparato fatti nuovi (quelli erano già nei pesi dal pretraining): ha imparato come comportarsi, in che forma usare ciò che già sa.

🔄 I tre passi dell'RLHF

Il passo 3 usa algoritmi di reinforcement learning come PPO, oppure metodi più recenti e diretti come DPO che saltano il reward model esplicito e ottimizzano direttamente sulle preferenze. L'obiettivo dichiarato è rendere il modello utile, onesto e innocuo (in inglese: helpful, honest, harmless).

✅ RLVR: rinforzo con ricompensa verificabile

Per matematica, codice e logica c'è una scorciatoia potente: la risposta è verificabile in automatico (il test passa o no, il risultato è giusto o no). Si può quindi dare il "premio" senza umani, semplicemente controllando se la soluzione è corretta. È uno degli ingredienti chiave dei moderni modelli di reasoning (prossimo capitolo): il modello prova tante strade, e viene rinforzato su quelle che arrivano alla risposta giusta.

➡️ Il forward pass, passo per passo

1. Il prompt viene tokenizzato (cap. 2) e trasformato in embedding (cap. 3).
2. I vettori attraversano tutti i blocchi transformer (cap. 5): attention + feed-forward, decine di volte.
3. L'ultimo strato produce i logit: un punteggio grezzo per ognuno dei token del vocabolario.
4. Un softmax trasforma i logit in probabilità (sommano a 1).
5. Si campiona un token da quella distribuzione (vedi sotto).
6. Il token scelto si aggiunge al prompt e si ricomincia dal punto 2 per il token dopo. È autoregressivo.

testo = tokenizza(prompt)
while not fine:
    logit = modello(testo)[-1]        # punteggi per il PROSSIMO token
    probs = softmax(logit / temperatura)  # → distribuzione
    prossimo = campiona(probs, top_p=0.9)  # scegline uno
    testo.append(prossimo)                # attaccalo e ripeti
    if prossimo == FINE_TESTO: break
# Ogni token costa un intero passaggio nella rete. Per questo
# le risposte lunghe sono più lente e costose.

💭 Chain-of-thought: mostrare i passaggi

Chiedi a un LLM "un bar ha 23 mele, ne usa 20 e ne compra 6, quante ne ha?". Se risponde di getto, spesso sbaglia. Se invece genera i passaggi — "23 − 20 = 3; 3 + 6 = 9" — ci azzecca molto più spesso. Perché? Ogni token generato è un'occasione di calcolo in più: scrivendo i passaggi, il modello si costruisce da solo gli appoggi intermedi invece di dover "indovinare" il risultato finale in un colpo. È la catena del ragionamento (chain-of-thought).

🤖 I modelli di reasoning (lo "thinking" che vedi)

I modelli di nuova generazione vengono addestrati apposta a fare questo monologo interno, usando il rinforzo con ricompensa verificabile (RLVR, cap. 8): provano lunghe catene di ragionamento su problemi di matematica e codice, e vengono premiati quando arrivano alla soluzione giusta. Imparano così a pianificare, verificare e correggersi da soli prima di consegnare la risposta.

<thinking>
  L'utente chiede X. Provo l'approccio A...
  Aspetta, questo caso limite non torna. Riprovo con B.
  Verifico: 2+2=4, coerente. Ok, la risposta è B.
</thinking>

La risposta è B, perché ...        ← questo è ciò che l'utente legge

# Il blocco "thinking" sono token generati ESATTAMENTE come gli altri.
# Non è un processo separato: è lo stesso "predici il prossimo token",
# ma allenato a usarlo come brutta copia prima della bella.

💾 I pesi sono un file: quanto pesa girarli

Un modello è letteralmente un file di numeri (i pesi). Per farlo girare devi caricarlo in memoria — idealmente nella VRAM della GPU. Regola spannometrica: parametri × byte-per-peso.

La quantizzazione è il trucco che comprime i pesi (da 16 bit a 8 o 4) per farli stare in meno memoria, perdendo pochissima qualità. È il motivo per cui oggi puoi far girare modelli seri in locale. Aggiungi un po' di overhead per la KV cache e il contesto.

🔄 Il ciclo di vita completo di un LLM