Riepilogo Tecnico: Valutazione del Fine-Tuning e delle Metriche per la Decompilazione Neurale di Binari Dart AOT

1. Definizione del Problema

La decompilazione neurale, ovvero il compito di tradurre il codice macchina nuovamente in codice sorgente ad alto livello, si è tradizionalmente concentrata su target C e C++. Tuttavia, linguaggi di programmazione moderni come Dart (utilizzato in Flutter) presentano sfide uniche a causa delle loro pipeline di compilazione Ahead-of-Time (AOT), che applicano ottimizzazioni aggressive come la specializzazione dei tipi, l'inlining delle funzioni e l'eliminazione del codice morto. Queste ottimizzazioni eliminano informazioni semantiche di alto livello, rendendo l'assembly x86-64 risultante significativamente più difficile da invertire rispetto a un C non ottimizzato.

Inoltre, la metodologia di valutazione per la decompilazione neurale rimane poco sviluppata. Gli studi precedenti si affidano spesso a metriche superficiali come CodeBLEU o tassi di successo della compilazione, che potrebbero non correlare con la correttezza funzionale. Esiste una lacuna critica nella comprensione se il fine-tuning di Large Language Models (LLM) su coppie assembly-sorgente migliori effettivamente la correttezza funzionale, come il training cross-lingua influenzi le prestazioni e se le metriche di valutazione standard predicano in modo affidabile l'utilità del codice decompilato.

2. Metodologia

2.1 Costruzione del Dataset

Gli autori hanno costruito un nuovo benchmark, HumanEval-Dart, composto da 154 funzioni Dart adattate dal benchmark HumanEval, ciascuna dotata di suite complete di unit test.

• Dati Naturali: 246 funzioni Dart provenienti da RosettaCode.
• Dati Sintetici: 948 coppie funzione Dart e Swift sintetiche generate da molteplici LLM (GPT-4, Claude, DeepSeek, Qwen).
• Corrispondenza dei Token: Per isolare l'effetto della scelta del linguaggio dal volume dei dati, gli autori hanno creato due dataset di training con conteggi di token corrispondenti entro il 2%:
  1. Dart+Synthetic: 1.194 coppie assembly–Dart.
  2. Dart+Swift: 1.000 coppie assembly–sorgente (246 Dart + 754 Swift).
• Nota sull'Ottimizzazione: I dati di training di Dart utilizzavano binari ottimizzati AOT, mentre i dati Swift utilizzavano binari non ottimizzati (-O0), introducendo un noto fattore di confondimento riguardo ai livelli di ottimizzazione.

2.2 Design Sperimentale

Lo studio ha impiegato un design fattoriale $3 \times 2$, effettuando il fine-tuning di sei varianti di modello su tre architetture base:

1. Qwen3-4B (4B di parametri)
2. DeepSeek-R1-0528-Qwen3-8B (8B di parametri, distillazione del ragionamento)
3. Qwen3-8B (8B di parametri, pre-training standard)

Ogni modello base è stato sottoposto a fine-tuning utilizzando LoRA con DoRA (Weight-Decomposed Low-Rank Adaptation) sia sui dataset Dart+Synthetic che Dart+Swift.

2.3 Metriche di Valutazione

Lo studio ha valutato i modelli utilizzando tre metriche complementari:

1. CodeBLEU: Similarità semantica (corrispondenza n-gram, AST e data-flow). È stata sviluppata un'implementazione custom di Dart.
2. compile@k: Validità sintattica (proporzione di output generati che compilano).
3. pass@k: Correttezza funzionale (probabilità che almeno uno di $k$ output superi tutti gli unit test), calcolata utilizzando lo stimatore non distorto.

2.4 Analisi Statistica

Gli autori hanno applicato test statistici accoppiati rigorosi per confrontare le varianti sottoposte a fine-tuning con i rispettivi modelli base:

• Test esatto di McNemar per esiti binari pass@1 (risolto vs non risolto).
• Intervalli di confidenza Bootstrap per le differenze medie.
• Test dei ranghi con segno di Wilcoxon e t-test per le metriche continue.

3. Risultati Chiave

3.1 Efficacia del Fine-Tuning (RQ1)

Contrariamente all'ipotesi che il fine-tuning migliori le prestazioni, nessuna configurazione di fine-tuning ha prodotto un miglioramento statisticamente significativo nel pass@k.

• Qwen3-8B (Base più forte): Il fine-tuning ha causato una regressione altamente significativa. La variante Dart+Synthetic (v5) è scesa dal 6,36% allo 0,71% di pass@1 ($p < 0,001$), perdendo 22 task e non guadrandone nessuno. La variante Dart+Swift (v6) ha mostrato un calo catastrofico simile.
• Qwen3-4B (Base più debole): La variante Dart+Synthetic (v1) ha mostrato un trend direzionalmente positivo ma non significativo (+0,71 pp, $p=0,21$).
• DeepSeek-R1-8B: Ha mostrato nessun cambiamento significativo, con una leggera regressione non significativa.

3.2 Interferenza Cross-Lingua (RQ2 & RQ3)

Lo studio ha indagato se l'addestramento su codice Swift interferisca con la decompilazione di Dart.

• Interferenza dipendente dalla scala: A 4B, l'aggiunta di dati di training Swift ha causato una degradazione significativa del pass@k di Dart ($\Delta = -2,66$ pp, $p < 0,001$).
• Ipotesi di Scaling: A 8B, questa interferenza è diventata statisticamente indistinguibile da zero. Tuttavia, gli autori notano che ciò è complicato dal fatto che entrambi i varianti 8B hanno subito regressioni massicce a causa del fine-tuning stesso, rendendo meno significativa l' "equivalenza" tra i due modelli degradati.

3.3 Divergenza delle Metriche (RQ4)

Un risultato critico è la divergenza tra le metriche superficiali e la correttezza funzionale.

• Caso di studio (v3): La variante DeepSeek-R1-8B addestrata su Dart+Synthetic ha mostrato miglioramenti significativi in CodeBLEU (+0,051, $p=0,001$) e compile@1 (+16 pp). Tuttavia, il suo pass@1 è regredito (dal 3,90% al 3,12%), sebbene non in modo significativo.
• Caso di studio (v5): La variante Qwen3-8B ha mostrato un massiccio crollo nel pass@1 (dal 6,36% allo 0,71%) mentre CodeBLEU e compile@k sono rimasti relativamente stabili o hanno mostrato solo modesti declini.
• Conclusione: I modelli possono imparare a produrre codice sintatticamente valido e superficialmente simile (alto CodeBLEU) pur fallendo nel catturare la logica sottostante necessaria per l'esecuzione funzionale.

3.4 Analisi degli Errori e della Complessità

• Lunghezza dell'Assembly: Il predittore più forte della difficoltà del task è stato la lunghezza della sequenza assembly ($p=0,001$). Esiste un "cliff di capacità" a circa 200 istruzioni; la risolvibilità scende dal 48% per i task <50 righe al 6% per i task >200 righe.
• Metriche Tradizionali: Le metriche di complessità del codice tradizionale (complessità ciclomatica, profondità di annidamento) hanno mostrato un potere predittivo trascurabile.
• Trade-off: Il fine-tuning a 4B di parametri sembrava scambiare l' "ampiezza" con l' "affidabilità". Il modello fine-tuned (v1) è diventato più affidabile su sequenze assembly brevi e semplici, ma ha perso la capacità di risolvere task complessi che il modello base occasionalmente risolveva tramite ragionamento generale stocastico.

4. Contributi

1. Benchmark HumanEval-Dart: Un nuovo benchmark di 154 funzioni Dart con unit test per valutare la correttezza funzionale nella decompilazione.
2. Implementazione Dart CodeBLEU: Un'implementazione specifica per il linguaggio di CodeBLEU con analisi AST e data-flow per Dart.
3. Evidenza Empirica sul Fine-Tuning: Uno studio sistematico che dimostra che il fine-tuning specifico per task su modelli di medie dimensioni (4B–8B) non garantisce il miglioramento delle prestazioni e può causare regressioni significative, specialmente nei modelli base più forti.
4. Dimostrazione della Divergenza delle Metriche: Evidenza che CodeBLEU e compile@k possono migliorare mentre il pass@k regredisce, sfidando l'affidamento sulle metriche superficiali nei compiti di generazione di codice.
5. Analisi Cross-Lingua: Evidenza controllata che l'interferenza cross-lingua è significativa su scale minori e si attenua con la capacità del modello, sebbene confusa da mismatch di ottimizzazione.

5. Significato e Affermazioni

Il paper si posiziona come un'analisi sistematica della metodologia di valutazione e dell'efficacia del fine-tuning piuttosto che come un sistema di decompilazione pronto per l'uso. Gli autori sottolineano che i numeri assoluti di pass@k rimangono bassi in tutti i modelli, inclusi i sistemi commerciali (Qwen3-Max: 18,38% pass@1).

La significatività primaria risiede nelle scoperte cautelative:

• Rifiuto delle Metriche Superficiali: Lo studio sostiene che CodeBLEU e compile@k siano insufficienti come proxy per la correttezza funzionale nella decompilazione. Un modello può apparire in miglioramento sulle metriche superficiali pur diventando funzionalmente inutile.
• Fine-Tuning Dipendente dalla Capacità: Gli autori propongono un'ipotesi (non una legge confermata) secondo cui il fine-tuning può sovrascrivere preziose capacità di ragionamento generale nei modelli più forti, portando a una regressione catastrofica, mentre può avere effetti neutri o leggermente positivi sui modelli più deboli.
• Protocollo di Valutazione: Il paper raccomanda il pass@k con unit test come metrica primaria per la decompilazione neurale e i compiti di generazione di codice dove la correttezza funzionale è fondamentale.

Gli autori dichiarano esplicitamente che le loro scoperte sulla "tendenza dipendente dalla capacità" si basano su tre architetture e una configurazione di iperparametri, inquadrandole come osservazioni che generano ipotesi piuttosto che leggi di scaling definitive. Riconoscono inoltre il limite dei mismatch di ottimizzazione nei loro esperimenti cross-lingua, notando che futuri lavori con dataset con ottimizzazione corrispondente sono necessari per isolare l'interferenza linguistica dai cambiamenti distribuzionali.