Debugging code world models

1. Il Problema

I Code World Models (CWM) sono modelli linguistici addestrati a simulare l'esecuzione di programmi prevedendo lo stato esplicito del runtime dopo ogni comando eseguito. A differenza del ragionamento a catena di pensiero (Chain-of-Thought) in linguaggio naturale, i CWM utilizzano una modellazione del mondo basata sull'esecuzione per verificare internamente la correttezza del codice.

Nonostante i progressi significativi su benchmark di ingegneria software, rimangono poco chiari:

1. Le fonti esatte degli errori nei CWM.
2. La natura dei loro limiti, specialmente in scenari di esecuzione a lungo termine (long-horizon) e con dati complessi.
3. Se la supervisione densa (rivelare tutto lo stato ad ogni passo) risolva effettivamente le difficoltà di tracciamento dello stato tipiche dei modelli Transformer.

2. Metodologia

Gli autori hanno studiato i CWM attraverso due prospettive complementari: esecuzione semantica locale e tracciamento dello stato a lungo termine.

• Benchmark su Codice Reale: Valutazione su CruxEval-O e HumanEval per identificare i modi di fallimento dominanti.
• Composizione Funzionale Controllata: Creazione di un "Composition Zoo" con programmi deterministici a profondità variabile (fino a 5 livelli) su diversi tipi di dati (booleani, interi, liste, dizionari, stringhe). Questo permette di isolare l'effetto del tipo di dato mantenendo fissa la struttura del programma.
• Analisi della Tokenizzazione: Indagine su come la tokenizzazione a subword (BPE) influenzi la rappresentazione degli stati delle stringhe.
• Benchmark di Tracciamento a Lungo Termine (Code S5): Utilizzo di un benchmark controllato basato su gruppi di permutazioni ($S_n$) espressi come codice Python. I modelli devono tracciare lo stato dopo $N$ operazioni (da 8 a 128).
• Interventi di "Teacher Forcing": Per distinguere tra errori di generazione dell'azione (comando) e errori di aggiornamento dello stato, gli autori hanno sostituito i comandi generati dal modello con quelli "ground-truth" (corretti) e hanno valutato solo la capacità del modello di propagare lo stato.
• Decomposizione del Codice: Interventi sintattici per rendere espliciti i valori intermedi (es. decomporre espressioni complesse in variabili temporanee) per testare se gli errori derivano da stati intermedi nascosti.

3. Risultati Chiave

A. Regimi di Fallimento Dominanti

Sui benchmark reali, gli errori si concentrano in due aree principali:

1. Esaurimento del Budget di Token: Le tracce di esecuzione dense (che rivelano lo stato ad ogni passo) generano sequenze molto lunghe. Programmi con iterazioni profonde o manipolazione di stringhe per elemento esauriscono rapidamente il contesto del modello, portando a truncation (taglio) prima della fine dell'esecuzione.
2. Fragilità degli Stati a Valore Stringa: Gli errori sono sproporzionatamente concentrati nelle operazioni su stringhe.
   • Le stringhe rappresentano solo il 46% degli output in CruxEval-O, ma causano il 73% dei fallimenti.
   • In HumanEval, le stringhe sono il 17% degli output ma il 44% dei fallimenti.
   • Causa: Non è una limitazione della struttura del programma, ma della tokenizzazione. La discontinuità indotta dal BPE (es. un separatore come "-." che diventa un singolo token in isolamento ma si frammenta all'interno di una stringa più lunga) impedisce al modello di allineare correttamente le operazioni semantiche (es. rsplit, rfind) ai token di input.

B. Composizione Funzionale

• Dati Non-Stringa: I CWM raggiungono il 100% di accuratezza nella composizione di funzioni su booleani, bit, matematica, liste, insiemi e dizionari, anche a profondità 5.
• Dati Stringa: L'accuratezza crolla drasticamente con la profondità (dal 75% a profondità 2 al 25% a profondità 5), confermando che il collo di bottiglia è la rappresentazione delle stringhe, non la logica di esecuzione.

C. Tracciamento a Lungo Termine (Long-Horizon)

• Allucinazione delle Azioni vs. Propagazione dello Stato: Nel benchmark Code S5, le prestazioni peggiorano all'aumentare della lunghezza della sequenza. Tuttavia, l'analisi rivela che il fallimento è causato principalmente dall'allucinazione del comando successivo (es. generare uno scambio di variabili sbagliato).
• Teacher Forcing: Quando i comandi corretti vengono forzati (teacher forcing) e il modello deve solo prevedere lo stato risultante, i CWM basati su Transformer mantengono un'accuratezza del 90% anche a 128 passi.
• Conclusione: I Transformer possono propagare lo stato fedelmente su lunghi orizzonti se l'azione è corretta. La supervisione densa (stato completo ad ogni passo) compensa le limitazioni architetturali dei Transformer nel tracciamento dello stato, riducendo il problema a una serie di aggiornamenti locali supervisionati.

4. Contributi Principali

1. Diagnosi dei Fallimenti: Identificazione che i fallimenti dei CWM non sono dovuti a incapacità di ragionamento logico generale, ma a limiti specifici di rappresentazione (tokenizzazione delle stringhe) ed efficienza (budget di token).
2. Isolamento delle Cause: Dimostrazione che la fragilità delle stringhe è un problema di rappresentazione (tokenizzazione) e non semantica, e che i fallimenti a lungo termine sono guidati dall'errore di generazione dell'azione, non dalla perdita dello stato.
3. Validazione della Supervisione Densa: Conferma che la supervisione densa dello stato è un meccanismo potente che permette ai Transformer di simulare dinamiche complesse, ma a un costo computazionale elevato.
4. Interventi Diagnostici: Sviluppo di tecniche di decomposizione del codice per isolare gli errori legati alla visibilità degli stati intermedi.

5. Significato e Implicazioni Future

Il lavoro suggerisce che per scalare i Code World Models è necessario un ripensamento sia della supervisione che dell'architettura:

• Efficienza: La supervisione densa è troppo costosa in termini di token. Futuri agenti dovranno essere in grado di propagare lo stato con osservazioni più sparsa (sparse observation).
• Architettura: Mentre i Transformer beneficiano della supervisione densa, architetture ricorrenti lineari o basate su spazi di stato (come Mamba o RNN lineari) potrebbero essere più adatte per il tracciamento dello stato a lungo termine con meno dati di supervisione.
• Rappresentazione: È necessario abbandonare o migliorare la tokenizzazione a subword per i task di esecuzione del codice, adottando approcci a livello di byte o token-free per evitare la fragilità semantica delle stringhe.

In sintesi, il paper dimostra che i CWM sono potenti simulatori quando l'azione è corretta e lo stato è ben rappresentato, ma la loro scalabilità è attualmente limitata dalla tokenizzazione delle stringhe e dal costo computazionale delle tracce di esecuzione dense.