Programmazione nello spazio dei pesi: come gli LLM leggono e modificano i pesi delle reti neurali

La programmazione nello spazio dei pesi è un metodo in cui un large language model (LLM) generico legge i pesi grezzi di una rete neurale e li modifica o li scrive direttamente a partire da un obiettivo espresso in linguaggio naturale, senza discesa del gradiente e senza loop di training. In un post del blog pubblicato il 2 novembre 2026, quattro ricercatori del MIT CSAIL riportano che GPT-6 Astra è già in grado di farlo: ha modificato lo 0,016% dei pesi di Qwen3.5-0.8B e ha portato il punteggio MATH-500 del modello dal 7,9% al 48,1%.

Gli autori sono Rikiya Takehi, Jayden Teoh, Alex Zhang e Omar Khattab, primo autore dell'articolo originale su DSPy. I risultati sono preliminari e provengono da un singolo LLM, ma il team ha pubblicato tutti i prompt, le risposte e le valutazioni alla base degli esperimenti.

In questo articolo vedremo cos'è la programmazione nello spazio dei pesi, cosa hanno mostrato gli esperimenti, dove il metodo si inceppa e cosa significa per il tuo lavoro. Se ti serve un ripasso del modello che fa le modifiche, consulta la nostra guida a GPT-6 Astra.

Cos'è la programmazione nello spazio dei pesi?

La programmazione nello spazio dei pesi consiste nel chiedere a un LLM di leggere, correggere o scrivere direttamente i pesi di una rete neurale, sulla base di una specifica in linguaggio naturale, talvolta senza alcun feedback dall'ambiente. L'LLM determina cosa calcola, o dovrebbe calcolare, ogni parte della rete e imposta di conseguenza i numeri.

È un percorso diverso da quello con cui di solito si ottengono i pesi. Oggi, i pesi provengono dalla discesa del gradiente con ottimizzatori come Adam o Muon, da reti addestrate a generare i pesi di altre reti o da compilatori che trasformano programmi formali in reti. Nell'impostazione del MIT, GPT-6 Astra non scrive alcun loop di training. Ragiona sui pesi come un ingegnere ragiona sul codice.

Gli LLM già ottimizzano prompt, programmi e codice di training. L'argomento degli autori è che questa ottimizzazione guidata dal ragionamento ora arriva fino ai pesi stessi.

Cosa hanno mostrato i ricercatori del MIT

Gli 8 esperimenti rientrano in tre gruppi: leggere i pesi, correggerli e scriverli da zero. La maggior parte usa piccole reti i cui pesi rientrano nella finestra di contesto di Astra come testo; per le più grandi si aggiunge un sandbox Python e in alcuni casi un budget di forward pass.

Lettura dei pesi di una rete

Il team ha addestrato quattro policy con proximal policy optimization (PPO), l'algoritmo standard di reinforcement learning per agenti di gioco, su versioni a griglia di Breakout, Pong, Pac-Man e Freeway, tutte con la stessa architettura da 17.253 pesi. Senza ricevere l'elenco dei giochi, Astra ha nominato il gioco giusto per tutte e 4 le reti, leggendo indizi come i pesi del primo layer dell'agente di Breakout allineati lungo la riga inferiore, dove si trova la racchetta.

Sono seguite due versioni più difficili:

• Modelli di diffusione: Dai pesi di 3 piccoli DDPM, senza consentire forward pass, Astra ha identificato quale genera cerchi, quadrati o triangoli. Li ha disegnati come contorni, sebbene i modelli producano forme piene, indizio che ha letto la geometria dei pesi invece di simulare la rete.
• Modelli linguistici: Avendo solo i 4 blocchi transformer centrali di modelli a caratteri da 7,2 milioni di parametri, Astra ha nominato la lingua di addestramento (Python, giapponese in romaji o inglese) per tutti e 3, in entrambi i tentativi. Ha anche trovato ogni copying head, detta anche induction head, e non ha etichettato nessun'altra head come tale. La nostra guida su multi-head attention spiega cosa fanno quelle head.

Riparare una policy difettosa

Una policy PPO addestrata per 1 miliardo di step su un livello con auto e rampa nell'ambiente Kinetix puntava dritta alla rampa e si piantava ogni volta. Dati i 171.664 pesi, la scena e un episodio registrato, Astra ha spiegato il guasto e ha scritto una correzione in un'unica risposta senza strumenti. La modifica ha cambiato il 3,5% dei pesi e ha portato il tasso di successo dallo 0% al 100% su 1.024 episodi.

La correzione è leggibile: un piccolo percorso aggiuntivo che fa fare retromarcia all'auto, poi si disattiva una volta superata la striscia.

Scrivere reti da zero

Per tre giochi MinAtar, Astra ha ricevuto le regole, il codice sorgente e una rete tutta a zeri, quindi ha scritto ogni peso come testo in un'unica risposta, senza dati, gradienti o strumenti. Tutte e tre le reti hanno battuto agenti PPO addestrati per 100 milioni di step.

Breakout è l'eccezione perché Astra l'ha scritto come un programma: il primo layer calcola dove atterrerà la palla, il secondo muove la racchetta lì. Una rete Go 9x9 con 1.480.274 pesi, scritta in un sandbox Python, ha battuto una rete PPO di pari dimensioni addestrata su 20 milioni di partite dopo che Astra ha avuto 50 forward pass per fare test a confronto.

Correggere i loop di ragionamento in Qwen3.5-0.8B

Il risultato più pratico prende di mira un difetto noto. La model card di Qwen avverte che Qwen3.5-0.8B è incline a loop di pensiero e nei test del MIT il 93,0% delle sue risposte a MATH-500 arrivava al limite di 32.768 token. Lavorando in un kernel Python con 50 forward pass su problemi di pratica da GSM8K e MATH, Astra ha ricondotto i loop a una direzione scritta dagli MLP dei layer 15 e 19 e l'ha sottratta da 64 colonne di output in ciascuno.

La quota di risposte che raggiunge il limite di token è scesa al 33,1% e, poiché i loop non sono specifici della matematica, è migliorata anche la capacità di seguire istruzioni. Il budget contava: con 10 o 25 forward pass i loop a malapena scomparivano. Ahsen Khaliq di Hugging Face ha ricostruito il checkpoint modificato dai log e ha rieseguito MATH-500 con le stesse impostazioni, ottenendo il 51,0%.

Dove la programmazione nello spazio dei pesi non basta

La programmazione nello spazio dei pesi non regge quando il problema non è un singolo difetto localizzato nei pesi. Gli autori riportano due fallimenti chiari, entrambi informativi.

• La piaggeria era invisibile nei pesi. Dati un fine-tuning onesto e uno piaggero di Gemma 3 270M, Astra non è riuscita a distinguerli dai soli pesi in nessuno dei suoi quattro tentativi. Una volta che ha potuto vedere i pattern di attenzione, ha individuato il piaggero in tutte e tre le coppie.
• Gemma 3 270M non è migliorata in matematica. Gemma raramente entra in loop, quindi non c'era un singolo difetto da rimuovere e la migliore modifica di Astra ha spostato MATH-500 dal 6,8% al 7,7%. Come dicono gli autori, modificare i pesi può rimuovere un ostacolo che nascondeva un'abilità, ma non può aggiungere un'abilità che il modello non aveva.

Avvertenze più ampie: ogni esperimento usa un LLM, la rete più grande ha 0,8 miliardi di pesi e questo è un post con risultati preliminari, non un articolo peer-reviewed. Gli autori affermano di star ancora costruendo un benchmark per il compito.

Cosa significa per i professionisti di dati e AI

Per chi lavora sul campo, la programmazione nello spazio dei pesi è oggi un segnale di ricerca, ma non ancora uno strumento. Due aspetti meritano attenzione già ora.

Il primo è l'interpretabilità. Metodi di attribuzione come SHAP spiegano un modello attraverso i suoi input, e l'interpretabilità meccanicistica richiede strumenti dedicati. Astra ha recuperato le induction head con un metodo noto di moltiplicazione di matrici che i ricercatori non le avevano mai menzionato. Se questo regge su modelli più grandi, "chiedere a un modello di frontiera cosa fa questo layer" diventa un primo passaggio prima degli strumenti più pesanti.

Il secondo è la riparazione mirata. Quando un modello piccolo ha un solo fallimento circoscritto, come i loop di Qwen, la correzione di solito è fare fine-tuning su nuovi dati. Una modifica di 131.072 pesi lascia intatto il resto del modello, il che secondo gli autori evita il catastrofico oblio che il fine-tuning può causare. Lo tratterei come un'ipotesi: il risultato su Gemma mostra che la modifica funziona solo quando c'è un singolo colpevole da trovare. La lista dei desideri degli autori, dall'audit dei modelli per backdoor senza eseguirli alla cancellazione di capacità senza dati, non è stata ancora dimostrata.

Come provare tu stesso la programmazione nello spazio dei pesi

Il modo più diretto per testarla è riprodurre uno degli esperimenti: i log contengono gli esatti prompt ricevuti da Astra e GPT-6 Astra è disponibile come gpt-6-astra nelle API di OpenAI, in Amazon Bedrock e nei piani a pagamento di ChatGPT. L'Esperimento 1, nominare il gioco dai pesi di una policy, è il punto di partenza più semplice:

1. Recupera i log. Clona il repository lm_understand-logs. Ogni cartella di esperimento ha un README che mappa ogni numero del post al file da cui proviene.

2. Scegli un esperimento senza strumenti. Negli esperimenti 1, 2, 4 e 5 Astra non ha ricevuto strumenti, quindi un singolo prompt riproduce ogni esecuzione. Nell'Esperimento 1, ogni cartella di run ha un prompt.txt con la descrizione della rete, la domanda e tutti i 17.253 pesi come testo.

3. Invialo come hanno fatto gli autori. Hanno chiamato gpt-6-astra tramite la CLI di Codex (codex exec, prompt su stdin) con tutti gli strumenti integrati disattivati, con high reasoning effort per l'Esperimento 1. Il resto della configurazione è in harness/codex_config.toml, ma i suoi default sono gpt-6-luna a medium effort, quindi imposta modello e reasoning effort a ogni chiamata, come hanno fatto gli autori.

4. Confronta le risposte. Ogni cartella di run contiene anche l'answer.md di Astra e eval/ contiene lo scoring e la soluzione.

Un'esecuzione ha usato circa 73.700 token di input e meno di 2.000 token di output, quindi, con $10 e $50 per milione di token dell'API, una riproduzione costa meno di $1. Gli esperimenti con sandbox Python (3, 6, 7 e 8) richiedono il harness/sandbox.py degli autori e molte più interazioni, quindi pianifica il budget di conseguenza.

Se preferisci non eseguire nulla, il Qwen3.5-0.8B modificato è su Hugging Face sotto Apache-2.0, con gli hash dei 2 tensori cambiati nella sua model card. Lo Space su Hugging Face ti permette di digitare un problema e vedere il modello base andare in loop mentre quello modificato lo risolve.

Considerazioni finali

La programmazione nello spazio dei pesi mostra che un LLM di frontiera può leggere e modificare i pesi delle reti neurali tramite ragionamento, almeno per reti piccole e difetti singoli e localizzati. La correzione su Qwen è il risultato che attirerà attenzione, e la merita, anche perché Hugging Face l'ha replicata in un giorno.

Resto più cauto sulle affermazioni più ampie. Un solo modello, reti piccole e nessun benchmark sono una base fragile per l'inquadramento degli autori secondo cui "i pesi delle nostre reti neurali saranno presto ottimizzati nativamente dagli LLM". Detto questo, i fallimenti sono riportati con la stessa cura dei successi, e questo mi porta a prendere i successi più sul serio.

Se vuoi capire meglio gli interni dei transformer verso cui puntano queste modifiche, ti consiglio il nostro percorso Developing Large Language Models.