Geen resource, geen benchmarks, geen probleem? Evalueren en verbeteren van LLM's voor codegeneratie in resource-loze talen

Samenvatting

Grote taalmodellen (Large Language Models, LLM's) hebben de automatisering van software-engineeringtaken aanzienlijk verbeterd. Een prominent voorbeeld is codegeneratie, waarbij een LLM code in een gespecificeerde programmeertaal produceert op basis van een beschrijving in natuurlijke taal. Het meeste onderzoek op dit gebied richt zich op talen met veel resources, zoals Python of Java, die profiteren van overvloedige trainingsdata. Een kleiner aantal studies heeft laagbrontalen onderzocht, die ondervertegenwoordigd zijn in trainingscorpora. Daarentegen blijven nulbrontalen – talen waarvoor LLM's vrijwel geen trainingsdata hebben gezien – grotendeels onbestudeerd. Dergelijke talen komen vaak voor in de industrie, waar organisaties eigen of domeinspecifieke talen ontwikkelen die niet worden ondersteund door commerciële tools zoals GitHub Copilot. Dit leidt tot de noodzaak voor bedrijven om hun eigen interne code-aanbevelingssystemen in te zetten. Om mogelijke oplossingen in deze context te onderzoeken, bouwen en publiceren we drie codegeneratie-benchmarks voor nulbrontalen, gebaseerd op twee recent voorgestelde programmeertalen waarvoor zeer weinig trainingsdata beschikbaar zijn. Met behulp van deze benchmarks experimenteren we met verschillende oplossingen om LLM's te leren over nulbrontalen, waaronder prompt-gebaseerde technieken, evenals pre-training en fine-tuning met de weinige beschikbare data. Hoewel verdere pre-training de grootste prestatiewinst oplevert voor nulbrontalen, schaadt het direct toepassen ervan op instructie-getunede modellen hun vermogen om instructies op te volgen. Om dit aan te pakken, beginnen we met een basismodel, voeren we verdere pre-training uit op de doeltaal, en injecteren we vervolgens instructie-opvolgingsmogelijkheden via gewichtsverschiloverdracht (weight diff transfer) van een instructiemodel. Deze aanpak verbetert de codegeneratiecapaciteiten in nulbrontaalomgevingen aanzienlijk, waardoor bedrijven goedkoop een gespecialiseerd instructiemodel kunnen implementeren zonder de rekenkosten van instructie-fine-tuning te hoeven dragen.

English

Large Language Models (LLMs) have significantly advanced the automation of software engineering tasks. One prominent example is code generation, where an LLM produces code in a specified programming language based on a natural language description. Most research in this area has focused on high-resource languages, such as Python or Java, which benefit from abundant training data. A smaller body of work has explored low-resource languages, which are underrepresented in training corpora. In contrast, no-resource languages for which LLMs have seen virtually no training data remain largely unstudied. These languages often emerge in industry, where organizations develop proprietary or domain-specific languages unsupported by commercial tools like GitHub Copilot. This results in the need for companies to deploy their own in-house code recommenders. To investigate possible solutions in this context, we build and release three code generation benchmarks for no-resource languages, based on two recently proposed programming languages for which very little training data is available. Using these benchmarks, we experiment several solutions to teach LLMs about no-resource languages, including prompt-based techniques as well as pre-training and fine-tuning exploiting the little data available. While further pre-training gives the largest performance gains for no-resource languages, applying it directly to instruction-tuned models harms their ability to follow instructions. To address this, we start from a base model, further pre-training it on the target language, and then inject instruction-following capabilities via weight diff transfer from an instruction model. Such an approach significantly improves code generation capabilities in no-resource settings, allowing companies to cheaply deploy a specialized instruct model without dealing with the computational cost of instruction fine-tuning.