PROBE: Benchmarking Code Generation in Large Language Models
Het artikel introduceert PROBE, een uitgebreid benchmarkframework dat codegeneratie in Large Language Models evalueert op het gebied van functionele correctheid, oplossingsproximiteit en codekwaliteit, waarbij wordt onthuld dat modellen weliswaar veelbelovend zijn, maar vaak moeite hebben met complexe problemen, onderbediende talen en fundamentele fouten.
Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer
Stel je voor dat je een robot leert koken. Je wilt niet alleen dat de robot een recept volgt; je wilt dat de robot begrijpt waarom de ingrediënten bij elkaar passen, dat de robot het gerecht proeft en weet of het zout genoeg is, en dat de robot ervoor zorgt dat de keuken niet per ongeluk in brand vliegt. Dit is de wereld van Large Language Models (LLMs) in software engineering. Denk aan deze modellen als superintelligente robots die bijna elk kookboek (code) hebben gelezen dat ooit geschreven is. Ze kunnen naar een beschrijving zoals "maak een broodje" kijken en direct de instructies (code) schrijven om het te doen. Maar hier is de adder onder het gras: alleen omdat een robot instructies kan schrijven, betekent het niet dat het broodje lekker zal smaken, of dat de instructies je niet zullen vertellen om een kettingzaag te gebruiken in plaats van een mes. Wetenschappers geven er veel om omdat, naarmate we deze robots meer van onze software laten schrijven, we moeten weten of ze daadwerkelijk betrouwbaar zijn of dat ze gewoon gokken en hopen op het beste.
Maak kennis met PROBE, een nieuwe, supergeorganiseerde "smaaktest" voor deze code-schrijvende robots. Vóór dit moment waren de meeste tests een beetje alsof je een robot vroeg: "Heb je het broodje gemaakt?" en alleen controleerde of de robot "Ja" zei. Als het broodje verbrand was of geen brood had, maakte de test het niet uit, zolang de robot maar beweerde dat het klaar was. De onderzoekers achter PROBE realiseerden zich dat dit niet eerlijk was. Ze bouwden een veel strenger, kleurrijker evaluatiesysteem dat drie dingen controleert: Werkt de code daadwerkelijk (Functionele Correctheid)? Hoe dicht kwam het recept van de robot bij een perfect menselijk recept (Nabijheid)? En was de code rommelig of elegant (Codekwaliteit)?
Het team liet zes verschillende robots — sommige klein en open-source, andere groot en propriëtair — hun kunnen tonen in vijf verschillende "talen" (Python, C++, Java, C en Rust). Ze probeerden drie verschillende manieren om met de robots te communiceren: alleen een opdracht geven, eerst één voorbeeld laten zien, of de robot laten proberen, falen, en vervolgens zijn fouten laten herstellen op basis van foutmeldingen.
Dit is wat ze vonden, en het is een mix van opwindende vooruitgang en sommige zeer grappige, zeer menselijke fouten. Ten eerste presteerden de grotere robots over het algemeen beter, maar zelfs de slimste waren niet perfect. Ze losten ongeveer 70% van de makkelijke problemen op, maar hadden grote moeite met de moeilijke. Ten tweede hielp het laten zien van een voorbeeld vooraf (een techniek genaamd "In-Context Learning") nauwelijks; het was alsof je een chef een foto van een broodje liet zien voordat je hem vroeg er een te maken; hij wist al hoe hij dat moest doen, dus de foto veranderde niet veel. Het laten proberen, falen en vervolgens de foutmelding geven om het te herstellen (Feedback Incorporation) was echter een gamechanger. Het hielp de robots om eenvoudige fouten te herstellen, zoals het vergeten te importeren van een hulpmiddel, en verhoogde hun succespercentage met ongeveer 5%.
Maar het echte verhaal zit in de fouten. De robots faalden vaak op manieren die verrassend basaal waren. Ze probeerden huizen te bouwen met te veel stenen (geheugenfouten), vergaten de sleutels van de deur mee te nemen (ontbrekende imports) of kwamen vast te zitten in een lus terwijl ze probeerden elk zandkorreltje op een strand te tellen (inefficiënte algoritmen). Eén robot probeerde zelfs een getal te berekenen dat zo groot was dat het systeem in paniek raakte, net als een rekenmachine die kapot gaat wanneer je deelt door nul. Interessant genoeg waren de robots geweldig in Python, maar verschrikkelijk in Rust, een taal die erg strikt is over veiligheid, wat suggereert dat ze nog niet genoeg "Rust-kookboeken" hebben gelezen.
Het belangrijkste is dat de onderzoekers ontdekten dat zelfs wanneer de robots de code werkend kregen, de code vaak eenvoudiger en korter was dan wat een mens zou schrijven. Hoewel dat goed klinkt, betekende het soms dat de robots sluiproutes namen die in de echte wereld niet zouden standhouden. De studie concludeert dat hoewel deze AI-tools beter worden, ze nog steeds vatbaar zijn voor domme, vermijdbare fouten. Ze zijn nog niet klaar om alleen in de keuken achtergelaten te worden; ze hebben een menselijke chef nodig om het recept te controleren voordat het aan de wereld wordt geserveerd.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.