RepoExec: Un Nuovo Benchmark per i Modelli di Generazione del Codice

La generazione di codice è diventata un'area importante nello sviluppo software, soprattutto con l'aumento dei grandi modelli di linguaggio (LLM) che aiutano ad automatizzare i compiti di codifica. Tuttavia, la capacità di questi modelli di generare codice completo e funzionante per un intero progetto non è stata testata ampiamente. Questo articolo presenta un nuovo benchmark chiamato RepoExec, che ha l'obiettivo di valutare quanto bene i modelli di generazione di codice possano creare codice eseguibile e corretto a livello di repository.

#Sfide nella Generazione di Codice

Molti benchmark esistenti si concentrano sulla generazione di codice per singole funzioni piuttosto che considerare come queste funzioni lavorino insieme in un progetto. Questa limitazione può portare a codice generato che non è allineato con il modo in cui l'intero codice dovrebbe funzionare. I modelli di generazione di codice spesso perdono contesto importante da file correlati, il che può portare a output inaccurati o incompleti.

Per comprendere le vere capacità di questi modelli, dobbiamo valutarli sulla generazione di codice a livello di repository, concentrandoci su tre aspetti chiave:

1. Eseguibilità: Il codice generato non deve solo essere corretto in termini di sintassi, ma deve anche funzionare correttamente in un ambiente reale.
2. Correttezza Funzionale: Il codice generato deve soddisfare i requisiti specificati nel progetto, dimostrato attraverso test che coprono una vasta gamma di scenari.
3. Uso delle dipendenze: I modelli devono tenere conto accuratamente delle dipendenze richieste dal codice, garantendo che utilizzino i contesti forniti in modo efficace.

#Benchmark Esistenti e Loro Limitazioni

I benchmark attuali come RepoBench, RepoCoder, CrossCodeEval, CoCoMIC e DevEval forniscono alcune informazioni sulle prestazioni della generazione di codice. Tuttavia, hanno evidenti carenze:

• Non garantiscono che il codice generato sia eseguibile in scenari reali.
• Spesso utilizzano metodi basilari per recuperare informazioni contestuali, risultando in dati "rumorosi" che possono danneggiare le prestazioni dei sistemi di generazione di codice.
• Non si concentrano su se il codice generato comprenda e incorpori correttamente le dipendenze fornite dagli sviluppatori.

#Introduzione di RepoExec

RepoExec è progettato per affrontare queste sfide fornendo una riflessione più accurata delle situazioni di codifica nel mondo reale. Il suo focus principale è su:

• Eseguibilità Migliorata: RepoExec verifica che il codice generato sia sintatticamente corretto e eseguibile in ambienti reali. Un sistema automatizzato controlla i requisiti di installazione e runtime.

• Generazione Dinamica di Casi di Test: RepoExec incorpora meccanismi avanzati per creare casi di test che garantiscano che il codice generato funzioni come previsto. Questi test sono personalizzati per abbinare la funzionalità del codice generato e mantenere un alto tasso di copertura.

• Valutazione dell'Uso delle Dipendenze: RepoExec valuta quanto bene i modelli gestiscono le dipendenze del codice, fornendo approfondimenti dettagliati su come queste dipendenze vengono utilizzate. Introduce anche un nuovo dataset che si concentra sulle chiamate di dipendenza, aiutando i modelli a imparare a sfruttarle correttamente.

Inoltre, RepoExec introduce una nuova metrica chiamata Tasso di Invocazione delle Dipendenze (DIR). Questa metrica misura quanto bene il codice generato incorpora le dipendenze fornite. Un punteggio DIR più alto indica che il modello comprende e utilizza le dipendenze in modo efficace.

#Esperimenti e Scoperte

Gli esperimenti condotti utilizzando RepoExec hanno rivelato importanti intuizioni sui modelli di generazione di codice. I risultati hanno mostrato che mentre alcuni modelli pre-addestrati potevano generare codice che funzionava correttamente, i modelli istruiti mostrano prestazioni più forti nella gestione delle dipendenze e nel debugging.

• I modelli pre-addestrati si sono distinti nella generazione di codice che superava i test iniziali, ma spesso faticavano a sfruttare le dipendenze.
• I modelli istruiti sono riusciti a includere le dipendenze in modo più efficace, ma a volte producevano codice eccessivamente complesso.

Test di debugging a più round hanno mostrato che modelli come GPT-3.5 e WizardCoder hanno migliorato significativamente le loro prestazioni dopo aver applicato questo metodo, migliorando sia la correttezza del loro codice che la loro capacità di utilizzare le dipendenze.

#Il Processo di Raccolta Dati

Per costruire RepoExec, è stata stabilita una pipeline di raccolta dati sistematica. Questo processo si è concentrato sull'assicurarsi che i repository potessero essere impostati per ambienti eseguibili, essenziale per una vera valutazione.

1. Estrazione di Funzioni e Dipendenze: Il repository viene analizzato per estrarre funzioni ritenute adatte per la generazione di codice a livello. Uno strumento chiamato tree-sitter viene utilizzato per suddividere i file e identificare funzioni e le loro dipendenze.

2. Generazione di Casi di Test: Dato che molti repository non hanno test sufficienti, vengono utilizzati LLM automatizzati per creare casi di test. Questi test generati vengono filtrati per correttezza e rilevanza sulla base di vari criteri, assicurando che valutino accuratamente la funzionalità del codice generato.

#Valutazione delle Prestazioni del Modello

RepoExec utilizza due tipi di prompt per valutare i modelli, variando la quantità di informazioni contestuali fornite:

• BasePrompt: Questo include tutto il contesto e le dipendenze disponibili, permettendo al modello di utilizzare tutte le informazioni complete dal repository.

• InstructPrompt: Questo formato include istruzioni specifiche per i modelli, progettate per guidarli nella generazione di codice in modo efficace.

Nella valutazione di diversi modelli come Codellama, è stato riscontrato che mantenere il contesto completo ha portato alle migliori prestazioni. Tuttavia, l'utilizzo di contesti più piccoli ha talvolta portato a risultati migliori perché riduceva la confusione nell'interpretazione delle dipendenze.

#Risultati tra Diversi Modelli

RepoExec è stato testato su 13 diversi modelli di generazione di codice. I risultati hanno svelato una scoperta critica: mentre i modelli fondazionali hanno ottenuto alta accuratezza, i modelli istruiti hanno eccelso nella gestione efficace delle dipendenze. Tuttavia, entrambi i tipi di modelli avevano limitazioni:

• I modelli istruiti producevano frequentemente implementazioni eccessivamente complesse e non sfruttavano sempre correttamente le dipendenze.
• I modelli pre-addestrati generavano spesso output corretti ma non riutilizzavano le dipendenze fornite, portando a codice ridondante.

Questi risultati suggeriscono che i modelli potrebbero avere difficoltà a produrre codice di alta qualità, richiedendo una revisione manuale e correzione sostanziali.

#Utilizzo del Debugging a Più Round

Per migliorare ulteriormente la qualità del codice generato, è stato impiegato un debugging a più round. Questo comporta l'esecuzione ripetuta di codice precedentemente generato più volte, analizzando i log degli errori e correggendo gli errori. Nei test, GPT-3.5 e WizardCoder hanno mostrato miglioramenti promettenti sia nella correttezza che nell'utilizzo delle dipendenze dopo tre round di debugging.

#Istruzione-Tuning per Migliorare le Prestazioni

Per facilitare un migliore utilizzo delle dipendenze e migliorare la correttezza degli output, è stato sviluppato un dataset di istruzione-tuning. Questo dataset è stato creato da repository di codice popolari e includeva un numero significativo di funzioni e delle loro dipendenze.

Il fine-tuning su questo dataset ha portato a miglioramenti notevoli nelle prestazioni del modello. Dopo il tuning delle istruzioni, i modelli hanno dimostrato migliori tassi di successo e DIR, indicando una comprensione più forte nella gestione delle dipendenze e della funzionalità.

#Conclusione e Lavori Futuri

RepoExec si dimostra uno strumento prezioso per valutare le prestazioni dei modelli di generazione di codice a livello di repository. Concentrandosi su eseguibilità, correttezza funzionale e utilizzo delle dipendenze, offre una rappresentazione più accurata dei compiti di codifica nel mondo reale.

Sebbene i modelli pre-addestrati eccellano nella generazione di codice corretto, i modelli istruiti mostrano potenziale nella comprensione delle dipendenze, sebbene con alcune sfide. I lavori futuri possono concentrarsi ulteriormente sul perfezionamento di questi modelli, magari integrando più livelli di contesti di dipendenze per migliorare la loro comprensione delle interazioni software complesse.

Man mano che il campo della generazione di codice evolve, benchmark come RepoExec possono guidare lo sviluppo di modelli più capaci, assicurandosi che soddisfino le esigenze dello sviluppo software reale.