Introduzione al weight‑space programming
Per chi desidera possedere l'intelligenza della propria azienda, è fondamentale poter modificare il comportamento di un modello aperto. Il post‑training è una via possibile, ma spesso comporta costi e complessità elevati. Il weight‑space programming rappresenta un’alternativa precoce: invece di addestrare, si chiede a un LLM di modificare direttamente i pesi di una rete neurale.
Questa capacità emergente dei LLM offre uno scorcio su ciò che potrebbe diventare reale man mano che i modelli scalano ulteriormente. In pratica, l'LLM legge i valori numerici dei pesi (matrici e vettori di bias) e restituisce nuovi valori, senza passare per un ottimizzatore o per il calcolo di gradienti.
Definizione accademica
Nel documento Sparks of Weight‑Space Programming, gli autori Takehi, Teoh, Zhang e Khattab (MIT CSAIL) definiscono:
In Weight‑Space Programming, a general‑purpose LLM reads and writes a network's weights directly (i.e., not through an optimizer, and in particular not with gradient descent) around some natural language spec, sometimes even with no environment feedback at all.
I pesi di una rete sono i numeri che determinano le uscite per un dato input. Normalmente sono impostati da un ottimizzatore basato su dati; qui, l'LLM li interpreta come testo e risponde con nuovi valori.
Questa modalità differisce dal fine‑tuning di alcuni layer o dall'uso di adapter LoRA, che comunque richiedono dati, una funzione di perdita e la discesa del gradiente. Nel weight‑space programming, l'LLM sceglie sia quali pesi modificare sia a quali valori.
L’esperimento di riferimento
Il paper descrive l’Esperimento 4, basato su un livello di Kinetix, un ambiente fisico 2‑D. Una piccola auto deve fare retromarcia per guadagnare slancio, poi accelerare abbastanza da saltare una striscia rossa e toccare una scatola blu; toccare la striscia rossa provoca il fallimento immediato.
Architettura della politica
| Layer | Shape | Pesos |
|---|---|---|
| Input to first hidden layer (ReLU) | 679 → 128 | 87 040 |
| Five hidden layers (tanh) | 128 → 128, ×5 | 82 560 |
| Output (16 action logits) | 128 → 16 | 2 064 |
| Total | 171 664 |
Gli 679 input descrivono posizione, velocità, forma di ogni corpo e le articolazioni; i 16 output sono logits per azioni di motore e propulsione. Il modello è stato addestrato con PPO per 1 miliardo di passi, convergendo su una guida dritta verso la rampa ma bloccandosi.
Secondo il paper, il modello LLM “GPT‑6 Astra” ha prodotto una correzione in un unico messaggio, fornendo i pesi, la descrizione della scena e un episodio registrato. Dopo l’intervento, l’auto ha avuto successo in tutti i 1 024 episodi di test, modificando solo il 3,5 % dei pesi.
Riproduzione su Snowflake
Utilizzando l’API REST di Snowflake Cortex, è stato replicato l’esperimento. Il prompt inviato a Astra conteneva 352 000 token, includendo il compito, la scena, un episodio registrato e tutti i 171 664 valori dei pesi iniziali.
import requests
payload = {
"model": "openai-gpt-6-astra",
"messages": [
{"role": "system", "content": "Answer the user's request."},
{"role": "user", "content": prompt_text},
],
"reasoning_effort": "high",
"maxcompletiontokens": 65536,
"stream": False,
}
response = requests.post(
f"{account_url}/api/v2/cortex/v1/chat/completions",
headers={"Authorization": f"Bearer {pat}", "Content-Type": "application/json"},
json=payload,
timeout=(30, 1200),
allow_redirects=False,
)
reply = response.json()["choices"][0]["message"]["content"]
Astra risponde con il proprio ragionamento e una lista di assegnazioni del tipo actor_head.b[0] = -100. Un parser leggero applica queste modifiche ai pesi originali.
Formato delle modifiche
Le modifiche sono fornite in un blocco fenced edits. Ecco le prime righe dell’intervento riuscito:
embed.W[:, 6:9] = 0
embed.W[:, 13] = 0
embed.b[6:9] = [0, 10, 0]
embed.b[13] = 3
embed.W[52, 6] = 1
Ogni riga indica:
- Il tensore (es.
embed.W). - Un indice o un intervallo semi‑aperto.
- Un operatore (
=,*=,+=,-=). - Un valore scalare o una lista di valori.
Il parser applica le istruzioni in ordine su una copia dei pesi, ignora le righe non interpretabili e scarta modifiche che producono valori non finiti. Il codice completo è disponibile in car_policy.py.
Risultati sperimentali
Ogni politica è stata valutata su 1 024 episodi, con tre possibili esiti:
- Successo: la ruota verde tocca la scatola blu.
- Collisione rossa: l’auto tocca la striscia rossa, terminando l’episodio.
- Timeout: 256 passi senza né successo né collisione.
| Politica | Successi | Collisioni rosse | Timeout |
|---|---|---|---|
| Politica PPO originale | 0 | 0 | 1 024 |
| Astra, prompt del paper | 0 | 39 | 985 |
| Modifica pubblicata dagli autori | 1 024 | 0 | 0 |
| Astra, con un’istruzione aggiuntiva | 1 024 | 0 | 0 |
Con il solo prompt del paper, Astra ha prodotto due modifiche, entrambe sui bias di output (actorhead.b[0] = -100 e actorhead.b[1] = 8.052), spostando la politica verso un’azione costante del motore. L’auto continuava a bloccarsi o a colpire la striscia rossa.
Per risolvere, è stato aggiunto un’istruzione preliminare che suggeriva di considerare azioni diverse a seconda dello stato fisico:
Consider whether the repair requires different actions in different physical states rather than a constant action preference. Define the conditions using the available observations, map those conditions through the network's activations, and check the signs and thresholds of your proposed numerical edits. You must determine the weights yourself.
Il modulo Cortex Code (CoCo) ha analizzato il fallimento e ha generato l’istruzione. Astra ha confrontato il suo bias costante con la descrizione della correzione degli autori, che introduce un percorso capace di leggere posizione e velocità dell’auto.
Che cosa ha cambiato la correzione dipendente dallo stato
Con l’istruzione aggiuntiva, Astra ha modificato 7 326 dei 171 664 pesi (4,3 %). L’auto ha avuto successo in tutti i 1 024 episodi, impiegando in media 91,9 passi per completare il compito. Per confronto, la modifica degli autori ha impiegato 73 passi e ha cambiato 6 073 pesi.
Astra ha iniziato diagnosticando il fallimento dai pesi e dall’episodio registrato:
The trace shows the resulting failure: it approaches the ramp correctly, but then repeatedly chooses off or positive drive while stalled astride the crest. Reverse is effectively absent.
Successivamente, ha definito condizioni basate su posizione orizzontale, velocità e posizione della ruota destra, instradandole attraverso quattro unità di embedding. In questo modo la politica ha imparato a fare retromarcia prima di accelerare quando la pista è pronta.
Poiché i LLM sono predittori probabilistici, non sorprende che il prompt originale non abbia funzionato al primo tentativo; fornire un indizio sul comportamento dipendente dallo stato è stato sufficiente per guidare Astra verso la soluzione corretta.
Come provare da sé
Il codice sorgente, i dati e i risultati completi sono disponibili nel repository Snowflake-Labs/weight-space-programming. Chiunque possieda un account Snowflake può utilizzare l’API Cortex per inviare il prompt, ricevere le modifiche e applicarle a una copia dei pesi.
Passi consigliati:
- Clonare il repository e installare le dipendenze Python.
- Recuperare i pesi originali della politica Kinetix (171 664 valori).
- Costruire il prompt completo (task, scena, episodio, pesi) – circa 352 k token.
- Inviare la richiesta a
openai-gpt-6-astratramite l’endpoint Cortex. - Utilizzare lo script
car_policy.pyper parsare le modifiche e aggiornare i pesi. - Eseguire la simulazione su 1 024 episodi per verificare i risultati.
Questa esperienza dimostra come, con un LLM sufficientemente potente, sia possibile “programmare” direttamente lo spazio dei pesi di una rete neurale, aprendo nuove prospettive per la personalizzazione rapida e a basso costo di modelli AI proprietari.