Non abbiamo considerato fino in fondo un fatto fondamentale. Questa volta abbiamo davanti una macchina nuova. Una black box per tutti. Una scatola che, ricevuta una combinazione di informazioni in ingresso, produce una combinazione in uscita che in qualche modo risulta corretta, coerente o utile. Non perché qualcuno abbia scritto una per una le regole che collegano quell’ingresso a quell’uscita. Non perché esista, nascosta da qualche parte, una lunga sequenza di istruzioni del tipo: se l’utente dice questo, allora rispondi quello. Dentro quella scatola esiste invece una rappresentazione. Una rappresentazione compressa, incompleta, imperfetta, ma straordinariamente vasta della nostra realtà, delle nostre conoscenze, del nostro linguaggio, delle nostre regole, delle relazioni tra gli oggetti, dei concetti che utilizziamo e di una parte enorme della cultura prodotta dagli esseri umani. Noi possiamo darle qualcosa che comprendiamo immediatamente. Una frase. Un’immagine. Un suono. Una sequenza di numeri. Un programma. La descrizione di un problema. La macchina riceve quella sequenza, la attraversa attraverso la propria struttura interna e produce un’altra sequenza. E quella sequenza torna nuovamente nel nostro mondo. Parole che comprendiamo. Codice che possiamo eseguire. Immagini che possiamo osservare. Azioni che possiamo compiere. Nella maggior parte dei casi, qualcosa di utile. Questo sembra normale soltanto perché ci siamo abituati molto rapidamente. Ma non lo è affatto.
Prima il codice
Per decenni abbiamo identificato il software con una cosa relativamente precisa. Un insieme di istruzioni. Il programmatore decideva cosa dovesse accadere e descriveva alla macchina come farlo. Il software poteva essere gigantesco, complesso, pieno di livelli di astrazione, librerie, dipendenze e comportamenti difficili da prevedere. Ma alla base rimaneva una logica familiare. Qualcuno aveva scritto delle istruzioni. Il codice rappresentava il comportamento della macchina. La complessità poteva essere enorme, ma esisteva ancora una relazione abbastanza chiara tra il programma e ciò che il programma faceva. Se volevamo modificarne il comportamento, modificavamo il codice. Se volevamo aggiungere una funzione, aggiungevamo codice. Se volevamo capire perché una certa cosa accadeva, almeno in teoria potevamo seguire l’esecuzione delle istruzioni. Era difficile. Ma il principio era chiaro.
Poi la macchina
Prima ancora del software avevamo la macchina fisica. Il motore. Il telaio. Gli ingranaggi. La turbina. Il circuito. Il computer. La macchina esisteva come oggetto. Aveva una forma. Aveva dei confini. Potevamo indicarla con un dito. Potevamo dire: questa è la macchina. Il software successivamente aveva introdotto qualcosa di diverso. La stessa macchina fisica poteva svolgere compiti completamente differenti cambiando il programma. Il computer era diventato una macchina universale. Ma continuavano a esistere due livelli facilmente distinguibili. Da una parte l’hardware. Dall’altra il software. La macchina. E il codice che la comandava. Questa distinzione è rimasta così radicata nel nostro modo di pensare che continuiamo a usarla anche oggi. Hardware e software. Il corpo e le istruzioni. Ma forse non basta più.
La terza cosa
Un grande modello neurale non è semplicemente codice. Naturalmente del codice esiste. Serve per definire l’architettura. Serve per addestrare il modello. Serve per caricare i pesi. Serve per eseguire le operazioni matematiche. Serve per distribuire il calcolo sull’hardware. Ma il codice, da solo, non contiene ciò che la macchina sa fare. Possiamo avere due copie perfettamente identiche del programma che esegue una rete neurale. Stesso codice. Stessa architettura. Stesso hardware. E ottenere due macchine radicalmente differenti caricando pesi differenti. Una può conoscere una lingua. L’altra no. Una può programmare. L’altra può riconoscere immagini. Una può essere quasi inutile. L’altra può contenere una rappresentazione estremamente sofisticata del mondo. Dove si trova allora la macchina? Non nel codice. Non completamente nell’hardware. È emersa una terza cosa. Una struttura appresa. Una configurazione numerica capace di trasformare ingressi in uscite attraverso un’enorme rete di relazioni. I pesi non sono semplicemente dati nel senso tradizionale del termine. Non sono un archivio di documenti. Non sono un database che possiamo interrogare cercando una riga precisa. Non sono neppure istruzioni. Sono la struttura stessa attraverso la quale l’informazione viene trasformata. Se cambiamo quella struttura, cambiamo il comportamento della macchina. Eppure nessun programmatore ha scritto direttamente quella struttura. È stata prodotta. Addestrata. Fatta emergere. Questa è la terza cosa. Non soltanto codice. Non soltanto macchina. Una macchina appresa.
Una macchina che nessuno ha programmato direttamente
Questa differenza è enorme. Per la prima volta abbiamo costruito sistemi nei quali il comportamento più interessante non deriva da istruzioni esplicite scritte una per una. Deriva da un processo. Mostriamo alla macchina enormi quantità di informazione. Definiamo un obiettivo. Correggiamo l’errore. Modifichiamo miliardi di parametri. Ripetiamo il processo un numero enorme di volte. Alla fine otteniamo qualcosa che funziona. Ma non abbiamo scritto direttamente ciò che è diventato. Abbiamo costruito il processo capace di produrlo. È una differenza simile a quella che esiste tra costruire un oggetto e creare le condizioni perché qualcosa cresca. Quando scriviamo un programma tradizionale, costruiamo direttamente il comportamento. Quando addestriamo una rete neurale, costruiamo soprattutto le condizioni attraverso le quali il comportamento può emergere. Il risultato finale può essere utilizzato come una macchina. Ma non è stato costruito nello stesso modo delle macchine precedenti.
La scatola
Da qui nasce la sensazione della black box. Forniamo un ingresso. Otteniamo un’uscita. Possiamo conoscere perfettamente l’architettura. Possiamo conoscere ogni peso. Possiamo osservare ogni moltiplicazione. Eppure questo non significa che siamo in grado di spiegare in modo semplice perché una determinata sequenza abbia prodotto proprio quella risposta. Non c’è necessariamente una regola localizzabile. Non c’è una riga di codice che contiene quella frase. Non esiste una casella nella quale sia conservata quella risposta. La risposta nasce dal passaggio dell’informazione attraverso l’intera configurazione. Questo rende la macchina profondamente diversa dalle precedenti. La sua funzione non può essere descritta facilmente elencando le sue istruzioni. La sua funzione è distribuita nella sua struttura.
Uno spazio quasi inesauribile
Le combinazioni possibili non sono infinite. Questo va detto con precisione. Qualunque sistema digitale finito possiede un numero finito di stati. Anche il più grande modello mai costruito è finito. Ma il numero delle possibili combinazioni è talmente grande che, dal nostro punto di vista pratico, può diventare quasi inesauribile. Possiamo formulare una frase che nessuno ha mai scritto prima. La macchina può produrre una risposta che nessuno aveva predisposto. Possiamo cambiare una parola. Cambiare il contesto. Aggiungere un’immagine. Modificare l’ordine delle informazioni. Chiedere di combinare concetti appartenenti a domini differenti. Ogni variazione può aprire un nuovo percorso. Lo spazio degli ingressi è enorme. Lo spazio delle trasformazioni interne è enorme. Lo spazio delle uscite è enorme. È questo che produce l’impressione di trovarci davanti a qualcosa che non è più semplicemente un programma. Il programma tradizionale percorre possibilità progettate. Questa macchina esplora uno spazio di possibilità apprese.
Una rappresentazione del mondo
Ma la parte forse più importante non è il numero delle combinazioni. È ciò che la macchina contiene. Per poter produrre risposte plausibili deve aver incorporato una quantità enorme di relazioni. La relazione tra una parola e un’altra. Tra un oggetto e il suo utilizzo. Tra una causa e un effetto. Tra un concetto e altri concetti. Tra una struttura linguistica e un’intenzione. Tra una descrizione e ciò che quella descrizione potrebbe rappresentare. Naturalmente questa rappresentazione non coincide con il mondo. Non è una copia perfetta della realtà. Può essere sbagliata. Può essere incompleta. Può contenere distorsioni. Può produrre associazioni assurde. Ma deve comunque possedere una struttura interna sufficientemente ricca da permettere di navigare tra parti differenti della conoscenza umana. Ed è proprio questa struttura a renderla interessante. Non abbiamo semplicemente costruito un sistema che contiene informazioni. Abbiamo costruito una macchina che contiene relazioni tra informazioni.
Una macchina senza forma
Qui compare un’altra differenza fondamentale rispetto al passato. Prima costruivamo la macchina fisica. Il motore aveva una dimensione. La turbina aveva una dimensione. Il computer aveva una dimensione. Una volta costruito, l’oggetto era quello. Naturalmente potevamo sostituire componenti. Potevamo migliorarlo. Potevamo costruirne uno più grande. Ma la sua identità fisica era chiara. La macchina neurale invece non possiede necessariamente una forma fisica propria. La scatoletta non esiste. Possiamo salvare il modello su un disco. Possiamo copiarlo. Possiamo spostarlo. Possiamo dividerlo. Possiamo eseguirlo su hardware differenti. Possiamo distribuirne parti su più dispositivi. La stessa struttura matematica può esistere oggi su un server e domani su un altro. L’hardware è il substrato che permette alla macchina di manifestarsi. Ma non coincide necessariamente con la macchina. Questo rende il modello qualcosa di strano. È reale. Produce effetti reali. Richiede energia reale. Richiede memoria reale. Occupa hardware reale. Ma la sua forma non coincide con nessuno di questi oggetti.
Il corpo temporaneo
Quando un modello viene eseguito, l’hardware diventa temporaneamente il suo corpo. GPU. CPU. RAM. Memoria distribuita. Interconnessioni. Rete. Per qualche secondo, qualche ora o qualche anno, quella struttura matematica vive attraverso quel substrato. Poi può essere spostata. Duplicata. Ridotta. Quantizzata. Suddivisa. Modificata. Il corpo può cambiare senza che necessariamente scompaia l’identità funzionale della macchina. Questo è un concetto che merita molta attenzione. Perché se una macchina non possiede un corpo fisico obbligato, allora non esiste una ragione fondamentale per cui debba avere un solo corpo.
L’hardware non è mai abbastanza
Ed è forse qui che possiamo capire uno dei fenomeni più evidenti dell’intelligenza artificiale contemporanea. L’hardware sembra non essere mai abbastanza. Più memoria. Più GPU. Più banda. Più energia. Più datacenter. Più interconnessioni. Ogni nuova generazione sembra immediatamente insufficiente. Non necessariamente perché stiamo costruendo male l’hardware. Ma perché per la prima volta l’aumento dell’hardware può trasformarsi direttamente in un aumento della macchina virtuale. Se costruisco un motore, a un certo punto il motore è finito. Posso costruirne uno più potente, ma sto costruendo un altro motore. Qui invece posso aumentare il substrato e rendere più grande la struttura che vi esiste sopra. Più parametri. Più contesto. Più memoria. Più modalità sensoriali. Più esperti. Più percorsi. Più capacità. Possiamo dare alla macchina un corpo più grande. E immediatamente la macchina può occupare quello spazio. Questo crea una fame potenzialmente continua di risorse.
Ma qui nasce un errore
Da questa caratteristica abbiamo tratto quasi automaticamente una conclusione. Se una macchina più grande richiede più hardware, allora dobbiamo costruire hardware sempre più grande nello stesso luogo. Più GPU dentro un server. Più server dentro un rack. Più rack dentro un datacenter. Più datacenter collegati tra loro. È una soluzione possibile. Ma non è necessariamente l’unica. Potrebbe essere semplicemente la continuazione del nostro vecchio modo di pensare. Siamo abituati a immaginare una macchina come qualcosa che deve essere contenuto. Una scatola. Una stanza. Una fabbrica. Un edificio. Un datacenter. Ma la macchina di cui stiamo parlando non ha un confine fisico naturale. Quel confine glielo stiamo imponendo noi.
Dove finisce la macchina?
Questa domanda diventa allora fondamentale. Se cento dispositivi partecipano all’esecuzione di un modello, dove si trova la macchina? Nel primo? Nel centesimo? Nella rete? Nei pesi? Nel codice? Nel traffico che passa tra i nodi? Oppure la macchina è l’intero sistema di relazioni che permette all’informazione di attraversare quei componenti? Questa domanda diventa ancora più interessante quando smettiamo di pensare a nodi identici. Immaginiamo migliaia di macchine differenti. Una possiede molta memoria. Una possiede una piccola GPU. Una possiede una NPU. Una contiene una parte di conoscenza. Una è specializzata nella visione. Una nel linguaggio. Una nel controllo di un robot. Una esiste soltanto per pochi minuti quando dispone di energia. Una entra nella rete. Un’altra ne esce. Dove si trova, a quel punto, la macchina? Forse la domanda è sbagliata. Forse la macchina non deve più trovarsi da qualche parte. Forse deve semplicemente esistere attraverso la rete.
Dal programma all’organismo
Qui il confine con le idee che svilupperemo più avanti diventa sottile. Se una struttura può essere distribuita, modificata, estesa e fatta crescere nel tempo, allora comincia ad assomigliare sempre meno a un programma tradizionale. Non perché diventi biologica. Non perché acquisisca magicamente proprietà che non possiede. Ma perché cambia il paradigma con cui dobbiamo descriverla. Un programma viene scritto. Una macchina viene costruita. Questa terza cosa può essere addestrata. Può essere fatta crescere. Può essere modificata senza riscriverne direttamente il comportamento. Può essere duplicata. Può fondersi con altre strutture. Può specializzare alcune parti. Può perdere capacità. Può acquisirne di nuove. Può, almeno in linea di principio, continuare a trasformarsi. A quel punto forse la metafora corretta non è più soltanto quella della macchina. Comincia a comparire quella dell’organismo. Non perché sia viva. Ma perché per comprenderne l’evoluzione potrebbe essere più utile parlare di crescita, specializzazione, connessione e adattamento che non soltanto di programmazione.
Il limite della scatola
Gli attuali grandi modelli sono ancora costruiti soprattutto come oggetti delimitati. Un modello. Una certa quantità di parametri. Una certa architettura. Una fase di addestramento. Una versione. Un rilascio. GPT-X. Gemma-X. Qwen-X. Llama-X. Nomi differenti per oggetti differenti. È comprensibile. Abbiamo bisogno di congelare qualcosa per poterlo distribuire, misurare, confrontare e vendere. Ma non è detto che questa forma sia quella definitiva. Potrebbe essere soltanto la prima forma industrialmente gestibile di questa nuova macchina. Come i primi computer occupavano intere stanze e venivano utilizzati come grandi calcolatori centralizzati. La loro forma iniziale non rappresentava il limite concettuale del computer. Era soltanto il modo in cui riuscivamo a costruirli in quel momento. Forse stiamo facendo la stessa cosa con i modelli. Abbiamo scoperto la terza cosa. E l’abbiamo immediatamente chiusa dentro una scatola.
Togliere i confini
Questo introduce una domanda fondamentale per La Matrice. Se la macchina che ci interessa non è più soltanto l’hardware, e non è più soltanto il codice, perché continuiamo a costruirla come se dovesse vivere dentro un’unica scatola? Perché il suo corpo dovrebbe coincidere con un server? Con un cluster? Con un datacenter? Con l’infrastruttura posseduta da una singola organizzazione? Perché dovrebbe esistere una dimensione massima definita dalla quantità di hardware che un’unica entità riesce a mettere nello stesso luogo? Forse il passo successivo non consiste nel costruire una scatola ancora più grande. Forse consiste nel togliere alla scatola i suoi confini. A quel punto il problema cambia completamente. Non dobbiamo più chiederci soltanto: quanto grande possiamo costruire un modello? La domanda diventa: quanto grande può diventare una struttura che non deve essere contenuta da nessuno? E poi: può crescere senza essere ricostruita da zero? Può aggiungere nuove cellule? Può accettare nuovi nodi? Può distribuire parti della propria conoscenza? Può sviluppare specializzazioni? Può perdere un nodo senza perdere sé stessa? Può continuare ad apprendere senza cancellare ciò che già conosce? Può esistere senza che nessun singolo individuo, azienda o Stato possieda l’intera macchina? Queste non sono più soltanto domande sull’intelligenza artificiale. Sono domande sull’architettura della macchina. E soprattutto sulla natura della terza cosa. Abbiamo avuto il codice. Abbiamo avuto la macchina. Ora abbiamo qualcosa che nasce dal codice, utilizza la macchina, ma non coincide completamente con nessuno dei due. Una struttura appresa. Una rappresentazione capace di trasformare informazione. Una macchina virtuale senza una forma fisica obbligata. Una cosa che possiamo ancora scegliere di rinchiudere dentro una scatola. Oppure lasciare crescere oltre i suoi confini.