Code Fingerprints: Disentangled Attribution of LLM-Generated Code

Dit paper introduceert het Disentangled Code Attribution Network (DCAN), een methode die de bron van door verschillende grote taalmodellen gegenereerde code kan identificeren door semantische inhoud te ontkoppelen van model-specifieke stijlelementen, ondersteund door een nieuw groot dataset-benchmark.

De kern

Stel je voor dat je een brief hebt ontvangen, maar je weet niet wie hem heeft geschreven. Is het een vriend, een collega, of misschien een robot? In de wereld van computerschrijven (coderen) gebeurt dit steeds vaker. Grote kunstmatige intelligentie (AI), zoals ChatGPT of Claude, schrijft nu steeds meer computercode.

Dit is geweldig, maar het creëert een nieuw probleem: Wie heeft deze code eigenlijk geschreven? Als er een fout in zit, of als iemand illegaal code gebruikt, moeten we weten welk AI-model het heeft gemaakt.

De auteurs van dit paper hebben een slimme oplossing bedacht, genaamd DCAN. Laten we het uitleggen alsof we een detectiveverhaal vertellen.

1. Het Probleem: De "Stijl" van de AI

Elk AI-model heeft zijn eigen "handtekening", net zoals mensen.

• De ene AI schrijft lange, gedetailleerde zinnen.
• De andere is kort en krachtig.
• De ene gebruikt specifieke namen voor variabelen (zoals gebruiker_id), terwijl de andere user_id gebruikt.
• De ene maakt veel commentaar (uitleg in de code), de andere niet.

Het probleem is dat als je kijkt naar wat de code doet (bijvoorbeeld: "bereken de som van twee getallen"), alle AI's dat op vrijwel dezelfde manier doen. Dat is de taak. Maar hoe ze het doen, is hun stijl.

Tot nu toe waren de methoden om AI te herkennen te simpel. Ze keken naar alles door elkaar, waardoor de unieke "stijl" van de AI verdween in de ruis van de "taak".

2. De Oplossing: De "Ontkoppelende" Detective

De auteurs van dit paper hebben een systeem gebouwd dat werkt als een slimme detective die twee dingen van elkaar scheidt:

1. De Taak (Wat er gebeurt): Dit is hetzelfde voor iedereen. Als je een taak hebt om een ladder te bouwen, bouwen een mens, een robot en een AI allemaal een ladder. Dit noemen ze Source-Agnostic (onafhankelijk van de bron).
2. De Stijl (Hoe het eruitziet): Dit is de unieke handtekening. Gebruikt de AI veel haakjes? Is de code netjes ingesprongen? Schrijft hij lange uitlegteksten? Dit noemen ze Source-Specific (afhankelijk van de bron).

De Creatieve Analogie: De Koffie en de Melk
Stel je voor dat elke code een kop koffie is.

• De koffie is de taak (bijv. "maak een rekenmachine"). Alle AI's maken koffie.
• De melk en suiker zijn de stijl van de AI.
  • ChatGPT giet misschien veel melk erbij.
  • Claude gebruikt een heel specifieke suikerdosering.
  • DeepSeek schudt de kop eerst even.

Vroeger keken de detectives naar de hele kop koffie en probeerden ze te raden wie het was. Dat was lastig, want de koffie smaakt voor iedereen ongeveer hetzelfde.

DCAN doet iets anders: Het heeft een magisch filter (een "Disentanglement Module"). Dit filter scheidt de koffie van de melk.

• Het filtert de "koffie" (de taak) eruit en legt die apart.
• Wat overblijft is puur de "melk en suiker" (de stijl).
• Vervolgens kijkt de detective alleen naar die melk en suiker om te zeggen: "Aha! Dit is zeker van ChatGPT, want die gebruikt altijd zoveel melk!"

3. Wat hebben ze gedaan? (Het Experiment)

Om dit te bewijzen, hebben de onderzoekers een gigantische database gemaakt.

• Ze hebben 4 populaire AI's (DeepSeek, Claude, Qwen, ChatGPT) gevraagd om 2.800 verschillende programmeertaken op te lossen.
• Ze lieten ze dit doen in 4 verschillende programmeertalen (Python, Java, C, Go).
• Ze deden dit op twee manieren: met uitlegteksten in de code en zonder.

In totaal hadden ze 91.804 stukjes code om op te analyseren.

4. De Resultaten: Het Werkt!

Het systeem (DCAN) was verrassend goed:

• Herkennen: Het kon met bijna 93% zekerheid zeggen welke AI de code had geschreven, zelfs als er geen uitlegteksten in stonden.
• Met uitleg: Als de AI's ook uitlegteksten (comments) schreven, steeg de zekerheid naar 98%. De manier waarop AI's uitleggen, is een nog sterkere vingerafdruk dan de code zelf.
• Moeilijkheid: Het systeem werd zelfs beter bij moeilijke taken. Bij simpele taken doen alle AI's ongeveer hetzelfde. Bij moeilijke taken moeten ze creatiever zijn, en dan komen hun unieke stijleigenschappen sterker naar voren.
• Talen: Het systeem werkt zelfs als je het traint op Python en het laat testen op Java. De "stijl" van de AI (bijv. "ik hou van lange zinnen") blijft hetzelfde, ongeacht de programmeertaal.

5. Waarom is dit belangrijk?

Dit is niet alleen een leuk trucje. Het heeft grote gevolgen voor de toekomst:

• Veiligheid: Als er een gevaarlijke fout in een stukje AI-code zit, weten we nu welk model het heeft gemaakt. Misschien moet dat model dan worden bijgesteld.
• Aansprakelijkheid: Als een bedrijf claimt dat ze zelf code hebben geschreven, maar het blijkt van een AI te zijn, kunnen we het bewijzen.
• Licenties: We kunnen controleren of AI-code per ongeluk auteursrechtelijk beschermde code bevat die door een specifiek model is gegenereerd.

Kortom:
De onderzoekers hebben een manier gevonden om de "ziel" van een AI (zijn unieke schrijfstijl) te scheiden van het "werk" (de code die het moet doen). Hierdoor kunnen we als detectives de echte maker van een stukje code altijd vinden, zelfs als de code perfect werkt. Het is alsof we eindelijk een vingerafdrukscanner hebben voor digitale schrijvers.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "Code Fingerprints: Disentangled Attribution of LLM-Generated Code", geschreven in het Nederlands.

Titel: Code Fingerprints: Ontkoppelde Toewijzing van door LLM's gegenereerde Code

1. Probleemstelling

De snelle adoptie van Large Language Models (LLM's) heeft de softwareontwikkeling getransformeerd door geautomatiseerde codegeneratie mogelijk te maken. Hoewel dit de productiviteit verhoogt, introduceert het nieuwe uitdagingen op het gebied van softwaregovernance, verantwoordingsplicht en naleving van licenties.

• Huidige situatie: Bestaand onderzoek focust voornamelijk op het onderscheid tussen door mensen geschreven code en door machines gegenereerde code.
• Het gat: Veel praktische scenario's (zoals het opsporen van kwetsbaarheden, incidentonderzoek en licentieaudits) vereisen niet alleen weten dat code door een AI is gegenereerd, maar specifiek welk LLM-model (bijv. ChatGPT, Claude, DeepSeek, Qwen) de bron is.
• De uitdaging: Het toewijzen van code aan een specifiek model is moeilijk omdat verschillende LLM's vaak vergelijkbare oplossingsstrategieën gebruiken voor dezelfde taak, wat leidt tot oppervlakkig vergelijkbare output. De subtiele, model-specifieke "stijl" en structurele variaties (de "vingerafdrukken") worden vaak overschaduwd door de taakgebonden semantiek.

2. Methodologie: DCAN

De auteurs stellen DCAN (Disentangled Code Attribution Network) voor, een nieuw raamwerk dat de latentie representatie van code ontkoppelt in twee componenten:

1. Source-Agnostic Information (Bron-onafhankelijk): Semantische informatie die afhankelijk is van de taak (het algoritme) en gemeenschappelijk is voor alle modellen.
2. Source-Specific Information (Bron-specifiek): Stijl- en structurele "vingerafdrukken" die uniek zijn voor het specifieke LLM-model.

Het Architectuurproces:

• Feature Extraction: Het model gebruikt de vooraf getrainde encoder UniXcoder om een basisrepresentatie ($h_{base}$) van de code te genereren. Deze representatie bevat zowel taaksemantiek als modelstijl.
• Disentanglement Module (Ontkoppeling):
  • Een niet-lineair projectienetwerk (MLP) schat de bron-onafhankelijke component ($h_{com}$) af. Dit wordt gedaan door code van verschillende modellen voor dezelfde taak te vergelijken en de gedeelde semantiek te aligneren.
  • De bron-specifieke component ($h_{spec}$) wordt verkregen door aftrekking: $h_{spec} = h_{base} - h_{com}$.
• Optimalisatie (Verliesfuncties):
  • Source Classification Loss ($\mathcal{L}_{cls}$): Een lineaire classifier wordt toegepast op $h_{spec}$ om de bron van de code te voorspellen. Dit zorgt ervoor dat de model-specifieke vingerafdrukken behouden blijven.
  • Representation Consistency Loss ($\mathcal{L}_{rc}$): Deze loss zorgt ervoor dat $h_{com}$ consistent is voor verschillende modellen die dezelfde taak oplossen. Dit forceert het model om de taaksemantiek te isoleren en te verwijderen uit de bron-specifieke component.
  • Totale Loss: $\mathcal{L}_{total} = \mathcal{L}_{cls} + \lambda\mathcal{L}_{rc}$.

3. Belangrijkste Bijdragen

1. Definitie van LLMCSA: De auteurs introduceren de taak van LLM Code Source Attribution (LLMCSA), een nieuw probleem binnen softwareforensiek dat zich richt op het identificeren van de specifieke bron van gegenereerde code.
2. Eerste Groot-Schaal Benchmark: Ze hebben een dataset samengesteld met 91.804 code samples, gegenereerd door vier populaire LLM's (DeepSeek, Claude, Qwen, ChatGPT) in vier programmeertalen (C, Go, Java, Python). De dataset dekt twee scenario's: code met en zonder commentaar.
3. DCAN Framework: Een innovatief ontkoppelingsraamwerk dat expliciet taaksemantiek scheidt van modelstijl, wat leidt tot robuustere attributie dan bestaande methoden.

4. Resultaten en Experimenten

De prestaties van DCAN zijn geëvalueerd tegenover aangepaste baselines (GPTSniffer en CodeGPTSensor).

• Algemene Prestaties:
  • Zonder commentaar (Plain Setting): DCAN bereikte een gemiddelde F1-score van 92,94%, wat significant hoger is dan de beste baseline (GPTSniffer: 89,15%).
  • Met commentaar (Comment Setting): De prestaties verbeterden nog verder naar een gemiddelde F1-score van 98,38%, wat aantoont dat natuurlijke taal in commentaar sterke attributiesignalen bevat.
• Robuustheid:
  • Taakcomplexiteit: In tegenstelling tot wat vaak wordt verwacht, presteerde het model beter op moeilijke taken (Medium/Hard) dan op eenvoudige taken. Dit komt omdat complexe taken meer ruimte bieden voor model-specifieke implementatiekeuzes.
  • Data-efficiëntie: DCAN presteerde goed zelfs met slechts 10% van de trainingsdata, wat aangeeft dat de ontkoppelde vingerafdrukken stabiel zijn.
  • Cross-taal Generalisatie: In een "Leave-One-Language-Out" (LOLO) setting (trainen op 3 talen, testen op 1) behaalde het model sterke resultaten, vooral wanneer commentaar aanwezig was. Dit suggereert dat LLM's consistente natuurlijke taalstijlen hebben die taal-onafhankelijk zijn.
• Ablatie-studie: Het verwijderen van de bron-onafhankelijke component ($h_{com}$) en het gebruik van alleen $h_{spec}$ leidde tot de beste resultaten, terwijl $h_{com}$ alleen geen onderscheidende informatie bevatte (presteerde op niveau van random guessing).

5. Betekenis en Conclusie

Dit paper is significant omdat het het probleem van softwareprovenance (herkomst) oplost op het niveau van het specifieke AI-model, niet alleen op het niveau van "mens vs. machine".

• Praktische Toepassing: Het stelt organisaties in staat om bij beveiligingsincidenten of licentieconflicten te bepalen welk AI-model de code heeft gegenereerd, wat essentieel is voor accountability.
• Wetenschappelijke Inzicht: Het bewijst dat LLM's, ondanks hun vermogen om functioneel identieke code te genereren, consistente en onderscheidbare "stijlvingerafdrukken" behouden in zowel syntaxis als commentaar.
• Toekomst: De gepubliceerde dataset en het framework bieden een solide basis voor toekomstig onderzoek in softwareforensiek en de ontwikkeling van detectiemethoden voor AI-generatie.

Kortom, DCAN toont aan dat door de "ruis" van de taaksemantiek te filteren, de unieke "handtekening" van een LLM-model helder zichtbaar wordt, waardoor betrouwbare bronattributie mogelijk is.