Technische Samenvatting: Wanneer LLM's Rust-crates verzinnen

Probleemstelling

Large Language Models (LLM's) worden steeds vaker gebruikt voor codegeneratie, maar blijven gevoelig voor "hallucinaties"—het produceren van plausibele maar feitelijk onjuiste of gefabriceerde outputs. Een kritieke subcategorie van dit probleem is package hallucinatie, waarbij een LLM een afhankelijkheid (dependency) aanbeveelt of importeert die niet bestaat. In talen zoals Python en JavaScript vormt dit een ernstig risico voor de veiligheid van de toeleveringsketen (supply chain), aangezien aanvallers kwaadaardige pakketten onder gehallucineerde namen kunnen registreren.

Hoewel eerder onderzoek uitgebreid heeft gestudeerd op package hallucinatie in populaire ecosystemen (Python, JavaScript), is er een aanzienlijke kloof met betrekking tot Rust. Rust wordt breed toegepast voor veiligheidskritische systeemprogrammering (bijv. besturingssystemen, blockchain). Hoewel het dependencybeheer van Rust (via Cargo.toml) verschilt van andere talen—het vereist een expliciete declaratie voordat een crate wordt gedownload—blijven gehallucineerde crate-referenties in de broncode een direct betrouwbaarheidsprobleem. Ze veroorzaken build-fouten, onopgeloste imports en namespace-verwarring. Bovendien, in veel door LLM ondersteunde workflows, worden broncodefragmenten gegenereerd zonder volledige projectmanifesten, waardoor crate-referenties op bronniveau de vroegste observeerbare signalen van fouten gerelateerd aan dependencies zijn.

Methodologie

Om het gebrek aan empirische gegevens over Rust aan te pakken, voerden de auteurs de eerste grootschalige studie uit naar crate hallucinatie in door LLM gegenereerde Rust-code.

1. Dataset Constructie

De auteurs construeerden een dataset uit meerdere bronnen bestaande uit 2.794 programmeertaken afkomstig van drie bronnen:

• Stack Overflow: 1.001 unieke, hoog gewaardeerde Rust-vragen die reële vragen van ontwikkelaars vertegenwoordigen.
• GitHub: 793 taken geëxtraheerd uit de top 100 Rust-repositories (op basis van sterren), gefilterd op kwaliteit om compiler-internals, vage taken en platformspecifieke beperkingen uit te sluiten.
• LLM-gegenereerde Taken: 1.000 taken gecreëerd door beschrijvingen van populaire crates (van lib.rs en crates.io) te transformeren naar implementatieverzoeken met behulp van een Qwen2.5-32B model.

2. Model Evaluatie

De studie evalueerde 14 modellen over zes families, waaronder:

• Commercieel: GPT-5, Gemini 2.5 Pro, Claude 4 Opus.
• Open-Source: Qwen2.5-Coder (diverse formaten), DeepSeek-Coder-V2, OpenCoder.
  Modellen werden getest onder standaardconfiguraties en verschillende decoding temperaturen (0 tot 5).

3. Detectiemechanisme

Een uitgebreide inventaris van geldige Rust-crates werd opgebouwd door crates.io, de Rust Standard Library en rustc compiler crates te scrapen. De auteurs hebben ook repository Cargo.toml bestanden gemined om crate aliases te vangen.

• Extractie: Het systeem extraheerde crate-namen uit de gegenereerde code met drie patronen: use declaraties, directe pad-prefixes en extern crate declaraties.
• Metriek: De Crate Hallucination Rate (CHR) werd berekend als de ratio van de geëxtraheerde namen die afwezig waren in de geldige inventaris ten opzichte van het totaal aantal geëxtraheerde namen.

4. Mitigatie Evaluatie

Twee prompt-engineering strategieën werden getest om hallucinaties te mitigeren zonder de modellen opnieuw te trainen:

• Self-Refinement: Een multi-turn proces waarbij het model zijn eigen output beoordeelt, controleert op het gebruik van de standaardbibliotheek en crate-namen verifieert voordat het de output definitief maakt.
• Retrieval Augmented Generation (RAG): Het model werd voorzien van een retrieval-index van de top 10.000 crates van crates.io en een lijst met standaardbibliotheek-modules om de generatie te grondvesten.

Belangrijkste Resultaten

RQ1: Prevalentie en Beïnvloedende Factoren

• Hoge Prevalentie: De algemene CHR over alle modellen was 20,23%. Hallucinaties werden waargenomen in alle geëvalueerde modellen.
• Modelgevoeligheid: Hoewel specifieke modellen beter presteerden (bijv. Gemini 2.5 Pro op 16,18% versus Claude 4 Opus op 26,90%), was het verschil tussen commerciële en open-source modellen gemiddeld niet statistisch significant.
• Parameteronafhankelijkheid: In tegenstelling tot bevindingen in Python/JavaScript, vertoonde modelgrootte (aantal parameters) geen statistisch significante correlatie met de hallucinatiecijfers binnen modelfamilies (bijv. Qwen2.5-Coder varianten).
• Temperatuuronafhankelijkheid: Het verhogen van de decoding temperatuur leidde niet tot een systematische toename van hallucinaties. De CHR bleef stabiel over de temperatuurinstellingen (0–5), wat contrasteert met eerder werk waar hogere temperaturen de hallucinatiecijfers verhoogden.

RQ2: Hallucinatiepatronen

De studie identificeerde vier onderscheidende, Rust-specifieke patronen:

1. Module-Crate Verwarring: Meer dan 45% van de hallucinaties waren eigenlijk geldige Rust standard library modules (bijv. std::thread, std::io) die onjuist werden gerefereerd als externe crates. De modellen faalden vaak om deze te kwalificeren met std:: of core::.
2. Cross-Model Consistentie: Module-hallucinaties vertoonden een hoge overlap tussen verschillende modellen (Jaccard-gelijkenis ≈ 0,44), wat wijst op gedeelde beperkingen in de trainingsdata, terwijl niet-module hallucinaties meer uniek waren voor specifieke modellen.
3. Near-Miss Varianten: Gehallucineerde namen waren voornamelijk kleine variaties van echte crates. 86,48% van de hallucinaties bevond zich binnen vijf Levenshtein-bewerkingen van een geldige crate. Een prominent patroon was het misbruik van streepjes, waarbij modellen camelCase namen genereerden (bijv. httpresponse) in plaats van de Rust kebab-case conventie (bijv. http-response).
4. Cross-Ecosysteem Transfer: Ongeveer 39% van de frequente hallucinaties hergebruikte namen uit andere ecosystemen (bijv. Python of Windows API's), wat duidt op gestructureerde maar verkeerd afgestemde kennisoverdracht.

RQ3: Effectiviteit van Mitigatie

• Beperkte Winst: Beide mitigatiestrategieën verminderden de hallucinatiecijfers, maar de verbeteringen waren bescheiden.
• Self-Refinement: Verminderde de CHR consistent met 2–3 procentpunten (ongeveer een relatieve reductie van 10–15%).
• RAG: Leverde beperkte en inconsistente verbeteringen; in sommige gevallen verhoogde het de rate zelfs licht.
• Conclusie: Eenvoudige prompt-niveau interventies zijn onvoldoende om crate-hallucinaties substantieel te elimineren.

Betekenis en Bijdragen

Het artikel claimt de volgende bijdragen:

1. Eerste Empirische Studie: Het biedt de eerste systematische investigatie naar crate-hallucinaties in door LLM gegenereerde Rust-code, waarmee een gat in de literatuur wordt opgevuld die gedomineerd wordt door Python en JavaScript studies.
2. Distinctieve Patronen: Het onthult dat Rust-hallucinaties een ander patroon volgen dan andere talen: ze zijn zeer gestructureerd (vaak betrokken bij moduleverwarring en naamgevingsconventiefouten) en zijn verrassend ongevoelig voor modelgrootte en decoding temperatuur.
3. Dataset Release: De auteurs hebben een dataset van 2.794 Rust programmeertaken vrijgegeven om toekomstig onderzoek te faciliteren.
4. Implicaties voor Veiligheid en Betrouwbaarheid: De studie benadrukt dat hoewel het dependency-model van Rust directe supply chain aanvallen mitigeert (door updates aan Cargo.toml te vereisen), gehallucineerde referenties nog steeds aanzienlijke build-fouten en betrouwbaarheidsproblemen veroorzaken. Het suggereert dat toekomstige mitigatie behoefte heeft aan Rust-bewuste guardrails (bijv. namespace validatie, registry-bewuste controle en Cargo.toml cross-referencing) in plaats van generieke prompt engineering.

De auteurs concluderen dat hoewel lichtgewicht strategieën marginale voordelen bieden, robuuste mitigatie waarschijnlijk een nauwere integratie vereist met toolchain-niveau verificatie en verbeteringen in de trainingsdata die specifiek zijn voor het Rust-ecosysteem.