Oggi, l’intelligenza artificiale ha compiuto un passo storico: Grok 4 ha superato Humanity’s Last Exam, un test ai limiti della conoscenza umana, pensato per mettere in difficoltà persino gli esperti.
È solo una nuova tappa… o stiamo davvero entrando nell’era delle menti artificiali superiori?
In un mondo in cui le intelligenze artificiali parlano, scrivono, programmano e rispondono a domande complesse, ci chiediamo sempre più spesso: sono davvero intelligenti o stanno solo recitando bene una parte?
Per rispondere a questa domanda, oggi ci affidiamo ai benchmark, test standardizzati che mettono alla prova le capacità logiche, linguistiche e culturali dei modelli. Sono diventati la nostra bussola scientifica per capire fino a che punto l’intelligenza artificiale si stia avvicinando – o superando – quella umana.
I benchmark e i loro limiti nell’era dei modelli linguistici avanzati
Negli ultimi anni, i benchmark sono diventati strumenti chiave per valutare le capacità dei grandi modelli linguistici (LLM), come GPT-4, Gemini o Grok. Tuttavia, molti di questi test — come il celebre MMLU “Massive Multitask Language Understanding” — sono ormai diventati troppo facili: i modelli più avanzati superano il 90% di accuratezza, rendendo difficile distinguere tra miglioramenti reali e semplici ottimizzazioni. (Quando l’accuratezza è troppo alta su un benchmark maturo, quel test non riesce più a distinguere tra un modello “buono” e uno davvero “intelligente”.
È un po’ come se tutti prendessero 10/10 in un esame: non capisci più chi ha studiato meglio o chi ha solo ripetuto a memoria.)
Un benchmark diventa poco informativo quando i modelli lo “saturano”: serve qualcosa di più impegnativo per capire chi è veramente migliore. Per rispondere a questa sfida, è nato Humanity’s Last Exam, un nuovo benchmark pensato per portare le AI ai limiti della conoscenza umana. Composto da 2.500 domande su oltre 100 discipline, copre ambiti come matematica, medicina, filosofia e scienze naturali. È strutturato per evitare il sovra-addestramento, con un set di test pubblico e uno privato, e rappresenta oggi uno degli strumenti più rigorosi per misurare l’intelligenza artificiale in ambito accademico e scientifico.
| Modello | Precisione (%) ↑ | Errore di calibrazione (%) ↓ |
|---|---|---|
| Grok 4 | 25.4 | — |
| Gemini 2.5 Pro | 21.6 | 72.0 |
| o3 | 20.3 | 34.0 |
| o4-mini | 18.1 | 57.0 |
| DeepSeek-R1-0528* | 14.0 | 78.0 |
| o3-mini* | 13.4 | 80.0 |
| Gemini 2.5 Flash | 12.1 | 80.0 |
| Qwen3-235B* | 11.8 | 74.0 |
| Claude 4 Opus | 10.7 | 73.0 |
| DeepSeek-R1* | 8.5 | 73.0 |
| Claude 3.7 Sonetto | 8.0 | 80.0 |
| o1 | 8.0 | 83.0 |
| Claude 4 Sonetto | 7.7 | 80.0 |
| Llama 4 Maverick | 5.7 | 83.0 |
| Anteprima GPT-4.5 | 5.4 | 85.0 |
| GPT-4.1 | 5.4 | 89.0 |
| Claude 3.5 Sonetto | 4.1 | 84.0 |
| GPT-4o | 2.7 | 89.0 |
Dataset aggiornato: 3 aprile 2025 – Modello di giudice: o3-mini
Fonte: Humanity’s Last Exam – disponibile anche nelle classifiche SEAL LLM
Questi test non sono semplici quiz: sono basati su prove accademiche reali, progettate per studenti di alto livello, in ambiti come matematica olimpionica, fisica teorica e ragionamento avanzato.
Tuttavia, è importante ricordare che i benchmark non dicono tutto: misurano specifiche abilità in contesti controllati, e non sempre riflettono la comprensione del mondo, il buon senso o l’affidabilità nel lungo periodo.
In altre parole, Grok 4 ha battuto la concorrenza in questi test, ma l’intelligenza artificiale va ancora valutata nel suo uso reale, quotidiano, e nel modo in cui interagisce con noi.
ARC-AGI 2
È sorprendente vedere come Grok 4 abbia ottenuto risultati così elevati su ARC-AGI 2, uno dei benchmark più ambiziosi e impegnativi mai sviluppati. Questa seconda versione dell’Abstraction and Reasoning Corpus è progettata per testare una qualità ancora sfuggente alla maggior parte delle intelligenze artificiali: la capacità di generalizzare come un essere umano.
A differenza dei test basati su conoscenze pregresse, ARC-AGI 2 propone compiti inediti che richiedono ragionamento astratto, riconoscimento di pattern, creatività e adattamento a regole sconosciute — il tutto su griglie visive apparentemente semplici, ma concettualmente complesse.
Sono problemi che gli esseri umani risolvono con facilità, spesso in pochi secondi, mentre le AI attuali riescono a malapena a superare il 5% di successo.
È per questo che ARC-AGI 2 è considerato da molti un banco di prova autentico per l’Intelligenza Artificiale Generale (AGI): superarlo significherebbe che un modello non solo sa “ricordare”, ma anche “pensare”.
Ogni immagine mostra delle griglie di pixel colorati o in scala di grigi con forme geometriche o simboli. L’obiettivo è capire la regola che trasforma la griglia di sinistra in quella di destra, ad esempio raggruppando o cambiando il colore di certe forme seguendo uno schema specifico.
L’ultimo pannello con il punto interrogativo è un esercizio di completamento: l’AI deve capire la regola e applicarla per completare la griglia mancante.
Transformer
Un transformer è un tipo di rete neurale progettata per gestire dati sequenziali (come testi, immagini suddivise in patch, serie temporali ecc.) e ottenere rappresentazioni utili di questi dati. È stato introdotto nel lavoro “Attention is All You Need” (Vaswani et al., 2017) e da allora ha rivoluzionato l’elaborazione del linguaggio naturale, la visione artificiale e molti altri settori.
Tokens
Un transformer è un’architettura di rete neurale composta da blocchi ripetuti, ognuno dei quali elabora una sequenza di “token” (che possono essere parole, patch di immagini, ecc.) per costruire una rappresentazione utile. A differenza delle RNN, i transformer non trattano i dati in ordine, ma usano un meccanismo chiamato self-attention per decidere a cosa prestare attenzione.
Immagina di leggere un libro e, a ogni nuova parola, il tuo cervello riesca istantaneamente a ricordare e confrontare tutto ciò che ha letto fino a quel momento — non solo le parole vicine, ma anche frasi all’inizio del capitolo, dettagli sottili, emozioni, persino toni impliciti. Questo è, in sostanza, ciò che fa un transformer: una macchina che, nel leggere una sequenza — che sia un testo, un’immagine spezzata in pezzi, o una serie temporale — riesce a comprendere ogni parte in relazione a tutte le altre, in un solo colpo d’occhio.
Gli ingredienti fondamentali del transformer
Il funzionamento del transformer si basa su alcuni elementi chiave che, insieme, ne determinano l’efficacia e la flessibilità:
- Multi-head Attention
Il cuore del transformer è il meccanismo di attenzione, che consente al modello di “guardare” l’intera sequenza e stabilire, per ogni token, quali altri sono rilevanti. Questo processo viene eseguito in parallelo attraverso più “teste” (heads), ognuna specializzata nel cogliere diverse relazioni o prospettive all’interno della sequenza. È come avere più osservatori indipendenti che, contemporaneamente, interpretano la stessa scena da angolazioni diverse. - Connessioni Residuali
Per facilitare l’apprendimento e la stabilità del modello, ogni blocco del transformer include connessioni residue: scorciatoie che bypassano le trasformazioni non lineari, permettendo al flusso dell’informazione originale di arrivare ai livelli più profondi. Questo aiuta il modello a non “dimenticare” ciò che ha già appreso e rende l’ottimizzazione più semplice. - Normalizzazione (LayerNorm)
Per evitare che le attivazioni crescano o si riducano troppo durante l’elaborazione, ogni token viene normalizzato in modo indipendente. Questo processo, chiamato layer normalization, contribuisce a mantenere stabile l’allenamento e migliora la qualità delle rappresentazioni apprese. - Codifica Posizionale (Positional Encoding)
Poiché il transformer non ha una struttura interna che rispetta l’ordine dei dati (a differenza, ad esempio, delle RNN), è necessario fornire esplicitamente informazioni sulla posizione di ciascun token nella sequenza. Questo avviene attraverso vettori detti positional encodings, che vengono sommati o concatenati alle rappresentazioni dei token, permettendo al modello di distinguere, ad esempio, tra “il gatto insegue il topo” e “il topo insegue il gatto”.
Funzionamento dell’Encoder nel Transformer
L’encoder del Transformer ha l’obiettivo di trasformare una sequenza di token (ad esempio una frase) in una rappresentazione numerica contestuale, utile per compiti come traduzione, classificazione o comprensione semantica. Vediamo in dettaglio i passaggi.
1. Embedding dei token + Positional Encoding
Ogni parola o token della frase viene prima convertito in un vettore denso (embedding) di dimensione fissa \( D \). Inoltre, poiché il Transformer non ha una struttura sequenziale interna, si aggiunge un encoding di posizione:
\[ x_i^{(0)} = \text{Embedding}(\text{token}_i) + p_i \]
dove \( p_i \) è il positional encoding del token alla posizione \( i \), e \( x_i^{(0)} \in \mathbb{R}^D \) è il vettore iniziale che rappresenta il token \( i \).
2. Calcolo di Query, Key e Value
Per ogni token si calcolano tre rappresentazioni: Query, Key e Value, attraverso trasformazioni lineari apprese:
\[ Q = X W^Q,\quad K = X W^K,\quad V = X W^V \]
dove \( X \in \mathbb{R}^{N \times D} \) è la matrice che contiene tutti i token \( x_i^{(0)} \), e \( W^Q, W^K, W^V \in \mathbb{R}^{D \times d_k} \) sono matrici di peso apprese durante l’addestramento.
3. Calcolo della Self-Attention
La self-attention calcola quanto ogni token dovrebbe “guardare” gli altri. Si usa il prodotto scalare tra query e key, normalizzato, e poi si applica la softmax:
\[ A = \text{softmax}\left( \frac{Q K^\top}{\sqrt{d_k}} \right) \]
La matrice \( A \in \mathbb{R}^{N \times N} \) contiene i pesi di attenzione: ogni riga somma a 1 e indica l’importanza degli altri token per il token corrente.
4. Combinazione con le Value
La nuova rappresentazione di ogni token è una somma pesata delle value:
\[ Y = A \cdot V \]
Il risultato \( Y \in \mathbb{R}^{N \times d_v} \) contiene i token aggiornati secondo il contesto della sequenza.
5. Residual Connection e Layer Normalization
Si aggiunge la rappresentazione originale (residual connection) e si normalizza il risultato:
\[ Z = \text{LayerNorm}(X + Y) \]
6. Feed-Forward Network
Ogni token passa attraverso una rete neurale feed-forward identica per tutti, applicata individualmente:
\[ \text{FFN}(z_i) = \text{ReLU}(z_i W_1 + b_1) W_2 + b_2 \]
7. Seconda Residual + Norm
Anche qui si applica un’altra residual connection e normalizzazione:
\[ \text{Output}_i = \text{LayerNorm}(z_i + \text{FFN}(z_i)) \]
Risultato dell’Encoder
Alla fine dell’encoder (dopo M layer ripetuti), si ottiene una matrice:
\[ Z \in \mathbb{R}^{N \times D} \]
che rappresenta ogni token arricchito dal contesto completo. Questa matrice può essere usata per traduzione, classificazione o come input al decoder.
Storicamente, le reti ricorrenti come LSTM e GRU sono state tra le architetture più usate per gestire sequenze, perché elaborano i dati passo dopo passo, mantenendo una memoria del passato. Questo le rendeva particolarmente efficaci nel catturare le cosiddette dipendenze puntuali, cioè le relazioni tra elementi vicini in una sequenza. Ad esempio, nella frase “Il gatto nero dorme”, la connessione tra “gatto” e “nero” è puntuale: le due parole sono vicine e legate semanticamente. Le RNN riescono facilmente a modellare questo tipo di relazione. Tuttavia, quando la distanza tra le parole aumenta, come in “Il gatto che hai visto ieri è salito sul tetto”, il soggetto “gatto” e il verbo “è salito” sono separati da molte parole. Qui entra in gioco una dipendenza a lungo raggio, che le reti ricorrenti faticano a gestire senza perdita di informazione. Il Transformer, invece, grazie al meccanismo di self-attention, riesce a valutare ogni parola rispetto a tutte le altre, assegnando importanza a quelle più rilevanti, anche se distanti. Così, può riconoscere che “gatto” è ancora il soggetto di “è salito”, superando elegantemente i limiti strutturali delle reti ricorrenti.
✍️ L’encoder prende una sequenza di token e restituisce una sequenza di vettori \(z_i\) che rappresentano i token, ma arricchiti del significato di tutto il contesto.
ESEMPIO concreto:
Passo 1 – Embedding della sequenza
Consideriamo una sequenza composta da 3 token già tokenizzati:
["Il", "gatto", "dorme"]
Supponiamo che ogni token sia rappresentato da un vettore embedding di dimensione 2. Allora la matrice di input \( X \in \mathbb{R}^{3 \times 2} \) sarà:
\[ X = \begin{bmatrix} x_1 \\ x_2 \\ x_3 \end{bmatrix} = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{bmatrix} \]
Ogni riga rappresenta il vettore embedding di un token nella sequenza:
- \( x_1 = [1,\ 0] \) → “Il”
- \( x_2 = [0,\ 1] \) → “gatto”
- \( x_3 = [1,\ 1] \) → “dorme”
Questa matrice \( X \) è l’input che verrà usato per calcolare le matrici Q, K e V nel passo successivo.
Passo 2 – Calcolo di Query, Key e Value
A partire dalla matrice \( X \in \mathbb{R}^{3 \times 2} \) (vettori embedding dei 3 token), calcoliamo le matrici di Query (\( Q \)), Key (\( K \)) e Value (\( V \)).
Per farlo, usiamo tre matrici di peso apprese (inizialmente casuali) di dimensione \( 2 \times 2 \):
\[ W^Q = \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix},\quad W^K = \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix},\quad W^V = \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix} \]
Ora applichiamo le trasformazioni:
\[ Q = X W^Q,\quad K = X W^K,\quad V = X W^V \]
Calcolo:
\[ X = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{bmatrix} \Rightarrow Q = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{bmatrix} \cdot \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{bmatrix} \]
\[ K = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{bmatrix} \cdot \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix} = \begin{bmatrix} 0 & 1 \\ 1 & 0 \\ 1 & 1 \end{bmatrix} \]
\[ V = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{bmatrix} \cdot \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix} = \begin{bmatrix} 1 & 1 \\ 1 & -1 \\ 2 & 0 \end{bmatrix} \]
Abbiamo quindi ottenuto le tre matrici:
- \( Q \in \mathbb{R}^{3 \times 2} \): rappresenta le query dei token (Cosa cerca ogni token nel contesto: Usi Q per chiedere: “a cosa devo prestare attenzione?”)
- \( K \in \mathbb{R}^{3 \times 2} \): rappresenta le key dei token (Cosa offre ogni token al contesto: Usi K per dire: “ecco in che cosa posso aiutare gli altri”)
- \( V \in \mathbb{R}^{3 \times 2} \): rappresenta le informazioni da trasmettere (Informazione da trasferire: Se un token è considerato importante, il suo V viene aggregato)
Nel prossimo passo, useremo \( Q \) e \( K \) per calcolare la matrice di attenzione \( A \).
Esempio intuitivo
Frase di esempio:
"Il gatto dorme"
Poniamo che stiamo esaminando il token "dorme".
- Query di “dorme” → chiede:
“Quali parole mi aiutano a capire cosa o chi dorme?”
- Key di “gatto” → risponde:
“Io rappresento un soggetto, potrei essere chi dorme.”
-
Il prodotto scalare tra query e key:
\[ q_{\text{“dorme”}} \cdot k_{\text{“gatto”}} \]
sarà alto ⇒ “dorme” presterà attenzione a “gatto”. -
Di conseguenza, il vettore value di “gatto” verrà usato per aggiornare il significato del token
"dorme".
Passo 3 – Calcolo dei punteggi di attenzione (prima della softmax)
Dopo aver ottenuto le matrici \( Q \), \( K \) e \( V \), il prossimo passo è calcolare la matrice dei punteggi di attenzione grezzi \( S \), che indica quanto ogni token presta attenzione agli altri:
\[ S = \frac{Q K^\top}{\sqrt{d_k}} \]
Dove:
- \( Q \in \mathbb{R}^{N \times d_k} \): matrice delle query
- \( K \in \mathbb{R}^{N \times d_k} \): matrice delle key
- \( K^\top \in \mathbb{R}^{d_k \times N} \): trasposta per il prodotto
- \( S \in \mathbb{R}^{N \times N} \): matrice dei punteggi grezzi
Ogni elemento \( S_{i,j} \) rappresenta il punteggio di attenzione tra il token \( i \) (che fa la query) e il token \( j \) (che offre la key). Più alto è il valore, maggiore sarà l’attenzione di \( i \) verso \( j \).
La divisione per \( \sqrt{d_k} \) serve a normalizzare i punteggi e migliora la stabilità numerica della successiva funzione softmax.
Passo 4 – Applicazione della softmax alla matrice dei punteggi
Dopo aver calcolato la matrice dei punteggi grezzi \( S \), applichiamo la softmax riga per riga per ottenere la matrice di attenzione \( A \).
\[ A_{i,j} = \frac{\exp(S_{i,j})}{\sum_{j’=1}^N \exp(S_{i,j’})} \]
In forma vettoriale:
\[ A = \text{softmax}(S) \]
La softmax trasforma ogni riga di \( S \) in una distribuzione di probabilità: ogni riga di \( A \) conterrà valori tra 0 e 1, e la somma degli elementi su ogni riga sarà pari a 1.
Questo significa che il token \( i \) “presta attenzione” a tutti gli altri token \( j \), ma con pesi diversi. I pesi maggiori sono assegnati ai token più rilevanti nel contesto.
