On the Effectiveness of Context Compression for Repository-Level Tasks: An Empirical Investigation

Probleemstelling

Large Language Models (LLMs) worden steeds vaker ingezet voor repository-level code-intelligentie taken, zoals het voltooien van code over meerdere bestanden heen en projectbewuste codegeneratie. Deze taken vereisen dat modellen lange, heterogene contexten verwerken die complexe afhankelijkheden tussen bestanden omvatten. Dit introduceert drie praktische uitdagingen:

1. Informatie-overbelasting: Cruciale context kan worden verdoezeld door ruis (zoals boilerplate-code) in lange bestanden, een fenomeen bekend als "lost in the middle".
2. Contextlimieten: De input kan de beperkte contextvensters van modellen overschrijden, wat leidt tot truncatie (afkappen) van belangrijke informatie.
3. Efficiëntie: De inferentiekosten en latentie groeien kwadratisch met de contextlengte vanwege de zelf-attentie-mechanismen, wat de schaalbaarheid beperkt.

Contextcompressie biedt een oplossing door lange inputs te comprimeren tot compacte surrogaten. Hoewel dit veel onderzoek heeft opgeleverd voor natuurlijke taal (NLP), is de toepasbaarheid op code-taken, waar syntactische structuren strikter zijn en cross-file afhankelijkheden kritiek zijn, nog grotendeels onontgonnen terrein.

Methodologie

De auteurs voeren het eerste systematische empirische onderzoek uit naar contextcompressie voor repository-level code. Ze organiseren acht representatieve methoden in drie paradigma's, gebaseerd op de representatieruimte van de output:

1. Text-to-Text (T2T):
   • Principe: Genereert een kortere, discrete tokenreeks door filtering, herschrijven of herordening van tokens.
   • Methoden: LLMLingua, LongLLMLingua, LLMLingua-2.
   • Mechanisme: Gebruikt een "score-and-select" mechanisme (vaak gebaseerd op perplexiteit) om tokens te verwijderen. Het is model-agnostisch en vereist geen training van het compressiemodule.
2. Text-to-Vector (T2V):
   • Principe: Encodeert de context in een compacte set continue latente vectoren (geheugentokens).
   • Methoden: Varianten zoals ICAE, gist-tokens en 500xCompressor. De auteurs evalueren combinaties van geheugenorganisatie (lokaal vs. context-gepropageerd) en extractiemechanismen (zelf-attentie vs. query-gedreven).
   • Mechanisme: Een lichtgewicht encoder (vaak LoRA) wordt getraind om de context te comprimeren tot een vaste grootte, terwijl de downstream LLM decoder bevroren blijft.
3. Text-to-Image (T2I):
   • Principe: Rendert de code als een afbeelding die wordt verwerkt door een Vision-Language Model (VLM).
   • Methoden: Rendering pipelines die code omzetten in rasterafbeeldingen.
   • Mechanisme: Benut de hogere informatiedichtheid van visuele modaliëteit. De compressie wordt gestuurd door de resolutie van de afbeelding, niet door token-filtering.

Experimenteel Opzet:

• Modellen: Qwen2.5-Coder (3B en 7B) voor T2V en T2T; Qwen2.5-VL (3B en 7B) voor T2I.
• Taken: Codegeneratie (synthese van een functie) en Codevoltooiing (voorspellen van ontbrekende code).
• Dataset: ComplexCodeEval (Java en Python), met een focus op realistische repository-scenario's.
• Metrieken: BLEU, Edit Similarity (ES), Exact Match (EM), en doorvoersnelheid/latentie.

Belangrijkste Resultaten

1. Prestaties per Paradigma (RQ1)

• T2V (Text-to-Vector): Dit paradigma presteert verrassend goed en overtreft zelfs de volledige context. Bij een compressiefactor van 4x presteerde T2V op Python-voltooiing tot 28,3% beter (BLEU-score) dan de volledige context. De latente vectoren fungeren als een geleerde filter die ruis (boilerplate) onderdrukt en relevante signalen versterkt, in plaats van context simpelweg af te kappen.
• T2I (Text-to-Image): Presteert goed bij voltooiingstaken (lokaal syntactisch inzicht blijft behouden), maar degradeert sterk bij generatietaken. Bij generatie daalt de prestatie met tot 50,8% onder de volledige context, omdat uniforme rendering cross-file relaties en structurele details verliest.
• T2T (Text-to-Text): Werkt redelijk bij lichte compressie, maar faalt bij agressieve compressie. Perplexiteit-based pruning verwijdert vaak syntactisch kritieke tokens (zoals import statements in Python) die linguïstisch voorspelbaar zijn maar structureel essentieel. Dit leidt tot een prestatie die soms zelfs onder de "geen context" baseline zakt.

2. Invloed van Compressiefactor (RQ2)

• T2V: Toont een uitzonderlijke stabiliteit. De prestaties blijven hoog en zelfs boven de volledige context, ongeacht of de compressiefactor 4x of 128x is.
• T2I: Bereikt een piek bij 4x compressie voor voltooiing, maar degradeert daarna. Voor generatie is er geen verbetering ten opzichte van de volledige context, ongeacht de factor.
• T2T: De prestaties voor generatie dalen scherp en bereiken de "geen context" baseline al bij compressiefactoren van 7x tot 12x.

3. Efficiëntie en Resources (RQ3)

• Alle drie de paradigma's verminderen de inferentiekosten ten opzichte van volledige context.
• T2I biedt de grootste verbetering in doorvoersnelheid en latentie, met een reductie van tot 50% in end-to-end latentie bij hoge compressiefactoren.
• T2V heeft een stabiele, voorspelbare overhead en blijft aanzienlijk goedkoper dan volledige context, hoewel het een trainingsstap vereist.
• T2T benadert de kosten van inferentie zonder context bij hoge compressie, maar dan is de prestatie al ingestort.

Kernbijdragen

1. Eerste Systematische Studie: Dit is het eerste onderzoek dat contextcompressie systematisch toepast op repository-level code-taken, waarbij drie paradigma's en acht methoden worden vergeleken.
2. Supra-context Prestaties: Het bewijs dat compressie niet per se verliesend hoeft te zijn. T2V kan de prestaties van een model verbeteren ten opzichte van volledige context door ruis te filteren.
3. Deploymentsrichtlijnen: Het biedt actiegericht advies voor het kiezen van een strategie:
   • Gebruik T2V voor maximale prestaties en generatietaken (vereist training).
   • Gebruik T2I voor voltooiingstaken waar doorvoersnelheid cruciaal is en training niet mogelijk is (vereist VLM).
   • Gebruik T2T alleen voor lichte compressie op grote modellen, maar vermijd dit voor complexe generatietaken.

Betekenis en Conclusie

De studie concludeert dat contextcompressie een haalbare en potentieel prestatieverbeterende strategie is voor code-LLMs. Het onthult dat repository-context vaak overbodig is en dat slimme compressie (vooral via latente vectoren) de "signal-to-noise ratio" kan verbeteren.

De auteurs wijzen op specifieke uitdagingen voor toekomstig onderzoek:

• Perplexiteit-based scoring is niet optimaal voor code; er moeten programmeertaalspecifieke signalen (zoals AST-nodes) worden gebruikt.
• Visuele compressie moet "layout-aware" worden om belangrijke code-secties (zoals functiehandtekeningen) hogere resolutie te geven.
• De verschillen tussen programmeertalen (bijv. Python vs. Java) vereisen dat compressiestrategieën taalspecifiek worden ontworpen.

Kortom, contextcompressie is niet alleen een oplossing voor kostenreductie, maar kan een essentiële component worden voor het verbeteren van de kwaliteit van code-generatie in complexe, multi-file omgevingen.