Il tono della voce resta uguale a ogni velocità. La voce parte da sola a ogni pannello; per andare avanti premi tu «Avanti».
Qui trovi ogni termine del corso con il nome originale inglese e una definizione breve. Clicca un termine per andare alla spiegazione completa con lo schema. Poi segui le sezioni in ordine: ognuna finisce con un test a scelta multipla che ti dà il voto.
Un modello di IA, alla fine, è un enorme insieme di numeri organizzati in strati. Questa sezione spiega di che numeri si tratta e come si chiamano.
Questa prima sezione risponde a una domanda che sembra ovvia e non lo è: che cosa c'è dentro un programma di intelligenza artificiale? Se hai già usato un assistente in chat, hai visto il risultato. Qui guardi dentro la scatola, partendo da zero e senza dare nulla per scontato.
Si comincia dal quadro generale. «Intelligenza artificiale» è un nome molto largo, e dentro ci sta un sottoinsieme che oggi domina tutto: i programmi che non vengono scritti riga per riga da una persona, ma ricavati da esempi. Il risultato di questo procedimento si chiama modello, e ragiona quasi sempre con probabilità invece che con certezze. Sono i primi quattro termini, e ti servono come vocabolario di base.
Poi si apre il modello e si guarda com'è fatto. Il mattone più piccolo è il neurone, che fa una somma di numeri. I numeri che dicono quanto conta ogni collegamento sono i pesi, e a questi si aggiunge il bias. Insieme formano i parametri, la «manopola» che regola tutto. I neuroni sono raggruppati in strati, e tra uno strato e l'altro agisce una funzione di attivazione, di cui vedrai le versioni più usate. Quando tutto questo è messo insieme hai una rete neurale, e se gli strati sono molti si parla di apprendimento profondo.
Infine c'è la matematica che sta sotto: le matrici, che permettono di fare in un colpo solo tutti i conti di uno strato. A fine sezione trovi tre termini che chiudono il cerchio: l'IA generativa, cioè i modelli che producono contenuti nuovi, il modello di fondazione, un modello generale da cui si parte per mille usi, il modello linguistico di grandi dimensioni, che è il cuore degli assistenti di oggi, e il tensore, il contenitore di numeri che la tecnica usa dappertutto. Alcuni di questi tre richiamano concetti che incontrerai più avanti: per ora ti basta il quadro, i dettagli arrivano al momento giusto.
Ogni scheda segue lo stesso schema: una definizione in una frase, la spiegazione del funzionamento, un esempio svolto con numeri che puoi rifare a mente e l'equivoco più comune da evitare. Se un passaggio ti sembra veloce, rileggi l'esempio: i numeri sono pensati per essere piccoli, in modo che tu possa controllare i conti da solo.
Il nome generale per i programmi che svolgono compiti che di solito richiedono intelligenza umana, come capire una frase, riconoscere un volto o decidere cosa fare.
La parola nasce nel 1956, in un'estate di lavoro al Dartmouth College negli Stati Uniti, dove un gruppo di ricercatori propose di costruire macchine capaci di imitare l'intelligenza umana. Da allora è rimasta un'etichetta larga: non indica una tecnica precisa, indica un obiettivo. Un programma è «intelligenza artificiale» se svolge un compito che, fatto da una persona, diremmo intelligente.
Dentro questa etichetta stanno due famiglie. La prima è fatta di programmi con regole scritte a mano da specialisti del settore: per esempio un sistema che, seguendo mille regole del tipo «se la febbre supera 38 e c'è tosse allora…», suggerisce una diagnosi. La seconda è fatta di programmi che non hanno regole scritte da nessuno ma le ricavano dagli esempi. Oggi, quando si parla di IA sui giornali, si intende quasi sempre la seconda famiglia, che è quella che ha prodotto i risultati più spettacolari degli ultimi anni.
Una curiosità utile: appena una tecnica funziona bene e diventa normale, smettiamo di chiamarla IA. Il correttore ortografico o il riconoscimento dei caratteri su un modulo scansionato erano IA, trent'anni fa. Per questo il confine è sfumato e cambia nel tempo.
Tutti i sistemi che usi oggi sono specializzati: bravi in un tipo di compito, e fuori da quello tendono a sbagliare. Gli assistenti in chat sono più versatili degli altri, ma restano programmi, non persone.
Prendi tre programmi che hai già incontrato. Il navigatore cerca il percorso più veloce tra due città: il metodo di ricerca l'hanno scritto dei programmatori e i dati sono la mappa e il traffico. Il filtro antispam ha guardato migliaia di mail già etichettate e ha imparato da solo quali indizi contano. L'assistente in chat ha letto una quantità enorme di testi e risponde alle domande.
Sono tre programmi molto diversi, costruiti in modi diversi, eppure tutti e tre stanno sotto la stessa etichetta. È per questo che «usa l'IA» non dice nulla di preciso: bisogna sempre chiedere quale tipo e per quale compito.
La parte dell'IA in cui il programma non viene scritto riga per riga, ma ricavato da esempi: i dati decidono i numeri interni.
Nella programmazione tradizionale tu scrivi le regole, il programma le applica ai dati e ottiene le risposte. Nell'apprendimento automatico (in inglese «machine learning») si ribalta lo schema: tu fornisci i dati e le risposte giuste, e il procedimento ricava le regole. Serve soprattutto dove le regole sono impossibili da scrivere: nessuno saprebbe elencare tutte le regole per riconoscere un gatto in una foto, ma è facile procurarsi diecimila foto già etichettate «gatto» e «non gatto».
Gli ingredienti sono tre. Primo, gli esempi. Secondo, un programma con tanti numeri regolabili al suo interno, all'inizio messi a caso. Terzo, un metodo che confronta ciò che il programma risponde con la risposta giusta e ritocca i numeri per ridurre l'errore, ripetendo l'operazione moltissime volte. Alla fine i numeri hanno assorbito le regolarità presenti negli esempi.
Si distinguono tre modi di apprendere. Nel primo gli esempi hanno la risposta (questa mail è spam). Nel secondo non hanno risposta e il programma cerca da solo gruppi e strutture. Nel terzo il programma prova azioni e riceve un punteggio, come un giocatore che impara per tentativi. Gli assistenti moderni usano un misto di tutti e tre.
Vuoi costruire un filtro antispam. Raccogli 10.000 mail: 4.000 sono spam e 6.000 no (numeri di esempio). Il procedimento conta quante volte compare ogni parola. Scopre che «vinci» è presente in 900 delle 4.000 mail spam, cioè nel 22,5%, mentre compare in 12 delle 6.000 mail normali, cioè nello 0,2%. Quindi «vinci» è un indizio forte: è circa 110 volte più frequente nello spam.
Ripete il conteggio per migliaia di parole e ricava un punteggio per ciascuna. Quando arriva una mail nuova somma i punteggi delle parole che contiene e decide. Nessuno ha scritto la regola «se c'è vinci, allora spam»: l'ha trovata il programma dagli esempi.
Apprendimento automatico fatto con reti neurali a molti strati in fila («profondo» vuol dire «tanti strati»). È la tecnica dietro i modelli moderni di linguaggio, immagini e voce.
In inglese «deep learning». Non è una tecnica diversa dalle reti neurali: è l'uso di reti con molti strati nascosti. Una rete con uno o due strati si chiama superficiale; i modelli attuali ne hanno decine o centinaia.
Prima degli anni 2010, per far riconoscere qualcosa a un programma gli specialisti dovevano progettare a mano le caratteristiche da guardare: per una foto, i bordi, gli angoli, le macchie di colore. Il programma imparava poi a combinarle. Con molti strati, invece, la rete impara da sola anche quelle caratteristiche: i primi strati trovano elementi semplici come bordi e colori, quelli di mezzo li combinano in forme come occhi e ruote, gli ultimi riconoscono l'oggetto intero.
La svolta pubblica è del 2012: una rete di 8 strati chiamata AlexNet vinse una gara di riconoscimento di immagini con un errore del 15,3%, contro il 26,2% del secondo classificato. Da quel momento la ricerca si è spostata quasi interamente su questa strada.
Serve però molto: tanti dati per imparare, e molta potenza di calcolo. Funziona bene quando c'è abbondanza di entrambi, e meno bene quando i dati sono pochi.
Riconoscere un volto in una foto. Il primo strato guarda gruppetti di puntini vicini e trova bordi e macchie di colore. Il secondo combina i bordi in forme: curve, angoli. Gli strati di mezzo riconoscono parti: un occhio, un naso, una bocca. Gli ultimi mettono insieme le parti e decidono se la disposizione è quella di un volto.
Ogni strato costruisce sul lavoro del precedente: nessuno ha dovuto spiegare alla rete che cosa sia un occhio. Per confronto: AlexNet aveva 8 strati, Llama 3 da 8 miliardi di parametri ne ha 32, GPT-3 ne ha 96.
Il risultato dell'apprendimento: un programma che trasforma un ingresso (un testo, un'immagine, dei numeri) in un'uscita, con una forma fissata e numeri interni ricavati dagli esempi.
Quando l'apprendimento automatico finisce, ti rimane qualcosa che puoi salvare e riusare: il modello. È una funzione, nel senso matematico: dato un ingresso, calcola un'uscita. Se il compito è prevedere il prezzo di una casa, l'ingresso sono le caratteristiche della casa e l'uscita è un prezzo. Se è riconoscere uno spam, l'uscita è un giudizio sulla mail.
Dentro un modello ci sono due cose distinte. La prima è la struttura, cioè la forma del calcolo: quante somme, quanti passaggi, in che ordine. La struttura la sceglie una persona. La seconda sono i numeri interni, e quelli li fissa l'apprendimento. Stessa struttura con numeri diversi dà comportamenti diversi: è come avere lo stesso schema di una formula con coefficienti diversi.
Un modello si può salvare in un file, e a quel punto funziona senza più bisogno degli esempi con cui è stato ottenuto. Le dimensioni variano moltissimo: il modello di un filtro antispam semplice occupa pochi kilobyte, quelli degli assistenti moderni arrivano a decine o centinaia di gigabyte. Per usarlo serve un altro programma che lo carica ed esegue i calcoli: il file da solo non fa nulla.
Un modello è sempre una semplificazione: cattura regolarità, non tutta la realtà. Per questo ne esistono tanti, uno per tipo di compito, e si possono confrontare e sostituire.
Immagina un modello molto semplice che stima il prezzo di un appartamento. Ingressi: metri quadri e chilometri dal centro. La struttura è: prezzo = (numero A × metri quadri) + (numero B × chilometri) + numero C. L'apprendimento, guardando i prezzi di vendite passate, ricava A = 1.800, B = −5.000, C = 10.000 (numeri di esempio).
Ora lo usi: appartamento di 80 metri quadri a 3 chilometri dal centro. Calcolo: 1.800 × 80 = 144.000; −5.000 × 3 = −15.000; poi 144.000 − 15.000 + 10.000 = 139.000 euro. Questo è il modello al lavoro: una struttura fissa e tre numeri imparati.
Un numero tra 0 e 1 (cioè tra 0% e 100%) che dice quanto una risposta è verosimile. Le probabilità di tutte le risposte possibili sommano 1.
Il mondo è ambiguo, e un buon modello lo sa: davanti a una frase interrotta, più continuazioni sono sensate. Per questo un modello raramente risponde con un'unica parola secca. Assegna a ogni risposta possibile un numero tra 0 (impossibile) e 1 (certa), e tutti i numeri insieme sommano esattamente 1. Scritti in percentuale, sommano 100%.
Il calcolo interno produce prima dei punteggi grezzi, che possono essere qualunque numero, anche negativo. Un passaggio finale li trasforma in numeri tra 0 e 1 che sommano 1, mantenendo l'ordine: il punteggio più alto diventa la probabilità più alta. Il risultato è un elenco ordinato di possibilità, ciascuna con la sua fiducia.
Come si sceglie la risposta finale? Si può prendere sempre la più probabile, oppure sorteggiare tenendo conto delle probabilità: con 0,64 su una risposta e 0,26 su un'altra, la prima esce circa 64 volte su 100 e la seconda circa 26. Questa scelta cambia molto il carattere del risultato: costante nel primo caso, più vario nel secondo.
Una probabilità è una misura di fiducia del modello, non un fatto. Un modello è ben calibrato quando, tra le risposte a cui dà il 90%, circa 9 su 10 sono davvero giuste. Quando non lo è, i numeri sono ottimisti o pessimisti.
Il modello deve completare «Il gatto dorme sul…». Calcola queste probabilità (numeri di esempio): divano 0,64; letto 0,26; tappeto 0,08; tutto il resto insieme 0,02. Controlla la somma: 0,64 + 0,26 + 0,08 + 0,02 = 1,00. In percentuali sono 64%, 26%, 8% e 2%.
Se prendi sempre la risposta più probabile, scrivi «divano». Se invece sorteggi 100 volte seguendo questi numeri, ti aspetti circa 64 «divano», 26 «letto», 8 «tappeto» e 2 risposte diverse. Nessuna delle quattro è sbagliata: la frase ha più continuazioni sensate.
L'unità di calcolo più piccola: riceve dei numeri, li moltiplica ciascuno per un numero di importanza, li somma e produce un numero in uscita.
Il nome viene dalle cellule nervose del cervello, ma il neurone artificiale è una formula molto più semplice. Nasce nel 1943 come schema teorico di due ricercatori, McCulloch e Pitts, e nel 1958 Frank Rosenblatt ne costruì una versione capace di imparare, il «perceptron».
Il lavoro che fa è sempre lo stesso, in quattro mosse. Riceve alcuni numeri in ingresso. Moltiplica ciascuno per un suo numero di importanza: più è alto, più quell'ingresso conta. Somma tutti i prodotti e aggiunge un valore di partenza. Infine passa il totale a una piccola regola che decide quanto segnale far uscire. Il numero che ne esce va ad altri neuroni, oppure è la risposta finale.
Da solo un neurone sa fare pochissimo: può, ad esempio, dividere i casi in due gruppi tracciando una linea. Il suo valore sta nel numero. Mettendone migliaia o milioni a lavorare insieme, ognuno su una piccola parte del problema, si ottengono comportamenti che nessun neurone da solo mostra.
La cosa che rende il neurone interessante è che i numeri di importanza non li sceglie nessuno: si ricavano dagli esempi. Un neurone appena creato ha numeri casuali e dice sciocchezze; dopo l'apprendimento ciascuno ha preso un ruolo.
Un neurone decide se uscire stasera. Tre ingressi, ciascuno 1 se vero e 0 se falso: c'è il sole, è sabato, sono stanco. I numeri di importanza sono +3, +2 e −4. Il valore di partenza è −1 (numeri di esempio).
Caso A: sole sì, sabato sì, stanco no. Calcolo: 3 × 1 + 2 × 1 + (−4) × 0 = 5; poi 5 − 1 = 4. Positivo, quindi il neurone dice «esco».
Caso B: sole sì, sabato no, stanco sì. Calcolo: 3 × 1 + 2 × 0 + (−4) × 1 = −1; poi −1 − 1 = −2. Negativo, quindi «resto a casa». La stanchezza ha pesato più del sole.
Un numero associato a un collegamento tra due neuroni che dice quanto quell'ingresso conta nel calcolo: alto, quasi ignorato, oppure negativo, cioè contrario.
Nell'esempio del neurone hai visto i numeri +3, +2 e −4: sono i pesi. Ogni collegamento ne ha uno. Un peso grande e positivo vuol dire che quell'ingresso spinge molto l'uscita verso l'alto. Un peso vicino a zero lo rende quasi irrilevante. Un peso negativo lo trasforma in un freno: più l'ingresso è alto, più l'uscita si abbassa.
I pesi sono il luogo in cui sta la «conoscenza» di un modello. Nessuno li scrive: all'inizio sono numeri casuali piccoli, di solito tra −1 e 1 e spesso anche più piccoli, e il procedimento di apprendimento li ritocca un po' alla volta per ridurre gli errori. Alla fine, la regolarità che il modello ha imparato è distribuita in tutti quei numeri, non in uno solo, e non c'è un punto in cui leggere «la regola».
In un modello grande i pesi sono miliardi. Per questo non si può spiegare una singola risposta indicando il peso responsabile: è l'effetto combinato di moltissimi pesi insieme. Quando si dice che un modello è «aperto» o che «si scarica», nella pratica si intende che i suoi pesi sono pubblici.
Un neurone decide se prendere l'ombrello. Ingressi tra 0 e 1: nuvolosità, probabilità di pioggia delle previsioni, sole pieno (0 o 1), giorno della settimana (codificato con un numero). Pesi di esempio: 4, 5, −3 e 0,01.
Giornata grigia: nuvolosità 0,8, previsioni 0,6, sole 0, giorno 3. Calcolo: 4 × 0,8 = 3,2; 5 × 0,6 = 3,0; −3 × 0 = 0; 0,01 × 3 = 0,03. Totale 6,23: molto positivo, ombrello.
Giornata di sole: nuvolosità 0,1, previsioni 0,1, sole 1, giorno 3. Calcolo: 0,4 + 0,5 − 3 + 0,03 = −2,07: negativo, niente ombrello. Il giorno della settimana, con peso 0,01, non cambia mai la decisione.
Un numero che si aggiunge alla somma di un neurone, indipendente dagli ingressi: sposta la soglia oltre la quale il neurone si accende. Anch'esso viene imparato.
Ogni neurone calcola la somma dei suoi ingressi moltiplicati per i pesi. A quel risultato si aggiunge un ultimo numero, sempre lo stesso qualunque sia l'ingresso: il bias, che in italiano si può rendere con «inclinazione» o «tendenza di base». Il neurone calcola quindi: somma dei prodotti, più bias.
A che cosa serve? Senza bias, se tutti gli ingressi valgono zero la somma sarebbe zero, sempre, e il neurone non potrebbe avere una tendenza propria. Con il bias può essere «pigro» (valore negativo: servono motivi forti per accendersi) oppure «ben disposto» (valore positivo: si accende anche con pochi motivi). In pratica il bias regola quanto è facile che il neurone entri in azione.
Come i pesi, il bias non è scelto da nessuno: parte da un valore iniziale e viene ritoccato dall'apprendimento. In una rete ogni neurone ha il suo bias, quindi i bias sono tanti quanti i neuroni, un numero piccolo rispetto ai pesi, che sono uno per ogni collegamento.
Se conosci la geometria, è la stessa differenza che c'è tra una retta che passa per forza dall'origine e una retta che può stare ovunque: il bias dà la libertà di spostarla.
Riprendi il neurone «esco stasera». Supponi che i motivi a favore sommati diano 2 (numero di esempio).
Con bias −3, il neurone è un pantofolaio: 2 − 3 = −1, negativo, resta a casa. Servirebbe una somma di almeno 4 per vincere: 4 − 3 = +1, e allora esce.
Con bias +1, il neurone è un entusiasta: 2 + 1 = 3, esce. Anzi, esce anche quando i motivi sommano 0: 0 + 1 = 1, positivo. Con lo stesso identico ragionamento sugli ingressi, il bias cambia da solo il carattere di chi decide.
Qualunque numero che il modello ricava dall'apprendimento: i pesi e i bias presi tutti insieme. È l'unità con cui si misura la grandezza di un modello.
Parametro è il termine collettivo: pesi più bias. Quando senti «modello da 8 miliardi di parametri», abbreviato 8B, vuol dire che dentro ci sono 8 miliardi di numeri regolati dall'apprendimento. È il modo più comune per dire quanto è grande un modello. Per dare un'idea: GPT-3, del 2020, ne ha 175 miliardi; Llama 3 nella versione piccola ne ha circa 8 miliardi.
I parametri contano per due ragioni. La prima è la capacità: più numeri regolabili ci sono, più dettagli un modello può assorbire. La seconda è il costo: ogni parametro occupa memoria e va usato nei calcoli. Se ogni numero è salvato con 2 byte, 8 miliardi di parametri occupano 8.000.000.000 × 2 = 16.000.000.000 byte, cioè circa 16 gigabyte. Un modello da 70 miliardi ne richiede circa 140.
Il numero di parametri si ricava dalla struttura: basta contare i collegamenti e i neuroni. Un neurone con n ingressi ha n pesi e 1 bias, cioè n + 1 parametri. Moltiplicando per il numero di neuroni di ogni gruppo e sommando i gruppi si arriva al totale.
Un parametro da solo non significa nulla: il comportamento viene dall'insieme, e non si può dire che «questo numero sa che Roma è la capitale».
Conta i parametri di una piccola rete per leggere cifre scritte a mano. Struttura: 784 numeri in ingresso, uno strato da 100 neuroni, un altro da 100, uno finale da 10 (numeri di esempio, ma tipici).
Primo strato: 100 neuroni con 784 pesi ciascuno, più 1 bias ciascuno: 784 × 100 + 100 = 78.500. Secondo: 100 × 100 + 100 = 10.100. Ultimo: 100 × 10 + 10 = 1.010. Totale: 78.500 + 10.100 + 1.010 = 89.610 parametri.
Con 2 byte ciascuno sono circa 179 kilobyte: un file minuscolo. Un modello da miliardi è lo stesso conto, fatto in grande.
Una piccola regola non lineare applicata al risultato di ogni neurone, che decide quanto segnale far passare. Senza di essa, mille strati varrebbero uno solo.
Dopo che un neurone ha fatto la somma pesata e aggiunto il bias, il risultato non esce così com'è: passa in una funzione di attivazione, che lo trasforma. Questa regola è «non lineare», cioè non è una semplice proporzione: raddoppiare l'ingresso non raddoppia l'uscita.
Perché è indispensabile? Senza di essa, ogni strato farebbe solo moltiplicazioni e somme. Ma una somma di moltiplicazioni di moltiplicazioni è ancora una moltiplicazione e una somma: cento strati in fila si ridurrebbero matematicamente a uno solo. Esempio: se uno strato calcola y = 2 × x e il successivo z = 3 × y, in tutto è z = 6 × x. Un solo conto, e la profondità non avrebbe aggiunto nulla.
Con una regola non lineare in mezzo, ogni strato può piegare un po' le relazioni, e la loro combinazione diventa una curva complessa invece di una retta. Le forme più semplici sono la soglia («se positivo passa, altrimenti zero») e le curve morbide a «S». Una buona funzione è facile da calcolare e non rende difficile la correzione dei numeri durante l'apprendimento.
La funzione si applica a ogni neurone, separatamente, e di solito è la stessa in tutta la rete, con qualche eccezione per l'ultimo strato.
Due neuroni in fila, uno con importanza 2 e l'altro con importanza 3 (numeri di esempio). Senza funzione di attivazione, ingresso 1 dà 2 × 1 = 2 e poi 3 × 2 = 6. Ingresso 2 dà 12; ingresso −1 dà −6. L'uscita è sempre 6 volte l'ingresso: una retta.
Ora metti dopo il primo neurone la regola «se il numero è negativo diventa 0». Ingresso 1: primo neurone 2, resta 2, poi 3 × 2 = 6. Ingresso −1: primo neurone −2, diventa 0, poi 3 × 0 = 0. Prima dava −6, ora dà 0: la linea retta si è piegata. È questa piega, ripetuta in migliaia di neuroni, a permettere alla rete di imparare cose complicate.
La funzione di attivazione più semplice: se il numero ricevuto è negativo restituisce 0, se è positivo lo lascia passare uguale.
Il nome sta per «Rectified Linear Unit», cioè unità lineare rettificata, e descrive un'operazione di una riga: il risultato è il maggiore tra 0 e il numero ricevuto. Se la somma di un neurone è negativa, il neurone si spegne e consegna 0. Se è positiva, la consegna invariata.
Perché è diventata lo standard per anni, dai primi anni 2010 in poi? Perché costa pochissimo: è un confronto con zero, senza calcoli elaborati. Perché, quando passa, non altera il numero, quindi non ne schiaccia il valore: questo aiuta le correzioni dei pesi a viaggiare da uno strato all'altro durante l'apprendimento. E perché spegnere molti neuroni rende la rete più «sparsa», con meno attivi per ogni caso.
Ha un difetto noto. Se un neurone riceve sempre somme negative, per qualunque esempio, emette sempre 0 e le correzioni non lo raggiungono più: resta spento per sempre. Si parla di neurone «morto». Succede quando i pesi finiscono in una zona sfortunata, per esempio dopo una correzione troppo brusca. Per questo sono nate le varianti più morbide.
Oggi ReLU si usa ancora molto, soprattutto nelle reti per le immagini, mentre i grandi modelli di testo preferiscono le varianti morbide.
ReLU(−3) = 0. ReLU(0) = 0. ReLU(2,5) = 2,5. È come un rubinetto che non può andare in negativo: o è chiuso, o lascia passare tutto quello che arriva.
Uno strato con tre neuroni ha calcolato −1,2, 0,7 e 3. Dopo ReLU escono 0, 0,7 e 3. Il primo neurone è spento: dice «questa caratteristica non c'è». Gli altri due lasciano passare il loro segnale, e lo strato successivo lavorerà solo su quello.
Due funzioni di attivazione «morbide», parenti di ReLU: lasciano passare quasi tutto se il numero è alto, quasi niente se è molto negativo, e fanno una curva dolce vicino allo zero.
ReLU ha uno spigolo: a zero la linea cambia direzione di colpo. GELU (Gaussian Error Linear Unit) e SiLU (Sigmoid Linear Unit, detta anche Swish) sono varianti senza spigolo. In entrambe il numero ricevuto viene moltiplicato per un coefficiente tra 0 e 1 che dipende dal numero stesso. Se il numero è molto positivo il coefficiente è quasi 1 e il numero passa quasi intero. Se è molto negativo il coefficiente è quasi 0 e il risultato è quasi nullo. Vicino a zero il coefficiente cambia con gradualità, e vale 0,5 esattamente nello zero.
La differenza con ReLU è che i piccoli numeri negativi non vengono azzerati ma sopravvivono un poco: l'uscita scende leggermente sotto zero e poi risale verso zero. Il punto più basso vale circa −0,17 per GELU e −0,28 per SiLU. Questa morbidezza rende più regolare la correzione dei pesi e riduce il rischio dei neuroni «morti».
Le due curve sono quasi sovrapponibili: cambia il modo di calcolare il coefficiente. GELU usa una curva a campana, SiLU una curva a «S» più semplice. Sono le funzioni più usate nei modelli di oggi: GPT-2 e BERT usano GELU, Llama usa SiLU. Per un lettore, la differenza è un dettaglio: l'idea di fondo è la stessa.
Metti a confronto le tre funzioni su alcuni ingressi (valori arrotondati).
Con ingressi molto grandi, positivi o negativi, le tre si somigliano. La differenza sta nella zona intorno allo zero, dove ReLU fa lo scatto e le altre due la curva.
Tanti neuroni collegati in strati successivi: ogni strato trasforma i numeri ricevuti dal precedente fino a produrre la risposta finale.
Una rete neurale è l'insieme di tutto quello che hai visto finora messo in ordine: neuroni con pesi e bias, raggruppati in strati, con una funzione di attivazione dopo ogni neurone. Nella forma più semplice i dati viaggiano in una sola direzione, dall'ingresso all'uscita, senza tornare indietro. Il percorso si chiama «passaggio in avanti».
Il conto è lo stesso a ogni strato: per ogni neurone, somma pesata degli ingressi più bias, poi funzione di attivazione. I risultati dello strato diventano gli ingressi del successivo. Strato dopo strato, la rete costruisce rappresentazioni sempre più astratte: i primi strati colgono dettagli piccoli e semplici, quelli finali combinazioni complesse.
C'è un risultato teorico importante: una rete con un solo strato nascosto abbastanza largo può approssimare quasi qualunque funzione con la precisione che si vuole. Ma è un risultato di possibilità: non dice come trovare i pesi giusti, né quanto serva essere larghi. Nella pratica si preferiscono reti con più strati.
Le prime reti utili risalgono agli anni Ottanta e Novanta: quelle di Yann LeCun leggevano le cifre degli assegni e dei codici postali. Oggi le reti sono la base di quasi tutti i modelli di IA.
Riconoscere una cifra scritta a mano. L'immagine è 28 × 28 puntini, quindi 784 numeri, ciascuno la luminosità di un puntino. Entrano nella rete, passano in due strati da 100 neuroni e arrivano all'uscita, composta da 10 neuroni, uno per cifra da 0 a 9.
Per un «7» scritto bene, l'uscita potrebbe essere: cifra 7 → 0,91; cifra 1 → 0,05; tutte le altre sotto 0,01 (numeri di esempio). Vince il più alto: la rete risponde «7».
All'inizio, con pesi casuali, la rete indovina circa 1 volta su 10, come tirare a sorte. Dopo l'apprendimento, reti di questa taglia leggono correttamente circa il 98% delle cifre di un insieme di prova molto usato.
Un gruppo di neuroni che lavora allo stesso «piano» del modello: c'è lo strato d'ingresso, quello d'uscita e in mezzo gli strati nascosti.
I neuroni non sono sparsi alla rinfusa: sono ordinati in gruppi chiamati strati, uno dopo l'altro. Lo strato d'ingresso riceve i dati grezzi: i numeri di un'immagine, di un testo. Lo strato d'uscita produce la risposta. Tutti quelli in mezzo si chiamano nascosti, perché non si vedono né all'ingresso né all'uscita: sono il lavoro interno.
Nel caso più semplice ogni neurone di uno strato riceve i risultati di tutti i neuroni dello strato precedente, ciascuno con il proprio peso. I conti procedono strato per strato, in ordine: finché lo strato 1 non ha finito, lo strato 2 non può partire. Ma dentro lo stesso strato i neuroni non dipendono l'uno dall'altro e si possono calcolare in contemporanea: è questa la proprietà che i computer moderni sfruttano per andare veloci.
Due misure descrivono la forma di una rete: la larghezza, cioè quanti neuroni ha uno strato, e la profondità, cioè quanti strati ci sono. Reti più larghe e più profonde possono rappresentare cose più complicate, ma costano più parametri, memoria e tempo.
Perché stratificare? Perché ogni strato può fare un piccolo passo e consegnare il risultato al successivo, come in una catena di montaggio. Nessuno strato deve risolvere tutto il problema.
Nella rete per le cifre: lo strato d'ingresso ha 784 numeri (i puntini di un'immagine 28 × 28, cioè 28 × 28 = 784). Il primo strato nascosto trasforma 784 numeri in 100. Il secondo nascosto trasforma 100 numeri in altri 100. L'ultimo strato trasforma 100 numeri in 10: uno per ogni cifra da 0 a 9.
Ogni passaggio cambia la lunghezza dell'elenco di numeri: 784 → 100 → 100 → 10. I modelli reali sono molto più grandi: Llama 3 nella versione da 8 miliardi di parametri ha 32 strati, ognuno con migliaia di neuroni.
Una tabella di numeri in righe e colonne. In una rete neurale è il modo ordinato di scrivere tutti i pesi tra due strati: ogni casella della tabella è uno dei collegamenti della rete.
Parti da un negozio. Due clienti comprano pane, latte e uova. Scrivi una tabella: una riga per cliente, una colonna per prodotto, e in ogni casella quanti pezzi ha preso. Accanto metti i prezzi, uno per prodotto. Per sapere quanto spende il primo cliente prendi la sua riga e la scorri insieme ai prezzi: pezzi di pane × prezzo del pane, più pezzi di latte × prezzo del latte, più pezzi di uova × prezzo delle uova. Poi fai lo stesso con la seconda riga. Questo è «moltiplicare una matrice per una lista di numeri»: ogni riga, accoppiata casella per casella con la lista dei prezzi, dà un totale.
Ora la rete. Uno strato con 3 ingressi e 2 neuroni ha 3 × 2 = 6 collegamenti, cioè 6 pesi. Mettili in una tabella con la stessa regola del negozio: una riga per ogni neurone che riceve (i clienti), una colonna per ogni ingresso da cui parte il collegamento (i prodotti). La casella alla riga 2, colonna 3 è il peso del collegamento che va dall'ingresso 3 al neurone 2. I valori degli ingressi fanno la parte dei prezzi.
Moltiplicando la tabella per gli ingressi, ogni riga dà la somma pesata del suo neurone: lo stesso conto del neurone visto prima, fatto per tutti i neuroni dello strato in un colpo solo. Si aggiungono i bias, si applica la funzione di attivazione, e i numeri che escono diventano gli ingressi della tabella dello strato dopo. Un modello grande è, in buona parte, una lunga fila di queste tabelle.
1. La rete. Ingressi: 4, 5, 6. Il neurone 1 riceve i tre ingressi con pesi 2, 0 e −1; il neurone 2 con pesi 1, 1 e 1.
2. La tabella (2 righe, 3 colonne):
| da ingresso 1 | da ingresso 2 | da ingresso 3 | |
| neurone 1 | 2 | 0 | −1 |
| neurone 2 | 1 | 1 | 1 |
3. Riga 1 per gli ingressi: 2 × 4 + 0 × 5 + (−1) × 6 = 8 + 0 − 6 = 2. Riga 2: 1 × 4 + 1 × 5 + 1 × 6 = 15.
4. Bias e attivazione: con i bias 1 e −20 diventano 3 e −5; la funzione di attivazione ReLU trasforma −5 in 0. Escono 3 e 0.
5. Strato dopo: un neurone con pesi 2 e 4 (una tabella di 1 riga e 2 colonne) riceve 3 e 0: 2 × 3 + 4 × 0 = 6. Numeri di esempio.
Il contenitore di numeri usato ovunque nell'IA: un numero singolo, un vettore, una matrice o una pila di tabelle sono tensori con 0, 1, 2 o più assi.
«Tensore» è il nome generale di un insieme di numeri organizzato in assi. Un numero solo è un tensore con 0 assi. Una lista di numeri, che in questo corso si chiama vettore, ha 1 asse. Una matrice ha 2 assi (righe e colonne). Una pila di matrici ha 3 assi, e così via. Il vantaggio di un nome unico è che i programmi trattano tutto allo stesso modo.
Un tensore si descrive con la sua forma, cioè la lunghezza di ogni asse. Una matrice con 2 righe e 3 colonne ha forma (2, 3). Il numero totale di elementi è il prodotto delle lunghezze: 2 × 3 = 6. Qui c'è un'ambiguità di linguaggio: «dimensione» può voler dire il numero di assi oppure la lunghezza di un asse. Controlla sempre quale dei due significati serve.
I programmi per costruire reti neurali, come PyTorch e TensorFlow, ragionano interamente in tensori. Le schede grafiche sono progettate per fare conti su insiemi di numeri di questo tipo. E il file di un modello è, in sostanza, un elenco di tensori, ciascuno con un nome, una forma e un tipo di numero. I pesi di uno strato sono una matrice, cioè un tensore a 2 assi.
Cinque tensori di complessità crescente. Il numero 5 ha 0 assi. La lista (1, 2, 3) ha forma (3). La tabella con 2 righe e 3 colonne ha forma (2, 3), cioè 6 numeri.
Una foto a colori di 224 × 224 puntini ha 3 numeri per puntino (rosso, verde, blu): forma (224, 224, 3). I numeri sono 224 × 224 × 3 = 50.176 × 3 = 150.528.
Se il programma lavora su 32 foto alla volta, aggiunge un asse: forma (32, 224, 224, 3), cioè 32 × 150.528 = 4.816.896 numeri in un solo tensore a 4 assi.
I modelli che producono contenuti nuovi (testo, immagini, audio, codice) invece di limitarsi a classificare qualcosa o a prevedere un numero.
Molti programmi di IA fanno un lavoro di giudizio: ricevono un ingresso e restituiscono un'etichetta o un numero («spam / non spam», «prezzo stimato»). L'IA generativa fa il contrario: riceve una richiesta e produce qualcosa che prima non c'era, come un paragrafo, un'immagine, una melodia, una funzione di programma.
Come ci riesce? Durante l'apprendimento il modello assorbe la forma dei contenuti: come sono fatte le frasi, come sono fatte le fotografie di gatti. Poi, per generare, parte dalla richiesta e costruisce l'uscita a piccoli pezzi, scegliendo ogni pezzo in base alle probabilità che ha imparato. Per questo la stessa richiesta, ripetuta, può dare risultati diversi: c'è un'estrazione a ogni passo.
L'esplosione recente ha tre cause che si sono incontrate: reti profonde molto grandi, quantità enormi di esempi da cui imparare e computer abbastanza potenti per farlo. Nel 2022 sono arrivati al grande pubblico sia gli assistenti in chat sia i generatori di immagini da una frase.
Generare non significa copiare un contenuto esistente, e nemmeno garantire che sia vero: il risultato è plausibile rispetto a ciò che il modello ha visto.
Stesso soggetto, due tipi di programma. Dai a un classificatore la foto di un gatto: risponde «gatto», una sola etichetta, e finisce lì. Dai a un modello generativo la richiesta scritta «un gatto con il cappello da cuoco, ad acquerello»: produce un'immagine che non esisteva.
Ripeti la richiesta tre volte e ottieni tre immagini diverse: il gatto cambia posa, il cappello colore. Nessuna delle tre è «quella giusta». Con il testo succede lo stesso: chiedi «scrivi due righe di auguri per un compleanno» tre volte e ricevi tre versioni, tutte sensate.
Una rete neurale molto grande, addestrata su enormi quantità di testo a fare una cosa sola: prevedere il token successivo. Da questa abilità nascono riassunti, traduzioni, ragionamenti e codice.
In inglese Large Language Model, abbreviato LLM. «Grande» indica da alcuni miliardi a centinaia di miliardi di parametri: non c'è una soglia ufficiale. GPT-3 ne aveva 175 miliardi, Llama 3 nella versione maggiore 405 miliardi.
Il compito di addestramento è uno solo: dato un testo, indovinare il token successivo, cioè il pezzetto di testo che segue (una parola intera o una parte di parola, più o meno tre quarti di parola in inglese e meno in italiano). Il modello restituisce una probabilità per ogni pezzo possibile, se ne sceglie uno, lo si aggiunge al testo e si ripete. Una risposta intera nasce così, un pezzo dopo l'altro.
Sembra un gioco da poco, ma per prevedere bene il pezzo successivo di testi di ogni genere il modello deve imparare la grammatica, molti fatti sul mondo, lo stile di chi scrive e anche schemi di ragionamento. Più è grande e più dati ha visto, meglio ci riesce. Alcune abilità, come tradurre o scrivere codice, emergono senza che nessuno le abbia insegnate a parte.
Un assistente in chat parte da un modello di questo tipo, poi viene rifinito con l'affinamento e con l'apprendimento dal giudizio umano, per rispondere in modo utile e sicuro. Quindi l'assistente non è solo «il completamento del testo», anche se questa è la sua base.
Scrivi «La capitale della Francia è». Il modello calcola le probabilità del pezzo successivo (numeri di esempio): « Parigi» 0,93; « Lione» 0,02; « una» 0,01; tutti gli altri insieme 0,04. Somma: 0,93 + 0,02 + 0,01 + 0,04 = 1,00. Viene scelto « Parigi».
Il testo ora è «La capitale della Francia è Parigi». Il modello ricalcola: «.» 0,70; «,» 0,15; « e» 0,05; il resto 0,10. Sceglie «.». Poi può fermarsi o continuare. Ogni parola che leggi in una chat nasce con questo ciclo: calcolare le probabilità, scegliere un pezzo, aggiungerlo, ripetere.
Un modello generale, addestrato una volta su dati vastissimi, che poi viene adattato a molti compiti diversi invece di addestrarne uno da zero per ciascuno.
Per anni ogni compito richiedeva il suo modello: uno per le traduzioni, uno per i riassunti, uno per le diagnosi. Ognuno si addestrava da zero con un dataset preparato per quel compito, con etichette costose da produrre. Il modello di fondazione cambia l'approccio: si addestra una sola volta un modello generale su una quantità immensa di dati, senza etichette specifiche, e poi lo si adatta.
Il termine è stato proposto nel 2021 da un gruppo di ricercatori dell'Università di Stanford. Per i modelli più grandi, il primo addestramento richiede migliaia di GPU per settimane o mesi, ed è un costo che pochi possono permettersi. Ma si paga una volta sola.
L'adattamento si fa in tre modi principali: con l'affinamento, cioè un addestramento breve su pochi esempi del compito; con istruzioni scritte, senza toccare i numeri del modello; oppure collegandolo a strumenti esterni. Il costo dell'adattamento è una piccola frazione di quello iniziale.
Un termine collegato è «modello base»: il modello di fondazione nel suo stato iniziale, prima di essere affinato per fare l'assistente. Il rovescio della medaglia è che i difetti del modello di fondazione, per esempio un pregiudizio presente nei dati, si trasmettono a tutti i modelli derivati.
Un'azienda vuole tre strumenti: un assistente in chat, un traduttore di contratti, un aiuto per programmare. Senza modello di fondazione addestra tre modelli da zero. Se ognuno costa 100 unità (numeri di esempio, solo per il confronto), la spesa è 3 × 100 = 300.
Con un modello di fondazione, ne addestra uno solo (100 unità) e poi fa tre adattamenti da 2 unità ciascuno: 100 + 3 × 2 = 106. Meno della metà. Inoltre ogni strumento parte già con una buona cultura generale, come un laureato che poi si specializza in un settore.
All'inizio i pesi sono numeri casuali. L'addestramento è un ciclo ripetuto miliardi di volte: prova, misura l'errore, correggi un pochino.
All'inizio un modello è una scatola di numeri casuali. I pesi, che hai incontrato nella sezione precedente, non contengono ancora nessuna conoscenza: se gli chiedi qualcosa, risponde a caso. Questa sezione racconta come quei numeri diventano utili, cioè come un programma impara da degli esempi.
L'idea di fondo si dice in una frase: mostri un esempio, misuri quanto il modello sbaglia, ritocchi ogni peso di un pochino nella direzione che riduce l'errore, e ripeti miliardi di volte. Tutto il resto della sezione serve a rendere preciso, veloce e affidabile questo giro.
Si comincia dalle materie prime: il dataset, cioè gli esempi, e le GPU, cioè i processori che fanno i calcoli. Poi si entra nel ciclo vero e proprio. L'addestramento è il processo nel suo insieme. La funzione di perdita e l'entropia incrociata misurano l'errore con un numero. Il gradiente e la retropropagazione dicono, per ogni peso, da che parte spostarsi. La discesa del gradiente e Adam trasformano quelle indicazioni in correzioni concrete.
Seguono le manopole che chi addestra deve regolare: gli iperparametri, il tasso di apprendimento e le unità con cui si conta il lavoro, cioè batch, step ed epoche. Poi un rischio che accompagna ogni addestramento, il sovradattamento, e lo strumento per scoprirlo, i dati di validazione.
Nell'ultima parte vedrai che cosa succede dopo la fase principale: l'affinamento che specializza un modello, LoRA che lo rende economico, l'apprendimento per rinforzo dal giudizio umano che lo avvicina alle preferenze delle persone, la distillazione che lo rimpicciolisce e i checkpoint che permettono di salvarlo e riprenderlo. Chiude la sezione il pre-addestramento, la fase da cui nascono i modelli che lavorano sul testo. Qualche calcolo è inevitabile, ma ogni volta ti viene mostrato per esteso, con numeri che puoi rifare a mente.
L'insieme di esempi da cui il modello impara. Può essere una tabella di casi con la risposta già indicata, oppure una montagna di testo grezzo in cui la risposta si trova da sola.
All'inizio un modello non sa nulla: i suoi pesi sono numeri casuali. Tutto ciò che saprà alla fine lo ricava dagli esempi, e per questo il dataset è la materia prima di tutto il lavoro. La sua qualità fissa un tetto a ciò che il modello potrà diventare: nessun modello impara ciò che gli esempi non gli hanno mai mostrato.
Esistono due grandi famiglie di dati. Nella prima ogni esempio arriva con la risposta già scritta da una persona: una mail con l'etichetta «spam» o «non spam», una foto con scritto «gatto». Sono i dati etichettati, ed etichettarli costa lavoro umano, quindi tempo e denaro. Nella seconda famiglia c'è solo il materiale grezzo, e la risposta si ricava dal materiale stesso. Per un modello che lavora sul testo basta una frase: dopo le prime parole, la parola successiva è la risposta giusta, già scritta lì. Così si può leggere una quantità enorme di testo senza che nessuno scriva etichette.
Per i modelli grandi il dataset è fatto di pagine web, libri, articoli, conversazioni e codice di programmazione, per un totale che arriva a migliaia di miliardi di parole. Prima dell'uso viene ripulito: si eliminano i duplicati, il materiale illeggibile e quello di bassa qualità. Questa pulizia conta quanto la quantità.
Di solito il dataset non si usa tutto per imparare: una parte viene messa da parte per controllare, come vedrai più avanti.
Filtro antispam, con numeri di esempio. Il dataset contiene 50.000 mail: 20.000 etichettate «spam» e 30.000 «non spam». Ogni mail è un esempio. Il modello ne legge una, tira a indovinare, confronta con l'etichetta e corregge i propri pesi. Dopo molti esempi scopre che la frase «hai vinto» compare nel 90% delle mail spam e quasi mai nelle altre: diventa un indizio forte.
Se però, per un caso fortuito, tutte le mail spam del dataset fossero scritte in maiuscolo, il modello imparerebbe che le maiuscole indicano spam e bloccherebbe anche le mail di un collega arrabbiato. Il modello impara ciò che trova, coincidenze comprese.
Per un modello che lavora sul testo il dataset è più semplice: la frase «Il gatto dorme sul divano» è già un esempio completo, perché dopo «Il gatto dorme sul» la risposta giusta, «divano», è scritta nel testo.
Il processo che trova i valori giusti dei pesi: il modello vede esempi, misura quanto sbaglia e ritocca i pesi, miliardi di volte, finché sbaglia poco.
All'inizio i pesi sono numeri casuali e il modello risponde a caso. L'addestramento li trasforma in numeri utili con un ciclo che si ripete, fatto di quattro mosse:
Un singolo giro è minuscolo e il miglioramento è quasi invisibile. Ma il ciclo si ripete milioni di volte, e i piccoli miglioramenti si sommano: l'errore medio scende un po' alla volta, fino a stabilizzarsi. A quel punto si ferma.
È la fase costosa. Ogni giro richiede moltiplicazioni che coinvolgono tutti i miliardi di pesi, e i giri sono tantissimi: per i modelli più grandi servono settimane o mesi su migliaia di GPU. Quando l'addestramento finisce, i pesi vengono congelati. Usare il modello significa soltanto fare calcoli con quei pesi, senza più modificarli. Le prossime schede spiegano una per una le quattro mosse.
Un modello minuscolo ha un solo peso, w, e deve imparare la regola «prezzo = w × metri quadrati». Il dataset ha due case: 50 m² a 100.000 € e 80 m² a 160.000 € (numeri di esempio).
Si parte da un peso casuale, w = 1.000. Previsione per la prima casa: 50 × 1.000 = 50.000 €, cioè 50.000 € sotto il prezzo vero. Il peso va aumentato. Con w = 1.500 la previsione è 75.000 €: meglio, ma ancora bassa. Con w = 2.000 si ottiene 50 × 2.000 = 100.000 € e per la seconda casa 80 × 2.000 = 160.000 €: tutto torna. L'addestramento è finito e il peso 2.000 resta fissato.
Qui i ritocchi sono stati scelti a occhio. Nei prossimi termini vedrai le regole precise con cui un vero addestramento decide di quanto e in che direzione muovere ciascun peso.
Il processore delle schede grafiche. Ha migliaia di piccole unità di calcolo che lavorano insieme, quindi è velocissimo nelle moltiplicazioni ripetute di cui sono fatte le reti neurali.
Un processore normale, la CPU, ha pochi nuclei di calcolo, da 4 a qualche decina. Ogni nucleo è molto versatile: sa fare qualsiasi tipo di operazione, e le esegue una dopo l'altra a grande velocità. Una GPU è nata per un altro scopo, disegnare la grafica dei videogiochi, dove bisogna calcolare il colore di milioni di punti dello schermo con la stessa operazione ripetuta su ciascuno. Per questo ha migliaia di unità di calcolo semplici che lavorano nello stesso istante: una scheda da gioco di fascia alta ne ha oltre 16.000.
Una rete neurale si presta benissimo a questo schema. Il suo lavoro consiste soprattutto in moltiplicazioni di matrici, cioè in enormi quantità di moltiplicazioni e somme indipendenti tra loro. Poiché nessuna aspetta il risultato di un'altra, si possono spartire tra migliaia di unità e svolgere insieme.
La GPU ha anche una memoria propria, molto veloce. Le schede per i centri di calcolo ne hanno circa 80 GB, quelle da gioco di fascia alta 24 GB. Questa memoria decide quanto grande può essere un modello che sta su una sola scheda: ogni peso occupa spazio, e un modello da 7 miliardi di pesi, memorizzati con 2 byte ciascuno, richiede 14 GB.
Per i modelli più grandi una GPU non basta: ne servono migliaia, collegate da cavi veloci, che si dividono il lavoro per settimane. Esistono anche chip costruiti apposta per questo scopo, come le TPU di Google. Senza questi acceleratori, far imparare a un modello miliardi di pesi richiederebbe tempi irrealistici.
Prendi due matrici da 4.096 × 4.096, un formato realistico nei modelli attuali. Ognuno dei 16.777.216 numeri del risultato (4.096 × 4.096) è la somma di 4.096 prodotti. In tutto: 16.777.216 × 4.096 = circa 69 miliardi di moltiplicazioni.
Con numeri semplificati, supponi che ogni unità di calcolo faccia un miliardo di moltiplicazioni al secondo. Un'unità sola impiega 69 secondi. Se il lavoro si divide tra 16.000 unità, ciascuna ne fa circa 4,3 milioni e il tempo scende a circa 4 millesimi di secondo. Un vero addestramento ripete calcoli simili miliardi di volte, e la differenza tra secondi e millesimi di secondo diventa la differenza tra anni e settimane.
Un numero che misura quanto il modello ha sbagliato su un esempio: zero se la previsione è perfetta, sempre più alto quanto più è lontana dalla risposta giusta.
Per correggere un errore bisogna prima misurarlo. La funzione di perdita (in inglese loss) è la regola che trasforma «quanto ha sbagliato il modello» in un solo numero. Zero vuol dire nessun errore; più è alto, peggio è andata.
Serve un numero e non un giudizio a parole perché il resto del meccanismo è matematica: ha bisogno di un valore che si possa calcolare e di cui si possa dire, dopo ogni piccola modifica dei pesi, se è salito o sceso. La perdita è la bussola dell'addestramento: se scende, i pesi vanno nella direzione giusta.
La formula dipende dal compito. Se il modello prevede un valore, come il prezzo di una casa, si usa la distanza tra previsione e valore vero, spesso elevata al quadrato. Così il segno non conta (sbagliare di 10 in più o di 10 in meno è lo stesso) e gli errori grandi pesano molto più di quelli piccoli. Se invece il modello deve scegliere tra più risposte possibili, serve una misura costruita sulle probabilità, che vedrai subito dopo.
La perdita si calcola su un esempio e poi si fa la media su un gruppetto di esempi. È il numero che vedi scendere nei grafici di un addestramento. Senza una funzione di perdita non ci sarebbe modo di dire al modello se sta migliorando o peggiorando.
Un modello prevede il prezzo di case, in migliaia di euro (numeri di esempio). Usiamo il quadrato dell'errore.
Prima casa: previsione 200, prezzo vero 250. Errore: 50. Perdita: 50 × 50 = 2.500.
Seconda casa: previsione 240, prezzo vero 250. Errore: 10. Perdita: 10 × 10 = 100. L'errore è cinque volte più piccolo, la perdita venticinque volte più piccola.
Terza casa: previsione 300, prezzo vero 250. Errore: 50 in più invece che in meno. Perdita: 2.500, uguale alla prima: il segno non conta.
Perdita media sulle tre case: (2.500 + 100 + 2.500) ÷ 3 = 5.100 ÷ 3 = 1.700. L'addestramento cerca di far scendere questo numero verso zero.
La funzione di perdita usata quando il modello deve scegliere tra più risposte: guarda solo quanta probabilità aveva assegnato a quella giusta, e punisce molto chi ne dava poca.
Quando deve scegliere, per esempio quale parola viene dopo, il modello non dà una risposta sola: assegna una probabilità a ciascuna possibilità, e le probabilità sommano al 100%. L'entropia incrociata (cross-entropy) guarda una cosa sola: quanta probabilità il modello aveva dato alla risposta giusta. Delle altre non si occupa, perché se la risposta giusta ne ha di più, per forza le altre ne hanno di meno.
La perdita è meno il logaritmo naturale di quella probabilità. Il logaritmo naturale è un tasto della calcolatrice scientifica (ln): per numeri tra 0 e 1 dà un risultato negativo, e cambiando il segno si ottiene un numero positivo. Gli effetti sono facili da ricordare. Se la probabilità è 100%, la perdita è zero. Più la probabilità scende, più la perdita cresce, e cresce sempre più in fretta man mano che ci si avvicina a zero.
Questa curva punisce soprattutto chi era sicuro e ha sbagliato. Dare alla risposta giusta l'1% costa il doppio che darle il 10%, anche se la differenza è di soli 9 punti. Così il modello impara a non escludere mai del tutto una risposta possibile. C'è anche un vantaggio pratico: più il modello sbaglia con sicurezza, più forte è la spinta correttiva.
Per i modelli che lavorano sul testo è la perdita standard: a ogni posizione si guarda la parola vera, si calcola la perdita e poi si fa la media. Un modello totalmente ignorante, che dà la stessa probabilità a 50.000 parole possibili, ha una perdita di circa 10,8.
La frase è «Il gatto dorme sul …» e la parola giusta è «divano». Vediamo quattro modelli (numeri di esempio) che differiscono solo per la probabilità data a «divano».
Se la probabilità scendesse a 0,01%, la perdita salirebbe a 9,2. Tra 10% e 1% la probabilità cala di 9 punti e la perdita raddoppia. È questo che spinge il modello a dare sempre un po' di probabilità alla risposta giusta.
Per ogni peso, un numero che dice in che direzione e di quanto cambierebbe la perdita se quel peso aumentasse di pochissimo. È la pendenza dell'errore rispetto a quel peso.
Hai un modello con miliardi di pesi e un numero, la perdita, che misura quanto sbaglia. Ora bisogna capire come ritoccare i pesi per far scendere la perdita. Provare a caso non funziona: con miliardi di manopole le combinazioni sono infinite. Il gradiente dà l'indicazione precisa.
Prendi un peso solo e immagina di aumentarlo di un'inezia, per esempio di 0,001. La perdita cambia: sale, scende o resta uguale. Il rapporto tra quanto cambia la perdita e quanto hai spostato il peso è la pendenza, ed è il gradiente di quel peso. Se è positivo, aumentare il peso fa salire la perdita, quindi conviene diminuirlo. Se è negativo, conviene aumentarlo. Se è vicino a zero, quel peso ha poca influenza in questo momento.
Il gradiente completo è la lista di tutte queste pendenze, una per peso: un modello con 7 miliardi di pesi ha 7 miliardi di numeri. Il segno indica la direzione, la grandezza dice quanto quel peso conta per l'errore. Spostando ogni peso in direzione opposta al suo gradiente, la perdita scende.
C'è un limite: la pendenza vale soltanto vicino al punto in cui ti trovi. Dopo aver mosso i pesi il paesaggio cambia, e il gradiente va ricalcolato. Come calcolarlo senza fare miliardi di prove è il tema del termine successivo.
Un modello ha un solo peso, w, e la sua perdita è (w − 3) × (w − 3), con numeri di esempio. Il valore migliore è w = 3, dove la perdita è zero.
Parti da w = 5. Perdita: 2 × 2 = 4. Aumenta w di 0,01, cioè 5,01: la perdita diventa 2,01 × 2,01 = 4,0401. È salita di 0,0401 per uno spostamento di 0,01: pendenza circa 4. Il gradiente è positivo, quindi per far scendere la perdita w va diminuito.
Ora parti da w = 1. Perdita: (−2) × (−2) = 4. Con w = 1,01 la perdita è (−1,99) × (−1,99) = 3,9601, scesa di 0,0399: pendenza circa −4. Gradiente negativo: w va aumentato. In entrambi i casi la direzione indicata porta verso 3.
L'algoritmo che calcola il gradiente di tutti i pesi in un colpo solo, partendo dall'errore in uscita e risalendo la rete all'indietro, strato per strato.
Il problema è la quantità: per conoscere l'effetto di ogni peso sulla perdita potresti spostarli uno alla volta e rifare ogni volta tutto il calcolo. Con 7 miliardi di pesi servirebbero 7 miliardi di calcoli completi per ogni singolo ritocco. Impossibile.
La retropropagazione sfrutta il fatto che una rete è una catena di strati: l'uscita di uno è l'ingresso del successivo. Funziona in due fasi. Nella fase in avanti l'esempio attraversa la rete dall'ingresso all'uscita, e i risultati intermedi di ogni strato vengono conservati; poi si calcola la perdita. Nella fase all'indietro si parte dalla perdita e si risale la catena: per ogni strato si calcola quanto ciascun numero ha influito sull'uscita, e gli effetti si moltiplicano lungo la strada (è la «regola della catena»). Così si ottiene il gradiente di ogni peso senza rifare il calcolo da capo.
L'idea chiave è il riuso: il lavoro fatto per gli strati vicini all'uscita serve anche per quelli precedenti. Per questo la fase all'indietro costa circa il doppio di quella in avanti, e con una sola passata di andata e una di ritorno si ottengono tutti i miliardi di pendenze.
Il metodo fu reso celebre da un articolo del 1986 di Rumelhart, Hinton e Williams. Oggi lo eseguono in automatico le librerie di programmazione: chi addestra non lo scrive a mano. Il prezzo da pagare è la memoria, perché i risultati intermedi di tutti gli strati vanno tenuti finché serve la fase all'indietro.
Una rete minuscola con due pesi in fila, senza funzione di attivazione, con numeri di esempio. Ingresso x = 2, peso w1 = 1,5, peso w2 = 2, risposta giusta 10.
In avanti: a = w1 × x = 1,5 × 2 = 3. Uscita y = w2 × a = 2 × 3 = 6. Perdita = (6 − 10) × (6 − 10) = 16.
All'indietro: la perdita cambia di −8 per ogni unità in più di y (è 2 × (6 − 10)). Il peso w2 influisce su y tramite a: −8 × 3 = −24. Per risalire a w1 serve prima l'effetto su a: −8 × w2 = −8 × 2 = −16. Poi −16 × x = −16 × 2 = −32.
Gradienti: −24 per w2 e −32 per w1, entrambi negativi, quindi vanno aumentati. Con una sola passata indietro, si è ottenuto tutto.
La regola che usa i gradienti per aggiornare i pesi: ogni peso viene spostato di poco in direzione opposta al suo gradiente. L'ottimizzatore è la versione concreta della regola.
Ora hai gli ingredienti: la perdita, che misura l'errore, e i gradienti, che dicono come cambierebbe. La regola di aggiornamento è una riga: nuovo peso = vecchio peso − passo × gradiente. Il passo è un piccolo numero fissato da chi addestra. Si sottrae perché il gradiente indica la direzione in cui l'errore sale, e a te serve la direzione opposta.
Ripetendo il giro (calcolo della perdita, calcolo dei gradienti, aggiornamento) la perdita scende gradualmente. È come scendere da una montagna nella nebbia: a ogni passo senti con i piedi da che parte il terreno scende di più, e fai un passo in quella direzione.
Calcolare il gradiente sull'intero dataset prima di ogni aggiornamento costerebbe troppo. Si usa allora un gruppetto di esempi scelti a caso: il gradiente che ne risulta è una stima rumorosa, ma buona, della pendenza vera. Questa variante si chiama discesa stocastica. Un po' di rumore aiuta perfino a non rimanere intrappolati in avvallamenti poco profondi.
«Ottimizzatore» è il nome del componente del programma che applica la regola ai pesi. La discesa del gradiente semplice è il caso base. Esistono varianti più raffinate, che aggiustano il passo o aggiungono slancio, e una di queste è la più usata per i modelli grandi. Per tutti, un aggiornamento ritocca contemporaneamente tutti i miliardi di pesi, e proprio qui le GPU fanno la differenza.
Riprendiamo la perdita (w − 3) × (w − 3), con w = 5 e passo 0,1 (numeri di esempio). Il gradiente di questa perdita è 2 × (w − 3).
Man mano che si avvicina al fondo, la pendenza diminuisce e i passi si accorciano da soli. Dopo molti giri w arriva vicinissimo a 3. In un modello vero succede lo stesso, ma per miliardi di pesi insieme.
L'ottimizzatore più usato per i modelli grandi: parte dalla discesa del gradiente e aggiunge slancio e un passo su misura per ogni peso. AdamW tiene anche piccoli i pesi.
La discesa del gradiente semplice usa lo stesso passo per tutti i pesi e si fida solo del gradiente dell'ultimo giro. Ha due difetti. I gradienti calcolati su pochi esempi sono rumorosi, e la discesa zigzaga. Inoltre pesi diversi hanno pendenze di grandezza molto diversa: un passo uguale per tutti è troppo lungo per alcuni e troppo corto per altri.
Adam (Adaptive Moment Estimation, 2014) mette due rimedi, e per ogni peso conserva due numeri in più. Il primo è una media dei gradienti recenti, ed è lo slancio. Se negli ultimi giri il gradiente puntava sempre nella stessa direzione, la media è forte e il peso accelera. Se oscillava da un segno all'altro, la media si smorza e il peso smette di zigzagare. Il secondo numero è una media dei quadrati dei gradienti, che misura quanto è «agitato» quel peso. Il passo viene diviso per la radice di questo valore: i pesi con gradienti grandi fanno passi più cauti, quelli con gradienti piccoli passi più decisi.
Le due medie hanno una memoria regolabile. I valori abituali sono 0,9 per lo slancio e 0,999 per l'altra, anche se nei modelli più grandi si usa spesso 0,95.
AdamW aggiunge un freno: a ogni giro ogni peso viene rimpicciolito di una piccolissima percentuale. Così i pesi restano piccoli e il modello è meno incline a imparare a memoria gli esempi. Si chiama «decadimento dei pesi», e AdamW lo applica separatamente dal gradiente, differenza che gli dà il nome e lo rende lo standard attuale.
Numeri di esempio, semplificati. Tre pesi, A, B e C, e la regola di passo 0,01.
Il peso A riceve gradienti che oscillano: +0,1, −0,1, +0,1, −0,1. Con la discesa semplice farebbe avanti e indietro. Adam ne fa la media e ottiene quasi zero: il peso resta fermo, senza zigzag.
Il peso B riceve sempre +0,02 e il peso C sempre +50. Con la discesa semplice, B si sposterebbe di 0,01 × 0,02 = 0,0002 (quasi niente) e C di 0,01 × 50 = 0,5 (un salto enorme). Adam divide ciascun gradiente per la propria grandezza abituale: per B 0,02 ÷ 0,02 = 1, per C 50 ÷ 50 = 1. Entrambi si spostano di circa 0,01 × 1 = 0,01, anche se i loro gradienti differiscono di 2.500 volte.
Il numero, scelto da chi addestra, che stabilisce quanto è grande ogni passo di correzione dei pesi. Troppo alto e l'errore rimbalza o esplode; troppo basso e l'addestramento non finisce mai.
Nella regola di aggiornamento il gradiente indica la direzione e la pendenza, ma il passo effettivo è tasso × gradiente. Il tasso di apprendimento (learning rate) è il fattore che decide quanto fidarsi della pendenza misurata. Ricorda che la pendenza vale solo vicino al punto in cui ti trovi: più ti allontani, meno è affidabile.
Ci sono tre casi. Se il tasso è troppo basso, i progressi sono microscopici: ci vorrebbe un'eternità e si spreca tempo di GPU. Se è troppo alto, salti oltre il fondo della valle e atterri dall'altra parte, magari più in alto di prima. La perdita allora oscilla, e nei casi peggiori cresce senza controllo fino a numeri enormi: si dice che l'addestramento «diverge». Se è giusto, la perdita scende in modo regolare.
I valori sono piccolissimi. Nei grandi modelli che lavorano sul testo vanno da circa 0,00006 a circa 0,0006, a seconda della grandezza del modello. Sono piccoli perché ogni peso si sposta poco a ogni aggiornamento, e la somma di miliardi di piccoli spostamenti basta a cambiare il comportamento.
Il tasso, inoltre, non resta fisso. Di solito parte da quasi zero e sale in qualche migliaio di aggiornamenti (fase di «riscaldamento»), perché all'inizio i pesi sono casuali, i gradienti poco affidabili e i passi grandi sarebbero pericolosi. Poi scende gradualmente, spesso fino al 10% del massimo, perché alla fine servono correzioni delicate. È considerato l'iperparametro più importante.
Perdita (w − 3) × (w − 3), con w = 5. Il gradiente è 2 × (5 − 3) = 4. Il fondo si trova in w = 3. Vediamo che cosa succede dopo un aggiornamento con quattro tassi diversi (numeri di esempio).
Un valore scelto da chi addestra, prima di cominciare, e che l'addestramento non modifica: la lunghezza dei passi di correzione, il numero di strati, quanti esempi usare per volta.
In un modello ci sono due tipi di numeri. Il primo tipo sono i parametri, cioè i pesi e i bias: li trova il modello stesso, durante l'addestramento. Il secondo tipo sono gli iperparametri: li sceglie una persona prima di cominciare, e durante l'addestramento restano fissi. Si chiamano «iper» perché stanno un livello sopra: regolano il processo con cui i parametri vengono trovati.
Gli esempi sono tanti: la lunghezza dei passi di correzione; quanti esempi usare per ogni correzione; quanti strati ha la rete e quanti neuroni per strato; quanto tenere piccoli i pesi nella variante AdamW; quante volte rivedere il dataset.
Non esiste una formula per sceglierli. Si prova: si lanciano più addestramenti con valori diversi e si confronta il risultato, provando le combinazioni in una griglia, a caso o con una ricerca guidata. Su un modello piccolo è economico. Su un grande addestramento di mesi non te lo puoi permettere: si prova su versioni ridotte e si ragiona per analogia, usando anche l'esperienza pubblicata da chi ha addestrato modelli simili.
Gli iperparametri contano molto. Con gli stessi dati e la stessa rete, valori diversi possono dare un modello ottimo oppure un addestramento che non decolla. Trovarli è una parte delicata del mestiere.
Stai addestrando un piccolo modello e provi tre valori per la lunghezza del passo di correzione, a parità di tutto il resto (numeri di esempio).
Scegli 0,01. Quel valore l'hai deciso tu, e non lo cambia il modello: è un iperparametro. I pesi, invece, il modello li ha trovati da solo.
È come in cucina: forno a 180 °C per 40 minuti sono scelte tue, mentre come lievita l'impasto lo decide la chimica.
Tre unità per contare l'addestramento: il batch è il gruppetto di esempi elaborati insieme, lo step è un singolo aggiornamento dei pesi, l'epoca è un passaggio completo su tutto il dataset.
Non si può far passare nel modello l'intero dataset prima di ogni correzione: sarebbe lentissimo. Ma correggere dopo un solo esempio darebbe indicazioni troppo rumorose, perché un esempio può essere strano. La via di mezzo è lavorare a gruppetti.
Il batch è il gruppetto di esempi (per esempio 32, oppure 256) elaborati insieme, in parallelo sulla GPU. Si calcola l'errore medio e il gradiente medio sul gruppo: la media attenua le stranezze dei singoli esempi. Un batch più grande dà una stima più affidabile, ma richiede più memoria e permette meno aggiornamenti nello stesso tempo. Nei più grandi modelli che lavorano sul testo si arriva a diversi milioni di pezzetti di testo per batch.
Lo step è un aggiornamento: il ciclo completo su un batch, cioè previsione, misura dell'errore, calcolo dei gradienti e spostamento dei pesi. Contare in step è il modo più comune per misurare la durata di un addestramento.
L'epoca è un passaggio completo su tutto il dataset. Gli step per epoca si ottengono dividendo il numero di esempi per la dimensione del batch. Con dataset piccoli si fanno molte epoche, magari decine, e prima di ogni epoca gli esempi si rimescolano. Con dataset enormi spesso basta una passata, o poco più.
Dataset di 10.000 esempi, batch da 100 (numeri di esempio).
Ogni step usa 100 esempi. Per vederli tutti servono 10.000 ÷ 100 = 100 step: sono un'epoca. Con 3 epoche si fanno 3 × 100 = 300 step, e ogni esempio è visto 3 volte. Gli esempi elaborati in tutto sono 300 × 100 = 30.000.
Se il batch fosse da 1.000, un'epoca avrebbe solo 10.000 ÷ 1.000 = 10 step, e 3 epoche ne farebbero 30: i pesi verrebbero corretti trenta volte invece di trecento, con indicazioni più affidabili ma meno frequenti. Con un batch da 10 gli step per epoca salirebbero a 1.000, molto più rumorosi.
Il modello impara a memoria gli esempi di addestramento invece della regola generale: va benissimo su ciò che ha già visto e male su casi nuovi. Il contrario si chiama underfitting.
Lo scopo dell'addestramento è saper trattare casi mai visti, e non ricordare gli esempi. Questa capacità si chiama generalizzare. Un modello con tanti pesi ha spazio per memorizzare i singoli esempi, compresi i dettagli casuali e gli errori, invece di cogliere la regola che li accomuna.
Si riconosce da un segno preciso. L'errore sugli esempi usati per imparare continua a scendere, fino quasi a zero. L'errore su esempi nuovi smette di scendere e poi risale. Il divario tra i due cresce sempre più.
Le cause tipiche sono: un modello con troppi pesi rispetto ai dati; troppi passaggi sugli stessi esempi; dati poco vari o pieni di errori. I rimedi sono: più dati e più vari; un modello più piccolo; fermare l'addestramento al momento giusto; tenere piccoli i pesi, come fa AdamW; spegnere a caso alcuni neuroni durante l'addestramento.
Il contrario è l'underfitting: il modello è troppo semplice o troppo poco addestrato, e l'errore resta alto anche sugli esempi già visti. Tra i due estremi c'è la zona giusta. Nei grandi modelli sul testo, con dataset enormi visti una sola volta, il sovradattamento classico è meno frequente, ma la memorizzazione si manifesta in altro modo: un modello può ripetere parola per parola passaggi che nei dati compaiono molte volte.
Uno studente impara a memoria le risposte di 20 simulazioni d'esame. Nelle simulazioni prende 10. All'esame vero, dove le domande sono diverse, prende 4. Ha memorizzato, non capito.
Lo stesso con un modello (numeri di esempio). Viene addestrato su 1.000 esempi.
È l'indizio classico: errore sempre più basso su ciò che ha visto, e più alto su ciò che non ha visto.
Una parte dei dati tenuta da parte e mai usata per correggere i pesi, che serve a misurare se il modello funziona su esempi nuovi. È lì che si vede il sovradattamento.
L'errore sugli esempi di addestramento non ti dice se il modello ha imparato a generalizzare. Serve un esame con domande mai viste. Si ottiene con un trucco semplice: prima di cominciare si mette da parte una percentuale degli esempi, per esempio il 10%, scelti a caso, e non li si usa mai per calcolare i gradienti. Sono i dati di validazione.
Durante l'addestramento, a intervalli regolari (ogni poche centinaia di step), si fa passare il modello su questi dati e si calcola la perdita, senza modificare niente. Si disegnano due curve: la perdita sugli esempi di addestramento e quella sui dati di validazione. All'inizio scendono insieme. Se la seconda smette di scendere e risale mentre la prima continua a calare, il modello sta memorizzando.
A che cosa serve il segnale: a fermare l'addestramento al momento giusto (si chiama arresto anticipato), a scegliere la versione migliore tra quelle salvate lungo il percorso e a confrontare gli iperparametri tra loro.
Spesso si tiene un terzo gruppo, i dati di test. I dati di validazione servono per prendere decisioni (quando fermarsi, quali iperparametri usare), e così a poco a poco il modello viene adattato anche a loro. Il giudizio finale si dà quindi su un gruppo mai toccato, usato una volta sola alla fine. Divisioni tipiche sono 80%, 10%, 10% oppure 90%, 5%, 5%.
Hai 10.000 esempi. Ne usi 8.000 per addestrare, 1.000 per la validazione e 1.000 per il test finale (numeri di esempio). Controlli la perdita a diversi momenti dell'addestramento.
La perdita di addestramento scende sempre. Quella di validazione scende fino a circa 6.000 aggiornamenti e poi risale: da lì il modello memorizza. Si sceglie la versione di quel momento e si misura il risultato finale sui 1.000 esempi di test, mai usati prima.
La fase principale e più costosa: il modello legge enormi quantità di testo e impara a prevedere il token successivo, senza etichette umane. Il risultato è un modello base.
Il compito di base è uno solo: dato un testo, prevedere il token successivo. Il token è il pezzetto di testo che il modello tratta come unità, in genere una parola o parte di una parola. Si parte da pesi casuali e si addestra per prevedere il token successivo, miliardi di volte.
Funziona senza etichette umane perché il testo contiene già le risposte. Da una sequenza di N token si ricavano N − 1 esercizi: da ogni posizione si chiede quale token viene dopo, e la risposta giusta è scritta lì. Si chiama apprendimento auto-supervisionato (self-supervised). La funzione di perdita è l'entropia incrociata, calcolata a ogni posizione e poi mediata.
La scala è enorme. Meta ha dichiarato che il suo modello Llama 3 (2024) è stato addestrato su oltre 15.000 miliardi di token; GPT-3 (2020) ne aveva visti circa 300 miliardi. Il lavoro richiede migliaia di GPU per settimane o mesi: per Llama 3 405B, fino a 16.000 GPU. Costa milioni, ed è alla portata di pochissime organizzazioni. Per prevedere bene il token successivo, il modello deve imparare grammatica, fatti, stili e perfino un po' di ragionamento e di programmazione, perché sono utili alla previsione.
Il risultato è un modello base, detto anche modello di fondazione. Sa continuare qualsiasi testo, ma non è ancora un assistente. L'affinamento e l'apprendimento per rinforzo dal giudizio umano lo trasformano in uno. Quasi tutti partono da un modello base già pubblicato e lo specializzano, invece di rifare la fase principale.
La frase è «Il gatto dorme sul divano». Dalle sue cinque parole nascono da sole quattro esercizi, senza che nessuno scriva una risposta (qui ogni parola è un token, per semplicità).
Nell'ultimo, se il modello dà a «divano» il 25%, la perdita è 1,39. Se gli dà il 60%, scende a 0,51. L'addestramento ritocca i pesi finché, mediamente, la probabilità data alla parola giusta cresce.
Un libro di 100.000 parole genera circa 100.000 esercizi. Un dataset di 15.000 miliardi di token ne genera 15.000 miliardi.
Un secondo addestramento, molto più breve e su dati scelti, che parte dai pesi già addestrati per specializzare il modello: seguire istruzioni, adottare uno stile, conoscere un dominio.
La prima fase di apprendimento, da pesi casuali, è lunghissima e costa moltissimo. Alla fine il modello sa molte cose in generale, ma non è specializzato. Invece di ripartire da zero, si parte dai pesi già buoni e si continua ad addestrare con la stessa procedura su un dataset molto più piccolo e mirato. I pesi cambiano poco: il modello conserva la sua cultura generale e aggiunge un'abilità. È come un medico che dopo la laurea si specializza in cardiologia: non rifà gli studi.
Gli usi tipici sono tre. Il primo è seguire le istruzioni (instruction tuning): con migliaia o decine di migliaia di coppie domanda-risposta scritte con cura, il modello impara a comportarsi da assistente. Il secondo è lo stile o il formato: scrivere con il tono di un'azienda, rispondere sempre in un certo schema. Il terzo è il dominio: testi legali, medici, il codice di un'azienda.
I costi sono molto minori: bastano ore o giorni su poche GPU, contro mesi su migliaia. Gli esempi vanno da qualche centinaio a qualche decina di migliaia. Si usa un tasso di apprendimento più basso, per non cancellare ciò che il modello sa già.
Ci sono rischi. Troppo affinamento può far «dimenticare» parte di ciò che sapeva. Con pochi esempi il sovradattamento è in agguato, quindi servono i dati di validazione per controllare.
Un modello già addestrato sul testo ha imparato a continuare qualsiasi frase. Alla domanda «Come cucino la pasta?» può continuare con «Come cucino il riso? Come faccio la pizza?», come in un forum, perché per lui è solo l'inizio di un testo.
Prepari un dataset di 5.000 coppie domanda → risposta scritta bene, per esempio «Come cucino la pasta?» → «Porta a bollore abbondante acqua, aggiungi sale, versa la pasta e cuocila per il tempo indicato sulla confezione» (numeri di esempio). Lanci l'affinamento: qualche ora su una GPU.
Dopo, la stessa domanda riceve una risposta ordinata, come farebbe un assistente. Il modello non ha imparato a cucinare: sapeva già come si cuoce la pasta. Ha imparato come rispondere.
Un modo economico di fare fine-tuning: i pesi originali restano congelati e si addestrano solo due piccolissime matrici affiancate a quelle grandi, che producono un file «adattatore» di pochi megabyte.
Un affinamento completo modifica tutti i pesi. Per un modello da 7 miliardi di pesi serve memoria per i pesi, per i gradienti e per i due numeri in più che Adam conserva per ogni peso: oltre 100 GB, fuori portata per una GPU da 24 GB. E per ogni versione specializzata bisognerebbe salvare una copia intera da 14 GB.
LoRA (Low-Rank Adaptation, 2021) parte da un'osservazione: la modifica che serve a una matrice di pesi è «semplice» e si può descrivere con poche informazioni. Si congela la matrice originale W, per esempio 4.096 × 4.096, e le si affiancano due matrici sottili: A, di 4.096 × 8, e B, di 8 × 4.096. Il loro prodotto è una matrice 4.096 × 4.096 che si somma a W, ma l'addestramento riguarda soltanto A e B. Il numero 8 si chiama rango: più è piccolo, meno numeri si addestrano.
I vantaggi sono tre. Si addestra meno dell'1% dei numeri. La memoria necessaria cala moltissimo, perché i gradienti e i numeri di Adam servono solo per A e B. E il risultato è un piccolo file, l'adattatore, di pochi megabyte, che si carica sopra il modello originale. Con un solo modello scaricato si possono avere decine di adattatori, uno per cliente o per stile, da cambiare al volo. Se serve, l'adattatore si può anche sommare ai pesi, e l'uso del modello non rallenta.
La qualità è spesso vicina a quella dell'affinamento completo quando si cambia stile o formato. È più limitata se bisogna insegnare molto di nuovo.
Una matrice di pesi 4.096 × 4.096 contiene 16.777.216 numeri, circa 16,8 milioni. LoRA le affianca A (4.096 × 8 = 32.768 numeri) e B (8 × 4.096 = 32.768 numeri). In tutto: 32.768 + 32.768 = 65.536 numeri da addestrare, cioè 65.536 ÷ 16.777.216 = 0,4% di quella matrice.
Supponi di applicare LoRA a 4 matrici in ciascuno di 32 strati (numeri di esempio, semplificati). Le matrici sono 4 × 32 = 128, e i numeri da addestrare sono 128 × 65.536 = 8.388.608, circa 8,4 milioni su circa 7 miliardi: poco più dello 0,1%.
Memorizzati con 2 byte ciascuno, pesano 8.388.608 × 2 = circa 17 MB. Il file adattatore è quindi di circa 17 MB, contro i 14 GB del modello completo: lo scambi per mail.
Reinforcement Learning from Human Feedback: dopo l'affinamento, le persone confrontano le risposte del modello e il modello viene spinto verso quelle preferite.
Dopo un affinamento sulle istruzioni, il modello risponde in modo plausibile ma non sempre come vorresti: può essere prolisso, sbrigativo, inventare, assecondare richieste dannose. Scrivere a mano la risposta ideale per ogni domanda costa troppo. È molto più facile giudicare che scrivere: davanti a due risposte, una persona sa dire quale preferisce.
La procedura ha tre passi. Per ogni domanda il modello genera più risposte, per esempio quattro, e valutatori umani le ordinano dalla migliore alla peggiore. Con decine di migliaia di confronti si addestra un secondo modello, detto modello di ricompensa, che impara a dare a ogni risposta un punteggio simile a quello che darebbe una persona. Infine il modello originale viene addestrato a produrre risposte con punteggio alto, con una tecnica di apprendimento per rinforzo: prova, riceve una ricompensa e rinforza ciò che ha funzionato. Si aggiunge un freno, perché il modello non deve allontanarsi troppo dal punto di partenza, altrimenti impara a ingannare il punteggio con testi che lo massimizzano ma non hanno senso.
Una variante più semplice, la DPO (2023), usa direttamente le coppie «risposta preferita» e «risposta scartata», senza modello di ricompensa. Il giudizio può venire anche da un altro modello, o da regole verificabili, come il fatto che un codice superi dei test.
Il metodo ha dato risultati netti: nell'articolo di OpenAI del 2022 sul modello InstructGPT, le risposte di una versione da 1,3 miliardi di pesi con questo metodo erano preferite dai valutatori a quelle di un modello da 175 miliardi senza.
Domanda: «Come sblocco un lavandino intasato?». Il modello genera due risposte (numeri e testi di esempio).
Risposta A: un paragrafo lungo e generico sull'idraulica. Risposta B: tre passi chiari, dal più semplice al più drastico, con l'avviso di non mischiare prodotti chimici diversi. Il valutatore sceglie B.
Dopo 30.000 confronti simili, il modello di ricompensa ha imparato che le risposte chiare, corrette e prudenti ottengono punteggi più alti: A prende 0,2 e B prende 1,5. Il modello originale viene poi corretto per rendere più probabili risposte come B e meno probabili risposte come A. Ripetuto su molte domande diverse, cambia il suo modo generale di rispondere.
Si addestra un modello piccolo, lo «studente», a imitare le risposte di uno grande, l'«insegnante». Si ottiene un modello più leggero e veloce che conserva buona parte della qualità.
I modelli grandi sono bravi, ma lenti e costosi da far girare. Per molti compiti basterebbe un modello più piccolo, che però, addestrato da zero sugli stessi dati, sarebbe meno bravo. La distillazione sfrutta il fatto che un insegnante bravo ha già una conoscenza «digerita» da trasmettere.
Nella forma classica allo studente non si dà solo la risposta giusta, come «divano»: gli si dà l'intera distribuzione di probabilità dell'insegnante, per esempio divano 60%, letto 30%, tappeto 6%. La funzione di perdita (l'entropia incrociata) confronta le probabilità dello studente con quelle dell'insegnante. È un'informazione molto più ricca: dice quali alternative sono ragionevoli e quali assurde. Hinton e colleghi la chiamarono «conoscenza oscura» (articolo del 2015).
La seconda forma, oggi molto diffusa, è più semplice: l'insegnante genera risposte, spiegazioni, soluzioni passo passo, e lo studente viene affinato su questi testi come su un normale dataset. È l'unica strada quando dell'insegnante si possono vedere solo le risposte e non le probabilità interne.
I limiti: lo studente raramente supera l'insegnante, e conserva buona parte della qualità ma non tutta, soprattutto sui compiti difficili. Inoltre molti fornitori vietano nelle condizioni d'uso di usare le loro risposte per addestrare modelli concorrenti.
Frase: «Il gatto dorme sul …». L'insegnante risponde: divano 60%, letto 30%, tappeto 9%, frigorifero 0,1%, altre parole il resto (numeri di esempio). Lo studente all'inizio dà a tutte le parole la stessa probabilità.
Con la sola etichetta «divano», lo studente sarebbe spinto soltanto verso quella parola. Con le probabilità dell'insegnante impara molte cose in un solo esempio: «divano» è la scelta migliore, «letto» è una buona seconda scelta, «tappeto» è possibile ma meno, «frigorifero» è quasi assurda.
Il guadagno in dimensione può essere grande: un insegnante da 70 miliardi di pesi, con 2 byte ciascuno, occupa 140 GB; uno studente da 8 miliardi ne occupa 16.
Una fotografia dei pesi, salvata su disco in un certo momento dell'addestramento, da cui si può ripartire invece di tornare da zero. Il modello che scarichi è un checkpoint.
Un addestramento dura settimane, su migliaia di GPU, e in quel tempo può succedere di tutto: un guasto, un'interruzione di corrente, un errore nei dati. Senza copie di sicurezza, perdere tutto dopo 20 giorni di lavoro sarebbe un disastro. Il checkpoint è il salvataggio: a intervalli regolari, per esempio ogni qualche centinaio o migliaio di step, i pesi vengono scritti su disco.
Un checkpoint completo, quello che serve per riprendere, contiene più dei soli pesi: anche i due numeri per peso dell'ottimizzatore Adam, il numero di step fatti e il punto raggiunto nella lista dei dati. Per questo è molto più grande dei soli pesi: un modello da 7 miliardi, a 2 byte per peso, pesa 14 GB, ma il checkpoint completo può essere di diverse volte tanto.
I checkpoint servono a molto altro. Se a metà percorso l'errore improvvisamente esplode, come è accaduto in grandi addestramenti documentati, si torna a un checkpoint precedente e si riparte saltando i dati incriminati. Permettono di scegliere la versione migliore, quella con la perdita più bassa sui dati di validazione. Permettono di confrontare le versioni intermedie, per vedere che cosa sa il modello a metà strada.
Infine, quando scarichi un modello da internet scarichi un checkpoint, di solito con i soli pesi, pubblicato dall'autore in uno o più file da diversi gigabyte.
Come i salvataggi di un videogioco. Un addestramento dura 30 giorni, cioè 30 × 24 = 720 ore, e un checkpoint viene salvato ogni 6 ore (numeri di esempio).
Il giorno 20 si guasta un computer. L'ultimo checkpoint risale al massimo a 6 ore prima: si perdono al più 6 ore di lavoro su 720, invece di 20 giorni, cioè 480 ore. Si ricarica il checkpoint e si riparte da lì.
Il prezzo è lo spazio. Ogni checkpoint di soli pesi di un modello da 7 miliardi occupa 14 GB. In 30 giorni se ne salvano 720 ÷ 6 = 120, cioè 120 × 14 = 1.680 GB, circa 1,7 TB. Per questo si tengono solo gli ultimi e qualcuno più vecchio, e si cancellano gli altri.
Una rete neurale lavora solo con numeri. Prima di tutto, quindi, il testo va spezzato e convertito.
Un modello di intelligenza artificiale è fatto di numeri e di operazioni tra numeri. Una frase come «Domani piove» è fatta di lettere. Tra le due cose c'è un vuoto, e questa sezione lo riempie. Ogni volta che scrivi a un assistente, nei primi istanti il tuo testo viene tradotto in numeri, poi quei numeri vengono elaborati, e alla fine altri numeri vengono tradotti di nuovo in parole che puoi leggere.
La traduzione ha due tappe. Nella prima il testo viene spezzato in pezzetti, i token, e a ogni pezzetto viene assegnato un numero di tessera, come in un grande dizionario numerato. Qui incontrerai il Token, il Tokenizer che spezza e numera, il Vocabolario che raccoglie tutti i pezzi conosciuti, il metodo con cui si decide quali pezzi tenere (la codifica a coppie di byte) e i token speciali, che non sono testo ma segnali di servizio.
Un numero di tessera, però, non dice nulla sul significato: la tessera 9906 non è «più simile» alla 9907 solo perché i numeri sono vicini. Nella seconda tappa ogni tessera diventa una lunga lista di numeri, un vettore, costruita in modo che parole dal significato vicino abbiano liste vicine. Il nome è embedding. Per capire come si misura la «vicinanza» serve uno strumento semplice, il prodotto scalare, che confronta due liste moltiplicandole posizione per posizione.
Restano due questioni pratiche. La finestra di contesto dice quanto testo il modello riesce ad avere davanti in una volta sola: è il suo tavolo di lavoro, e quello che resta fuori dal tavolo per lui non esiste. La codifica posizionale gli dice in che ordine stanno le parole, perché il vettore di un token, da solo, non dice se quel token sta all'inizio o alla fine della frase.
In coda trovi la similarità del coseno, la misura di vicinanza che si usa davvero nelle ricerche per significato: è il prodotto scalare reso più equo, e la capirai bene solo dopo aver visto tutto il resto. Alla fine saprai che cosa accade tra il momento in cui premi invio e quello in cui il modello comincia a ragionare sui numeri, e capirai perché in limiti, velocità e prezzi si parla sempre di token e quasi mai di parole.
Il pezzo di testo con cui lavora il modello: una parola corta intera, un frammento di parola, un segno di punteggiatura o uno spazio. Il modello legge e scrive solo token, mai lettere o parole intere.
Un modello non legge lettere e non legge parole: legge token. Un token può essere una parola breve e comune («casa»), un frammento di una parola lunga o rara, un segno di punteggiatura, uno spazio insieme alla parola che segue, oppure un singolo carattere insolito come una lettera accentata o un simbolo.
Perché non lavorare con le singole lettere? Perché ogni frase diventerebbe lunghissima e il modello dovrebbe rimettere insieme «gatto» lettera per lettera a ogni passo. Perché non con le parole intere? Perché ogni lingua ne ha centinaia di migliaia, con coniugazioni, errori di battitura, nomi propri e numeri: una lista così sarebbe enorme e qualunque parola nuova resterebbe fuori. I token sono il compromesso: abbastanza lunghi da essere efficienti, abbastanza corti da poter comporre qualunque testo.
Come regola pratica, un testo italiano vale indicativamente da 1,5 a 2 token per parola. L'inglese di solito ne richiede meno, perché i modelli vedono molto più inglese e le sue parole comuni sono più corte. Numeri e codice informatico costano parecchio: una cifra può essere un token a sé.
Il token è l'unità di conto di tutto. Il modello produce la risposta un token alla volta, scegliendo ogni volta il successivo in base alla probabilità. Anche i limiti di lunghezza, la velocità (quanti pezzi al secondo escono) e il prezzo dei servizi a pagamento sono espressi in token.
Prendi «Il gatto dormicchia». Un modello potrebbe spezzarla in 4 token: «Il», «␣gatto» (lo spazio è incluso nel pezzo), «␣dorm», «icchia». La parola comune resta intera, quella rara si spezza. Un altro modello potrebbe usarne 5 o 6: ognuno spezza a modo suo.
Ora il costo, con prezzi di esempio (non di un servizio vero). Hai un testo di 3.000 parole e un servizio che chiede 2 euro ogni milione di token. Prima stimi quanti token sono, poi quanto costano.
| Token, se ogni parola ne vale 1,5 | 3.000 × 1,5 | = 4.500 token |
|---|---|---|
| Token, se ogni parola ne vale 2 | 3.000 × 2 | = 6.000 token |
| Costo con 4.500 token | 4.500 × 2 € ÷ 1.000.000 | = 0,009 € |
| Costo con 6.000 token | 6.000 × 2 € ÷ 1.000.000 | = 0,012 € |
Il testo costa tra 0,9 e 1,2 centesimi: circa un centesimo di euro.
Il programma che spezza il testo in token e li trasforma in numeri, e che fa il percorso inverso per ridare testo leggibile. È un normale programma con regole fisse, non una rete neurale.
Il tokenizer è il traduttore posto all'ingresso e all'uscita del modello. Ha due funzioni: codificare, cioè trasformare il testo in una lista di numeri, e decodificare, cioè trasformare una lista di numeri in testo. Non ha neuroni, non ha pesi e non viene addestrato con la discesa del gradiente: è un normale programma che segue regole e consulta una tabella.
Quella tabella e quelle regole vengono costruite una volta sola, prima del pre-addestramento del modello, analizzando un grande insieme di testi (un dataset) per scoprire quali pezzi conviene tenere. Poi restano congelate per sempre.
Il percorso in codifica ha tre passi:
In decodifica fa il contrario: prende i numeri prodotti dal modello, trova i pezzi corrispondenti e li incolla uno dopo l'altro.
Il modello e il suo tokenizer sono una coppia inseparabile. Il modello è stato addestrato vedendo solo i numeri di quel tokenizer: con un altro tokenizer riceverebbe numeri che per lui significano altre cose, e produrrebbe testo senza senso. Per questo ogni famiglia di modelli ha il suo, e per questo lo stesso testo dà conteggi di token diversi con modelli diversi.
Scrivi «Ciao mondo». I numeri sono di esempio.
Se usassi per sbaglio la tabella di un altro modello, 9906 potrebbe corrispondere a «gatto» e 31910 a «luna»: stessi numeri, testo diverso.
Il metodo più usato per costruire il vocabolario: si parte dai caratteri o dai byte e si fondono ripetutamente le coppie più frequenti. Le parole comuni diventano un solo token, quelle rare si spezzano in pezzi.
Il problema è decidere quali pezzi mettere nel vocabolario. La codifica a coppie di byte (in inglese Byte-Pair Encoding, abbreviato BPE) lo risolve contando, senza bisogno di grammatica. I passi sono questi:
Il risultato è che le sequenze molto frequenti («che», «per», «zione») diventano un pezzo solo, mentre le sequenze rare restano divise in pezzi più piccoli. Le parole comuni costano un token, quelle rare ne costano di più.
Perché partire dai byte? Un byte è un numero da 0 a 255, e ogni testo del mondo, in qualunque lingua, emoji compresi, si può scrivere come sequenza di byte (una lettera accentata ne occupa 2, un emoji fino a 4). Se il vocabolario contiene tutti i 256 byte, nessun testo è mai «impossibile da scrivere»: nel caso peggiore si scrive byte per byte.
L'ordine delle fusioni viene salvato. Il tokenizer lo ripete identico sul tuo testo: applica le stesse fusioni, nello stesso ordine, finché non ce ne sono più di possibili.
Un mini-testo contiene tre parole (numeri di esempio): «sole» 5 volte, «solo» 2 volte, «sale» 4 volte. All'inizio ogni parola è divisa in lettere: s·o·l·e, s·o·l·o, s·a·l·e. A ogni giro si conta quante volte compare ogni coppia di pezzi vicini e si fonde la più frequente.
Giro 1. Vince la coppia «l»+«e»:
| «l»+«e»: in «sole» e in «sale» | 5 + 4 | = 9 volte |
|---|---|---|
| «s»+«o»: in «sole» e in «solo» | 5 + 2 | = 7 volte |
| «s»+«a»: solo in «sale» | 4 | = 4 volte |
Nasce il pezzo «le». Le parole ora sono s·o·le, s·o·l·o, s·a·le.
Giro 2. Vince «s»+«o»:
| «s»+«o»: in «sole» e in «solo» | 5 + 2 | = 7 volte |
|---|---|---|
| «o»+«le»: solo in «sole» | 5 | = 5 volte |
Nasce «so». Le parole ora sono so·le, so·l·o, s·a·le.
Giro 3. Vince «so»+«le», che compare 5 volte (in «sole»); le altre coppie arrivano al massimo a 4. Nasce «sole».
Dopo 3 fusioni «sole», la parola più frequente, è un token solo. «solo» e «sale» sono ancora fatte di pezzi: «so»+«l»+«o» e «s»+«a»+«le».
L'elenco fisso di tutti i token che un modello conosce, ciascuno con il proprio numero. Il modello può scrivere solo combinando queste voci, ma con esse può comporre qualunque testo.
Il vocabolario è una tabella con due colonne: un numero (chiamato ID) e il pezzo di testo che gli corrisponde. Parte dal numero 0 e arriva fino a N−1, dove N è la dimensione del vocabolario. È fisso: una volta costruito insieme al tokenizer non cambia più, e il modello viene addestrato proprio su quelle voci.
Le dimensioni tipiche vanno da circa 32.000 a circa 200.000 voci. Per esempio Llama 2 ne ha 32.000, Llama 3 circa 128.000. Dentro ci sono parole comuni di varie lingue, pezzi di parole, cifre, segni di punteggiatura, pezzi di codice informatico e voci per i singoli caratteri, in modo che ogni testo si possa sempre scrivere.
La dimensione è una scelta di progetto con vantaggi e costi. Con più voci le parole intere sono più numerose, i testi diventano più brevi in token e il modello fa meno passi per scrivere la stessa cosa. Ma ogni voce ha il suo spazio da imparare, e a ogni passo di scrittura il modello assegna una probabilità a ciascuna voce: con 128.000 voci sono 128.000 probabilità da calcolare, ogni volta, per ogni token prodotto.
Il vocabolario è anche il confine di quello che il modello può dire: non ha una voce per ogni parola del mondo, però ha abbastanza pezzi per scrivere qualunque parola, anche inventata.
Immagina un vocabolario piccolo, con numeri di esempio: 0 «!», 1 «"», … 9906 «Ciao», … 31910 «␣mondo». Per scrivere «Ciao mondo» il tokenizer usa le voci 9906 e 31910.
Ora una parola inventata, «Zorbolino». Se non è una voce, il tokenizer la scompone in pezzi che il vocabolario conosce, per esempio «Z», «or», «bol», «ino» (4 voci, ognuna col suo numero). Il modello non incontra mai una parola «sconosciuta»: incontra solo pezzi noti messi in un ordine nuovo.
Il lavoro costa però di più: 4 token al posto di 1.
Voci del vocabolario che non sono testo ma segnali: inizio e fine di un testo, fine di un turno, ruolo di chi parla. Il chat template è il formato che li usa per impacchettare i messaggi di una chat.
Oltre ai pezzi di testo, il vocabolario riserva alcune voci a funzioni di servizio. Sono i token speciali. Il tokenizer li inserisce da solo, a certi posti, e il modello è stato addestrato a riconoscerli. I più comuni:
Senza un segnale di fine, un modello che produce un token dopo l'altro non saprebbe quando fermarsi e continuerebbe a scrivere fino al limite consentito. Senza i separatori, le istruzioni, la tua domanda e la sua risposta sarebbero un'unica fila di parole senza confini.
Il chat template è la ricetta esatta con cui messaggi e token speciali vengono messi insieme. Ogni famiglia di modelli ha il proprio: qualcuno usa <|im_start|> e <|im_end|>, qualcun altro <|start_header_id|> e <|eot_id|>. Il modello è stato addestrato con un formato preciso e si aspetta proprio quello.
Quando usi un assistente, l'app costruisce tutto questo per te. Lo vedi solo se usi un modello da solo, sul tuo computer.
Scrivi «Ciao» a un assistente con istruzione «Sei un assistente cortese». Il testo che il modello riceve, nel formato <|im_start|> (esempio semplificato), è:
<|im_start|>system Sei un assistente cortese<|im_end|> <|im_start|>user Ciao<|im_end|> <|im_start|>assistant
Tutto il blocco diventa numeri; le voci tra < > sono token speciali, ognuna con un solo numero. Il modello continua a scrivere dopo «assistant». Quando ha finito produce <|im_end|>, e il programma sa che può smettere di aspettare.
Un vettore è una lista ordinata di numeri; la sua lunghezza si chiama dimensione. Nei modelli attuali va da 768 a oltre 8.000. Conta la posizione complessiva del vettore, non il valore di un singolo numero.
Un vettore è semplicemente una lista di numeri in un ordine preciso, per esempio (90, 3, 2). La dimensione è quanti numeri contiene: questo vettore ha dimensione 3. Qui «dimensione» indica soltanto quanti numeri ha la lista, senza nessun legame con lo spazio fisico.
Si usano vettori perché un numero solo non basta a descrivere una cosa. Una casa si descrive con superficie, stanze, piano; un colore sullo schermo con la quantità di rosso, verde e blu; un punto sulla mappa con latitudine e longitudine. Ogni numero è una «coordinata», e l'insieme dice dove si trova la cosa in uno spazio.
Quello spazio si può disegnare solo con 2 o 3 numeri, ma le regole di calcolo funzionano identiche con 768 o 4.096. Si possono sommare due vettori (posizione per posizione), moltiplicarli per un numero, e soprattutto dire quando due vettori sono «vicini» o «lontani».
È questo che manca ai numeri di tessera dei token: il numero 9906 non è vicino a 9907 nel significato, e invece due vettori possono esserlo. Per questo la rete lavora con vettori. Le dimensioni usate vanno da 768 nei modelli piccoli a 4.096 nei modelli medi, fino a 8.192 e oltre nei più grandi.
Un punto importante: in un vettore di un modello nessuno ha scelto cosa rappresenta ogni posizione. Quei numeri vengono regolati durante l'addestramento, proprio come i pesi.
Descrivi tre case con tre numeri: metri quadri, stanze, piano. Sono vettori di dimensione 3.
| metri quadri | stanze | piano | |
| Casa A | 90 | 3 | 2 |
| Casa B | 85 | 3 | 1 |
| Casa C | 250 | 7 | 0 |
A e B hanno numeri vicini in ogni colonna, quindi sono case simili. C è lontana da tutte e due in ogni colonna.
Ora una somma. Una famiglia aggiunge 10 metri quadri e una stanza alla casa A: l'aggiunta è il vettore (10, 1, 0). Si somma colonna per colonna:
| Metri quadri | 90 + 10 | = 100 |
|---|---|---|
| Stanze | 3 + 1 | = 4 |
| Piano | 2 + 0 | = 2 |
Un vettore di un modello fa lo stesso, ma con migliaia di caratteristiche che nessuno ha scelto a mano.
Il vettore di numeri che rappresenta un token dentro il modello. Si ottiene cercando il token in una tabella imparata durante l'addestramento: token dal significato simile ricevono vettori simili.
Il tokenizer ha prodotto una lista di numeri di tessera. Il primo passo del modello è trasformare ognuno in un vettore: quel vettore si chiama embedding. L'operazione si fa con una tabella di embedding, una matrice con una riga per ogni voce del vocabolario e tante colonne quante sono le dimensioni. Il numero di tessera dice quale riga prendere. Nessun calcolo: è una semplice ricerca, come aprire il cassetto numero 9906.
Quanto è grande questa tabella? Con un vocabolario di 128.000 voci e vettori di dimensione 4.096, sono 128.000 × 4.096 = 524.288.000 numeri, circa mezzo miliardo di parametri solo per questo primo passo (numeri di esempio).
Questi numeri non li scrive nessuno. All'inizio sono casuali, e l'addestramento li sposta pian piano: quando due token compaiono in frasi simili, le loro righe si avvicinano. Alla fine «gatto» e «micio» hanno vettori vicini, «bullone» ne ha uno lontano. Le direzioni dello spazio acquistano un significato: un esempio famoso, anche se approssimato, è che «re» − «uomo» + «donna» finisce vicino a «regina».
L'embedding è solo il punto di partenza: i calcoli successivi della rete lo trasformano più volte. Un token ambiguo come «banco» ha un solo embedding iniziale; sarà il resto della rete, guardando le parole vicine, a capire se si parla di scuola o di pesci.
Lo stesso nome si usa anche per un vettore che rappresenta un'intera frase o un documento, con lo stesso scopo: dare una posizione al significato.
Prendi una tabella minuscola: 3 righe, e vettori di dimensione 3 al posto di 4.096 (numeri di esempio).
| 1° numero | 2° numero | 3° numero | |
| riga 0, «gatto» | 0,8 | 0,6 | 0,1 |
| riga 1, «micio» | 0,7 | 0,7 | 0,2 |
| riga 2, «bullone» | −0,5 | 0,1 | 0,9 |
Il testo «micio» diventa il numero di tessera 1; il modello prende la riga 1 e ottiene (0,7; 0,7; 0,2). Nessun calcolo: solo una ricerca.
Ora confronta le righe, un numero alla volta: quanto distano?
| «gatto» e «micio», 1° numero | 0,8 − 0,7 | = 0,1 |
|---|---|---|
| «gatto» e «micio», 2° numero | 0,7 − 0,6 | = 0,1 |
| «gatto» e «micio», 3° numero | 0,2 − 0,1 | = 0,1 |
| «gatto» e «bullone», 1° numero | 0,8 − (−0,5) | = 1,3 |
|---|---|---|
| «gatto» e «bullone», 2° numero | 0,6 − 0,1 | = 0,5 |
| «gatto» e «bullone», 3° numero | 0,9 − 0,1 | = 0,8 |
Tra «gatto» e «micio» la distanza è 0,1 in ogni posizione: sono vicini. Tra «gatto» e «bullone» è 1,3; 0,5; 0,8: sono lontani. È così che il modello «sa» che un gatto è più simile a un micio che a un bullone, senza che qualcuno glielo abbia mai detto.
Il modo più semplice di confrontare due vettori: si moltiplicano i numeri che stanno nella stessa posizione e si sommano i risultati. Esce un solo numero, grande se i vettori vanno nella stessa direzione.
Il prodotto scalare prende due vettori della stessa lunghezza e dà un solo numero. Il procedimento è in due passi: moltiplichi i numeri che stanno nella stessa posizione, poi sommi tutti i prodotti. Per due vettori di dimensione 3, chiamati a e b, si scrive così:
Perché misura una somiglianza? Guarda cosa succede a ogni coppia. Se i due numeri hanno lo stesso segno, il prodotto è positivo e il totale cresce. Se hanno segni opposti, è negativo e il totale scende. Se uno dei due è zero, quella posizione non conta. Quindi un risultato grande e positivo vuol dire che i vettori «concordano» in molte posizioni; vicino a zero vuol dire che non hanno nulla in comune; negativo vuol dire che sono opposti.
Il prodotto scalare è l'operazione fondamentale dentro le reti. Ogni neurone fa proprio questo: moltiplica i suoi ingressi per i suoi pesi, somma tutto e aggiunge il bias. E quando si moltiplicano due matrici si fanno in realtà tanti prodotti scalari tutti insieme: è il lavoro per cui servono le GPU, che ne eseguono milioni in parallelo. Anche i confronti tra parole che vedrai più avanti si basano su questa operazione.
Un limite da sapere: il risultato dipende anche da quanto sono lunghi i vettori. Due vettori molto lunghi danno un numero grande anche se non sono particolarmente simili. Come si corregge lo vedrai in fondo alla sezione.
Primo conto: (1, 2, 3) · (4, 5, 6).
| 1ª posizione | 1 × 4 | = 4 |
|---|---|---|
| 2ª posizione | 2 × 5 | = 10 |
| 3ª posizione | 3 × 6 | = 18 |
| Somma dei tre prodotti | 4 + 10 + 18 | = 32 |
Secondo conto: (1, 0) · (0, 1).
| 1ª posizione | 1 × 0 | = 0 |
|---|---|---|
| 2ª posizione | 0 × 1 | = 0 |
| Somma | 0 + 0 | = 0 |
Il risultato è 0: in ogni posizione uno dei due numeri è zero, quindi nessuna posizione «concorda».
Terzo conto: un neurone con 3 ingressi (numeri di esempio). Ingressi (2; 1; 3), pesi (0,5; −1; 0,2), bias 0,1. È lo stesso procedimento, con il bias aggiunto alla fine.
| 1° ingresso × 1° peso | 2 × 0,5 | = 1 |
|---|---|---|
| 2° ingresso × 2° peso | 1 × (−1) | = −1 |
| 3° ingresso × 3° peso | 3 × 0,2 | = 0,6 |
| Somma dei tre prodotti | 1 − 1 + 0,6 | = 0,6 |
| Più il bias | 0,6 + 0,1 | = 0,7 |
Quel 0,7 passa poi alla funzione di attivazione.
L'informazione su dove si trova ogni token nella frase, aggiunta ai suoi numeri. Serve perché il meccanismo di attenzione, da solo, vede i token come un insieme senza ordine.
Il primo passo del modello dà a ogni token il suo embedding, e quel vettore è identico ovunque il token compaia: «cane» ha la stessa riga della tabella all'inizio o alla fine di una frase. Il meccanismo di attenzione poi confronta tutti i token tra loro in una volta sola, senza un ordine. Una rete ricorrente leggeva invece una parola dopo l'altra e conosceva l'ordine di suo, ma era lenta. Per avere la velocità del confronto simultaneo e anche l'ordine, la posizione va aggiunta in modo esplicito.
Il metodo originale è il seguente: a ogni embedding si somma un vettore di posizione, diverso per la posizione 0, la 1, la 2 e così via. Questi vettori erano costruiti con onde che oscillano a velocità diverse. L'intuizione è quella dell'orologio: la sola lancetta dei secondi ripete lo stesso valore ogni minuto, ma l'insieme di secondi, minuti e ore indica un istante unico. Allo stesso modo, onde a velocità diverse danno a ogni posizione una «firma» unica.
Esistono varianti: vettori di posizione imparati durante l'addestramento, oppure, in molti modelli attuali, un'informazione sulla distanza fra due token che entra direttamente nel confronto tra loro. Cambia il metodo, non lo scopo.
Un limite pratico: un modello è addestrato su sequenze fino a una certa lunghezza. Se gli dai testi molto più lunghi, le posizioni oltre quel limite non le ha mai viste e la qualità cala, a meno che non si usino tecniche per estenderle.
«Il cane morde l'uomo» e «L'uomo morde il cane» hanno le stesse parole, quindi gli stessi embedding. Per far capire l'ordine si somma la posizione. Versione semplificata, con numeri di esempio e vettori di dimensione 2.
Prima frase, «cane» in posizione 1:
| Vettore di posizione | (0; 0,1 × 1) | = (0; 0,1) |
|---|---|---|
| Embedding + posizione | (0,5; 0,2) + (0; 0,1) | = (0,5; 0,3) |
Seconda frase, «cane» in posizione 3:
| Vettore di posizione | (0; 0,1 × 3) | = (0; 0,3) |
|---|---|---|
| Embedding + posizione | (0,5; 0,2) + (0; 0,3) | = (0,5; 0,5) |
La stessa parola ora ha due vettori diversi, (0,5; 0,3) e (0,5; 0,5): il modello può distinguere chi morde e chi è morso. Nei modelli veri i vettori di posizione hanno migliaia di numeri.
Il numero massimo di token che il modello può considerare in una volta: istruzioni, conversazione, documenti e risposta in corso. Tutto ciò che sta fuori da questo limite, per il modello, non esiste.
La finestra di contesto è il tavolo di lavoro del modello. Contiene tutto ciò che il modello può vedere mentre produce il prossimo token: le istruzioni iniziali, la conversazione fin qui, i documenti che hai allegato, e anche la risposta che sta scrivendo. Si misura in token e va da qualche migliaio a un milione o più, secondo il modello.
Il punto cruciale è questo: il modello non ha altra memoria. Tra un messaggio e l'altro non conserva nulla da sé. Quando fai una nuova domanda, l'applicazione rimanda al modello l'intera conversazione fino a quel punto, e il modello la rilegge da capo. «Ricorda» solo ciò che gli viene rimesso davanti.
Il limite pesa su tre cose. Primo, la lunghezza: se la conversazione supera la finestra, qualcosa deve uscire; le applicazioni tagliano i messaggi più vecchi o li riassumono, e il modello «dimentica» ciò che è stato tolto. Secondo, il costo: ogni richiesta rimanda tutto, quindi una conversazione lunga costa di più a ogni scambio. Terzo, la qualità: alcune ricerche mostrano che le informazioni a metà di un testo molto lungo vengono usate peggio di quelle all'inizio o alla fine.
Importante: anche la risposta occupa spazio nella finestra. Se hai una finestra da 8.000 token e il tuo testo ne usa 7.900, al modello restano 100 token per rispondere.
Hai una finestra da 8.000 token: circa 4.000 parole, una decina di pagine. Dentro devono starci (numeri di esempio):
| Spazio che resta per le domande | 8.000 − 500 − 5.000 − 1.000 | = 1.500 token |
|---|---|---|
| Scambi possibili, se ognuno usa 300 token | 1.500 ÷ 300 | = 5 scambi |
Dopo 5 scambi (domanda e risposta) la finestra è piena e qualcosa deve uscire.
Con una finestra da un milione di token, quanti romanzi da 80.000 parole ci stanno? Un romanzo vale da 1,5 a 2 token per parola:
| Token di un romanzo, stima bassa | 80.000 × 1,5 | = 120.000 token |
|---|---|---|
| Token di un romanzo, stima alta | 80.000 × 2 | = 160.000 token |
| Romanzi nella finestra, stima alta | 1.000.000 ÷ 160.000 | = 6,25 → 6 interi |
| Romanzi nella finestra, stima bassa | 1.000.000 ÷ 120.000 | = 8,33 → 8 interi |
Ne entrano da sei a otto.
La misura standard di quanto due vettori puntano nella stessa direzione: 1 significa direzione identica, 0 nessuna relazione, −1 direzioni opposte. È la base delle ricerche per significato.
Il prodotto scalare ha un difetto: cresce con la lunghezza dei vettori. La similarità del coseno lo corregge dividendo per le lunghezze, così resta solo la direzione. Si prendono due vettori, chiamati A e B:
Per esempio, la lunghezza del vettore (3, 4):
| Quadrati dei due numeri | 3 × 3 e 4 × 4 | = 9 e 16 |
|---|---|---|
| Somma dei quadrati | 9 + 16 | = 25 |
| Radice quadrata | √25 | = 5 |
Il risultato è sempre un numero tra −1 e 1. Vale 1 se i due vettori hanno la stessa direzione, 0 se sono perpendicolari (nessuna relazione), −1 se sono opposti. Per i vettori dei testi, nella pratica, i valori di solito stanno tra 0 e 1.
Il suo uso principale è la ricerca per significato. Si trasforma ogni documento in un embedding (con un modello di embedding) e li si conserva in un database vettoriale. Poi si trasforma allo stesso modo la domanda, si calcola la similarità con ciascun documento e si prendono i più vicini. Così si trova un testo che parla della stessa cosa anche con parole diverse. Questo meccanismo sta alla base della generazione aumentata dal recupero (RAG).
Spesso i vettori sono già portati a lunghezza 1 prima di essere conservati: in quel caso similarità del coseno e prodotto scalare coincidono, ed è un calcolo più veloce.
Confronta il vettore A = (3, 4), che ha lunghezza 5, con tre vettori diversi. Per ognuno i passi sono gli stessi: lunghezza, prodotto scalare, divisione.
B = (6, 8): il doppio di A, stessa direzione.
| Lunghezza di B | √(36 + 64) = √100 | = 10 |
|---|---|---|
| Prodotto scalare A · B | 3 × 6 + 4 × 8 = 18 + 32 | = 50 |
| Similarità | 50 ÷ (5 × 10) = 50 ÷ 50 | = 1 |
C = (4, −3): perpendicolare ad A.
| Lunghezza di C | √(16 + 9) = √25 | = 5 |
|---|---|---|
| Prodotto scalare A · C | 3 × 4 + 4 × (−3) = 12 − 12 | = 0 |
| Similarità | 0 ÷ (5 × 5) = 0 ÷ 25 | = 0 |
D = (−3, −4): A girato dalla parte opposta.
| Lunghezza di D | √(9 + 16) = √25 | = 5 |
|---|---|---|
| Prodotto scalare A · D | 3 × (−3) + 4 × (−4) = −9 − 16 | = −25 |
| Similarità | −25 ÷ (5 × 5) = −25 ÷ 25 | = −1 |
Risultati: 1 con B (stessa direzione, anche se B è lungo il doppio), 0 con C (nessuna relazione), −1 con D (direzioni opposte).
Con embedding veri (numeri di esempio): «gatto» e «micio» 0,9; «gatto» e «cane» 0,6; «gatto» e «bullone» 0,05.
Quasi tutti i modelli attuali usano la stessa architettura, il Transformer. La sua idea centrale è l'attenzione: ogni parola guarda le altre per capire cosa significa in quel contesto.
Nelle sezioni precedenti hai visto come un testo diventa una fila di token e come ogni token diventa un vettore di numeri, il suo embedding. Resta il problema più difficile: quei vettori, all'inizio, non sanno nulla delle parole vicine. Il vettore di «banca» è lo stesso nella frase sul fiume e in quella sul mutuo. Per capire un testo, ogni parola deve potersi arricchire di quello che dicono le altre.
Fino al 2017 questo lavoro lo facevano le reti ricorrenti, che leggono un token alla volta e si portano dietro un riassunto. Funzionavano, ma dimenticavano l'inizio dei testi lunghi ed erano lente da addestrare. Poi è arrivata un'idea semplice: lasciare che ogni token guardi direttamente tutti gli altri e scelga da chi prendere informazione. È l'attenzione, e su di essa è costruito il Transformer, l'architettura di tutti i grandi modelli di linguaggio di oggi.
In questa sezione smonti il Transformer pezzo per pezzo, nell'ordine in cui serve capirlo. Prima l'attenzione in generale, poi la sua forma usata dentro uno stesso testo, l'auto-attenzione, poi il meccanismo concreto con cui si calcola: Query, Key e Value. Vedrai perché se ne usano molte copie in parallelo, le teste, e perché in un modello che scrive testo ogni token deve guardare solo all'indietro, con la maschera causale.
Poi arrivano i pezzi che stanno intorno all'attenzione: la rete feed-forward che rielabora ogni token, la connessione residua e la normalizzazione che tengono stabile il calcolo. Messi insieme formano il blocco, che si ripete decine di volte. Seguendo lo stato nascosto di un token lungo la pila, capirai come una parola si carica di significato strato dopo strato.
Alla fine avrai tutti gli elementi per riconoscere il Transformer intero e le sue tre forme: encoder, decoder e solo-decoder. Sono le stesse idee che trovi dentro GPT, Llama e gli altri modelli che usi ogni giorno.
Un tipo di rete neurale che legge una sequenza un token alla volta, portandosi dietro un vettore che riassume quanto ha letto finora. Era lo standard per il testo prima del 2017.
Una rete ricorrente ha una memoria di lunghezza fissa: un vettore, per esempio di 512 numeri. A ogni passo riceve due cose, l'embedding del token nuovo e il vettore-memoria del passo prima, e con gli stessi pesi calcola un nuovo vettore-memoria. Poi passa al token successivo. Gli stessi pesi si riusano a ogni passo: per questo si chiama «ricorrente».
Il primo limite è la memoria. Che il testo sia di 10 token o di 10.000, tutto deve stare negli stessi 512 numeri. Ogni token nuovo riscrive un po' il riassunto, e i dettagli dell'inizio sbiadiscono. Anche l'addestramento ne soffre: per correggere i pesi, il gradiente deve tornare indietro passo per passo lungo tutta la sequenza, e lungo centinaia di passi tende a ridursi quasi a zero. Così la rete impara male i legami tra parole lontane. Varianti come la LSTM, del 1997, hanno attenuato il problema senza risolverlo.
Il secondo limite è la velocità. Il passo 100 non può partire finché non è finito il passo 99. Una GPU è fatta per eseguire migliaia di calcoli insieme, ma qui deve aspettare. Con dataset di miliardi di token, l'addestramento diventava molto lento.
Memoria corta e calcolo in fila sono proprio i due limiti che l'idea arrivata nel 2017 ha eliminato: lasciare che ogni token guardi direttamente tutti gli altri, tutti nello stesso momento.
Prendi la frase «Il libro che mi ha prestato Giulia la settimana scorsa, dopo averlo cercato per mesi, è bellissimo» e immagina una memoria di soli 4 numeri (numeri di esempio).
E per arrivare all'ultima parola ha dovuto elaborare tutte le altre una dopo l'altra, senza poterne anticipare nessuna.
L'architettura di rete neurale presentata da Google nel 2017 che elabora tutti i token in parallelo e li mette in relazione con l'attenzione. È alla base dei grandi modelli di linguaggio.
Il Transformer nasce nel 2017 con l'articolo «Attention Is All You Need», scritto da un gruppo di ricercatori di Google. Il titolo riassume l'idea: per capire un testo basta l'attenzione, senza la lettura in fila delle reti ricorrenti. Il primo uso era la traduzione automatica, dove superò i sistemi migliori dell'epoca addestrandosi molto più in fretta.
Visto dall'alto, un Transformer che genera testo funziona così:
Il vantaggio decisivo è il parallelismo. Durante l'addestramento tutti i token di una sequenza si elaborano insieme, con grandi moltiplicazioni tra matrici, il lavoro per cui le GPU sono fatte. Questo ha permesso di addestrare modelli su quantità enormi di testo e di farli crescere da milioni a centinaia di miliardi di parametri.
La «T» di GPT sta per Transformer. Llama, Gemini e quasi tutti gli LLM attuali sono varianti di questa architettura.
Frase: «Il cane che abbaiava ieri sera ora dorme». Confrontiamo i due modi di elaborarla.
Con 32 blocchi, il Transformer fa 32 passaggi di questo tipo, ognuno in parallelo su tutta la frase. La rete ricorrente, su un testo di 1.000 token, dovrebbe fare 1.000 passi uno dopo l'altro.
Il meccanismo con cui ogni token sceglie quanto prendere da ciascun altro token: assegna a ognuno un peso, con pesi che sommano a 1, e fa una media pesata delle loro informazioni.
Ricorda il problema: all'ingresso, il vettore di ogni token è preso dalla tabella di embedding e non sa nulla delle parole vicine. L'attenzione serve a fargli raccogliere quello che gli serve dal resto del testo. Il procedimento ha tre passi.
La differenza con una rete ricorrente è netta. Lì l'informazione di una parola lontana arriva solo se è sopravvissuta a tutti i riassunti intermedi. Qui ogni token guarda direttamente qualunque altro, in un solo passo, che sia vicino o a 5.000 token di distanza. E poiché ogni token fa il suo calcolo da solo, una GPU può farli tutti insieme.
Il prezzo: se il testo ha N token, i confronti sono N × N. Con 1.000 token sono 1.000.000 di punteggi; con 100.000 token diventano 10 miliardi. Per questo la finestra di contesto non può crescere senza limiti.
Frase: «La banca del fiume era piena di fango». Seguiamo il token «banca» (numeri di esempio).
Somma di controllo: 0,6 + 0,2 + 0,05 + 0,05 + 0,1 = 1. Il nuovo vettore di «banca» ora pende verso il significato di «riva»: l'istituto di credito non c'entra con fiumi e fango.
L'attenzione applicata dentro una stessa sequenza: ogni token guarda i token dello stesso testo, compreso sé stesso, e da loro raccoglie informazione.
L'attenzione è nata, qualche anno prima del 2017, per la traduzione: la frase che si stava scrivendo in inglese guardava la frase di partenza in un'altra lingua. Erano due sequenze diverse. L'auto-attenzione (self-attention) è il caso in cui chi guarda e chi viene guardato stanno nella stessa sequenza. «Auto» significa proprio questo: il testo guarda sé stesso.
In pratica, se il contesto contiene 8 token, ognuno degli 8 calcola i propri pesi verso tutti gli 8, sé stesso compreso. Si ottiene una tabella di 8 × 8 = 64 pesi, e ogni riga somma a 1. Tutte le righe si calcolano nello stesso momento, con poche moltiplicazioni tra matrici: per questo il calcolo corre veloce sulle GPU.
Perché serve? Il significato di una parola dipende dalle altre parole dello stesso testo. Un pronome va collegato al nome a cui si riferisce, un verbo al suo soggetto, un aggettivo al nome che descrive. L'auto-attenzione è il modo in cui ogni token raccoglie questi legami.
Una sola passata non basta. Dopo il primo giro, il vettore di ogni token contiene già qualcosa dei vicini. Al giro successivo, guardando gli altri, raccoglie anche ciò che loro avevano raccolto. Ripetendo l'operazione in molti strati, un'informazione può viaggiare lungo tutto il testo e combinarsi con altre.
Frase: «Marta ha detto a Luca che lei arriverà tardi». Seguiamo «lei» (numeri di esempio).
Nello stesso istante anche «arriverà», «Luca» e tutti gli altri fanno lo stesso calcolo verso la frase intera.
Le tre versioni che ogni token ricava dal proprio vettore per l'attenzione: la Query dice cosa cerca, la Key dice cosa offre, il Value è l'informazione che consegna.
Fin qui abbiamo detto che i token si «confrontano». Confrontare direttamente i vettori di partenza però funzionerebbe male: lo stesso vettore dovrebbe servire per cercare, per farsi trovare e per trasmettere, tre compiti diversi. Per questo ogni token moltiplica il proprio vettore per tre matrici di pesi diverse, imparate in addestramento, e ottiene tre vettori nuovi.
Per un token il calcolo procede così. Il punteggio verso ogni altro token è il prodotto scalare tra la propria Query e la Key dell'altro. Ogni punteggio viene diviso per la radice quadrata della lunghezza dei vettori: con vettori da 64 numeri si divide per 8. Serve a evitare punteggi enormi, che concentrerebbero tutto il peso su un solo token. Poi i punteggi diventano pesi che sommano a 1, e il risultato è la somma dei Value, ciascuno moltiplicato per il suo peso.
La separazione dei ruoli è il punto chiave. Un token può essere trovato per un motivo, grazie alla sua Key, e consegnare un'informazione più ricca con il suo Value. Il pronome «lei» cerca un nome femminile; «Marta» si fa trovare come nome femminile e consegna tutto ciò che il modello ha raccolto su Marta.
Numeri di esempio, con vettori di 2 soli numeri. Il token «lei» ha Query [1; 2]. Tre token hanno queste Key e questi Value:
Risultato [8,7; 1,3]: «lei» ha preso quasi tutto da «Marta». Per semplicità abbiamo saltato la divisione per la radice quadrata.
Una copia completa del meccanismo Query, Key, Value, con matrici sue. Ogni strato ne usa molte in parallelo, così può seguire più tipi di relazione nello stesso momento.
Un solo calcolo di attenzione produce, per ogni token, una sola media pesata. Una parola però ha bisogno di più informazioni insieme: chi è il soggetto, quando avviene l'azione, a quale nome si riferisce un aggettivo. Con un solo insieme di pesi dovrebbe scegliere.
La soluzione è usare più teste in parallelo (multi-head attention). Il lavoro viene diviso: in un modello con vettori da 4.096 numeri e 32 teste, ogni testa lavora con Query, Key e Value da 4.096 ÷ 32 = 128 numeri. Ogni testa ha le sue matrici, calcola i suoi punteggi e i suoi pesi, e produce il suo risultato di 128 numeri. I 32 risultati vengono rimessi in fila, tornando a 4.096 numeri, e passati per un'ultima matrice che li mescola.
Il costo totale resta simile a quello di un'unica attenzione grande, perché ogni testa lavora su vettori più corti. In cambio, ognuna può specializzarsi. Nessuno le programma: le specializzazioni emergono durante l'addestramento. Studiando modelli addestrati, i ricercatori hanno trovato teste che collegano i pronomi ai nomi, teste che guardano sempre il token precedente, teste che accoppiano parentesi aperte e chiuse.
Le teste lavorano dentro ogni strato: un modello con 32 strati e 32 teste per strato ne ha 1.024 in tutto.
Frase: «Il gatto che ho adottato ieri sul divano ora dorme». Immagina uno strato con 4 teste e guarda che cosa fa il token «dorme» in ciascuna (esempio illustrativo).
Ognuna produce un vettore di 128 numeri. Messi in fila fanno 4 × 128 = 512 numeri, che una matrice finale mescola nel nuovo vettore di «dorme». Ora quel vettore porta insieme «il soggetto è un gatto», «la parola prima è ora» e «c'entra un divano».
La regola che impedisce a ogni token di guardare i token che vengono dopo di lui: può raccogliere informazione solo da sé stesso e da quelli precedenti.
Un modello di linguaggio impara prevedendo il token successivo. Durante il pre-addestramento riceve un testo intero e, per ogni posizione, deve indovinare il token che segue. Se il token in posizione 5 potesse guardare il token 6, la risposta sarebbe già lì: il modello imparerebbe a copiarla invece che a prevederla. Una volta in uso, quando il token 6 non esiste ancora, non saprebbe più cosa fare.
La maschera risolve il problema dentro l'auto-attenzione. Prima di trasformare i punteggi in pesi, tutti i punteggi verso token successivi vengono sostituiti con «meno infinito». Nella trasformazione in pesi un punteggio meno infinito diventa esattamente 0, e i pesi rimasti continuano a sommare a 1. Nella tabella dei pesi tutto ciò che sta sopra la diagonale è zero: la parte utile ha la forma di un triangolo.
Il vantaggio è enorme. Grazie alla maschera, una sola sequenza di 1.000 token fornisce 1.000 esercizi di previsione, tutti calcolati nello stesso passaggio: il token 1 prevede il 2, i token 1 e 2 prevedono il 3, e così via. Nessuno può barare, e la GPU lavora su tutto in parallelo. Una rete ricorrente avrebbe dovuto fare 1.000 passi in fila.
«Causale» richiama l'idea di causa ed effetto: ciò che viene dopo non può influire su ciò che viene prima.
Frase di 4 token: «Il», «gatto», «dorme», «.». Ecco cosa può guardare ognuno:
Nella tabella 4 × 4 dei pesi, 6 caselle su 16 sono a zero: quelle in cui un token guarderebbe avanti (3 + 2 + 1 = 6). Durante l'addestramento «gatto» deve prevedere «dorme» senza averlo visto, e «dorme» deve prevedere il punto. Ogni posizione è un esercizio di previsione, e si calcolano tutti insieme.
L'unità che si ripete per formare il modello: un sotto-strato di attenzione e uno di rete feed-forward, ciascuno preceduto da normalizzazione e avvolto da una connessione residua.
Un blocco Transformer mette insieme, in un ordine preciso, tutti i pezzi visti finora. Seguendo il vettore x di ogni token, i passi sono:
Il vettore esce con la stessa lunghezza con cui è entrato. Per questo i blocchi si possono impilare: l'uscita di uno è l'ingresso del successivo. Ogni blocco ha i suoi pesi, diversi da quelli degli altri.
Quando si dice che un modello ha «32 layer» si intendono 32 blocchi. Llama 3 8B ne ha 32; GPT-2, nella versione più piccola, ne aveva 12. Dentro ogni blocco succede sempre la stessa coppia di cose: prima comunicazione tra token, poi elaborazione di ogni token.
Con molti blocchi il modello costruisce significati via via più complessi. Gli studi sui modelli addestrati indicano che i primi blocchi tendono a occuparsi di aspetti vicini alla superficie del testo, come la grammatica locale, e quelli successivi di relazioni più astratte. La divisione resta sfumata.
Segui il token «dorme» in «Il gatto dorme» dentro un blocco, con un vettore di 4.096 numeri.
In Llama 3 8B questo giro si ripete 32 volte, con pesi diversi in ogni blocco.
Una piccola rete neurale a due strati che, dopo l'attenzione, rielabora il vettore di ogni token da solo, senza guardare gli altri token.
L'attenzione sposta informazione da un token all'altro, ma elabora poco: in sostanza calcola medie pesate. Serve un passaggio in cui ogni token, con quello che ha raccolto, «ci pensa su». È la rete feed-forward, detta anche MLP. «Feed-forward» significa che i dati la attraversano in una sola direzione, dall'ingresso all'uscita. Per ogni token:
La stessa rete, con gli stessi pesi, si applica a tutti i token, ognuno per conto suo. Non c'è scambio tra token: quello lo fa l'attenzione.
Queste due matrici sono grandi. Con vettori da d numeri e allargamento di 4 volte, ognuna ha 4 × d × d pesi, quindi 8 × d × d in tutto, contro circa 4 × d × d dell'attenzione. Per questo la rete feed-forward contiene circa due terzi dei parametri del modello. Gli studi indicano che qui si concentra buona parte delle conoscenze memorizzate: fatti, associazioni, regolarità della lingua.
Prendi il token «Parigi» nella frase «Ho comprato un biglietto per Parigi». Dopo l'attenzione, il suo vettore contiene già qualcosa del resto della frase: si parla di un viaggio. Ora entra nella rete feed-forward (numeri di esempio: un vettore di 4 numeri allargato a 16).
Il token esce con informazioni che nella frase non c'erano: le ha aggiunte la memoria del modello.
Il collegamento che somma l'ingresso di un sotto-strato alla sua uscita: ogni passaggio aggiunge una correzione al vettore invece di sostituirlo.
Senza connessione residua, ogni passaggio prenderebbe un vettore e ne restituirebbe uno nuovo al posto del vecchio. Con la connessione residua il calcolo diventa: uscita = ingresso + correzione. L'attenzione calcola la sua correzione e la somma al vettore; poi la rete feed-forward calcola la sua e la somma a sua volta. Questo semplice «più» risolve due problemi.
L'idea è nata nel 2015 per le reti che riconoscono immagini, e ha permesso di addestrarne con oltre 100 strati. Oggi si trova in tutti i modelli di linguaggio.
C'è un modo utile di vederla. Il vettore di ogni token scorre dall'inizio alla fine della pila come un canale, il residual stream. Ogni sotto-strato legge dal canale e ci scrive sopra le sue aggiunte.
Numeri di esempio, con un vettore di 3 numeri per il token «banca».
Il vettore iniziale non è stato buttato: ogni passaggio ha aggiunto il suo pezzo. Senza connessione residua, la rete feed-forward avrebbe dovuto ricostruire da zero l'intero vettore, anche se non aveva quasi nulla da aggiungere.
Un'operazione che riporta i numeri del vettore di ogni token a una scala standard prima di ogni sotto-strato, per mantenere stabile il calcolo.
Lungo la pila, le connessioni residue continuano a sommare correzioni. In un modello con decine di strati, alcuni numeri dei vettori possono crescere molto e altri restare piccoli. Le matrici di pesi però funzionano bene solo se i numeri in ingresso hanno una scala prevedibile: con valori fuori scala i calcoli diventano instabili e l'addestramento può saltare.
La normalizzazione prende un vettore e lo riporta a una scala standard. Esistono due versioni principali:
In entrambe, alla fine ogni numero viene moltiplicato per un coefficiente imparato in addestramento, così il modello può ridare più importanza alle posizioni che gli servono.
Si applica a ogni token separatamente, subito prima dell'attenzione e subito prima della rete feed-forward. È la disposizione detta «pre-norm», più stabile di quella del modello originale del 2017, che normalizzava dopo. RMSNorm è oggi la scelta più diffusa perché costa meno e funziona altrettanto bene.
Numeri di esempio. Un vettore di 4 numeri è cresciuto troppo: [300; −500; 100; 100]. Applichiamo RMSNorm.
I rapporti tra i numeri sono rimasti uguali: il secondo è ancora il più grande in valore assoluto ed è ancora negativo. È cambiata solo la scala, ora vicina a 1. Infine ogni posizione verrebbe moltiplicata per il suo coefficiente imparato.
Il vettore che rappresenta un token in un certo punto della pila di blocchi. Cambia dopo ogni blocco, caricandosi di contesto; la sua lunghezza è la dimensione nascosta.
Ogni token, mentre attraversa il modello, è rappresentato da un vettore. All'ingresso è il suo embedding, preso dalla tabella. Dopo il primo blocco è un vettore nuovo, dopo il secondo un altro ancora. Ciascuno di questi è uno stato nascosto. Si chiama «nascosto» perché sta all'interno del modello: non lo vedi in ingresso, dove ci sono i token, né in uscita, dove c'è il token previsto.
La lunghezza del vettore è la dimensione nascosta (hidden size, spesso scritta d_model). È la stessa in tutta la pila, perché ogni blocco restituisce un vettore lungo quanto quello che riceve. Alcuni valori reali: 768 nella versione più piccola di GPT-2, 4.096 in Llama 3 8B.
Il contenuto invece cambia molto. All'ingresso lo stato nascosto di «banca» è identico in ogni frase. Dopo qualche blocco contiene il contesto: chi c'è intorno, che ruolo ha nella frase, di cosa parla il testo. Negli ultimi blocchi lo stato nascosto dell'ultimo token si orienta sempre più verso il token che dovrà venire dopo.
Per un testo di N token, in ogni punto della pila ci sono N stati nascosti, uno per token. Con 1.000 token e dimensione 4.096 sono 1.000 × 4.096 = 4.096.000 numeri a ogni livello della pila, ed è uno dei motivi per cui i testi lunghi richiedono più memoria sulla GPU.
Due frasi: «Mi siedo sulla banca del fiume» e «La banca mi ha concesso un mutuo». Seguiamo il token «banca» (descrizione semplificata).
Se misuri quanto si somigliano i due stati nascosti, il valore scende di blocco in blocco: la stessa parola, in contesti diversi, è diventata due cose diverse.
Le tre forme del Transformer. L'encoder legge tutto il testo guardando in entrambe le direzioni; il decoder genera un token alla volta guardando solo indietro; i modelli solo-decoder usano soltanto questa seconda parte.
Il Transformer originale del 2017 era fatto per tradurre e aveva due metà.
In seguito le due metà sono state usate anche separatamente. I modelli solo-encoder, come BERT (Google, 2018), non generano testo: trasformano un testo in vettori. Servono a classificare, per esempio recensione positiva o negativa, mail di spam o no, e a produrre embedding per trovare documenti simili. I modelli encoder-decoder, come T5, restano utili per tradurre e riassumere.
I modelli solo-decoder (decoder-only) tengono solo la pila con maschera causale, senza il secondo tipo di attenzione. Il testo ricevuto e quello che il modello scrive stanno nella stessa sequenza. È la forma più semplice da addestrare su grandi quantità di testo, perché ogni posizione è un esercizio di previsione. GPT, Llama e quasi tutti gli LLM attuali sono solo-decoder; dei modelli chiusi l'architettura non è pubblicata nei dettagli, ma si ritiene che seguano lo stesso schema.
Tre compiti, tre forme.
Nei casi 2 e 3 il compito è lo stesso; cambia il modo in cui il modello è costruito.
Apriamo fisicamente un modello attuale: l'ordine dei componenti, i nomi che trovi nei file e nelle schede tecniche, gli esperti dei MoE e la testa MTP.
Nella sezione precedente hai smontato un blocco Transformer pezzo per pezzo: attenzione, Query, Key e Value, teste, rete feed-forward, connessioni residue, normalizzazione. Basta conoscere quei pezzi per capire un modello vero? Quasi. Se apri la pagina di un modello su Hugging Face trovi un file di configurazione pieno di numeri e un elenco di pesi con nomi strani come q_proj, gate_proj o experts.17. Questa sezione ti insegna a leggerli.
Si parte dal progetto complessivo, l'architettura, e dai tre numeri che danno la taglia di un modello. Poi arriva l'ultimo pezzo che mancava: la testa di linguaggio, che trasforma il vettore finale in un punteggio per ogni token del vocabolario, i logit. Da lì torni dentro il blocco e incontri le versioni moderne dei pezzi che già conosci: le matrici di proiezione dell'attenzione, il risparmio delle query raggruppate, il modo «rotante» di indicare la posizione, la rete feed-forward con il cancello.
La seconda parte racconta l'idea che ha cambiato i modelli più grandi degli ultimi anni. Invece di una sola rete feed-forward per blocco se ne mettono tante affiancate, gli esperti, e per ogni token ne lavorano solo poche. Vedrai chi decide quali usare, perché si distinguono parametri totali e attivi, e che cosa cambia per la memoria e la velocità.
Chiudono la sezione due allargamenti, i modelli che vedono anche le immagini e quelli che generano immagini partendo dal rumore, più due schede pratiche che leggerai più avanti nell'ordine di studio: i formati dei file che scarichi e il modulo che prevede più di un token alla volta. Alla fine dovresti poter aprire la scheda tecnica di Llama, Mixtral o DeepSeek e capire che cosa c'è dentro, numero per numero.
Il progetto di un modello: quali pezzi contiene, in che ordine sono collegati e quanto è grande ciascuno, indipendentemente dai valori dei pesi.
Quando si parla di un modello si mescolano due cose diverse. La prima è la struttura: quanti blocchi ci sono, come è fatta l'attenzione, che funzione di attivazione si usa, quanto sono lunghi i vettori, quanto è grande il vocabolario. La seconda sono i numeri dentro le matrici, cioè i pesi imparati con l'addestramento. L'architettura è la prima cosa: il progetto vuoto, prima di sapere quali valori ci finiranno dentro.
Nei modelli pubblicati su Hugging Face l'architettura sta in un file piccolissimo, config.json, di poche decine di righe. Contiene il nome della famiglia (per esempio LlamaForCausalLM) e una lista di numeri: num_hidden_layers, hidden_size, vocab_size e così via. I pesi invece stanno in file enormi, da molti gigabyte. Il programma che carica il modello legge prima la configurazione, costruisce le matrici vuote della forma giusta, poi le riempie con i pesi.
Questa separazione ha conseguenze pratiche. Due modelli con la stessa architettura ma pesi diversi si comportano in modo diverso: un modello di fondazione e la sua versione dopo l'affinamento hanno la stessa struttura e risposte molto diverse. Al contrario, non puoi caricare i pesi di un modello dentro un'architettura diversa: le matrici non avrebbero la forma giusta, come un mobile che non entra nella stanza. E un programma che sa costruire un'architettura, per esempio quella di Llama, sa usare tutti i modelli che la condividono, anche se li hanno addestrati aziende diverse.
Prendi due file config.json veri, quello di Llama 3 8B e quello di Llama 3 70B. Il nome della famiglia è lo stesso, LlamaForCausalLM: stessa architettura, stessi tipi di pezzi. Cambiano i numeri: 32 strati contro 80, vettori da 4.096 numeri contro 8.192, 32 teste contro 64. Il vocabolario è identico, 128.256 token.
Ora prendi Llama 3 8B e Llama 3 8B Instruct, la versione addestrata a conversare. I numeri della struttura sono gli stessi e i file dei pesi hanno la stessa dimensione, circa 16 GB. Ma se scrivi «Ciao, come stai?» il primo continua il testo come se fosse l'inizio di un romanzo, il secondo ti risponde. La differenza sta tutta nei valori dei pesi.
I tre numeri principali della configurazione: quanti blocchi sono impilati, quanto è lungo il vettore di ogni token e quante teste di attenzione lavorano in ogni blocco.
Nel config.json li trovi con nomi inglesi. num_hidden_layers è la profondità: quanti blocchi Transformer attraversa il vettore di ogni token, uno dopo l'altro. hidden_size è la larghezza: la lunghezza del vettore che rappresenta ogni token in ogni punto del modello, cioè la dimensione nascosta. num_attention_heads dice in quante teste si divide l'attenzione di ogni blocco. Ogni testa lavora su una fetta del vettore, quindi la dimensione di una testa è la larghezza divisa per il numero di teste.
Accanto a questi tre ce ne sono altri che completano la taglia: intermediate_size, cioè quanto si allarga il vettore dentro la rete feed-forward; vocab_size, quanti token ha il vocabolario; e nei modelli recenti num_key_value_heads, che vedrai tra poco.
Questi numeri decidono quasi tutto il conto dei parametri. In ogni blocco le matrici dell'attenzione e della rete feed-forward hanno lati pari alla larghezza o a un suo multiplo, quindi i pesi crescono col quadrato della larghezza: raddoppiare hidden_size rende ogni blocco circa quattro volte più pesante. La profondità invece conta in modo lineare: il doppio dei blocchi, il doppio dei parametri. Più parametri vogliono dire più memoria e più calcolo per ogni token. Per questo, quando un'azienda prepara la versione grande di un modello, di solito aumenta tutti e tre i numeri insieme, cercando un equilibrio tra larghezza e profondità.
Llama 3 8B ha 32 strati, larghezza 4.096 e 32 teste. Ogni testa lavora quindi su 4.096 ÷ 32 = 128 numeri. Contiamo i pesi di un blocco, arrotondando:
Moltiplicato per 32 strati fa circa 6,98 miliardi. Restano la tabella di embedding e la matrice finale che produce i punteggi, ciascuna 128.256 × 4.096 ≈ 525 milioni: insieme circa 1,05 miliardi. 6,98 + 1,05 = 8,03 miliardi, il numero ufficiale del modello.
| Modello | Parametri | Strati | Dim. nascosta | Teste | Vocabolario | Note |
|---|---|---|---|---|---|---|
| GPT-2 small (2019) | 124 milioni | 12 | 768 | 12 | 50.257 | denso |
| Llama 3 8B | 8 miliardi | 32 | 4096 | 32 | 128.256 | denso, GQA, RoPE, SwiGLU |
| Mixtral 8x7B | 46,7 miliardi (12,9 attivi) | 32 | 4096 | 32 | 32.000 | MoE: 8 esperti, 2 attivi |
| DeepSeek-V3 | 671 miliardi (37 attivi) | 61 | 7168 | 128 | ~129.000 | MoE: 256 esperti + 1 condiviso, 8 attivi; 1 modulo MTP |
Dei modelli chiusi (GPT, Claude, Gemini) questi numeri non sono pubblici: la tabella usa modelli a pesi aperti, i cui file si possono ispezionare. Dati dalle schede tecniche e dagli articoli dei rispettivi modelli.
Un modello in cui tutti i parametri lavorano per ogni token: è il caso classico, contrapposto alla miscela di esperti.
«Denso» vuol dire che il calcolo passa per tutta la rete: ogni token attraversa tutti i blocchi, tutte le teste e tutta la rete feed-forward, e ogni peso viene usato. Llama 3 8B, Llama 3 70B, Mistral 7B e la maggior parte dei modelli piccoli sono densi. Il contrario si dice «sparso», perché per ogni token si usa solo una parte dei pesi.
Il modello denso ha il vantaggio della semplicità. Il costo di ogni token è prevedibile: grosso modo 2 operazioni per parametro, quindi circa 16 miliardi di operazioni per token in un modello da 8 miliardi. La memoria serve tutta, ma tutta lavora, e nulla resta fermo. L'addestramento è più stabile, perché non c'è da bilanciare il lavoro tra esperti, e i programmi per usarlo sono più semplici e diffusi.
Lo svantaggio emerge alle grandi dimensioni. Se vuoi un modello più capace devi aggiungere parametri, e ogni parametro in più rallenta ogni token. Per questo i modelli piccoli e medi sono spesso densi, perché lì la memoria è il limite e conviene sfruttare ogni peso, mentre molti dei modelli più grandi sono miscele di esperti. Le due strade convivono: la stessa azienda pubblica spesso sia versioni dense sia versioni a esperti della stessa famiglia.
Confronta tre modelli, con numeri arrotondati.
Il terzo occuperebbe la stessa memoria di Mixtral, circa 94 GB a 16 bit, ma richiederebbe 94 ÷ 26 ≈ 3,6 volte il calcolo per ogni token. È questo il conto che spinge i modelli molto grandi verso gli esperti.
L'ultima matrice del modello: trasforma il vettore finale di un token in un punteggio per ogni token del vocabolario, cioè nella previsione di quale token verrà dopo.
Dopo l'ultimo blocco Transformer, e un'ultima normalizzazione, ogni token ha uno stato nascosto finale: un vettore di 4.096 numeri in Llama 3 8B. Quel vettore riassume tutto ciò che il modello ha capito del testo fino a quel punto, ma non è ancora una risposta. Serve un ultimo passaggio che lo traduca in una scelta tra i token del vocabolario.
Lo fa la testa di linguaggio, nei file chiamata di solito lm_head. È una matrice con una riga per ogni token del vocabolario e una colonna per ogni numero del vettore: in Llama 3 8B 128.256 righe × 4.096 colonne, circa 525 milioni di pesi. Moltiplicare il vettore per la matrice equivale a fare un prodotto scalare tra il vettore e ogni riga: ne escono 128.256 punteggi. Ogni riga è come il ritratto di un token, e il punteggio dice quanto il vettore finale gli somiglia.
Nota la simmetria con l'embedding. All'ingresso la tabella di embedding prende un token e dà un vettore; all'uscita la testa prende un vettore e dà un punteggio per ogni token. Le due matrici hanno la stessa forma, e molti modelli piccoli le fanno coincidere: si chiama condivisione dei pesi (weight tying) e risparmia centinaia di milioni di parametri. Llama 3.2 1B la usa, Llama 3 8B no. Durante l'addestramento i punteggi si calcolano per ogni posizione del testo; quando si genera serve solo quella dell'ultimo token.
Frase: «Il gatto dorme sul». Il vettore finale di «sul» ha 4.096 numeri; per semplicità immagina che ne abbia solo 3: (1, 2, 0). Prendiamo tre righe della testa, con numeri di esempio:
Il vettore di «sul» somiglia molto alla riga di «divano» e poco a quella di «forno». Nel modello vero lo stesso calcolo si ripete per 128.256 righe, ognuna con 4.096 moltiplicazioni: circa 525 milioni di moltiplicazioni per un solo token.
I punteggi grezzi che escono dalla testa di linguaggio, uno per ogni token del vocabolario: più alto è il punteggio, più il modello ritiene probabile quel token.
Logit è il nome tecnico dei 128.256 numeri (in Llama 3 8B) che la testa di linguaggio produce a ogni passo. Sono numeri qualunque: possono essere positivi o negativi, piccoli o grandi, e la loro somma non vale niente di particolare. Per questo non sono probabilità. Dicono una classifica e quanto distano i candidati tra loro.
Conta la differenza tra due logit, non il loro valore. Se a tutti i punteggi aggiungi 10, la classifica e le distanze restano uguali e la previsione finale non cambia. Una differenza di 1 tra due token corrisponde a un rapporto di circa 2,7 tra le loro probabilità finali; una differenza di 2 a circa 7,4; una differenza di 5 a circa 148. Bastano quindi pochi punti di distacco perché un token diventi quasi certo.
I logit esistono perché a una matrice è facile produrre numeri qualunque, mentre le probabilità devono essere positive e sommare a 1. Così si divide il lavoro: la testa produce punteggi liberi, e un passaggio successivo, che vedrai più avanti, li trasforma in probabilità. Durante l'addestramento proprio su queste probabilità si calcola l'entropia incrociata: se il token giusto aveva un logit basso, l'errore è grande e la retropropagazione corregge i pesi in modo da alzarlo. Guardare i logit è utile anche per capire quanto il modello era sicuro di una scelta.
Dopo «Il gatto dorme sul» la testa produce, tra gli altri: divano 6,1; letto 5,2; tappeto 4,0; forno −3,4 (numeri di esempio).
Guardiamo le distanze. Tra divano e letto c'è 0,9: divano sarà circa 2,5 volte più probabile di letto. Tra divano e tappeto c'è 2,1: circa 8 volte. Tra divano e forno c'è 9,5: divano è circa 13.000 volte più probabile, quindi forno in pratica non uscirà mai.
Ora aggiungi 100 a tutti: 106,1; 105,2; 104,0; 96,6. I numeri sembrano diversi, ma le differenze sono identiche, e lo saranno anche le probabilità finali.
Un modello a pesi aperti è un elenco di tensori con un nome. Questi sono i nomi reali di Llama 3 8B (formato Hugging Face); gli altri modelli usano nomi molto simili.
model.embed_tokens.weight [128256 × 4096] tabella di embedding model.layers.0.input_layernorm.weight [4096] norm prima dell'attenzione model.layers.0.self_attn.q_proj.weight [4096 × 4096] matrice delle Query model.layers.0.self_attn.k_proj.weight [1024 × 4096] matrice delle Key model.layers.0.self_attn.v_proj.weight [1024 × 4096] matrice dei Value model.layers.0.self_attn.o_proj.weight [4096 × 4096] uscita dell'attenzione model.layers.0.post_attention_layernorm.weight [4096] norm prima della MLP model.layers.0.mlp.gate_proj.weight [14336 × 4096] MLP: allarga (ramo «cancello») model.layers.0.mlp.up_proj.weight [14336 × 4096] MLP: allarga model.layers.0.mlp.down_proj.weight [4096 × 14336] MLP: restringe … identico per model.layers.1 fino a model.layers.31 … model.norm.weight [4096] norm finale lm_head.weight [128256 × 4096] testa di linguaggio
Le quattro matrici di pesi dell'attenzione in ogni blocco: tre ricavano Query, Key e Value dal vettore del token, la quarta riunisce i risultati delle teste.
Hai visto che l'attenzione confronta Query e Key e mescola i Value. Ma da dove vengono questi tre vettori? Si ottengono moltiplicando lo stato nascosto del token per tre matrici diverse, imparate con l'addestramento. Nei file dei pesi si chiamano q_proj, k_proj e v_proj: «proiezione» perché ognuna porta il vettore in uno spazio diverso, adatto al suo ruolo.
Le teste non hanno matrici separate: una sola q_proj produce un vettore lungo, che poi viene tagliato in fette, una per testa. In Llama 3 8B q_proj trasforma 4.096 numeri in 4.096 numeri, cioè 32 fette da 128. Quando ogni testa ha finito, i 32 risultati vengono rimessi in fila e passano per la quarta matrice, o_proj (o sta per output, uscita), che li mescola e manda il risultato nella connessione residua.
I nomi completi dei pesi dicono anche dove si trovano. model.layers.5.self_attn.q_proj.weight si legge così: modello, strati, numero 5 (il sesto, perché si conta da zero), auto-attenzione, matrice delle Query, pesi. In tutto Llama 3 8B ha 32 × 4 = 128 di queste matrici. Se guardi le dimensioni noterai una stranezza: k_proj e v_proj producono solo 1.024 numeri invece di 4.096. È un risparmio voluto, spiegato nel prossimo termine.
Il token «gatto» arriva al sesto blocco con il suo vettore di 4.096 numeri. Seguiamolo in Llama 3 8B:
q_proj: da 4.096 a 4.096 numeri, cioè 32 domande da 128 numeri, una per testa.k_proj: da 4.096 a 1.024 numeri, cioè 8 etichette da 128.v_proj: da 4.096 a 1.024 numeri, cioè 8 contenuti da 128.o_proj: da 4.096 a 4.096 numeri, e il risultato si somma al vettore di partenza.Pesi coinvolti: 16,8 + 4,2 + 4,2 + 16,8 = 42 milioni circa, per un solo blocco.
Un risparmio usato nei modelli recenti: gruppi di teste di attenzione condividono le stesse Key e gli stessi Value, mentre ogni testa mantiene la propria Query.
Quando un modello scrive un testo, un token dopo l'altro, non ricalcola ogni volta Key e Value di tutte le parole precedenti: le tiene in memoria e aggiunge solo quelle del token nuovo. Con testi lunghi, o con molti utenti serviti insieme, questa memoria diventa enorme, a volte più grande dei pesi stessi, e rallenta tutto perché va riletta a ogni passo.
Nell'attenzione classica a più teste ogni testa ha le sue Key e i suoi Value. L'idea delle query raggruppate è dividere le teste in gruppi: dentro un gruppo ogni testa fa la propria domanda, ma tutte consultano le stesse Key e gli stessi Value. In Llama 3 8B le 32 teste formano 8 gruppi da 4. Nel config.json lo vedi così: num_attention_heads: 32 e num_key_value_heads: 8. Per questo k_proj e v_proj producono 8 × 128 = 1.024 numeri invece di 4.096.
Il caso estremo è un solo gruppo per tutte le teste: risparmia di più ma perde un po' di qualità. Il caso opposto è un gruppo per ogni testa, cioè l'attenzione classica. Le query raggruppate stanno nel mezzo: in Llama 3 8B la memoria per Key e Value si riduce di 4 volte, mentre la qualità misurata resta quasi uguale. Si risparmia anche qualche peso, perché due delle quattro matrici dell'attenzione diventano più piccole.
Conti per Llama 3 8B, con numeri a 16 bit (2 byte ciascuno). Per ogni token e ogni strato vanno conservati Key e Value:
Moltiplica per 32 strati: 512 KB contro 128 KB per ogni token. Con un testo di 8.192 token: 512 KB × 8.192 = 4 GB senza gruppi, 128 KB × 8.192 = 1 GB con i gruppi. Su una scheda grafica da 24 GB, dove i pesi occupano già 16 GB, sono 3 GB liberati per ogni testo di quella lunghezza.
Il modo più usato oggi per dire al modello dove si trova ogni token: Query e Key vengono ruotate di un angolo che cresce con la posizione.
Hai visto che l'attenzione, da sola, non sa in che ordine stanno le parole, e che la codifica posizionale classica risolve il problema sommando all'embedding un vettore diverso per ogni posizione. Funziona, ma la posizione viaggia mescolata al resto attraverso tutti i blocchi, e al modello interessa di più la distanza tra due parole che il loro numero esatto.
La codifica rotante cambia approccio. In ogni blocco, subito prima del confronto, i numeri di Query e Key vengono presi a coppie; ogni coppia viene trattata come una freccia su un piano e ruotata di un angolo proporzionale alla posizione del token. Il token in posizione 10 ruota di 10 volte un angolo base, quello in posizione 11 di 11 volte. Le diverse coppie girano a velocità diverse: le prime velocissime, per distinguere parole vicine, le ultime lentissime, per distinguere distanze di migliaia di token, come le lancette dei secondi, dei minuti e delle ore.
Il trucco è che il prodotto scalare tra due frecce ruotate dipende solo dalla differenza tra i loro angoli. Così il punteggio di attenzione tra due token dipende dalla loro distanza, non dalla posizione assoluta. Non servono pesi: le rotazioni si calcolano con una formula fissa. I Value non vengono ruotati. Nel config.json c'è rope_theta, il numero che fissa le velocità: 10.000 nei primi modelli, 500.000 in Llama 3, dove le lancette più lente girano ancora più piano per gestire testi più lunghi.
Immagina un modello minuscolo con una sola coppia di numeri e un angolo base di 10 gradi (numeri di esempio).
Ora sposta tutto 100 posizioni più avanti: posizione 103, rotazione 1.030 gradi; posizione 107, rotazione 1.070 gradi. Differenza: ancora 40 gradi. Il confronto tra Query e Key dà lo stesso risultato, perché conta l'angolo tra le due frecce. Per il modello «due parole a 4 posti di distanza» significa la stessa cosa all'inizio e a metà del testo.
La versione di rete feed-forward usata da Llama e da molti modelli recenti: tre matrici invece di due, con un ramo che fa da cancello per l'altro.
La rete feed-forward classica del blocco ha due matrici: la prima allarga il vettore (per esempio da 4.096 a 16.384 numeri), una funzione di attivazione lo piega, la seconda lo riporta a 4.096. SwiGLU aggiunge un terzo pezzo. Nei file dei pesi trovi gate_proj, up_proj e down_proj:
up_proj allarga il vettore: è il ramo del contenuto.gate_proj lo allarga in parallelo, e al risultato si applica la SiLU: è il ramo del cancello.down_proj riporta il risultato alla dimensione nascosta.Il nome unisce Swish, un altro nome della SiLU, e GLU, sigla inglese di «unità lineare con cancello». L'idea è dare alla rete un controllo più fine: invece di decidere solo quanto si accende ogni numero, una parte della rete decide, token per token, quanto lasciar passare dell'altra. Nelle prove pubblicate dà modelli un po' migliori a parità di calcolo. Per compensare la matrice in più, di solito si allarga meno delle 4 volte classiche: in Llama 3 8B la dimensione interna è 14.336, cioè 3,5 volte 4.096.
Guarda un solo numero della parte allargata, con numeri di esempio. La SiLU di un valore x vale x moltiplicato per un fattore tra 0 e 1 che cresce con x.
Stesso contenuto, uscite molto diverse: è il cancello, cioè un'altra parte dei pesi, a decidere quanto conta quel numero per quel token. Lo stesso succede per tutti i 14.336 numeri della parte allargata.
I due formati più comuni per i pesi: safetensors, lo standard di Hugging Face con soli tensori e nomi, e GGUF, il file unico usato da llama.cpp e Ollama.
Un modello scaricato è soprattutto un grande insieme di tensori, ciascuno con un nome (per esempio model.layers.0.self_attn.q_proj.weight), una forma e un tipo di numero. Il formato del file decide come sono messi in fila e che cos'altro c'è insieme.
safetensors è il formato standard di Hugging Face. Il file inizia con un piccolo indice che elenca nome, forma, tipo e posizione di ogni tensore; poi vengono i numeri, uno dopo l'altro. Non contiene codice eseguibile. I vecchi file .bin di PyTorch usavano un formato che all'apertura poteva eseguire istruzioni nascoste, quindi un file malevolo poteva infettare il computer. safetensors si può anche leggere a pezzi, senza caricarlo tutto in memoria. I modelli grandi sono divisi in più file, con un indice che dice quale tensore sta dove; configurazione e tokenizer stanno in file a parte.
GGUF è il formato di llama.cpp, usato anche da Ollama e LM Studio, ed è pensato per far girare il modello su un PC. È un solo file che contiene i pesi, di solito ridotti con la quantizzazione, più tutto il necessario per usarli: la configurazione, il vocabolario, le regole del tokenizer e il chat template. Il nome del file dice il livello di quantizzazione, per esempio Q4_K_M (in media circa 5 bit per peso) o Q8_0 (circa 8 bit).
Scarichi Llama 3 8B Instruct in due versioni.
model-00001-of-00004.safetensors a model-00004-of-00004.safetensors, circa 16 GB in tutto, più config.json, tokenizer.json e un indice. Conto: 8,03 miliardi di pesi × 2 byte ≈ 16 GB.Q4_K_M: un solo file di circa 4,9 GB. Conto: 8,03 miliardi × circa 4,9 bit ÷ 8 ≈ 4,9 GB.Il secondo si apre con Ollama con un solo comando, anche su un portatile. Il primo si usa di solito con programmi in Python, su una scheda grafica con più di 16 GB di memoria.
Un'architettura in cui la rete feed-forward di ogni blocco è sostituita da molti esperti, di cui per ogni token ne lavorano solo pochi.
Più parametri di solito significano un modello più capace, ma in un modello normale ogni parametro lavora per ogni token: raddoppiare i parametri raddoppia il calcolo e dimezza la velocità. La miscela di esperti rompe questo legame. Il modello ha moltissimi pesi in totale, ma per ogni token ne usa solo una parte, quella degli esperti scelti.
Il blocco funziona così:
La rete feed-forward contiene la maggior parte dei pesi di un blocco (in Llama 3 8B circa l'80 per cento), quindi è il posto giusto per moltiplicare la capacità. Il prezzo è la memoria: tutti gli esperti devono restare caricati, perché non sai in anticipo quali serviranno al token successivo. Anche l'addestramento è più delicato: se lo smistamento si abitua a mandare tutto agli stessi pochi esperti, gli altri restano inutilizzati, e servono accorgimenti per bilanciare il lavoro. Oggi molti dei modelli più grandi, come DeepSeek-V3, usano questa architettura.
Mixtral 8x7B: 32 strati, ciascuno con 8 esperti, e 2 esperti usati per ogni token. Il nome fa pensare a 8 × 7 = 56 miliardi di parametri, ma il totale vero è circa 47 miliardi, perché solo le reti feed-forward sono moltiplicate per 8: attenzione, embedding e matrice finale esistono una volta sola.
Per ogni token lavorano l'attenzione di tutti gli strati più 2 esperti su 8 in ogni strato: circa 13 miliardi di parametri. Il modello occupa la memoria di uno da 47 miliardi ma calcola ogni token più o meno come uno da 13. Alla sua uscita, a fine 2023, nei confronti pubblicati da Mistral superava Llama 2 70B in molte prove, pur essendo molto più veloce.
Una delle tante reti feed-forward affiancate nello stesso punto di un blocco: per ogni token ne lavorano solo poche, scelte di volta in volta.
In un modello classico ogni blocco ha una sola rete feed-forward, e ogni token passa da lì. Alcuni modelli recenti mettono invece nello stesso posto molte reti feed-forward uguali nella forma ma con pesi diversi: 8 in Mixtral 8x7B, 256 in DeepSeek-V3. Ognuna si chiama esperto. Per ogni token un piccolo strato di smistamento sceglie quali usare (2 in Mixtral, 8 in DeepSeek-V3) e le loro uscite vengono sommate.
Il nome inganna. Nessuno assegna un argomento a un esperto: tutti partono da pesi casuali, e la specializzazione nasce da sola durante l'addestramento, perché lo smistamento e gli esperti imparano insieme. Quando gli autori di Mixtral hanno analizzato quali token andavano dove, non hanno trovato esperti per materia, come biologia o filosofia. Le scelte seguivano piuttosto la forma del testo: certe parole del codice, l'indentazione, la punteggiatura. Spesso token vicini nella frase finiscono allo stesso esperto.
Dentro, ogni esperto è una rete feed-forward normale, di solito con cancello (SwiGLU). Nei file dei pesi lo riconosci dai nomi, per esempio layers.10.block_sparse_moe.experts.3.w1 in Mixtral. Alcuni modelli aggiungono anche uno o più esperti condivisi, che lavorano sempre per ogni token e raccolgono le conoscenze comuni, lasciando agli altri le particolarità. DeepSeek-V3 ne ha uno per blocco, accanto ai 256 da scegliere.
Frase in Python: «def somma(a, b):», un blocco di Mixtral con 8 esperti numerati da 0 a 7 (assegnazioni di esempio).
Guardando migliaia di frasi si scopre che l'esperto 3 riceve soprattutto simboli e punteggiatura, ovunque compaiano, anche in una ricetta. Non esiste quindi un «esperto di programmazione» nel senso umano: c'è un pezzo di rete che è diventato bravo con un certo tipo di token.
Il piccolo strato che, in un blocco con esperti, dà un punteggio a ogni esperto per il token corrente e sceglie quali far lavorare.
Il router è la parte più piccola di una miscela di esperti, ma decide tutto. È una matrice con una riga per esperto: in Mixtral 8 righe da 4.096 numeri, appena 32.768 pesi per strato. Per ogni token fa il prodotto scalare tra lo stato nascosto e ogni riga e ottiene un punteggio per ogni esperto. Poi:
La scelta si ripete per ogni token e in ogni strato: lo stesso token può andare agli esperti 2 e 5 nel primo strato e agli esperti 0 e 7 nel decimo. Il router si addestra insieme a tutto il resto, con la retropropagazione.
Il problema principale è il bilanciamento. All'inizio il router tende a preferire gli esperti che vanno un po' meglio; quelli, ricevendo più token, migliorano ancora, e gli altri restano a guardare. Per evitarlo si aggiunge alla funzione di perdita un termine che penalizza lo squilibrio, oppure, come in DeepSeek-V3, si corregge piano piano il punteggio di ogni esperto in base a quanto viene usato. Quando gli esperti sono distribuiti su più GPU, un buon bilanciamento serve anche a non lasciare schede ferme.
Un token arriva a uno strato con 4 esperti e k = 2 (numeri di esempio). Il router dà questi punteggi: esperto A 2,0; B 1,0; C −0,5; D 0,3.
Gli esperti C e D, per questo token, non calcolano nulla.
Nei modelli a esperti, i parametri totali sono tutti quelli caricati in memoria; quelli attivi sono la parte che lavora davvero per ogni token.
Per un modello denso basta un numero: 8 miliardi di parametri, tutti caricati e tutti al lavoro. Con la miscela di esperti ne servono due, perché misurano due costi diversi.
Spesso il nome del modello li contiene entrambi: Qwen3-30B-A3B significa circa 30 miliardi totali e 3 attivi (A sta per active, attivi). DeepSeek-V3 ha 671 miliardi totali e 37 attivi: calcola come un modello denso da 37 miliardi ma occupa come uno da 671.
Il conto pratico è semplice. La memoria si stima dai totali: a 16 bit servono 2 byte per parametro, a 8 bit uno. La velocità si stima dagli attivi. Per questo un modello a esperti può andare veloce su una macchina con tanta memoria e poca potenza di calcolo, ed essere impossibile da caricare su una scheda grafica piccola anche se i suoi attivi sono pochi.
DeepSeek-V3: 671 miliardi totali e 37 attivi. I suoi pesi sono pubblicati in gran parte a 8 bit, cioè 1 byte per parametro.
Stessa memoria, un diciottesimo del calcolo: ecco perché i due numeri vanno sempre letti insieme.
Un modulo aggiunto al modello che, oltre al prossimo token, prova a prevedere anche quello successivo: arricchisce l'addestramento e può accelerare la generazione.
Un LLM normale, a ogni posizione, impara a prevedere un solo token: il prossimo. La previsione di più token (in inglese Multi-Token Prediction, MTP) gli chiede di guardare un po' più avanti. In DeepSeek-V3, che l'ha resa famosa, funziona così:
In addestramento l'errore del modulo si somma a quello normale. Il segnale è più ricco: per ogni posizione il modello viene corretto su due token invece di uno, e le sue rappresentazioni interne imparano a preparare anche ciò che verrà dopo.
Quando il modello si usa, il modulo si può buttare via: il tronco funziona identico anche da solo. Oppure si può sfruttare per la decodifica speculativa: il modulo propone il token successivo e al passo dopo il modello principale lo verifica mentre calcola il proprio. Se la proposta è giusta, si ottengono due token al costo di poco più di uno. DeepSeek riporta che la seconda previsione viene accettata nell'85-90 per cento dei casi, con una generazione circa 1,8 volte più veloce.
Testo di addestramento: «Il gatto dorme sul divano rosso». Posizione: dopo «sul» (probabilità di esempio).
In uso, dopo «Il gatto dorme sul» il modello produce «divano» e il modulo propone già «rosso». Al passo dopo il tronco conferma «rosso»: due token con un passo solo.
Un modello che, oltre al testo, accetta immagini, audio o video, trasformandoli in vettori che il modello di linguaggio tratta come se fossero token.
Un LLM sa lavorare solo con vettori della sua dimensione nascosta, uno per token. Per fargli «vedere» un'immagine bisogna trasformarla in una fila di vettori di quel tipo. Lo schema più diffuso ha tre pezzi:
Di solito l'encoder visivo nasce da un addestramento separato su milioni di coppie immagine e didascalia; poi si addestra soprattutto il proiettore, e infine si affina tutto insieme su esempi di domande sulle immagini. L'audio segue lo stesso schema, con un encoder che trasforma pezzi di suono in vettori. Un'immagine costa molti token, centinaia o a volte migliaia, e occupa la finestra di contesto come un lungo testo. Alcuni modelli producono anche immagini o audio in uscita, ma è un passo in più: la parte che legge e quella che genera sono diverse.
Il modello LLaVA 1.5 riceve la foto di uno scontrino e la domanda «Quanto ho speso?».
Il tipo di modello più usato per generare immagini e video: parte da rumore casuale e lo ripulisce un passo alla volta, guidato da una descrizione scritta.
Un LLM produce una cosa piccola alla volta, un token dopo l'altro. Per un'immagine questa strada è scomoda: milioni di pixel devono essere coerenti tra loro. I modelli di diffusione lavorano invece su tutta l'immagine insieme, rifinendola per passi.
L'addestramento si basa su un'idea semplice. Prendi una foto vera e aggiungi un po' di rumore, poi ancora un po', per molti passi (1.000 nella versione originale), finché resta solo una nebbia casuale. Al modello si mostra l'immagine a un certo livello di rumore e gli si chiede di indovinare quale rumore è stato aggiunto. Se ci riesce, togliendolo si torna indietro di un passo. Ripetuto su milioni di immagini con le loro didascalie, il modello impara che aspetto hanno le cose.
Per generare si fa il percorso inverso. Si parte da puro rumore, il modello stima quanto rumore c'è e ne toglie una parte, poi ripete, di solito per 20-50 passi. La descrizione scritta entra con l'attenzione: i vettori dell'immagine consultano quelli della frase, preparati da un encoder di testo. Per risparmiare calcolo molti modelli non lavorano sui pixel ma su una versione compressa: Stable Diffusion riduce un'immagine di 512 × 512 pixel a una griglia di 64 × 64. Al suo interno oggi si usano sempre più spesso blocchi Transformer. Rumore di partenza diverso, immagine diversa: per questo la stessa frase dà ogni volta un risultato nuovo.
Chiedi «un gatto con il cappello», con 30 passi (fasi indicative, numeri di esempio).
Se rifai la richiesta partendo da un'altra nebbia esce un altro gatto, con un altro cappello.
Finito l'addestramento, i pesi non cambiano più. Usare il modello significa farlo calcolare: un token alla volta.
Scrivi una domanda, premi Invio e dopo un attimo le parole cominciano ad apparire una dopo l'altra. Che cosa sta succedendo in quel momento? Fin qui hai visto come è fatto un modello linguistico e come si addestra. Questa sezione parte da quando l'addestramento è finito e il modello viene usato davvero: è quello che si chiama inferenza.
La prima sorpresa è come nasce una risposta. Il modello non scrive un paragrafo tutto in una volta: produce un solo token, lo aggiunge al testo e ricomincia, finché la risposta è completa. Questo ciclo si chiama generazione autoregressiva e spiega molte cose che hai notato in una chat: le parole che compaiono a pezzetti, le risposte lunghe che richiedono più tempo, il costo che cresce con la lunghezza.
La seconda parte riguarda la scelta del token. A ogni giro il modello restituisce un punteggio per ogni token del vocabolario. La softmax li trasforma in probabilità, e poi bisogna decidere quale token usare davvero: è il campionamento. Due manopole, la temperatura e i filtri top-k e top-p, regolano quanto il modello può rischiare, e le condizioni di arresto decidono quando fermarsi. Con questi quattro pezzi capisci perché la stessa domanda può dare risposte diverse e come ottenere risposte più prevedibili quando serve.
L'ultima parte è più concreta e parla dei limiti dell'hardware. La cache KV evita di ripetere gli stessi calcoli a ogni token, ma occupa memoria. La quantizzazione comprime il modello per farlo entrare su un computer normale. La memoria della scheda grafica decide che cosa puoi far girare, e la velocità si misura in token al secondo. Infine la decodifica speculativa è un trucco per andare più veloci senza cambiare il risultato.
Gli undici termini seguono questo ordine perché ognuno si appoggia sul precedente. Alla fine saprai rispondere a domande molto pratiche: perché un servizio è lento, perché un modello non entra nel tuo computer, che cosa cambia girando una manopola.
L'uso di un modello già addestrato per produrre un risultato: i dati attraversano la rete una volta, dall'ingresso all'uscita, e i pesi restano esattamente come sono.
Un modello ha due vite. Nella prima, l'addestramento, i pesi vengono corretti milioni di volte con la retropropagazione, finché il modello sbaglia poco. Nella seconda, l'inferenza, i pesi sono fissi e di sola lettura: il modello li usa per calcolare e basta. Il calcolo che attraversa la rete una volta, dall'ingresso all'uscita, si chiama forward pass, cioè «passaggio in avanti».
Per un modello linguistico un forward pass funziona così. Il tokenizer spezza il testo in token. Ogni token diventa un embedding, cioè un vettore di numeri. I vettori attraversano uno dopo l'altro i blocchi Transformer, e alla fine la testa di linguaggio produce un punteggio, un logit, per ognuno dei token del vocabolario. Il risultato di un forward pass è quindi un elenco di punteggi, che dice quanto ogni token è adatto a venire subito dopo il testo ricevuto.
Perché si distingue dall'addestramento? Perché costa in modo molto diverso. Addestrare richiede, oltre al passaggio in avanti, il calcolo dei gradienti e la correzione dei pesi, e si fa una volta sola con migliaia di GPU per settimane o mesi. L'inferenza invece si ripete a ogni richiesta di ogni utente, per tutta la vita del modello. Come regola pratica approssimata, un forward pass costa circa 2 operazioni per ogni parametro e per ogni token, mentre l'addestramento ne costa circa 6, il triplo.
Scrivi: «Qual è la capitale della Francia?». Numeri di esempio: il tokenizer la spezza in 8 token e il modello ha 8 miliardi di parametri. Gli 8 token diventano 8 vettori, passano attraverso i blocchi e la testa di linguaggio assegna un logit a ciascuno dei circa 100.000 token del vocabolario. I punteggi più alti sono quelli di «La» e «Parigi», e da lì nasce la risposta.
Costo del forward pass: 8 token × 2 operazioni × 8 miliardi di parametri = 128 miliardi di operazioni. I pesi, prima e dopo, sono gli stessi. Se ripeti la domanda cento volte, il modello non è diventato più bravo.
Il modo in cui un modello linguistico scrive: produce un token alla volta, lo aggiunge al testo e rifà il calcolo per scegliere il successivo, finché la risposta è finita.
Un forward pass dà i punteggi per un solo token: quello che viene subito dopo il testo ricevuto. Per scrivere una risposta intera il modello ripete l'operazione in un ciclo. Primo giro: legge il testo e sceglie un token. Secondo giro: il testo comprende ora anche quel token, e se ne sceglie un altro. E così via. Il nome viene da qui: «auto» significa «da sé» e «regressivo» indica una previsione basata sui valori precedenti. L'uscita di ogni giro diventa parte dell'ingresso del giro dopo.
Le conseguenze pratiche sono tre. La prima: una risposta di 500 token richiede 500 forward pass uno dopo l'altro, e non si possono fare in parallelo, perché il token numero 200 dipende dal 199. Per questo il tempo cresce con la lunghezza, e di solito i servizi fanno pagare i token in uscita più di quelli in ingresso. La seconda: il testo che compare a pezzetti, il cosiddetto streaming, è il modo in cui il testo nasce davvero. Il servizio ti manda ogni pezzo appena è pronto, invece di aspettare la fine.
La terza riguarda la lettura della tua domanda. I token che hai scritto tu sono già tutti noti, quindi il modello li elabora insieme in un solo passaggio, grazie alla maschera causale che impedisce a ogni token di guardare quelli successivi. Lo stesso vale nell'addestramento, dove il testo corretto è già disponibile. Solo nella generazione i token da leggere non esistono ancora e vanno creati uno alla volta, fino a quando il modello emette il token speciale EOS, che significa fine.
Parti dal testo «Il gatto». Numeri di esempio: ogni forward pass dura 25 millisecondi.
Cinque giri per tre parole, un punto e il segnale di fine: 5 × 25 = 125 millisecondi. Una risposta di 500 token richiederebbe 500 × 25 = 12.500 millisecondi, cioè 12,5 secondi.
La funzione che trasforma i logit in probabilità: numeri tutti positivi, con somma 1, in cui i punteggi più alti ottengono la parte più grande.
Alla fine di un forward pass il modello ha un logit per ogni token del vocabolario: un numero qualsiasi, positivo o negativo, grande o piccolo. Non si possono usare direttamente per scegliere, perché non sono probabilità: possono essere negativi e non sommano a 1. La softmax li trasforma in una distribuzione di probabilità in due mosse.
Il nome «soft max» viene dal fatto che è un massimo «morbido»: il logit più alto prende la fetta più grande e gli altri conservano una probabilità piccola ma diversa da zero. Conta solo la distanza tra i logit, non il loro valore assoluto: aggiungere 10 a tutti non cambia il risultato. Per questo bastano due o tre punti di distacco per avere un vincitore netto.
La softmax compare in due punti del modello. In uscita, per scegliere il token. E dentro l'attenzione, dove trasforma i punteggi di confronto tra i token nei pesi di attenzione: numeri che sommano a 1 e dicono quanta attenzione dare a ciascun token precedente.
Tre candidati per la parola dopo «Il gatto dorme sul»: divano con logit 2, letto con logit 1, tappeto con logit 0.
La somma è 100%. Se aggiungi 10 a tutti i logit (12, 11 e 10) ottieni le stesse percentuali. Se invece divano avesse logit 10 e un concorrente logit 0, la probabilità del primo salirebbe a circa 99,995%.
La scelta del token da usare tra quelli resi probabili dalla softmax: o sempre il più probabile (greedy), o uno estratto a sorte in proporzione alle probabilità.
Dopo la softmax hai una probabilità per ogni token e devi scegliere. Ci sono due strade.
La prima si chiama greedy, «avida»: prendi sempre il token con la probabilità più alta. Il risultato è deterministico, cioè identico a ogni prova, ed è veloce. Ha però un difetto: il testo tende a diventare piatto e ripetitivo, e a volte il modello cade in un ciclo e ripete la stessa frase.
La seconda è il campionamento vero e proprio: si estrae a sorte un token, con probabilità proporzionali a quelle calcolate. Il computer genera un numero pseudocasuale tra 0 e 1 e lo confronta con le fette di probabilità, come in una ruota della fortuna in cui ogni token occupa uno spicchio largo quanto la sua probabilità. Un token al 64% esce circa 64 volte su 100.
Ecco perché la stessa domanda può dare risposte diverse: a ogni giro c'è un'estrazione, e basta un token diverso all'inizio perché il resto prenda un'altra strada, dato che ogni scelta entra nel testo da cui parte il giro successivo. Il seed è il valore iniziale del generatore pseudocasuale: con lo stesso seed la sequenza di numeri estratti è sempre la stessa, quindi a parità di tutto il resto il risultato si può ripetere.
C'è anche un rischio. Con un vocabolario di decine di migliaia di token, i token improbabili messi insieme valgono qualche punto percentuale a ogni giro, e su centinaia di token prima o poi ne esce uno fuori luogo. Per questo il campionamento si regola con le manopole dei prossimi termini.
Dopo «Il gatto dorme sul» le probabilità sono: divano 64%, letto 26%, tappeto 10%. Il computer le mette in fila: da 0,00 a 0,64 è divano, da 0,64 a 0,90 è letto, da 0,90 a 1,00 è tappeto. Poi estrae numeri a caso (numeri di esempio):
Su 100 estrazioni escono circa 64 divano, 26 letto e 10 tappeto. Con greedy uscirebbe sempre «divano».
Un numero che scegli a ogni richiesta e che regola quanto il modello rischia: i logit vengono divisi per questo valore prima della softmax. Bassa dà risposte prevedibili, alta più varie.
La temperatura è la manopola più usata per regolare il campionamento. Non cambia i pesi del modello e non richiede nessun addestramento: la scegli tu a ogni richiesta. Il funzionamento è semplice: prima della softmax, ogni logit viene diviso per la temperatura T.
Come si usa. Per codice, estrazione di dati, calcoli e tutto ciò in cui conta la ripetibilità, valori bassi, da 0 a 0,3. Per brainstorming, nomi e testi creativi, valori più alti, da 0,8 a 1,2. Il valore predefinito di molti servizi sta tra 0,7 e 1, ma cambia da servizio a servizio. Valori molto alti, sopra 1,5 o 2, portano il testo a sfaldarsi in parole senza nesso.
Due candidati: divano con logit 2 e letto con logit 1. Si dividono i logit per T e poi si applica la softmax (numeri di esempio).
Stesso modello, stessi logit di partenza: cambia solo la forma della distribuzione. A T = 0,5 su 100 risposte «letto» esce circa 12 volte, a T = 2 circa 38 volte.
Due filtri che eliminano la coda dei token molto improbabili prima dell'estrazione: top-k tiene solo i k più probabili, top-p tiene il gruppo più piccolo la cui probabilità sommata raggiunge p.
Il problema è questo: il vocabolario ha decine di migliaia di token e la maggior parte non ha senso nel punto in cui ti trovi. Ognuno ha una probabilità minuscola, ma messe insieme possono valere qualche punto percentuale, e il campionamento ogni tanto ne pesca uno. I due filtri tagliano questa coda.
Top-k. Ordini i token dal più probabile al meno probabile e tieni solo i primi k, per esempio 40. Gli altri vengono azzerati. Poi le probabilità dei token rimasti si ridividono in modo che sommino di nuovo a 1, e si estrae. Con k = 1 ottieni greedy. Il limite è che k è fisso: quando il modello è sicuro (un token al 98%) tieni comunque 40 candidati inutili, e quando è incerto 40 potrebbero tagliare alternative valide.
Top-p, detto anche campionamento nucleus. Ordini allo stesso modo ma, invece di contare i token, sommi le probabilità finché raggiungi p (per esempio 0,9) e tieni quel gruppo, il nucleo. Il numero di candidati si adatta: pochi quando il modello è sicuro, di più quando è incerto. Anche qui si ridivide per far tornare il totale a 1.
I filtri lavorano insieme alla temperatura: di solito si applica prima la temperatura, poi i filtri, poi si estrae. Valori tipici: top-p tra 0,9 e 0,95, top-k tra 20 e 100. Di solito conviene cambiarne uno solo alla volta.
Candidati dopo «Il gatto dorme sul»: divano 60%, letto 25%, tappeto 10%, forno 5%.
«Forno» è scartato in entrambi i casi. Se il modello fosse molto sicuro (divano 97%), top-p = 0,9 terrebbe solo divano, mentre top-k = 2 terrebbe comunque due candidati.
Le regole che dicono quando il ciclo di generazione si ferma: il modello emette il token di fine, compare una sequenza di stop scelta da te, o si raggiunge il numero massimo di token consentito.
Il ciclo di generazione non ha una fine naturale: va fermato. Ci sono tre modi, e vince il primo che scatta.
C'è un quarto limite, quello della finestra di contesto: domanda e risposta insieme devono starci, e quando è piena la generazione si deve fermare.
Il limite massimo esiste perché protegge dai cicli infiniti e fissa un tetto al tempo e al costo, dato che di solito si paga ogni token generato. Molti servizi riportano il motivo dello stop: se è il limite e non il token di fine, la risposta è troncata.
Chiedi: «Elenca le capitali europee con un numero davanti a ciascuna». Imposti due controlli: sequenza di stop 11. e massimo 100 token (numeri di esempio).
Con un limite di soli 30 token il modello si fermerebbe dopo pochi elementi, forse a metà di un nome. Con 100 token (circa 60 parole in italiano, stima mia) c'è spazio per tutta la lista.
Una memoria in cui si conservano le Key e i Value già calcolati per i token precedenti, così a ogni nuovo token si calcola solo ciò che è nuovo: molto più veloce, al prezzo di memoria che cresce con il contesto.
Ricorda come funziona l'attenzione: ogni token produce una Query, una Key e un Value, e la Query del token corrente viene confrontata con le Key di tutti i token precedenti per decidere quali Value leggere. Succede in ogni testa di attenzione di ogni blocco.
Nella generazione, a ogni giro il testo è quello di prima più un token. Grazie alla maschera causale, i token già presenti non guardano quelli nuovi, quindi le loro Key e i loro Value non cambiano mai. Ricalcolarli a ogni giro sarebbe spreco puro. La cache KV li conserva in memoria: a ogni giro si calcolano solo Query, Key e Value del token nuovo, si aggiungono alla cache e si usa tutto il contenuto per l'attenzione.
Il guadagno è enorme. Senza cache, per scrivere n token il lavoro cresce come n × (n + 1) ÷ 2. Con la cache cresce come n.
Il prezzo è la memoria. Per ogni token si conservano una Key e un Value per ogni strato e per ogni gruppo di Key e Value. In Llama 3.1 8B (32 strati, 8 gruppi grazie all'attenzione a query raggruppate, vettori di 128 numeri, 2 byte a numero) il calcolo è 2 × 32 × 8 × 128 × 2 = 131.072 byte, circa 0,13 MB per token. Con 8.000 token sono circa 1 GB, con 128.000 token circa 16,8 GB, più dei pesi stessi (circa 16 GB). Per questo la lunghezza del contesto ha un costo fisico.
Scrivi una risposta di 500 token (per semplicità la domanda è vuota). Senza cache, a ogni giro il modello deve rielaborare tutti i token già presenti: 1 al primo giro, 2 al secondo, 3 al terzo, fino a 500. Il totale è 1 + 2 + 3 + … + 500 = 125.250 elaborazioni di token.
Con la cache, a ogni giro si elabora solo il token nuovo: 500 in tutto. Il rapporto è 125.250 ÷ 500, circa 250 volte meno lavoro. Il confronto della nuova Query con le Key già presenti resta da fare a ogni giro, ma è un lavoro molto più leggero.
Ridurre la precisione con cui sono scritti i pesi, da 16 bit a 8, 4 o meno, per avere un file molto più piccolo e un modello che gira su computer comuni, con una perdita di qualità di solito piccola.
I pesi sono numeri decimali. Dopo l'addestramento di solito sono memorizzati con 16 bit ciascuno, cioè 2 byte. Un modello da 8 miliardi di parametri occupa quindi 8 miliardi × 2 byte = 16 GB, e uno da 70 miliardi circa 140 GB. Troppo per quasi tutti i computer.
La quantizzazione riscrive i pesi con meno bit. Il metodo più comune lavora a gruppi: si prendono blocchi di, per esempio, 32 pesi, si cerca il valore più grande del gruppo e se ne ricava un fattore di scala. Ogni peso viene sostituito da un numero intero piccolo (con 4 bit, da -8 a 7) che, moltiplicato per il fattore di scala, ricostruisce un valore vicino all'originale. Si salvano gli interi e il fattore di ogni gruppo.
Il risparmio è grande. A 8 bit il file si dimezza, circa 8 GB per un modello da 8 miliardi di parametri. A 4 bit scende intorno a un quarto: 4,9 GB per Llama 3.1 8B nella variante Q4_K_M, un po' più di 4 perché i fattori di scala e alcune parti delicate occupano spazio. Il modello da 70 miliardi scende a circa 40 GB. A 8 bit la qualità è in pratica uguale all'originale, a 4 bit la perdita è di solito piccola, sotto i 4 bit comincia a vedersi. Spesso un modello grande quantizzato batte uno più piccolo non quantizzato che pesa lo stesso.
Le sigle nei nomi dei file, come Q4_K_M o Q8_0, indicano il livello: il numero dopo la Q è circa il numero di bit, le lettere successive indicano la variante dello schema. Un file più piccolo ha un altro vantaggio: a ogni token bisogna leggere meno dati, quindi la generazione è anche più veloce.
Numeri di esempio: un gruppo di quattro pesi, 0,42, -0,18, 0,07 e -0,35, da scrivere con 4 bit (interi da -8 a 7).
Gli errori sono 0, 0, 0,01 e 0,01. Sono piccoli, ma si accumulano su miliardi di pesi: è da qui che nasce la perdita di qualità.
Per girare in fretta l'intero modello deve stare nella memoria della scheda grafica (VRAM); la velocità si misura in token al secondo, mentre l'attesa prima della prima parola si chiama TTFT.
La GPU ha una propria memoria, la VRAM, molto più veloce di quella del computer. Per generare in fretta, i pesi del modello devono stare lì dentro, insieme alla cache KV e a un po' di spazio di lavoro. Il conto di base è parametri × byte per parametro: un modello da 8 miliardi di parametri a 4 bit (mezzo byte ciascuno) occupa circa 4 GB di pesi, 4,9 GB nella pratica. Aggiungi la cache KV, che cresce con il contesto, e un margine di circa mezzo GB per i calcoli intermedi (regola pratica mia). Se tutto non entra, una parte del modello finisce nella memoria normale del computer e la velocità crolla, perché quella memoria è molto più lenta.
Due misure descrivono la velocità. I token al secondo dicono quanto è veloce la scrittura. A ogni token la GPU deve rileggere tutti i pesi dalla memoria (in un modello denso), quindi il limite massimo è la velocità di lettura della memoria divisa per la dimensione del modello. Con 300 GB/s e un modello da 4,9 GB: 300 ÷ 4,9 = circa 61 token al secondo, come tetto teorico. Per questo anche la quantizzazione accelera: file più piccolo, meno da leggere. In una miscela di esperti conta solo la parte attiva dei parametri, ma l'intero modello deve comunque restare in memoria.
Il TTFT (time to first token) è l'attesa prima del primo token: il tempo per leggere la tua domanda e riempire la cache KV. Cresce con la lunghezza della domanda: una frazione di secondo per una riga, diversi secondi per un documento lungo. Come riferimento (stima mia), una persona legge circa 6-8 token al secondo, e sopra i 10 la scrittura appare fluida.
Numeri di esempio: scheda grafica con 8 GB di VRAM e Llama 3.1 8B a 4 bit (4,9 GB).
Un trucco per generare più in fretta senza cambiare il risultato: un meccanismo leggero propone alcuni token in anticipo e il modello grande li controlla tutti in un solo passaggio, tenendo quelli giusti.
Il punto di partenza: nella generazione il collo di bottiglia è leggere i pesi dalla memoria, più che fare i calcoli. Per questo far verificare al modello grande 5 token in un colpo solo costa quasi quanto farne uno. Grazie alla maschera causale, un solo forward pass sui 5 token dà il logit di ogni posizione, cioè che cosa il modello metterebbe dopo ciascuno.
Ogni passaggio del modello grande garantisce almeno un token, il suo, e se tutti i k sono giusti se ne ottiene uno in più. Con il campionamento la regola di accettazione è più elaborata: un token proposto si accetta con una probabilità ricavata dal confronto tra le due distribuzioni, e se lo si rifiuta se ne estrae uno corretto. È costruita in modo che i token finali abbiano esattamente la distribuzione del modello grande da solo: il risultato non è un'approssimazione.
La velocità aumenta spesso di 1,5-3 volte, secondo quanto la bozza indovina. Funziona bene su testo prevedibile come codice, formule di cortesia e citazioni, peggio su testo creativo con temperatura alta. Il costo è memoria in più per la bozza, e se i suggerimenti sono quasi sempre sbagliati si può andare più piano.
Testo finora: «Il gatto dorme». Il meccanismo di bozza propone quattro token: «sul», «divano», «del», «salotto» (numeri di esempio).
Risultato: tre token («sul», «divano», «in») con un solo passaggio del modello grande. Se la bozza costa un decimo di un passaggio grande, i quattro tentativi costano 0,4: totale 1,4 per tre token, contro 3 con il metodo normale, circa 2,1 volte più veloce.
I termini che si incontrano quando un modello viene messo al lavoro dentro un'applicazione.
Finora hai visto come nasce un modello e come genera il testo, un token alla volta. In questa sezione lo metti al lavoro. Usare bene un modello è un mestiere con regole sue: sapere che cosa dargli in ingresso, che cosa aspettarti in uscita e dove può ingannarti.
Si parte da ciò che gli scrivi. Il prompt è tutto il testo che il modello legge prima di rispondere, e il prompt di sistema è la parte fissa che decide ruolo e regole. Poi vedrai come si guida il modello con alcuni esempi, senza cambiarlo di una virgola.
Subito dopo arrivano i limiti. Il modello conosce il mondo solo fino a una certa data e, quando non sa, tende a inventare con la stessa sicurezza con cui dice cose vere. Per questo servono dei rimedi. Il primo è farlo ragionare per iscritto prima di rispondere. Il secondo è dargli dei documenti da consultare: la generazione aumentata dal recupero, che si regge su tre pezzi che incontrerai in fila, cioè la ricerca per significato con i vettori, la divisione dei testi in frammenti e l'inserimento dei frammenti trovati nel prompt.
Da lì il modello smette di essere un semplice generatore di testo. Con la chiamata di strumenti può usare una calcolatrice, un calendario, un archivio. Messo in un ciclo diventa un agente, e con il protocollo MCP trova gli strumenti attraverso una presa comune, come i dispositivi con la porta USB. Seguono due aspetti molto pratici: ottenere risposte in un formato che un programma sappia leggere e spendere meno quando l'inizio del prompt si ripete.
La sezione si chiude con due domande da persona che deve scegliere: come capisco se un modello è buono per il mio caso, e dove lo faccio girare, sui miei computer o sui server di un fornitore. Ogni termine ha un esempio svolto con dei numeri: provalo a rifare a mente, perché è così che il meccanismo diventa tuo.
Tutto il testo che il modello riceve in ingresso prima di rispondere: la tua richiesta, ma anche le istruzioni, gli esempi, i documenti allegati e la conversazione fin lì.
Il modello legge una lunga sequenza di token e da quella calcola il token successivo, poi il successivo, fino alla fine della risposta. Tutto ciò che sta in quella sequenza si chiama prompt. Dentro ci sono la tua richiesta, le istruzioni sul modo di rispondere, gli eventuali esempi, i documenti allegati e, in una chat, tutti i messaggi precedenti.
Questo ha una conseguenza che sorprende: il modello non ricorda nulla tra una richiesta e l'altra. Ogni volta il programma gli rimanda l'intera conversazione e il modello la rilegge da capo. La sua «memoria» è la finestra di contesto, cioè lo spazio massimo di token che può leggere in una volta. Se la conversazione cresce oltre quel limite, qualcosa va tolto.
Il prompt conta tanto perché il modello completa ciò che legge nel modo più plausibile. Una richiesta vaga lascia aperte molte strade e il modello ne imbocca una qualsiasi. Una richiesta precisa ne chiude quasi tutte. Un buon prompt dice chi sarà il destinatario, qual è l'obiettivo, quanto deve essere lungo il risultato e in che forma. Senza queste indicazioni ottieni una risposta media, generica, che dovrai poi riscrivere.
Prima versione: «scrivi una mail». Il modello non sa a chi, per quale motivo, quanto lunga: produce un testo generico.
Seconda versione: «Scrivi una mail cortese al fornitore Bianchi per spostare la consegna dell'ordine 4471 da lunedì a giovedì. Spiega che il cantiere è in ritardo. Al massimo 5 righe, tono formale, firma Giulia.»
Ora sono fissati destinatario, motivo, date, lunghezza, tono e firma. La risposta si può inviare quasi così com'è. La differenza è tutta qui: hai messo nel prompt le informazioni che il modello non poteva indovinare.
Le istruzioni iniziali, scritte da chi costruisce l'applicazione, che fissano ruolo, regole e tono del modello per tutta la conversazione, di solito senza che l'utente le veda.
Una conversazione con un modello è fatta di messaggi, ciascuno con un ruolo: quello del sistema, quello dell'utente, quello del modello. Il messaggio di sistema sta in cima ed è il prompt di sistema. Chi sviluppa l'applicazione lo scrive una volta e il programma lo mette davanti a ogni richiesta. Tu scrivi solo la tua domanda, ma il modello legge prima quelle istruzioni.
Che cosa ci si mette? Il ruolo («sei l'assistente di un negozio di biciclette»), il tono, la lingua, gli argomenti ammessi e quelli vietati, il formato delle risposte, la data di oggi, l'elenco degli strumenti a disposizione. Con poche centinaia di token si trasforma lo stesso modello in un tutor di matematica, in un revisore di contratti o in un servizio clienti.
Come distingue il modello i vari messaggi? I confini tra i ruoli sono segnati da token speciali, secondo il chat template del modello. Durante l'affinamento il modello è stato addestrato a dare più peso alle istruzioni di sistema che a quelle dell'utente, e a rispettarle anche quando la conversazione va altrove.
Il prompt di sistema occupa spazio nella finestra di contesto e viene riletto a ogni richiesta, quindi conviene tenerlo asciutto: regole chiare, poche, in ordine di importanza. Quando cambia il comportamento dell'applicazione, di solito cambia solo questo testo, mentre il modello resta lo stesso.
Un negozio di biciclette scrive questo prompt di sistema: «Sei l'assistente clienti del negozio Pedala. Rispondi solo su biciclette, ricambi e orari. Risposte di massimo 3 righe, in italiano, cortesi. Se non sai, invita a telefonare al negozio.»
Il cliente chiede: «Che tempo farà domani?». Il modello, vincolato dalle regole, risponde che può aiutare solo su biciclette e ricambi.
Il cliente chiede: «Che catena serve per una bici da corsa a 11 velocità?». Ora la domanda rientra nell'argomento: il modello risponde in 3 righe e consiglia di verificare il modello esatto della bici. Il cliente non vede il prompt di sistema, e intanto ne sente gli effetti a ogni risposta.
Zero-shot: si descrive il compito senza esempi. Few-shot: si inseriscono nel prompt alcune coppie di richiesta e risposta attesa, e il modello ne imita lo schema senza modificare i suoi pesi.
Un modello è molto bravo a continuare i testi in modo coerente. Se nel prompt trova tre righe con la stessa forma, la quarta la completa nella stessa forma. Sfruttiamo questa abitudine: invece di spiegare a parole che cosa vogliamo, lo mostriamo. È il few-shot, che significa «pochi colpi», cioè pochi esempi. Con un solo esempio si parla di one-shot, con nessuno di zero-shot.
Il meccanismo si chiama apprendimento in contesto (in-context learning). Il nome può trarre in inganno: i pesi del modello restano identici, non viene calcolato nessun gradiente e non si memorizza niente. Gli esempi vivono solo nel contesto di quella richiesta e spariscono con essa. È molto diverso dall'affinamento, che invece modifica i pesi e produce un modello nuovo.
Gli esempi servono soprattutto quando il formato conta o il compito è difficile da descrivere: classificare messaggi, estrarre dati, uniformare un tono. Di solito bastano da due a cinque esempi, vari e rappresentativi dei casi veri, tutti con lo stesso formato.
Hanno un costo: ogni esempio occupa token nella finestra di contesto e li paghi a ogni richiesta. I modelli recenti, ben addestrati a seguire le istruzioni, nei compiti semplici funzionano bene anche zero-shot. Gli esempi rendono il risultato più stabile dove la sola istruzione lascia dei dubbi.
Vuoi che il modello assegni una priorità alle email di assistenza. Nel prompt scrivi tre esempi:
«Il sito è fermo, non vendiamo niente» → alta
«Potete cambiare il mio indirizzo di fatturazione?» → bassa
«Il pagamento è stato addebitato due volte» → alta
Poi aggiungi: «Vorrei sapere se fate anche il colore blu» → e lasci la risposta in bianco. Il modello ha capito lo schema: parola singola, tra alta e bassa, in base all'urgenza. Risponde bassa. Non hai scritto da nessuna parte «classifica la priorità»: gli esempi hanno detto tutto.
Una risposta scorrevole e sicura di sé, ma falsa o inventata: una citazione che non esiste, un dato errato, una funzione di libreria mai scritta.
Il modello è costruito per produrre il testo più plausibile dopo quello che ha letto, un token alla volta, scegliendo tra le probabilità che calcola. Plausibile vuol dire «somiglia ai testi su cui è stato addestrato», e di verificato non c'è nulla. Dentro non esiste un archivio di fatti da consultare e nemmeno un controllo che confronti la frase con la realtà. Quando il modello conosce bene l'argomento, il testo plausibile coincide con quello vero. Quando lo conosce poco, continua comunque a scrivere una risposta, perché fermarsi per dire «non lo so» è un comportamento che deve avere imparato.
Le allucinazioni hanno tratti riconoscibili. Nomi, date, numeri, titoli, riferimenti di legge e indirizzi sono dettagli precisi e poco frequenti: il modello li completa con forme verosimili. Il problema si aggrava se l'addestramento premia le risposte sicure più di quelle prudenti.
I rimedi, dal più efficace: dare al modello le fonti con il RAG e chiedergli di rispondere solo da quelle; fargli usare uno strumento per i fatti che si possono controllare, come un calcolo o una ricerca; abbassare la temperatura nei compiti fattuali; chiedere esplicitamente di dire «non lo so» quando l'informazione manca; verificare a mano ciò che conta. Nessun metodo porta il rischio a zero.
Chiedi: «Dammi una sentenza della Cassazione sul licenziamento durante la malattia, con numero e anno».
Il modello risponde sicuro: «Cass. civ., sez. lav., n. 12345 del 2018, che ha stabilito...». Il numero e l'anno sono inventati per questo esempio, ma la frase è del tutto verosimile: ha la forma di una vera citazione.
Controlli nella banca dati: quella sentenza non esiste, o riguarda un altro argomento. Il modello ha semplicemente completato lo schema «sentenza + numero + anno».
Rimedio: incolli nel prompt i testi di tre sentenze vere e scrivi «usa solo questi testi, altrimenti rispondi: non l'ho trovato». Ora può citare solo ciò che hai fornito.
La data oltre la quale i dati di addestramento del modello non arrivano: di ciò che è accaduto dopo il modello non sa nulla, salvo che glielo si fornisca.
Il pre-addestramento usa una grande raccolta di testi, e quella raccolta ha una data di chiusura. Tutto ciò che è stato scritto dopo non è entrato nel modello: è la data limite delle conoscenze. Poi servono mesi di affinamento, prove e controlli prima della pubblicazione, e dopo l'uscita il modello viene usato per un anno o più. Quando lo usi, la sua conoscenza ha quindi spesso molti mesi di ritardo, a volte più di un anno.
Il limite non è netto. Gli ultimi mesi prima della data compaiono in pochi documenti, perché il mondo non ha ancora avuto il tempo di scriverne, e il modello li conosce male. Per lo stesso motivo molti modelli, se glielo chiedi, indicano una data limite più antica di quella reale.
Il modello inoltre non ha un orologio. Non sa che giorno è oggi, a meno che il programma glielo scriva nel prompt. Senza quell'informazione ragiona come se fosse ancora il momento in cui l'addestramento è finito: può dare per «ultima» una versione di un programma già superata, o sbagliare l'età di una persona.
I rimedi sono due. Il primo è scrivere nel prompt la data di oggi e i fatti recenti che servono. Il secondo è fargli consultare il web o i tuoi documenti prima di rispondere, come vedrai nei prossimi termini. Il modello resta lo stesso: cambia quello che ha davanti agli occhi mentre risponde.
Immagina, con date di esempio, un modello con dati fino a marzo 2025, pubblicato a settembre 2025 e usato da te a novembre 2026. Sono passati 20 mesi dalla data limite.
Chiedi: «Chi ha vinto il campionato di quest'anno?». Il modello non ha visto nessun risultato del 2026: risponde con il vincitore del 2025, oppure ne inventa uno.
Ora riprova scrivendo nel prompt: «Oggi è il 21 novembre 2026. Ecco un articolo di ieri sul campionato:» e incolli il testo. Il modello legge l'articolo, trova il vincitore e risponde bene, senza aver imparato nulla di nuovo: il fatto era nel contesto.
Modalità in cui il modello, prima di rispondere, scrive un ragionamento passo per passo, fatto di token come gli altri: migliora i compiti difficili, al costo di più tempo e più token.
Pensa a un'operazione risolta a mente e a una fatta con carta e penna. Il modello, per ogni token, compie un numero di calcoli fisso, stabilito dalla sua architettura: lo stesso numero di passaggi attraverso i blocchi, sia che la domanda sia facile, sia che sia difficile. Se la risposta richiede molti passi e il modello deve scriverla subito, i passi non ci stanno. La soluzione è dargli la carta: farlo scrivere i passaggi intermedi, un token alla volta.
Funziona perché ogni token scritto rientra nel contesto e diventa un ingresso per quelli successivi. Il ragionamento è una memoria di lavoro: i risultati parziali restano sulla pagina e il modello li può rileggere con l'attenzione. L'idea nasce come chain of thought, «catena di pensiero», e all'inizio bastava aggiungere al prompt «ragiona passo per passo».
I modelli di ragionamento attuali fanno di più: sono stati addestrati a ragionare a lungo, anche per migliaia di token, a verificare i passaggi e a tornare indietro quando si accorgono di un errore. Il testo del ragionamento viene spesso mostrato in forma ridotta o nascosto, e in molti servizi puoi regolare il budget di token concesso.
Il prezzo è reale. I token di ragionamento si generano uno alla volta, quindi la risposta arriva più tardi, e si pagano come gli altri token di uscita. Conviene per matematica, codice, logica e pianificazione. È sprecato per tradurre una frase o riscrivere una mail.
Problema: «3 operai costruiscono un muro in 6 ore. Quanto ci mettono 9 operai?».
Risposta d'istinto, senza ragionare: «18 ore», perché si moltiplica 3 × 6 senza chiedersi che cosa significhi. È l'errore tipico di chi risponde subito.
Con il ragionamento il modello scrive: «Il lavoro totale è 3 operai × 6 ore = 18 ore di lavoro di un operaio. Con 9 operai ognuno fa una parte: 18 ÷ 9 = 2 ore». Poi risponde: 2 ore. I passaggi intermedi, scritti sulla pagina, hanno fatto il lavoro che a mente non riusciva.
Prima di rispondere, l'applicazione cerca nei propri documenti i passaggi pertinenti alla domanda e li inserisce nel prompt: il modello risponde basandosi su quelli.
Il modello sa solo ciò che ha visto in addestramento, fino alla sua data limite. Non conosce il regolamento della tua azienda, le email di ieri, il listino di oggi. Si potrebbe incollare tutto nel prompt, ma la finestra di contesto è limitata, ogni token si paga e un modello con troppa carta davanti trova peggio le informazioni utili. RAG risolve il problema portando nel prompt solo i pezzi che servono alla domanda.
Rispetto all'affinamento ha vantaggi pratici. I documenti si aggiornano in un minuto, senza riaddestrare nulla. Si può indicare da quale pagina viene la risposta. Se un documento è riservato a certi utenti, basta non recuperarlo per gli altri. L'affinamento resta la scelta quando devi cambiare lo stile o il comportamento del modello, e serve poco per fargli imparare dei fatti.
Numeri di esempio. L'azienda ha un regolamento di 40 pagine, diviso in circa 120 pezzi, già pronti nell'archivio. Un dipendente assunto il 1° luglio chiede: «Quanti giorni di ferie mi spettano quest'anno?».
Il sistema cerca e trova tre pezzi: l'articolo 12 («le ferie sono 26 giorni all'anno»), l'articolo 13 («maturano in dodicesimi, mese per mese») e l'articolo 14 («il mese iniziato conta per intero»). Li incolla nel prompt con la domanda.
Il modello calcola: 26 ÷ 12 = 2,17 giorni al mese; da luglio a dicembre sono 6 mesi; 6 × 2,17 = 13 giorni circa. Risponde «circa 13 giorni» e cita gli articoli 12 e 13. Senza il recupero avrebbe tirato a indovinare.
Il modello di embedding trasforma un testo intero in un solo vettore che ne riassume il significato. Il database vettoriale conserva questi vettori e trova in fretta i più vicini a quello della domanda.
Hai già visto che un embedding è un vettore, cioè una lista di numeri, associato a un token. Un modello di embedding fa lo stesso per un testo intero: una frase, un paragrafo, una pagina diventano un unico vettore, tipicamente di qualche centinaio o qualche migliaio di dimensioni (valori comuni: 768, 1.024, 3.072). È un modello a sé, più piccolo e più veloce di un modello di chat, addestrato in modo che testi dal significato vicino finiscano in punti vicini. «Rimborso trasferte» e «come mi faccio pagare un viaggio di lavoro» hanno poche parole in comune, eppure i loro vettori stanno vicini.
«Vicino» si misura con un confronto tra vettori, basato sul prodotto scalare e simili: dà numeri alti per vettori che puntano nella stessa direzione. Confrontare una domanda con cento vettori è facile, con dieci milioni è pesante. Qui entra il database vettoriale, un archivio specializzato che conserva i vettori accanto al testo originale e costruisce degli indici per trovare i più vicini senza confrontarli tutti, accettando un piccolo margine di approssimazione.
Il risultato è la ricerca semantica: trova per significato e non per parole uguali. Tre regole pratiche. I documenti e le domande vanno trasformati con lo stesso modello di embedding, perché i vettori di modelli diversi non sono confrontabili. Se cambi modello devi ricalcolare tutto. Per codici, sigle e nomi propri conviene spesso affiancare la ricerca per parole esatte.
Numeri di esempio. Un'azienda ha 20.000 pezzi di documenti. Ogni pezzo è stato trasformato in un vettore di 1.024 numeri, memorizzati ciascuno in 4 byte. Spazio occupato: 20.000 × 1.024 × 4 = 81.920.000 byte, circa 82 MB. Con un milione di pezzi sarebbero circa 4 GB.
Arriva la domanda «come mi faccio rimborsare un viaggio?». Il modello di embedding la trasforma in un vettore di 1.024 numeri. Il database lo confronta con i vettori dell'archivio, usando il suo indice, e restituisce i più vicini: al primo posto «Procedura note spese trasferte», anche se non ha nessuna parola in comune con la domanda. Il documento sulle ferie è lontano e non compare.
La divisione dei documenti in pezzi (chunk) di qualche centinaio di token, prima di calcolarne gli embedding e di conservarli.
Perché non calcolare un solo embedding per un intero manuale? Perché un vettore ha dimensioni fisse: se ci schiacci dentro 200 pagine, resta una media sfocata di tutti gli argomenti, che non somiglia a nessuna domanda precisa. Spezzato in frammenti, il manuale ha un vettore per ogni pezzo, e ciascun pezzo parla di una cosa sola. Inoltre i pezzi trovati andranno nel prompt: pezzi piccoli lasciano spazio nella finestra di contesto e costano meno.
La scelta della misura è un compromesso. Pezzi troppo grandi diluiscono il significato e portano nel prompt molto testo inutile. Pezzi troppo piccoli perdono il contesto: una frase come «Questa regola vale solo per i contratti a termine», da sola, non dice di quale regola si parla. Un punto di partenza comune sono 200-500 token per pezzo.
Alcune tecniche migliorano il risultato. Tagliare dove il testo finisce in modo naturale (paragrafi, titoli, voci di elenco) invece che a metà frase. Sovrapporre i pezzi di circa il 10-20%, così una frase al confine compare in entrambi. Salvare con ogni pezzo il titolo del documento e della sezione. Tenere intere le tabelle e gli elenchi.
Le cifre giuste dipendono dai documenti e si trovano provando: si preparano 20-30 domande vere e si guarda con quale misura il pezzo giusto compare tra i primi risultati.
Numeri di esempio. Un manuale di 200 pagine, circa 250 parole per mezza pagina, cioè 375 token (1,5 token per parola). Si taglia a mezza pagina: 200 ÷ 0,5 = 400 pezzi, con una sovrapposizione di 50 token tra un pezzo e il successivo.
Una regola sta a cavallo del confine: il pezzo 87 finisce con «Il rimborso spetta solo se», il pezzo 88 inizia con «la richiesta arriva entro 30 giorni». Senza sovrapposizione nessun pezzo conterrebbe la regola intera. Con i 50 token ripetuti, il pezzo 88 comincia con la frase completa e viene trovato.
A ogni domanda si cercano i 3-5 pezzi più vicini, circa 1.100-1.900 token, non le 200 pagine.
Al modello si descrive un elenco di funzioni; quando gli serve, produce una richiesta con il nome della funzione e gli argomenti, il programma la esegue e rimette il risultato nel contesto.
Un modello da solo scrive solo testo. Non sa che ora è, non legge il tuo calendario e nei calcoli lunghi sbaglia. Le funzioni risolvono questo limite: il programma che usa il modello gli descrive degli strumenti, ciascuno con un nome, con l'indicazione di che cosa serve e con i parametri che accetta, per esempio «meteo(città)» o «cerca_cliente(nome)». Questa descrizione viene inserita nel prompt.
Il punto chiave è che il modello non esegue niente: propone, e il programma decide. Questo permette di fissare dei limiti: quali funzioni sono disponibili, quali richiedono la conferma di una persona (inviare una mail, pagare), quali valori sono accettati. I modelli sono stati affinati su moltissimi esempi di questo schema, e per questo lo seguono in modo affidabile. Gli strumenti più usati sono la ricerca sul web, la calcolatrice, l'esecuzione di codice, la lettura di un database e l'invio di messaggi.
Descrizione data al modello: lo strumento meteo con il parametro città.
Utente: «Che tempo fa a Roma?».
1. Il modello scrive, invece del testo: {"funzione": "meteo", "città": "Roma"}.
2. Il programma chiama il servizio meteorologico e ottiene «18 °C, sereno».
3. Il programma rimette questo risultato nella conversazione.
4. Il modello scrive: «A Roma ci sono 18 °C e il cielo è sereno».
Il modello non ha mai toccato internet: ha solo scritto una richiesta, e un programma l'ha eseguita.
Un modello messo in un ciclo con degli strumenti: decide un passo, lo esegue, legge il risultato e decide il successivo, finché l'obiettivo è raggiunto o scatta un limite.
Una chiamata di strumenti risolve una domanda: chiedo, il modello usa uno strumento, risponde. Molti compiti richiedono invece un percorso di passi che non si conosce all'inizio, perché dipende da ciò che si scopre strada facendo. L'agente è il modello a cui si dà un obiettivo, un insieme di strumenti e il permesso di ripetere un ciclo: osserva la situazione, ragiona su che cosa fare, sceglie uno strumento, legge l'esito e ricomincia.
Ciò che distingue un agente da un programma tradizionale è che il percorso lo decide il modello, passo dopo passo, e non il programmatore. Gli agenti per la programmazione sono l'esempio più diffuso: leggono i file, cercano nel codice, lo modificano, eseguono i test, vedono l'errore e correggono. Ogni risultato si accumula nel contesto e guida il passo seguente.
Il ciclo finisce per le condizioni di arresto: obiettivo raggiunto, numero massimo di passi, budget di token esaurito, richiesta di intervento umano. In un sistema multi-agente il lavoro è diviso tra più agenti: per esempio un coordinatore assegna dei sottocompiti ad agenti specializzati, ciascuno con il proprio contesto pulito e i propri strumenti.
I rischi crescono con i passi. Se, per ipotesi, ogni passo riesce nel 95% dei casi, dieci passi di fila riescono nel 60% circa (0,95 moltiplicato per sé stesso dieci volte). Inoltre ogni passo rilegge un contesto sempre più lungo, quindi costi e tempi salgono. Per questo gli agenti seri hanno dei limiti, un registro di ciò che hanno fatto e la conferma umana per le azioni importanti.
Obiettivo: «Prenotami un tavolo per 4 sabato sera vicino all'ufficio».
1. Cerca i ristoranti entro 1 km dall'ufficio: ne trova 12.
2. Ne legge le recensioni e ne tiene 3 con valutazione sopra 4,5.
3. Controlla i posti liberi del primo: sabato alle 20 è pieno.
4. Prova il secondo: ci sono posti alle 20:30.
5. Prenota, e riceve una conferma con il numero di prenotazione.
6. Ti scrive: «Tavolo per 4, sabato alle 20:30, da Rossi».
Il percorso non era scritto in anticipo: al passo 3 la situazione è cambiata e l'agente ha scelto un'altra strada. Sono 6 passi decisi uno dopo l'altro.
Uno standard aperto per collegare i modelli a strumenti e fonti di dati: un server espone le sue funzioni in un formato comune e qualunque applicazione compatibile può usarle.
Senza uno standard, ogni applicazione che usa un modello deve scrivere un collegamento su misura per ogni strumento: uno per il calendario, uno per i file, uno per il gestionale. Con 4 applicazioni e 5 strumenti servono 4 × 5 = 20 collegamenti. Con uno standard comune ogni applicazione impara quel protocollo una volta e ogni strumento lo offre una volta: bastano 4 + 5 = 9 pezzi. È lo stesso vantaggio della presa USB.
Il Model Context Protocol (MCP) è stato presentato da Anthropic a fine 2024 come standard aperto e poi adottato da molti altri produttori. Prevede due ruoli. L'applicazione che ospita il modello (un assistente, un ambiente per programmare) contiene un client. Il server MCP è un piccolo programma che sta davanti a un servizio e lo descrive. I due si scambiano messaggi in formato JSON, sullo stesso computer o attraverso la rete.
Un server può offrire tre tipi di cose: strumenti (azioni che il modello può chiedere, come «crea evento»), risorse (dati da leggere, come un file o una tabella) e prompt preconfezionati. Quando l'applicazione si collega, chiede al server che cosa sa fare e inserisce le descrizioni nel prompt. Da lì in poi funziona come una normale chiamata di strumenti.
Il vantaggio riguarda anche la libertà di scelta: puoi cambiare applicazione tenendoti i tuoi server, o cambiare servizio senza riscrivere l'applicazione.
Installi nel tuo assistente un server MCP per il calendario. L'assistente gli chiede che cosa sa fare e riceve due strumenti: elenca_eventi(data) e crea_evento(titolo, data, ora).
Scrivi: «Fissa una riunione con Rossi giovedì alle 15».
1. Il modello chiede elenca_eventi per giovedì.
2. L'applicazione inoltra la richiesta al server, che interroga il calendario e risponde: «giovedì alle 15 libero».
3. Il modello chiede crea_evento con titolo «Riunione con Rossi», giovedì, 15:00.
4. Il server crea l'evento e conferma.
5. Il modello ti scrive: «Fatto, riunione fissata giovedì alle 15».
Lo stesso server funziona in qualsiasi altra applicazione compatibile, senza modifiche.
Costringere il modello a rispondere in un formato preciso, per esempio JSON conforme a uno schema, così che un programma possa leggere la risposta senza doverla interpretare.
Un programma non sa leggere una frase come «il cliente si chiama Mario Rossi e ha 45 anni». Vuole dei campi con nome e tipo: nome testo, età numero. Se la risposta è testo libero, basta una parola in più, un commento dopo il JSON o una virgola mancante e l'elaborazione si ferma.
Esistono tre livelli di affidabilità. Il primo è chiedere il formato nel prompt, con un esempio: funziona spesso, non sempre. Il secondo è una modalità JSON offerta dal fornitore, che garantisce un JSON valido ma non i campi attesi. Il terzo è la generazione vincolata da uno schema, che dà la garanzia più forte. A ogni token da generare, il programma consulta lo schema, calcola quali token mantengono valida l'uscita e cancella tutti gli altri dalle scelte, portando i loro logit a meno infinito prima del softmax. Il modello può scegliere solo tra mosse lecite, e l'uscita rispetta lo schema per costruzione.
Lo schema può imporre i nomi dei campi, i tipi, quali campi sono obbligatori e un elenco di valori ammessi («urgente», «normale», «bassa»). È la base per estrarre dati da email, fatture e moduli, e serve anche alle chiamate di strumenti, dove gli argomenti devono avere una forma esatta.
Email ricevuta: «Buongiorno, sono Mario Rossi, ho 45 anni e vorrei disdire l'abbonamento n. 2231 entro fine mese».
Schema richiesto: nome (testo), eta (numero, oppure vuoto), richiesta (solo «disdetta», «informazioni» o «reclamo»), abbonamento (numero, oppure vuoto).
Il modello restituisce: {"nome": "Mario Rossi", "eta": 45, "richiesta": "disdetta", "abbonamento": 2231}. Il programma lo legge direttamente e lo salva in archivio. Se nell'email l'età non ci fosse stata, il campo sarebbe null, cioè vuoto: lo schema permette di dichiarare che manca invece di inventarla.
Se molte richieste iniziano con lo stesso testo, il fornitore conserva il calcolo già fatto su quella parte: le richieste successive costano meno e partono prima.
Hai visto che, per generare, il modello tiene una cache KV: i risultati già calcolati per i token precedenti, per non rifarli a ogni nuovo token. Di solito questa cache vive solo per una richiesta. La cache del prompt la fa vivere più a lungo: il fornitore la conserva tra una richiesta e la successiva, se la successiva comincia con gli stessi identici token.
Ci sono alcune cose da sapere. Funziona solo sull'inizio del prompt, il prefisso: basta cambiare un carattere in cima e tutto ciò che segue va ricalcolato. Per questo si mettono per primi i pezzi stabili (istruzioni, descrizione degli strumenti, documento) e per ultima la parte che cambia, cioè la domanda. Serve una lunghezza minima, spesso intorno al migliaio di token, e la cache scade dopo pochi minuti senza uso, in alcuni servizi dopo un'ora.
Il vantaggio è doppio. È più veloce, perché il tempo prima del primo token si accorcia: la parte lunga non va rielaborata. È più economico, perché molti fornitori fanno pagare i token letti dalla cache una frazione del prezzo normale, a volte un decimo, con un piccolo sovrapprezzo alla prima scrittura. I prezzi cambiano, quindi controlla il listino.
Si ottiene il massimo con prompt di sistema lunghi, documenti consultati più volte e cicli di agenti, dove il contesto cresce ma l'inizio resta uguale.
Numeri di esempio, con un prezzo inventato: 3 € ogni milione di token in ingresso, e 0,30 € quando i token sono letti dalla cache.
Un manuale di 50 pagine vale circa 30.000 token e viene allegato a ognuna delle 100 domande di una chat di assistenza.
Senza cache: 100 × 30.000 = 3.000.000 di token, cioè 3 × 3 € = 9 €.
Con cache: la prima domanda costa 30.000 token a prezzo pieno, 0,09 €. Le altre 99 leggono il manuale dalla cache: 99 × 30.000 = 2.970.000 token, cioè 2,97 × 0,30 € = 0,89 €. Totale circa 0,98 €, trascurando il sovrapprezzo di scrittura.
Da 9 € a meno di 1 €, e a ogni domanda la risposta parte prima.
Raccolte di prove standard per misurare e confrontare i modelli. Le evals sono le prove costruite sul proprio caso d'uso, e di solito dicono di più dei benchmark pubblici.
Come si decide se un modello è migliore di un altro? Li si mette a confronto sullo stesso esame. Un benchmark è un esame standard: un insieme di domande o problemi con risposte note e un modo automatico di dare il punteggio. Alcuni esempi noti: MMLU (domande a risposta multipla su molte materie), GSM8K (problemi di matematica da scuola), HumanEval (funzioni di programmazione verificate da test), SWE-bench (correzione di errori veri trovati in progetti di software reali). Il punteggio è di solito la percentuale di prove superate.
I benchmark pubblici hanno dei limiti. I modelli migliori raggiungono punteggi vicini al massimo e la prova smette di distinguerli. Le domande possono essere finite nei dati di pre-addestramento (contaminazione): il modello sembra bravo perché ha già visto le risposte. I produttori scelgono i test in cui fanno bella figura. E un compito standard somiglia poco al tuo.
Per questo si costruiscono le evals: da 30 a 100 casi veri del tuo lavoro, ciascuno con la risposta giusta o con dei criteri per giudicarla («cita l'articolo, risponde in 3 righe, non inventa prezzi»). Il controllo può essere automatico (confronto di valori), umano o affidato a un altro modello che giudica secondo una griglia. Le evals si rilanciano a ogni cambio di modello, di prompt o di fornitore, così sai se hai migliorato o peggiorato. Includi anche costo e tempo di risposta: il «migliore» è quello che basta al tuo caso al prezzo giusto.
Numeri di esempio. Un'azienda vuole un assistente per i clienti. Raccoglie 50 domande vere dall'archivio dei messaggi, con la risposta corretta scritta da un collega.
Fa rispondere due modelli alle stesse 50 domande e controlla ogni risposta. Il modello A ne azzecca 41: 41 ÷ 50 = 82%. Il modello B ne azzecca 46: 46 ÷ 50 = 92%.
Differenza: 5 casi, 10 punti percentuali. Con soli 50 casi un divario di 1 o 2 casi direbbe poco; 5 casi sono un segnale. Poi si guarda il resto: B costa il triplo e risponde più piano? Si leggono i 4 errori di B per capire che cosa sbaglia. Nessun benchmark pubblico dice questo.
Con i pesi aperti il file del modello si scarica e si esegue sulle proprie macchine. Via API il modello resta sui server del fornitore e lo si usa a consumo, pagando i token in ingresso e in uscita.
Un modello è, in concreto, un grande file di pesi più un programma che lo esegue. Chi lo produce può scegliere di pubblicare il file (pesi aperti) oppure di tenerlo per sé e vendere l'uso (via API: il tuo programma invia il prompt attraverso la rete e riceve la risposta). Llama, Mistral, DeepSeek e Qwen sono esempi di pesi aperti. GPT, Claude e Gemini si usano via API.
Con i pesi aperti i dati restano da te e nessun fornitore li vede. Il costo è quasi fisso (macchine e corrente) e non dipende dai token. Puoi affinare il modello e usarlo anche senza connessione. Serve però una macchina adatta: i pesi devono stare nella memoria video, e la quantizzazione aiuta a farli entrare. Un modello da 8 miliardi di parametri a 4 bit occupa circa 4 GB, uno da 70 miliardi circa 40 GB. I modelli aperti più grandi richiedono più GPU, e non sempre eguagliano i migliori modelli via API. «Aperto» vuol dire che i pesi si possono scaricare: la licenza può comunque limitare l'uso, e i dati di addestramento di solito restano privati.
Via API non serve nessun hardware, hai accesso ai modelli più capaci e aggiornati e parti subito. Si paga a consumo, in genere un prezzo per milione di token in ingresso e uno più alto per quelli in uscita. Il testo però viaggia verso i server del fornitore: servono un contratto chiaro sull'uso dei dati e, in certi settori, delle verifiche di conformità. Dipendi anche dal fornitore, dai suoi prezzi e dalla disponibilità dei modelli.
Spesso si usano entrambi: un modello aperto locale per i dati sensibili e per i compiti semplici ad alto volume, un modello via API per i casi difficili.
Numeri di esempio. Uno studio professionale fa 3.000 richieste al mese, ognuna con circa 4.000 token in ingresso e 500 in uscita. Prezzi inventati: 3 € per milione in ingresso, 15 € per milione in uscita.
Via API: ingresso 3.000 × 4.000 = 12.000.000 token, cioè 12 × 3 € = 36 €. Uscita 3.000 × 500 = 1.500.000 token, cioè 1,5 × 15 € = 22,50 €. Totale 58,50 € al mese.
In locale: un computer con una GPU adatta costa, poniamo, 3.000 €. Si ripaga in 3.000 ÷ 58,50 = 51 mesi, oltre 4 anni. Il costo quindi non giustifica l'acquisto. Lo giustifica un solo motivo: se le pratiche dei clienti non possono lasciare lo studio, si sceglie il modello aperto locale, anche se costa di più.
I voti dei test che hai consegnato. Restano salvati in questo browser; puoi rifare ogni test quando vuoi (vale l'ultimo voto).