CodeMonkeys: Schalen van testtijd berekeningen voor software engineering

CodeMonkeys: Scaling Test-Time Compute for Software Engineering

January 24, 2025

Auteurs: Ryan Ehrlich, Bradley Brown, Jordan Juravsky, Ronald Clark, Christopher Ré, Azalia Mirhoseini

cs.AI

Samenvatting

Het schalen van testtijd berekeningen is een veelbelovende aanpak om de mogelijkheden van LLM's te verbeteren. Echter, testtijd berekeningen kunnen op verschillende manieren worden geschaald, en het effectief combineren van verschillende benaderingen blijft een actief onderzoeksgebied. Hier verkennen we dit probleem in de context van het oplossen van echte GitHub problemen uit de SWE-bench dataset. Ons systeem, genaamd CodeMonkeys, stelt modellen in staat om iteratief een codebase te bewerken door gezamenlijk een testscript te genereren en uit te voeren naast hun conceptbewerking. We nemen veel van deze multi-turn trajecten voor elk probleem om een verzameling kandidaatbewerkingen te genereren. Deze aanpak stelt ons in staat om "seriële" testtijd berekeningen te schalen door het aantal iteraties per traject te verhogen en "parallelle" testtijd berekeningen te schalen door het aantal trajecten per probleem te verhogen. Met parallelle schaling kunnen we de initiële kosten verdelen over meerdere downstream monsters, waardoor we relevante codebase-context kunnen identificeren door een LLM elk bestand te laten lezen. Om tussen kandidaatbewerkingen te selecteren, combineren we stemmen met behulp van door het model gegenereerde tests met een uiteindelijke multi-turn traject dat is gewijd aan selectie. Over het algemeen lost CodeMonkeys 57,4% van de problemen van SWE-bench Verified op met een budget van ongeveer 2300 USD. Onze selectiemethode kan ook worden gebruikt om kandidaten van verschillende bronnen te combineren. Door te selecteren uit een ensemble van bewerkingen van bestaande top SWE-bench Verified inzendingen behalen we een score van 66,2% en presteren we beter dan het beste lid van het ensemble op zichzelf. We publiceren onze code en gegevens volledig op https://scalingintelligence.stanford.edu/pubs/codemonkeys.

English

Scaling test-time compute is a promising axis for improving LLM capabilities. However, test-time compute can be scaled in a variety of ways, and effectively combining different approaches remains an active area of research. Here, we explore this problem in the context of solving real-world GitHub issues from the SWE-bench dataset. Our system, named CodeMonkeys, allows models to iteratively edit a codebase by jointly generating and running a testing script alongside their draft edit. We sample many of these multi-turn trajectories for every issue to generate a collection of candidate edits. This approach lets us scale "serial" test-time compute by increasing the number of iterations per trajectory and "parallel" test-time compute by increasing the number of trajectories per problem. With parallel scaling, we can amortize up-front costs across multiple downstream samples, allowing us to identify relevant codebase context using the simple method of letting an LLM read every file. In order to select between candidate edits, we combine voting using model-generated tests with a final multi-turn trajectory dedicated to selection. Overall, CodeMonkeys resolves 57.4% of issues from SWE-bench Verified using a budget of approximately 2300 USD. Our selection method can also be used to combine candidates from different sources. Selecting over an ensemble of edits from existing top SWE-bench Verified submissions obtains a score of 66.2% and outperforms the best member of the ensemble on its own. We fully release our code and data at https://scalingintelligence.stanford.edu/pubs/codemonkeys.