In-Place TTT: ByteDance fa imparare gli LLM mentre leggono, riusando un pezzo dei pesi che hanno già

Chi ha letto un romanzo russo con venti personaggi conosce il trucco del margine. Non si torna indietro ogni volta a cercare chi fosse Pëtr Stepanovič: la seconda volta che compare, a matita accanto al nome c’è già scritto «figlio del precettore». Il libro resta quello che è, ma chi legge si è costruito, strada facendo, un piccolo prontuario che lo aiuta a indovinare che cosa verrà dopo. E non ci scrive il nome del personaggio, che ha già sotto gli occhi: ci scrive quello che il nome lascia prevedere.

È, trasportata dentro un modello linguistico, l’idea di In-Place Test-Time Training, depositato su arXiv il 7 aprile 2026 (2604.06169). Lo firmano sette ricercatori di ByteDance Seed e dell’Università di Pechino: Guhao Feng e Shengjie Luo a pari merito come primi autori, Kai Hua, Ge Zhang, Tianle Cai, e Di He e Wenhao Huang come autori corrispondenti. Il codice è pubblico nel repository ByteDance-Seed/In-Place-TTT.

Il test-time training e i suoi tre ostacoli

Un modello linguistico, una volta addestrato, ha i pesi congelati: tutto ciò che impara da un documento lungo deve stare nel contesto, e il contesto costa, perché l’attenzione cresce con il quadrato della sua lunghezza. Il test-time training (TTT) propone un’alternativa: tenere una piccola parte dei parametri, i cosiddetti fast weights, libera di cambiare durante l’inferenza, con un passo di discesa del gradiente per ogni pezzo di testo letto. Il documento, invece di essere ricordato parola per parola, viene compresso in quei pesi.

Su paithon ne abbiamo già scritto a proposito di un altro lavoro, End-to-End Test-Time Training for Long Context (dicembre 2025), che addestra il modello a imparare mentre legge fin dal pre-training. Il paper di ByteDance parte da un punto diverso, pratico: il TTT finora non è entrato nei modelli che si usano davvero, e gli autori individuano tre ragioni.

La prima è di compatibilità: i metodi esistenti aggiungono strati specializzati, spesso al posto dell’attenzione, e un modello con strati nuovi va riaddestrato da zero, un costo che frena l’adozione sui modelli da miliardi di parametri. La seconda è di efficienza: l’aggiornamento canonico procede token per token, in sequenza, e le GPU sono fatte per il parallelo; le versioni a blocchi esistono, ma quando il TTT è l’unico meccanismo che mescola i token i blocchi devono restare piccoli. La terza è di obiettivo: i fast weights imparano di solito a ricostruire il token corrente, un compito che non coincide con quello per cui il modello esiste, prevedere il successivo.

La memoria c’era già: il blocco MLP

La risposta al primo ostacolo è la parte che dà il nome al metodo. Ogni blocco Transformer contiene, oltre all’attenzione, un MLP; nei modelli moderni è un MLP con gate, fatto di due proiezioni in ingresso e una in uscita, $W_{\text{down}}$. Un filone di ricerca, a partire da Geva e colleghi nel 2020, li legge come una memoria chiave-valore per ciò che il modello ha imparato in addestramento. Gli autori ne tengono congelate le proiezioni in ingresso e trattano come fast weights soltanto $W_{\text{down}}$, che viene aggiornata sul posto mentre il modello legge. Nessuno strato nuovo da far convivere con miliardi di parametri già addestrati: l’architettura resta quella di partenza, e gli unici pezzi aggiunti, che vedremo fra poco, servono a calcolare il bersaglio dell’aggiornamento.

Il secondo ostacolo si scioglie di conseguenza. Siccome l’attenzione resta al suo posto e continua a mescolare i token fra loro, il TTT non ha più bisogno di aggiornamenti fini: il testo si divide in blocchi grandi, e per ciascuno il modello prima applica i pesi com’erano, poi li aggiorna con il blocco appena letto. L’ordine conta: un blocco non vede mai l’aggiornamento prodotto da sé stesso, e la causalità è rispettata. Nelle ablazioni, su un modello da 1,7 miliardi di parametri, i blocchi migliori sono da 512 e 1024 token, e il secondo è più efficiente del primo.

Scrivere nel margine quello che viene dopo

Il terzo ostacolo è quello più interessante, ed è il senso dell’analogia iniziale. Il bersaglio verso cui si aggiornano i pesi non è più il token corrente ma una combinazione appresa dei token che seguono di poco, ottenuta da una piccola convoluzione sugli embedding seguita da una proiezione:

$$\hat V = \mathrm{Conv1D}(X_0)\, W_{\text{target}}.$$

Con un kernel che pesa solo il token successivo e una proiezione identità, il bersaglio diventa esattamente l’embedding del prossimo token; in pratica la convoluzione ha finestra 5 e impara da sé quanto guardare avanti. Con una perdita di tipo prodotto scalare, l’aggiornamento per il blocco $i$ si riduce a una somma:

$$W_{\text{down}}^{(i)} = W_{\text{down}}^{(i-1)} + \eta\, \hat V_{[i]}^{\top} Z_{[i]},$$

dove $Z_{[i]}$ sono le attivazioni intermedie del MLP sul blocco. Proprio perché è una somma, gli aggiornamenti di tutti i blocchi si possono calcolare in parallelo e poi accumulare con una somma prefissa: il metodo è compatibile con il context parallelism, cioè con la divisione di una sequenza lunghissima su più GPU. Alla fine di ogni documento i pesi tornano al valore di partenza, perché ciò che si è letto in un testo non trapeli nel successivo.

Gli autori accompagnano la scelta con un teorema, in un’impostazione molto semplificata: un solo blocco, una coppia di token che compare una volta, poi il primo riappare e il modello deve indovinare il secondo, lo schema delle cosiddette induction head. Sotto due ipotesi, embedding quasi ortogonali fra loro e attivazioni simili fra la prima comparsa della chiave e la sua ricomparsa, l’aggiornamento con il bersaglio «token successivo» alza in media il logit della risposta giusta lasciando quasi fermi gli altri; quello con il bersaglio di ricostruzione lo sposta in modo trascurabile. È un argomento a favore, non una dimostrazione che valga per un LLM vero.

I numeri

La prova principale è un innesto. Gli autori prendono Qwen3-4B-Base, che ha una finestra nativa di 32k token, aggiungono In-Place TTT a un blocco MLP ogni sei e fanno un addestramento continuato in due fasi: circa 20 miliardi di token a 32k, poi circa 15 miliardi a 128k, con YaRN per estendere le posizioni. Il confronto è con lo stesso modello passato per lo stesso identico percorso senza TTT, ed è la parte più onesta dell’impianto: l’unica variabile è il metodo. I componenti nuovi partono inizializzati quasi a zero, così che all’inizio il modello si comporti come l’originale.

Su RULER, il benchmark sintetico per il contesto lungo, fino a 32k le due versioni restano vicine: il TTT è avanti di 0,6-1,5 punti, e a 4k è perfino un soffio sotto. La distanza si apre dopo, e regge anche a 256k, oltre la lunghezza di addestramento.

Ripetuto su LLaMA-3.1-8B e Qwen3-14B-Base con 20 miliardi di token a 32k, il guadagno a 64k è di 2,1 e 2,7 punti.

Il salto più netto viene dall’addestramento da zero. A 500 milioni e 1,5 miliardi di parametri, con contesto di 32k, In-Place TTT ottiene una perplessità più bassa, riportata solo in un grafico, di finestra scorrevole, Gated Linear Attention, DeltaNet e LaCT, un altro metodo TTT a blocchi grandi. A 4 miliardi, dopo 120 miliardi di token con contesto 8k, RULER-16k passa da 6,58 a 19,99 nella versione con attenzione piena, RULER-8k da 9,91 a 26,80 in quella con finestra scorrevole. Sui test di buon senso i cambiamenti sono piccoli e non tutti in salita: ARC-Challenge con attenzione piena scende da 33,19 a 32,34.

Che cosa resta da verificare

Un solo benchmark di contesto lungo. A parte le curve di perplessità dei modelli piccoli, tutte le misure di contesto lungo sono RULER, cioè compiti sintetici come trovare un ago in un pagliaio. Mancano prove su documenti veri, domande su libri o codice, dove comprimere nei pesi potrebbe aiutare o no.

Guadagni modesti dove conta di più. Sui modelli già addestrati, che sono lo scenario per cui il metodo nasce, si parla di due-quattro punti e mezzo dai 64k in su. Reali e costanti, ma non una svolta. I salti di circa tre volte riguardano modelli da zero con punteggi assoluti bassissimi, dove un piccolo miglioramento pesa molto in proporzione.

Il costo è solo in un grafico. Gli autori scrivono che l’overhead in throughput e memoria è trascurabile, ma il testo non riporta numeri, e le curve si fermano a 128k con batch unitario su H800. Nella valutazione del Qwen3-4B, inoltre, serve un tetto alla norma di ogni aggiornamento, perché la loro somma non cresca senza limite sulle sequenze lunghe: un dettaglio in appendice che fa pensare a un meccanismo delicato.

«Apprendimento continuo» è una promessa, non un risultato. Il paper si chiude presentando il metodo come un passo verso LLM che imparano di continuo. Ma i pesi si azzerano a ogni documento: quello che il modello impara leggendo dura quanto la lettura. È memoria di lavoro più capiente, non esperienza che si accumula. I dati di addestramento, infine, sono raccolti dagli autori e descritti solo a grandi linee, e sui modelli preaddestrati il confronto è con il modello di partenza e con altri modelli pubblici, mai con altri metodi innestabili.

Perché conta adesso

Il test-time training è rimasto a lungo un’idea da laboratorio: elegante, promettente, e incompatibile con i modelli che le aziende hanno già speso milioni ad addestrare. Questo lavoro cambia il tipo di domanda. Non più «quale architettura sostituirà l’attenzione», ma «quanto si può aggiungere a un modello che esiste già, con qualche decina di miliardi di token di addestramento in più». La risposta, per ora, è: un po’, soprattutto dove la finestra di contesto comincia a cedere. Il codice è pubblico, e permette a chiunque di provare l’innesto su modelli più grandi e su compiti meno sintetici di RULER. Sarà lì che si capirà se il margine a matita serve davvero al lettore, o solo all’esaminatore.