Come funziona l’AI: guida semplice ai modelli linguistici

Negli ultimi anni abbiamo imparato a convivere con l’intelligenza artificiale, in particolare con gli LLM, i Large Language Model, che una parte ormai maggioritaria dei professionisti utilizza quotidianamente.

Li utilizziamo, li commentiamo, per certi versi li temiamo. Ma li interpretiamo in modo errato, perché applichiamo una lente umana a un sistema che umano non è.

Spesso si sente dire che gli LLM non “ragionano” come noi, dibattiamo di come individuare e controllare le cosiddette “allucinazioni” degli LLM, ma non abbiamo una chiara idea di come gli LLM funzionino e, pertanto, sia nell’utilizzo sia nella loro comprensione procediamo a tentoni, con approssimazioni.

In particolare, negli ambiti giuridico e aziendale, da cui proviene chi scrive, si stanno moltiplicando normative, linee guida, consulenze e convegni, allarmi sui rischi e diffusione sempre più capillare, ma da nessuna parte è dato ritrovare una guida che illustri, in modo semplice, diretto e non troppo tecnico, quale sia la logica di base degli LLM. Con una duplice conseguenza:

1. di sottostimare i rischi, in quanto il rischio, per definizione, deriva da quell’area di mancata o parziale conoscenza di un fatto, evento o teoria; e
2. di non utilizzare bene gli LLM, o di non sfruttarne appieno le capacità e potenzialità.

L’idea di una serie di scritti – di cui il presente è il primo di natura introduttiva e generalista – nasce proprio da questa considerazione, da questo “disagio” nell’utilizzare uno strumento, ormai fondamentale e da cui dipende in modo sostanziale come lavoriamo, senza comprenderlo appieno.

E non si tratta solamente di una nostra incomprensione, ma di un elemento sistemico, come anche indicato in modo molto chiaro da Tommaso Poggio in una recente intervista su Eta Beta^[1]: “Nell’intelligenza artificiale siamo nel momento in cui non abbiamo una teoria comprensiva dell’intelligenza artificiale, di questi sistemi tipo ChatGPT, di come funzionano, di come si potrebbero migliorare. Non abbiamo una teoria, abbiamo dei pezzi di teoria, e probabilmente ci arriveremo a una teoria che aprirà delle prospettive ancora più grandi, a meno che l’intelligenza artificiale non arrivi prima lei di noi”.

Cosa sono gli LLM

Gli LLM sono i modelli di intelligenza artificiale addestrati su enormi quantità di testo per comprendere e generare linguaggio naturale.

Non “capiscono” nel senso umano: funzionano prevedendo, passo dopo passo, la parola (o sequenza di parole) più probabile in base al contesto ricevuto.

In fase di addestramento apprendono dai testi pattern ricorrenti: strutture grammaticali, relazioni tra concetti e uso del linguaggio in diversi contesti. Questo apprendimento massivo e statistico consente loro di produrre risposte coerenti e utili: rispondere a domande, sintetizzare informazioni, tradurre lingue, generare codice o testi articolati. Le prestazioni dipendono da tre fattori chiave: (1) quantità e qualità dei dati,(2) dimensione del modello e (3) modalità di addestramento (es. istruzioni, fine-tuning).

Non verificano i fatti: possono generare contenuti convincenti ma errati (le cosiddette “allucinazioni”). Infatti, non hanno accesso diretto una “verità” oggettiva: operano esclusivamente su correlazioni probabilistiche apprese dai dati, che “pescano” anche autonomamente dal web o dalle banche dati. Per aumentare affidabilità e aggiornamento, possono essere collegati a fonti esterne (database, API^[2]).

Sono alla base di applicazioni diffuse: assistenti virtuali, motori di ricerca evoluti, strumenti di scrittura e automazione documentale. I più diffusi alla data di fine aprile 2026 sono i seguenti^[3].

Ciò detto, abbiamo individuato quelli che sono i passaggi o mattoni fondamentali del “ragionamento” dell’AI, che di seguito introdurremo brevemente procedendo per blocchi:

• token
• vettori
• matrici
• meccanismo di attenzione
• funzioni non lineari
• probabilità; e
• ottimizzazione.

In una serie di scritti successivi analizzeremo nel dettaglio i singoli blocchi. In estrema sintesi: il filo conduttore o idea guida è che il nostro linguaggio è solo l’ingresso: il “pensiero” degli LLM è matematica.

Token: il linguaggio scomposto

Quando noi scriviamo o parliamo agli LLM (la funzione dettatura è semplicemente utilissima) cosa capiscono o cosa ritengono gli LLM? Perché non recepiscono il nostro linguaggio così come è ma lo riducono e sezionano in token?

Il motivo è semplice: la parola sembra un’unità naturale per noi, ma per una macchina è in realtà un concetto ambiguo e costoso. Considera infatti che:

• “gatto” e “gatti” — sono la stessa parola o due? Per noi intuitivamente la stessa, ma come stringa di caratteri sono diverse;
• “New York” — una parola o due?
• In tedesco: Donaudampfschifffahrtsgesellschaft (società di navigazione a vapore sul Danubio) è tecnicamente una parola sola; e
• In cinese e giapponese non esistono spazi tra le parole: dove finisce una parola e inizia l’altra?

Un vocabolario basato sulle parole diventerebbe enormemente grande — milioni di voci — e ogni parola mai vista (neologismo, nome proprio, errore di battitura) sarebbe semplicemente sconosciuta al modello, un buco nero. Qui arriva in soccorso la tokenizzazione. Questa segue logiche statistiche (BPE – Byte Pair Encoding –, WordPiece)^[4]: sequenze di caratteri frequenti nei dati di addestramento diventano token autonomi; quelle rare sono scomposte in parti più piccole. Non è linguistica, è statistica.

Le unità di elaborazione non corrispondono necessariamente alle parole del linguaggio naturale, ma alle sequenze di caratteri statisticamente più efficienti. Ciò consente al modello di gestire neologismi, parole straniere e termini tecnici senza mai incontrare «parole sconosciute».

Esempio:

Frase: “Il ricorso è stato rigettato dal tribunale”

Token: Il | ri | corso | è | stato | ri | gettato | dal | tribun | ale

Un effetto rilevante: parole morfologicamente correlate — come “ricorso”, “ricorrente”, “ricorrere” — condividono token (“ri”, “corso”, ecc.), e il modello ne apprende implicitamente la struttura senza che essa gli sia insegnata esplicitamente. Gli LLM non vedono concetti, ma sequenze ottimizzate.

La ratio del token è dunque: compressione + generalizzazione.

I token nascono da algoritmi BPE o WordPiece il cui principio è: trova i sottosequenze di caratteri che appaiono più frequentemente nel testo e trattale come unità atomiche.

Il risultato è un vocabolario di dimensione controllata (tipicamente 50.000–100.000 token) che (i) per le parole comuni coincide con la parola intera → “casa” è un token, (ii) per le parole rare o lunghe le scompone in parti riconoscibili → “sostenibilità” potrebbe diventare [“sosten”, “ibilità”] e (iii) per i prefissi e suffissi crea automaticamente unità morfologiche → “-mente”, “pre-“, “un-” diventano token stabili.

Questo ha una conseguenza potente: il modello impara la morfologia senza che nessuno gliela abbia insegnata esplicitamente; capisce che “felicemente” e “tristemente” condividono struttura perché condividono token.

I modelli lavorano quindi su sequenze di lunghezza fissa. Con i token si ha un testo breve: pochi token, meno calcoli. Le parole rare o statisticamente meno ricorrenti non “sprecano” un intero slot del vocabolario. Inoltre, sempre utilizzando la logica del token, si possono rappresentare anche codice, matematica, URL con gli stessi meccanismi.

Se si usassero i singoli caratteri (l’alternativa più complessa e granulare), le sequenze diventerebbero lunghissime e il modello faticherebbe a imparare dipendenze a lungo raggio. Se si usassero le parole intere, il vocabolario esploderebbe e la generalizzazione sarebbe povera. Inoltre, gli LLM assorbirebbero molta più memoria, energia e lieviterebbero necessariamente i costi.

Vettori (embeddings): dove nasce il significato

Abbiamo visto nel paragrafo precedente come gli LLM ritengono e immagazzinano il nostro linguaggio. Ora, come sono lavorati e interpolati i token in modo da generare la risposta che ci attendiamo dal nostro LLM?

Il primo passo è quello dell’utilizzo dei vettori^[5]. Ogni token è trasformato in un vettore numerico — una lista di centinaia o migliaia di numeri — che ne codifica il “significato” in relazione a tutti gli altri token appresi durante l’addestramento.

Ma perché si usano i vettori? Questo è un passaggio fondamentale. Si usano i vettori perché trasformano il linguaggio in numeri manipolabili matematicamente, consentendo al modello di calcolare in modo efficiente relazioni, similarità e trasformazioni tra token.

La similarità si misura con la distanza (euclidea) o con l’angolo tra vettori (cosine similarity)^[6]: più vettori puntano nella stessa direzione nello spazio, più i concetti che rappresentano sono semanticamente vicini. Si noti come la similarità nei modelli è quasi sempre misurata con cosine similarity o prodotto scalare; la distanza euclidea è meno tipica nell’uso operativo dei LLM. Questo perché cosine similarity e prodotto scalare misurano l’allineamento tra vettori (direzione), che cattura meglio il significato indipendentemente dalla loro lunghezza.

Riprendendo lo stesso esempio di cui sopra di matrice giuridica, cluster semantici emergono spontaneamente dai dati:

• ricorso, appello, impugnazione
• tribunale, giudice, corte
• contratto, obbligazione, clausola

Il significato diventa posizione nello spazio, vicinanza o lontananza tra cluster rappresentati da vettori.

Facciamo un esempio: pensiamo a una mappa, dove ogni parola è un punto nello spazio. Parole con significati simili (“contratto”, “clausola”) sono vicine; parole diverse sono più lontane. Il modello, lavorando su numeri, può quindi “misurare” queste distanze e capire quali parole sono più coerenti tra loro. Quando deve generare una risposta, un LLM sceglie i punti (parole) più vicini e compatibili con il contesto dato.

Infine, si consideri che i vettori (embedding) non sono fissi, ma sono appresi e aggiornati durante l’addestramento, così che la posizione nello spazio riflette progressivamente meglio le relazioni semantiche tra parole e contesti.

Matrici: il motore delle trasformazioni

Ora, una volta che dalle parole siamo transitati ai numeri, tramite token e vettori, come gli LLM lavorano i dati? Qui entrano in gioco le matrici^[7]. Le matrici trasformano i vettori da uno spazio all’altro o, più tecnicamente, applicano trasformazioni lineari nello stesso spazio (o in uno spazio di diversa dimensione). Ogni strato della rete neurale applica una serie di trasformazioni matriciali che possono produrre effetti geometrici come:

• rotazione (cambio di contesto)
• compressione (avvicinamento di concetti simili)
• espansione (separazione di concetti diversi)
• distorsione (creazione di nuove relazioni semantiche)

Esempio:

“ricorso” → inserito in un contesto decisionale

“rigettato” → associato a un esito negativo

“contratto” → mantenuto in spazio separato

Le matrici sono, in sostanza, il “luogo” in cui il modello conserva ciò che ha imparato. Durante l’addestramento, i numeri che le compongono sono continuamente aggiornati: è così che il modello impara come trasformare un’informazione iniziale (un vettore) in una rappresentazione sempre più coerente con il contesto.

Ogni strato della rete applica una trasformazione diversa. E’ come passare lo stesso testo attraverso più “filtri” successivi, ognuno dei quali mette in evidenza relazioni diverse tra le parole. A ogni passaggio il significato non cambia in modo arbitrario, ma è progressivamente raffinato. Ciò che all’inizio è una rappresentazione generica diventa via via più precisa rispetto alla frase e al contesto.

Il risultato finale non è una singola operazione, ma una sequenza di trasformazioni che, sommate, permettono al modello di costruire una comprensione operativa del linguaggio e generare una risposta coerente.

Ma perchè si utilizzano le matrici per “lavorare” i vettori e non altri strumenti? Si usano le matrici perché permettono di applicare molte trasformazioni ai vettori in modo simultaneo ed efficiente, sfruttando operazioni standard dell’algebra lineare ottimizzate su hardware (GPU/TPU). Di nuovo, l’esigenza è quella della semplificazione, ottimizzazione e costi in relazione alle esistenti architetture hardware.

Da questo punto in poi il modello lavora interamente su rappresentazioni vettoriali, mai sul testo originale.

Meccanismo di attenzione: il contesto che cambia tutto

Ma i dati che sono stati inseriti nel modello secondo i passi precedenti, hanno tutti lo stesso valore? La medesima importanza? No, e qui sta una variabile essenziale. Il cuore dell’architettura dei moderni modelli linguistici — il Transformer — è il meccanismo di self-attention (auto-attenzione)^[8].

Per ogni token, il modello calcola dinamicamente quanto “prestare attenzione” a ciascuno degli altri token presenti nella sequenza. Il risultato è una mappa di pesi: alcuni token sono considerati molto rilevanti, altri quasi ignorati.

Esempio:

“Il giudice ha rigettato il ricorso perché era tardivo.”

Nel processare il token “tardivo”, il modello non lo considera in isolamento: guarda in tutta la sequenza (e non solo all’indietro)^[9] verso “rigettato” e “ricorso”, capendo che “tardivo” è la ragione del rigetto. L’attenzione quantifica queste dipendenze con pesi numerici calcolati a partire dai vettori stessi. Si usa il meccanismo di attenzione perché permette di pesare dinamicamente l’importanza di ogni parola rispetto alle altre, catturando relazioni anche lontane nella frase in modo diretto e altamente parallelizzabile (più efficiente delle architetture sequenziali).

I “pesi di attenzione” non sono fissi: il modello li ricalcola ogni volta, in base alla frase che sta leggendo e alla posizione della parola. In pratica, per ogni parola costruisce tre rappresentazioni numeriche (query, key, value)^[10] derivate dai vettori: servono a confrontare le parole tra loro e capire quali sono più rilevanti nel contesto. Questo meccanismo consente ai modelli di cogliere dipendenze anche a grande distanza nella frase — qualcosa che le architetture precedenti (reti ricorrenti)^[11] non riuscivano a fare efficacemente.

Facciamo un esempio pratico e semplice partendo dalla frase: “Il giudice ha rigettato il ricorso perché era tardivo.” Prendiamo il token “tardivo”.

• Query (Q) // è “cosa sto cercando per capire il mio significato? “Tardivo” cerca il motivo di un esito, guarda a parole che indicano decisioni o atti (“rigettato”, “ricorso”).
• Key (K) // è “che tipo di informazione offro agli altri?” “Rigettato” segnala un esito negativo; “ricorso” segnala l’oggetto della decisione.
• Value (V) → è “il contenuto che porto se considerato rilevante”. “Rigettato” porta l’informazione dell’esito; “ricorso” porta il contesto procedurale.

Il modello confronta la query di “tardivo” con le key degli altri token: trova forte corrispondenza con “rigettato” e “ricorso”. A quel punto “tardivo” assorbe più informazione (value) da quei termini e meno dagli altri. Risultato: il modello capisce operativamente che “tardivo” è la ragione del rigetto del ricorso.

Il confronto tra queste rappresentazioni produce dei punteggi: più alto è il punteggio, più una parola “influenza” le altre. Questi pesi sono poi usati per combinare le informazioni e passare allo strato successivo, dove il processo si ripete e il significato è via via raffinato.

N.B.! Chi assegna l’importanza alle parole? Non c’è un soggetto che decide: è il modello stesso, attraverso i parametri appresi durante l’addestramento. In altri termini, l’importanza emerge da milioni/miliardi di esempi: il modello ha imparato, statisticamente, quali relazioni tra parole sono più rilevanti in certi contesti. Questo implica un punto chiave: l’“importanza” non è una verità oggettiva, ma una stima probabilistica basata sui dati.

Per l’utilizzatore, significa che le risposte possono essere molto coerenti, ma non garantiscono accuratezza assoluta: dipendono da come il modello ha appreso i pattern nei dati.

È per tutto questo che il meccanismo di attenzione è considerato la principale innovazione che ha reso possibili i grandi modelli linguistici attuali.

N.B.! Attenzione alla lunghezza massima di ciascuna chat! Un limite strutturale di questo meccanismo è la finestra di contesto (context window): il numero massimo di token che il modello può “vedere” simultaneamente quando elabora una risposta. Tutto ciò che eccede quel limite semplicemente non esiste per il modello — non è dimenticato, non è ignorato: non è mai stato letto. Nei modelli attuali la finestra va da poche decine di migliaia a oltre un milione di token, ma il principio non cambia: un documento lungo, una conversazione prolungata o un fascicolo articolato possono superare la soglia, con conseguenze dirette sull’affidabilità della risposta. Per gli usi professionali — analisi contrattuali, due diligence, ricerca giuridica — è un parametro da conoscere prima ancora di valutare la qualità dell’output.

Funzioni non lineari: la complessità

Ora, al di là dei pesi o importanza di ciascuna parola, le relazioni tra parole non seguono nel nostro linguaggio schemi semplici, lineari e proporzionali. Spesso sono rapporti più complessi, che mettono in relazione termini diversi in modo più sottile, saltando dall’uno all’altro secondo schemi tante volte intuitivi o inconsci del nostro cervello e della nostra cultura. Le funzioni non lineari servono proprio a rendere il modello capace di cogliere relazioni complesse tra le parole, che non seguono schemi semplici o proporzionali.

Se il modello usasse solo trasformazioni lineari, anche passando attraverso molti passaggi diversi, il risultato sarebbe equivalente a un’unica operazione elementare: troppo limitata per distinguere davvero i contesti.

In pratica, queste funzioni intervengono su ogni valore dei vettori e introducono “soglie” o cambi di comportamento: alcune informazioni sono rafforzate, altre attenuate o eliminate. È questo meccanismo che permette al modello di selezionare ciò che è rilevante e scartare il resto. Il risultato è che combinazioni di numeri che all’inizio appaiono simili possono evolvere in rappresentazioni molto diverse, rendendo possibile distinguere significati anche sottili o opposti all’interno di una frase.

Le funzioni non lineari^[12] — come ReLU (Rectified Linear Unit) o GELU (Gaussian Error Linear Unit)^[13] — introducono soglie e separazioni che le sole trasformazioni matriciali lineari non permetterebbero.

Senza non-linearità, l’intera rete si comporterebbe come una singola trasformazione lineare, indipendentemente dalla sua profondità, e non potrebbe modellare relazioni complesse.

Esempio:

“ricorso accolto” ← regione semantica positiva

“ricorso rigettato” ← regione semantica opposta

La non-linearità separa queste regioni nello spazio matematico, rendendo possibile distinguere esiti radicalmente diversi anche quando le parole di partenza sono simili.

Probabilità: la vera decisione

A questo punto il modello ha elaborato, sulla base dei passi precedenti, le informazioni ricevute a partire dal nostro linguaggio naturale, ma non “sa” quale sia la risposta corretta in senso umano, e allora assegna una probabilità a ciascuna possibile parola successiva in base al contesto.

In altre parole, valuta diverse opzioni e stima quanto ciascuna sia plausibile, sulla base di ciò che ha appreso durante l’addestramento.

La funzione softmax^[14] trasforma queste valutazioni in una distribuzione ordinata e leggibile: ogni parola riceve un peso tra 0 e 1 e la somma totale è 1. Questo consente al modello di confrontare le alternative in modo coerente, distinguendo chiaramente quelle più probabili da quelle meno rilevanti.

La parola generata è quindi quella che, dato il contesto, ha la probabilità più alta oppure rientra tra le più alte, a seconda della strategia adottata (più deterministica o più “creativa”). Subito dopo, il processo si ripete: la parola scelta entra nel contesto e il modello ricalcola una nuova distribuzione per il passo successivo.

Ne deriva una generazione progressiva, parola dopo parola, in cui ogni scelta è il risultato di una valutazione probabilistica continua. È importante sottolineare che questa probabilità misura la coerenza linguistica, non la verità: una frase può essere molto plausibile, ma non necessariamente corretta nei fatti.

L’output del modello non è una risposta certa, ma una distribuzione di probabilità sull’intero vocabolario, calcolata appunto tramite la funzione softmax. Ogni possibile token successivo riceve un peso proporzionale alla sua plausibilità nel contesto dato.

Esempio:

“Il giudice ha dichiarato il contratto…”

nullo → 60%

valido → 25%

inefficace → 15%

Le probabilità dipendono sempre dal contesto: la stessa frase incompleta genera distribuzioni diverse se cambia anche un solo token precedente (si veda il paragrafo precedente sul meccanismo di attenzione).

Ottimizzazione (gradient descent): come impara

A questo punto il modello ha generato una risposta. Questa può essere giusta, sbagliata (in entrambi i casi in tutto o parte), perfettibile o altro. Come fa il modello a imparare dal passato per generare risposte più corrette?

Fondamentale è il riscontro che gli utenti danno e il continuo addestramento e riaddestramento degli LLM, dai bug alle allucinazioni alla segnalazione di risposte diverse od opportune in contesti diversi^[15]. Il modello impara minimizzando l’errore tra output prodotto e dato atteso.

Il meccanismo si chiama gradient descent (discesa del gradiente)^[16] e funziona così:

output prodotto vs. risposta attesa

↓

calcolo dell’errore (loss function)

↓

backpropagation (retropropagazione del gradiente)

↓

aggiornamento dei pesi del modello

La backpropagation è l’algoritmo che, a partire dall’errore commesso sull’output, calcola quanto ciascun peso interno abbia contribuito a quell’errore e lo aggiorna di conseguenza.

Il modello non capisce l’errore: lo corregge matematicamente.

Esempio:

“ricorso approvato” → errore rilevato (rispetto al precedente rigettato)

→ aggiornamento dei pesi verso “accolto” o “rigettato”

In modo meno tecnico, il modello apprende confrontando, a ogni passo, ciò che produce con il dato corretto presente nei testi di addestramento (di norma, il token successivo). La differenza tra i due è quantificata in un errore numerico: più la previsione è lontana, più l’errore è alto.

Questo errore non resta sull’output, ma è “riportato indietro” lungo tutti i passaggi che hanno portato a quella previsione (backpropagation). In questo modo il modello stima quanto ciascun parametro interno abbia contribuito all’errore e li corregge di poco, nella direzione che lo riduce.

Il processo è graduale: non ci sono correzioni drastiche, ma moltissimi piccoli aggiustamenti distribuiti su miliardi di parametri. Ripetendo questo ciclo su enormi quantità di dati, il modello costruisce progressivamente rappresentazioni sempre più accurate del linguaggio. Il risultato non è una “comprensione” in senso umano, ma una capacità sempre più raffinata di prevedere sequenze di parole coerenti con i contesti visti durante l’addestramento.

Prima di chiudere, è essenziale chiarire un equivoco molto diffuso: tutto ciò che è descritto in questo paragrafo — gradient descent, backpropagation, aggiornamento dei pesi — avviene esclusivamente durante la fase di addestramento (training), che si svolge prima che il modello venga reso disponibile. Quando l’utente interagisce con un LLM, il modello è in fase di inferenza (inference): i suoi parametri sono fissi e non vengono modificati dalla conversazione. Il modello non impara da ciò che gli scriviamo, non memorizza le nostre domande e non si aggiorna in tempo reale. Ogni sessione riparte da zero. Gli eventuali miglioramenti futuri del modello derivano da nuovi cicli di addestramento condotti dagli sviluppatori, non dall’uso quotidiano. A cui però gli utenti possono collaborare segnalando bug, allucinazioni e risposte non corrette.

Considerazioni finali

Riprendendo in estrema sintesi gli esempi fatti sul linguaggio giuridico:

• l’LLM non interpreta il diritto;
• non applica norme;
• trasforma parole in numeri;
• numeri in geometrie; e
• sceglie ciò che è più probabile.

Note

^[1] Tommaso Poggio è il Director of the Center for Brains, Minds and Machines at Massachusetts Institute of Technology (Linkedin Tommaso Poggio) e l’intervista completa è disponibile a questo link.

^[2] Un’API (Application Programming Interface) è un “ponte” che permette a software diversi di comunicare tra loro e scambiarsi dati o funzioni.

In pratica definisce regole semplici e standard su come fare richieste e ricevere risposte, così un’app può “chiedere” a un’altra di eseguire un’azione o fornire informazioni.

^[3] Abbiamo fatto una cernita sul web e inserito valori medi tratti da trentina di siti, comprendendo quelli degli stessi LLM e fonti giornalistiche o pubblicazioni di primario standing. In particolare, i dati sugli utenti sono stime basate su fonti pubbliche (DemandSage, DataReportal, SimilarWeb, Epoch AI) e si riferiscono al periodo 2025–inizio 2026. Le cifre per la Cina (ERNIE Bot, Tongyi Qianwen) si riferiscono prevalentemente al mercato domestico cinese.

^[4] BPE (Byte Pair Encoding) è un metodo di tokenizzazione che spezza il testo in unità frequenti. Parte da singoli caratteri e, durante l’addestramento, unisce progressivamente le coppie di simboli che compaiono più spesso. In questo modo costruisce “sotto-parole” ricorrenti (es. prefissi, suffissi), riducendo la dimensione del vocabolario ma mantenendo flessibilità. Funziona quindi su base statistica: più una sequenza è frequente, più è probabile che sia trattata come un unico token.

WordPiece è un metodo simile, usato ad esempio nei modelli di BERT (Bidirectional Encoder Representations from Transformers – è un modello di linguaggio open-source sviluppato da Google AI per l’elaborazione del linguaggio naturale NLP, rilasciato nel 2018). Anche qui il testo è suddiviso in sotto-parole, ma la selezione delle unità si basa su quanto migliorano la probabilità del modello. Non unisce solo le coppie più frequenti, ma quelle che rendono il linguaggio più “prevedibile” per il modello. Il risultato è un vocabolario compatto che gestisce bene parole rare o nuove scomponendole in parti note.

^[5] Un vettore è una lista ordinata di numeri che descrive qualcosa in modo misurabile. Nel contesto dell’AI, serve a rappresentare una parola (o un token) come una posizione in uno spazio numerico. In questo modo il modello può confrontare parole tra loro, capire quali sono simili e come si relazionano.

^[6] La distanza euclidea misura quanto due punti (o vettori) sono lontani nello spazio: è la “distanza in linea retta”, come tra due punti su una mappa. L’angolo tra vettori (cosine similarity) misura invece quanto due direzioni sono simili, indipendentemente dalla loro lunghezza. Se due vettori puntano nella stessa direzione, l’angolo è piccolo e vi è alta similarità. Se sono opposti, l’angolo è grande e riscontriamo una bassa similarità.

La distanza euclidea è sensibile alla “scala” (quanto sono grandi i vettori), mentre la cosine similarity guarda solo all’orientamento. In sintesi: la prima misura “quanto distano”, la seconda “quanto sono simili nella direzione”.

^[7] Una matrice è una tabella di numeri (righe e colonne) che serve a trasformare una lista di numeri (vettore) in un’altra, cambiandone posizione e valori secondo regole precise.

^[8] Meccanismo di auto-attenzione (self-attention): sistema con cui ogni parola valuta quanto sono rilevanti tutte le altre parole della frase per interpretare il proprio significato, assegnando pesi numerici che guidano la comprensione del contesto.

^[9] Questo è vero per i modelli encoder (es. BERT), ma i modelli decoder come GPT e Claude usano la causal attention: vedono solo i token precedenti, non altri.

^[10] Query (Q): rappresentazione numerica di un token che esprime “cosa cerca” nel contesto per interpretare il proprio significato.

Key (K): rappresentazione numerica che descrive “che informazione offre” un token agli altri, rendendolo più o meno rilevante.

Value (V): rappresentazione numerica che contiene il contenuto informativo del token, utilizzato quando è considerato rilevante nel calcolo dell’attenzione.

^[11] Reti ricorrenti (RNN) sono modelli che elaborano il testo una parola alla volta in sequenza, portandosi dietro una “memoria” dei passaggi precedenti. Sono semplici ed efficaci ma meno adatti a catturare relazioni lontane e meno efficienti da parallelizzare rispetto al meccanismo di attenzione.

^[12] Una funzione lineare trasforma i dati in modo proporzionale (raddoppi l’input → raddoppia l’output): è prevedibile e limitata. Una funzione non lineare introduce soglie o curvature: piccoli cambiamenti possono avere effetti diversi, non proporzionali.

^[13] ReLU (Rectified Linear Unit) è una funzione che mantiene i valori positivi e azzera quelli negativi: se il numero è >0 resta, se è <0 diventa 0. Serve a “filtrare” il segnale, attivando solo le informazioni rilevanti e rendendo il modello più efficiente.

GELU (Gaussian Error Linear Unit) è invece una funzione più “morbida”: invece di tagliare bruscamente i valori negativi, li riduce in modo graduale in base alla loro probabilità. Serve a modellare meglio le sfumature, mantenendo anche contributi deboli ma potenzialmente utili al contesto.

^[14] La funzione softmax è una trasformazione matematica che prende una serie di valori numerici (punteggi grezzi del modello) e li converte in probabilità comprese tra 0 e 1, tali che la loro somma sia pari a 1. Funziona “amplificando” le differenze: i valori più alti diventano probabilità significativamente maggiori, mentre quelli più bassi sono ridimensionati. In questo modo il modello può confrontare tutte le opzioni possibili e selezionare il prossimo token in modo coerente rispetto al contesto.

^[15] Tecnicamente il feedback umano riguarda il RLHF (fine-tuning), che è una fase separata e successiva al pre-training. Il gradient descent puro opera sui testi di addestramento, non sulle conversazioni degli utenti.

^[16] Il gradient descent (discesa del gradiente) è un algoritmo di ottimizzazione che aggiorna iterativamente i parametri di un modello muovendosi nella direzione opposta al gradiente della funzione di errore (loss). In pratica, calcola come varia l’errore rispetto ai parametri e li modifica a piccoli passi per ridurlo progressivamente, fino a raggiungere un minimo (locale o globale).