Breve storia dell’intelligenza artificiale: da Turing ai modelli linguistici

Il test di Turing, il seminario di Dartmouth, gli anni d’oro, due inverni dell’IA e i sistemi esperti, l’apprendimento statistico, l’apprendimento profondo e i modelli linguistici — una cronologia con collegamenti alle parti della serie e la lezione amara di settant’anni di ricerca.

10 minuti Matěj Žalmánek 2026-10-16

Serie Basi di IA Parte 2 di 52

Programma completo della serie 52 di 83 argomenti pubblicati

Cosa porterai a casa

Come si è sviluppata l’IA e perché l’entusiasmo si è alternato agli inverni.
Da dove vengono le idee su cui si basano i modelli odierni.
Che cos’è la lezione amara e perché vincono i metodi generali con molto calcolo.

Utile sapere prima: Mappa dell’intelligenza artificiale: che cos’è ciascuna cosa e come si incastra tutto

L’intelligenza artificiale non è nuova. La sua storia è più antica dei personal computer e ricorda le montagne russe: periodi di entusiasmo e grandi promesse, seguiti da disillusione e fuga di denaro — gli «inverni» —, e poi una nuova ascesa quando si scopriva che una vecchia idea all’improvviso funzionava. La maggior parte delle idee su cui si basano gli odierni modelli linguistici è stata inventata decenni fa. In questa parte le ripercorriamo nell’ordine in cui sono arrivate e, per ognuna di quelle che la serie spiega, troverai un collegamento alla parte corrispondente.

Riprende la parte Mappa dell’intelligenza artificiale.

Cronologia dell’intelligenza artificiale (in verde i periodi di fioritura, in viola gli inverni)

1. Gli inizi: una macchina può pensare?

Definizione — test di Turing

Nel 1950 Alan Turing sostituì la vaga domanda «le macchine possono pensare?» con una prova: un giudice si scrive con due interlocutori nascosti, una persona e una macchina, e deve capire chi è chi. Se la macchina riesce a mascherarsi bene quanto una persona, secondo Turing non abbiamo motivo di negarle l’intelligenza. Turing stesso parlava di «gioco dell’imitazione».

In parole semplici

Invece di un dibattito filosofico, una prova pratica: se scrivi con qualcuno e non riesci a capire se è una persona o un programma, per te quella è intelligenza. Gli odierni modelli linguistici superano spesso questa prova in una breve conversazione — e si scopre che ciò dice sull’intelligenza meno di quanto ci si aspettasse.

Definizione — il test di Turing come prova statistica

Il giudice conduce n conversazioni indipendenti e in ciascuna stabilisce quale interlocutore è la macchina. Sia S il numero di risposte corrette. Se la macchina è indistinguibile da una persona, il giudice tira solo a indovinare e S ~ Bin(n, ½), quindi ES = n/2 e la deviazione standard è σ = √n / 2. La macchina supera il test se il risultato non differisce statisticamente dal caso: |z| < 1,96 (test bilaterale al livello del 5 %, approssimazione normale della distribuzione binomiale).

Nota. Questa è una formalizzazione odierna, non quella di Turing. Nel 1950 Turing descrisse il test a parole e, invece di una soglia, diede una previsione: intorno al 2000 un giudice medio, dopo cinque minuti di conversazione, non avrebbe riconosciuto correttamente la macchina con una probabilità superiore al 70 %.

In parole semplici

Una sola conversazione non dimostra nulla — il giudice può indovinare anche per caso. Per questo si conducono molte conversazioni e ci si chiede se il giudice riconosca la macchina più spesso che lanciando una moneta. Se no, la macchina è passata.

z = (S − n/2) / √n / 2

S: quante volte il giudice ha riconosciuto la macchina — l’unica cosa che il test misura
n/2: quante volte indovinerebbe tirando a caso; lo sottraiamo perché interessa solo ciò che sta sopra il caso
√n / 2: la dispersione tipica del tirare a caso; dividendo confrontiamo l’eccedenza con il rumore normale — 6 in più su 100 conversazioni è diverso da 6 in più su 10 000

Di quante «deviazioni normali» il giudice è migliore di una moneta.

Esempio — 100 conversazioni

Il giudice ha riconosciuto la macchina in 56 conversazioni su 100. Tirando a caso se ne aspetterebbe 100/2 = 50, la deviazione è √100 / 2 = 5, quindi z = (56 − 50) / 5 = 1,2. È meno di 1,96 — non differisce dal caso e la macchina è passata. Non sarebbe passata se il giudice avesse indovinato in almeno 50 + 1,96 · 5 = 59,8, cioè 60 conversazioni.

1943 Neurone artificiale. Warren McCulloch e Walter Pitts descrissero il neurone come un elemento logico con soglia. → parte della serie
1950 Test di Turing. Alan Turing, nell’articolo Computing Machinery and Intelligence, propose il gioco dell’imitazione al posto della domanda «le macchine pensano?».
1950 Scacchi con la ricerca. Claude Shannon descrisse come un computer giocherebbe a scacchi: esplorare le mosse fino a una certa profondità e valutare le posizioni con una funzione. → parte della serie

2. Gli anni d’oro (1956–1974)

A un seminario a Dartmouth nell’estate del 1956 si riunirono persone convinte che «ogni aspetto dell’apprendimento o qualsiasi altra caratteristica dell’intelligenza possa in linea di principio essere descritto con tale precisione che una macchina possa simularlo». Seguirono due decenni di ottimismo. I programmi dimostravano teoremi, risolvevano problemi a parole, giocavano a dama e parlavano di blocchi su un tavolo. Nel 1965 Herbert Simon predisse che entro vent’anni le macchine sarebbero state in grado di svolgere qualsiasi lavoro svolto da una persona.

1956 Seminario di Dartmouth. John McCarthy, Marvin Minsky, Nathaniel Rochester e Claude Shannon convocarono un seminario estivo; il nome «artificial intelligence» si affermò.
1956 Logic Theorist. Allen Newell e Herbert Simon: un programma che dimostrava teoremi matematici tramite ricerca. → parte della serie
1958 Percettrone. Frank Rosenblatt costruì un neurone che impara; i giornali scrivevano di una macchina che avrebbe camminato e parlato. → parte della serie
1959 Apprendimento automatico. Arthur Samuel: un programma di dama che migliorava giocando contro sé stesso. Da lui viene l’espressione machine learning. → parte della serie
1960 Filtro di Kalman. Rudolf Kálmán: stima dello stato da misure rumorose; volò con l’Apollo. → parte della serie
1965 Insiemi fuzzy. Lotfi Zadeh introdusse l’appartenenza a un insieme come un numero tra 0 e 1. → parte della serie
1966 ELIZA. Joseph Weizenbaum scrisse un programma che imitava uno psicoterapeuta con poche regole — e le persone gli confidavano segreti.
1969 Il libro Perceptrons. Marvin Minsky e Seymour Papert mostrarono che cosa un singolo neurone non sa fare (XOR); l’interesse per le reti neurali calò. → parte della serie
1971 Shakey e STRIPS. Il robot Shakey di Stanford pianificava i passi nel linguaggio STRIPS. → parte della serie
1973 Rapporto Lighthill. Il governo britannico fece valutare i risultati dell’IA; il rapporto fu critico e i finanziamenti vennero ridotti.

Il percettrone: il primo neurone che impara

Definizione — percettrone

Un percettrone con pesi w ∈ ℝ^d e bias b ∈ ℝ assegna un input x ∈ ℝ^d alla classe +1 se w · x + b > 0, altrimenti alla classe −1 (w · x = w₁x₁ + … + w_dx_d è il prodotto scalare). Su un esempio (x, y) con la classe corretta y ∈ {−1, +1} sbaglia se y · (w · x + b) ≤ 0. Il confine w · x + b = 0 è una retta (in generale un iperpiano).

In parole semplici

Ogni input riceve un peso in base a quanto parla a favore del «sì». Il neurone somma gli input con i loro pesi e, se la somma risulta positiva, dice «sì». Imparare significa regolare i pesi in modo che dica «sì» quando è giusto.

La regola di Rosenblatt corregge i pesi solo quando il percettrone sbaglia:

w ← w + η · y · x

w: i pesi — l’unica cosa che si impara; il nuovo valore è il vecchio più una correzione, quindi si impara gradualmente, un esempio dopo l’altro
η: tasso di apprendimento — quanto è grande il passo; in un percettrone che parte da zeri si limita a ingrandire tutti i pesi allo stesso modo, e quindi non cambia il confine
y: la classe corretta ±1 — stabilisce la direzione: un esempio positivo attira i pesi verso di sé, uno negativo li respinge
x: l’input su cui ha sbagliato — la correzione punta proprio lì; un input con valore 0 non ha contribuito all’errore, e per questo il suo peso non cambia

Il bias si corregge allo stesso modo, b ← b + η · y. Dopo la correzione y · (w · x + b) cresce esattamente di η · (‖x‖² + 1) > 0: la risposta su quell’esempio si sposta nella direzione giusta.

perceptron(data, η):
    w ← (0, …, 0);  b ← 0
    ripeti:
        chyb ← 0
        per ogni esempio (x, y) in data:
            se y · (w · x + b) ≤ 0:              # ha sbagliato (o sta sul confine)
                w ← w + η · y · x
                b ← b + η · y
                chyb ← chyb + 1
    finché chyb > 0                              # un’intera epoca senza errori: fatto
    restituisci w, b

Esempio — un percettrone impara AND

Dati: (0, 0) → −1, (0, 1) → −1, (1, 0) → −1, (1, 1) → +1; η = 1, partenza w = (0, 0), b = 0.

(0, 0), y = −1: −1 · (0 + 0) = 0 ≤ 0, errore. w = (0, 0) + (−1) · (0, 0) = (0, 0), b = 0 − 1 = −1.
(0, 1) e (1, 0): −1 · (0 − 1) = 1 > 0, corretto, non cambia nulla.
(1, 1), y = +1: 1 · (0 + 0 − 1) = −1 ≤ 0, errore. w = (0, 0) + (1, 1) = (1, 1), b = −1 + 1 = 0.

E così via: in tutto 18 correzioni, l’ultima nell’epoca 8, e il risultato è w = (3, 2), b = −4. Verifica: 3 · 1 + 2 · 1 − 4 = 1 > 0 e per gli altri input −4, −2, −1 < 0.

Teorema — un percettrone non riesce a fare XOR (Minsky e Papert, 1969)

Non esistono w₁, w₂, b tali che un percettrone classifichi correttamente (0, 0) → −1, (1, 1) → −1, (0, 1) → +1, (1, 0) → +1.

Dimostrazione. Una classificazione corretta significherebbe b ≤ 0, w₁ + w₂ + b ≤ 0, w₂ + b > 0 e w₁ + b > 0. Sommando le ultime due disuguaglianze si ottiene w₁ + w₂ + 2b > 0, quindi w₁ + w₂ + b > −b ≥ 0 — in contraddizione con la seconda disuguaglianza. ∎

In parole semplici

I punti di XOR sono disposti come su una scacchiera: i positivi su una diagonale, i negativi sull’altra. Una sola retta non riesce a separarli. Due strati di neuroni ce la fanno — solo che nel 1969 non si sapeva come addestrarli. Di più nella parte Percettrone.

3. Due inverni e i sistemi esperti (1974–1993)

Definizione — inverno dell’intelligenza artificiale

Un inverno dell’IA è un periodo in cui, dopo promesse non mantenute, i finanziamenti e l’interesse per il settore crollano. Di solito se ne contano due: all’incirca 1974–1980 (dopo il rapporto Lighthill nel Regno Unito e i tagli dell’agenzia statunitense di finanziamento DARPA) e 1987–1993 (dopo il crollo del mercato dei computer specializzati per il linguaggio Lisp e la disillusione nei confronti dei sistemi esperti).

In parole semplici

I programmi che padroneggiavano mondi giocattolo fatti di blocchi si scontrarono con il mondo reale: troppe possibilità, troppe eccezioni, computer troppo lenti. Chi aveva promesso una macchina che «tra dieci anni penserà» dovette spiegare perché non pensava. I soldi andarono altrove.

Tra un inverno e l’altro arrivò un’ondata di sistemi esperti: invece dell’intelligenza generale, un ambito ristretto e centinaia di regole scritte insieme agli esperti («se temperatura > 38 e … allora …»). Funzionavano e facevano guadagnare. Ma le regole erano difficili da mantenere, i sistemi non sapevano fare nulla al di fuori del loro ambito e non riuscivano a imparare. All’ombra di quell’epoca, però, tornarono silenziosamente le reti neurali: la retropropagazione (1986) mostrò come addestrare reti a più strati.

1975 Algoritmi genetici. John Holland sintetizzò l’evoluzione di una popolazione di soluzioni con incrocio e mutazione. → parte della serie
1980 Sistemi esperti. XCON (R1) configurava i computer dell’azienda DEC con regole di esperti e faceva risparmiare milioni di dollari all’anno. → parte della serie
1986 Retropropagazione. David Rumelhart, Geoffrey Hinton e Ronald Williams mostrarono come addestrare reti a più strati. → parte della serie
1988 Reti bayesiane. Judea Pearl: ragionamento probabilistico su un grafo di dipendenze. → parte della serie
1989 Reti convoluzionali. Yann LeCun insegnò a una rete convoluzionale a leggere i codici postali scritti a mano. → parte della serie
1989 Q-learning. Christopher Watkins: imparare il valore delle azioni senza conoscere le regole del mondo. → parte della serie

Retropropagazione: come addestrare più strati

Definizione — retropropagazione (backpropagation)

La retropropagazione è un algoritmo che, per una rete composta da strati h_l = φ(W_lh_l−1 + b_l), calcola il gradiente della perdita L rispetto a tutti i pesi. Calcola le derivate dall’uscita verso l’ingresso secondo la regola di derivazione della funzione composta (la regola della catena) e riutilizza ogni risultato intermedio, così che l’intero gradiente costa dello stesso ordine di un passaggio in avanti attraverso la rete.

In parole semplici

La rete ha sbagliato. Quanta parte di quell’errore va attribuita a quale peso? La retropropagazione fa i conti: parte dall’uscita e rimanda la colpa all’indietro, strato dopo strato, secondo quanto ciascun peso ha influito sul risultato.

Per un singolo neurone ŷ = σ(z), z = wx + b con la perdita L = ½(ŷ − y)², la catena è questa:

∂L/∂w = ∂L/∂ŷ · ∂ŷ/∂z · ∂z/∂w

∂L/∂w: ciò che vogliamo: come cambia l’errore se muoviamo il peso — il segno dice in quale direzione spostarlo
∂L/∂ŷ: = ŷ − y: quanto l’errore dipende dall’uscita; qui inizia il passaggio all’indietro
∂ŷ/∂z: = ŷ(1 − ŷ) per la sigmoide: quanto è sensibile l’attivazione; in un neurone saturo è quasi 0 e l’apprendimento si ferma
∂z/∂w: = x: quanto il peso ha portato alla somma; in una rete a più strati qui c’è l’uscita dello strato precedente e la catena prosegue più indietro

Il gradiente è il prodotto delle derivate locali lungo il percorso dall’errore al peso.

Esempio — un passo di apprendimento

x = 1, w = 0,5, b = 0, risposta corretta y = 1. In avanti: z = 0,5, ŷ = σ(0,5) = 1 / (1 + e^−0,5) = 0,6225, L = ½ · (0,6225 − 1)² = 0,0713.

All’indietro: ∂L/∂ŷ = −0,3775, ∂ŷ/∂z = 0,6225 · 0,3775 = 0,2350, ∂z/∂w = 1. Prodotto: ∂L/∂w = −0,0887.

Passo con η = 1: w ← 0,5 − 1 · (−0,0887) = 0,5887. Il gradiente è negativo, quindi il peso cresce e l’uscita si avvicina a 1.

zpětné_šíření(x, y):
    h₀ ← x                                   # in avanti: memorizza i risultati intermedi
    per l = 1 … L:
        zₗ ← Wₗ · hₗ₋₁ + bₗ
        hₗ ← φ(zₗ)
    δ ← ∂Ztráta/∂h_L                         # all’indietro: parti dall’errore dell’uscita
    per l = L … 1:
        δ ← δ ⊙ φ′(zₗ)                       # attraverso l’attivazione (componente per componente)
        ∂Ztráta/∂Wₗ ← δ · hₗ₋₁ᵀ               # gradiente dei pesi di questo strato
        ∂Ztráta/∂bₗ ← δ
        δ ← Wₗᵀ · δ                          # passa la colpa allo strato inferiore
    restituisci tutti i ∂Ztráta/∂Wₗ, ∂Ztráta/∂bₗ

Per approfondire: Una rete neurale da zero.

4. Apprendimento statistico (1993–2012)

Il settore si trasformò. Al posto di «programmiamo l’intelligenza» arrivò «impariamolo dai dati» — e con esso la probabilità, la statistica e la misurazione accurata. Il riconoscimento vocale, i filtri antispam, le raccomandazioni e la ricerca funzionavano grazie ai modelli di Markov nascosti, ai metodi bayesiani, alle SVM e agli insiemi di alberi. L’espressione «intelligenza artificiale» allora si usava poco — si diceva apprendimento automatico. Deep Blue sconfisse Kasparov nel 1997, ma non imparando: con la forza bruta della ricerca e una funzione di valutazione regolata a mano.

1995 SVM. Corinna Cortes e Vladimir Vapnik: classificazione con il margine massimo e il trucco del kernel. → parte della serie
1997 Deep Blue. Un computer IBM sconfisse il campione del mondo di scacchi Garri Kasparov — con la ricerca, non con l’apprendimento. → parte della serie
1997 LSTM. Sepp Hochreiter e Jürgen Schmidhuber: una rete ricorrente con porte che ricorda a lungo. → parte della serie
2001 Foresta casuale. Leo Breiman: un insieme di alberi di decisione vota. → parte della serie

5. Apprendimento profondo (2012–2018)

Nel 2012 la competizione di riconoscimento di immagini ImageNet fu vinta dalla rete convoluzionale profonda AlexNet (Alex Krizhevsky, Ilya Sutskever e Geoffrey Hinton) con un tale distacco che nel giro di pochi anni il settore si spostò sulle reti neurali. Non era un’idea nuova — le reti convoluzionali esistevano dalla fine degli anni ’80. Nuove erano tre cose: grandi dati etichettati (ImageNet contava oltre un milione di immagini), schede grafiche che moltiplicano matrici mille volte più velocemente e qualche piccolo trucco (ReLU, dropout). Seguì una valanga: voce, traduzione, giochi, generazione.

2012 AlexNet. Una rete convoluzionale profonda addestrata su schede grafiche vinse la competizione ImageNet con grande distacco. → parte della serie
2013 word2vec. Tomáš Mikolov e altri: parole come vettori con cui si possono calcolare analogie. → parte della serie
2014 GAN. Ian Goodfellow: due reti l’una contro l’altra generano immagini. → parte della serie
2014 Attenzione. Dzmitry Bahdanau e altri: una rete di traduzione guarda le parole importanti della frase. → parte della serie
2015 DQN. DeepMind insegnò a una sola rete a giocare a decine di giochi Atari dallo schermo. → parte della serie
2016 AlphaGo. Il programma di DeepMind sconfisse Lee Sedol a go per 4 a 1; il gioco era considerato dominio dell’intuizione umana.
2017 Transformer. L’articolo «Attention Is All You Need» (Vaswani e altri, Google) — l’architettura degli attuali modelli linguistici. → parte della serie
2017 PPO. John Schulman e altri (OpenAI): apprendimento stabile di una politica. → parte della serie

Esempio — perché ReLU ha aiutato

La derivata della sigmoide è σ′(z) = σ(z)(1 − σ(z)) ≤ ¼ (massimo in z = 0). Nella retropropagazione queste derivate si moltiplicano attraverso tutti gli strati, così che dopo dieci strati sigmoidi il gradiente è al massimo (¼)¹⁰ = 9,5 · 10^-7 della dimensione originale (i pesi possono ingrandirlo o ridurlo, ma questo fattore resta). ReLU(z) = max(0, z) ha derivata 1 per z > 0 — il gradiente attraversa i neuroni attivi senza ridursi, e così le reti profonde si possono addestrare.

6. Modelli linguistici (dal 2018)

Il transformer del 2017 si lasciava scalare meglio di qualunque cosa precedente. I modelli GPT preaddestrati su una grande parte di internet mostrarono che un modello più grande e più dati portano un miglioramento prevedibile. Nel 2020 GPT-3 affrontava compiti per cui nessuno l’aveva addestrato, solo a partire da qualche esempio nel prompt. Rifinendolo secondo le preferenze umane nacque ChatGPT (novembre 2022) — il primo modello linguistico provato da centinaia di milioni di persone. Oggi i modelli diventano agenti che lavorano al computer in autonomia.

2020 GPT-3. Un modello linguistico con 175 miliardi di parametri affronta compiti nuovi solo a partire da esempi nel prompt. → parte della serie
2020 Modelli di diffusione. Jonathan Ho e altri: l’immagine emerge dal rumore passo dopo passo. → parte della serie
2020 AlphaFold 2. DeepMind prevede la forma tridimensionale delle proteine con una precisione vicina a quella sperimentale.
2022 ChatGPT. Un modello linguistico rifinito secondo le preferenze umane; in due mesi, secondo le stime, lo usavano 100 milioni di persone. → parte della serie
2024 Premi Nobel. Per la fisica John Hopfield e Geoffrey Hinton (reti neurali), per la chimica Demis Hassabis e John Jumper (AlphaFold) insieme a David Baker.
2024 Agenti. I modelli linguistici con strumenti programmano, cercano e lavorano al computer in autonomia. → parte della serie

L’attenzione: la formula su cui si regge il transformer

Attenzione(Q, K, V) = softmax(QK^T / √d_k) V

QK^T: prodotti scalari di ogni query con ogni chiave — grandi quando i vettori puntano nella stessa direzione; così una parola «cerca» le parole che la riguardano
√d_k: il prodotto scalare di d_k componenti casuali ha una varianza proporzionale a d_k; senza la divisione, al crescere della dimensione il softmax si fisserebbe su una sola parola e i gradienti svanirebbero
softmax: trasforma punteggi qualsiasi in pesi positivi con somma 1 — e, a differenza di «scegli il massimo», è derivabile, quindi si può imparare
V: i valori — l’informazione che viene effettivamente trasmessa; l’uscita è la loro media ponderata

Ogni parola si compone un nuovo vettore come media ponderata delle altre, con pesi in base alla somiglianza.

Esempio — una query, due chiavi

q = (1, 0), k₁ = (1, 0), k₂ = (0, 1), v₁ = (10, 0), v₂ = (0, 10), d_k = 2.

Punteggi: q · k₁ / √2 = 0,707 e q · k₂ / √2 = 0. Softmax: e^0,707 / (e^0,707 + e⁰) = 0,670 e 0,330. Uscita: 0,670 · (10, 0) + 0,330 · (0, 10) = (6,70; 3,30). La query ha «guardato» di più la prima parola perché la sua chiave le somiglia — ma non ha ignorato nemmeno la seconda.

Per approfondire: Attenzione e Transformer.

La legge di scala: perché «di più» funziona in modo prevedibile

L(N, D) = E + A / N^α + B / D^β

E: la perdita irriducibile: il testo stesso è incerto e nemmeno un modello infinito conosce con certezza la parola successiva
A / N^α: la tassa per un modello piccolo (N parametri); scende secondo una legge di potenza — il doppio dei parametri la riduce solo del 21 %, ed è per questo che i modelli crescono di ordini di grandezza
B / D^β: la tassa per pochi dati (D token); sta a parte, perché un modello enorme su pochi dati va a sbattere contro questo termine

L è la perdita media (entropia incrociata) per token. Il calcolo dell’addestramento è circa C ≈ 6 · N · D operazioni; la legge dice come ripartirlo tra dimensione del modello e dati.

Esempio — Gopher contro Chinchilla

Costanti adattate su centinaia di modelli (Hoffmann e altri, 2022): E = 1,69, A = 406,4, B = 410,7, α = 0,34, β = 0,28.

Gopher: N = 280 mld., D = 300 mld.: L = 1,69 + 0,052 + 0,251 = 1,993; calcolo 5,0 · 10²³.
Chinchilla: N = 70 mld., D = 1 400 mld.: L = 1,69 + 0,083 + 0,163 = 1,937; calcolo 5,9 · 10²³.

A parità di calcolo, Chinchilla, quattro volte più piccolo, è migliore: in Gopher il termine dei dati prevaleva nettamente su quello dei parametri (0,251 contro 0,052), quindi conveniva togliere parametri e aggiungere dati.

7. Che cosa ci insegna la storia

Definizione — la lezione amara (the bitter lesson)

Richard Sutton, in un saggio del 2019, ha riassunto settant’anni di ricerca: nel lungo periodo vincono i metodi generali capaci di sfruttare la crescente potenza di calcolo — la ricerca e l’apprendimento — rispetto ai metodi in cui le persone inseriscono a mano le proprie conoscenze sul compito. Le conoscenze manuali aiutano nel breve periodo, ma alla fine vengono superate da un metodo che le impara da sé dai dati e dal calcolo.

In parole semplici

Gli scacchi li ha vinti la ricerca, non le regole dei grandi maestri. Le immagini le ha vinte una rete che ha imparato da sola che cos’è un bordo, non rilevatori di bordi progettati a mano. Il linguaggio l’ha vinto un modello che ha letto internet, non una grammatica scritta dai linguisti. È «amara» perché le persone cercano ogni volta di nuovo di mettere nelle macchine le proprie idee brillanti — e ogni volta le supera la forza bruta con un buon metodo generale.

E si vede ancora una cosa quando guardiamo da dove vengono le idee che la serie spiega. Delle 37 tappe della cronologia, 30 hanno una parte propria:

Da quale decennio vengono le tappe con una parte propria nella serie

La maggior parte (7) viene dal decennio 2010 — ma quasi altrettanto importanti sono gli anni ’50 e ’80. Il percettrone, la retropropagazione, le reti convoluzionali, le LSTM e il Q-learning hanno decenni; aspettavano i dati e la potenza di calcolo. Gran parte di ciò che oggi sembra un miracolo è un’abile combinazione di vecchie idee su larga scala. E ogni ondata di entusiasmo finora è finita con una disillusione — la domanda è solo quanto profonda.

8. Riepilogo

1950 il test di Turing, 1956 Dartmouth (il nome «intelligenza artificiale» viene dalla proposta del seminario del 1955), 1958 il percettrone.
Dopo gli anni d’oro arrivarono due inverni (all’incirca 1974–1980 e 1987–1993), con i sistemi esperti nel mezzo.
Dagli anni ’90 l’apprendimento statistico: dai dati invece che dalle regole, con misurazione e probabilità.
2012 AlexNet e l’apprendimento profondo; 2017 il transformer; 2022 ChatGPT; oggi gli agenti.
La lezione amara: nel lungo periodo vincono i metodi generali che sfruttano il calcolo — la ricerca e l’apprendimento.
La maggior parte delle idee odierne è vecchia; nuovi sono i dati, il calcolo e la scala.

Vuoi provare di persona? Chiedi a un agente IA di scriverti un programma ELIZA con venti regole e conversaci. Poi confronta la stessa conversazione con un modello linguistico odierno — e rifletti su quanto della differenza sia «intelligenza».

La vedi diversamente? Scrivi a support@coden-app.com.

Breve storia dell’intelligenza artificiale: da Turing ai modelli linguistici

1. Gli inizi: una macchina può pensare?

2. Gli anni d’oro (1956–1974)

Il percettrone: il primo neurone che impara

3. Due inverni e i sistemi esperti (1974–1993)

Retropropagazione: come addestrare più strati

4. Apprendimento statistico (1993–2012)

5. Apprendimento profondo (2012–2018)

6. Modelli linguistici (dal 2018)

L’attenzione: la formula su cui si regge il transformer

La legge di scala: perché «di più» funziona in modo prevedibile

7. Che cosa ci insegna la storia

8. Riepilogo

Un Agente sul tuo computer, guidato dal telefono