Technische Samenvatting: Stapgewijze Redeneringsverbetering voor LLM's via Externe Subgraafgeneratie (SGR)

Probleemstelling

Large Language Models (LLM's) hebben significante capaciteiten getoond in natuurlijke taalgeneratie en few-shot leren. Echter, bij toepassing op complexe, kennisintensieve meerstapsredeneringstaken, worden zij geconfronteerd met kritieke beperkingen:

1. Gebrek aan feitelijke gronding: Outputs kunnen vertrouwen op impliciete parametrische kennis in plaats van verifieerbare externe feiten.
2. Logische inconsistentie: Redeneerprocessen kunnen gebrekkig of tegenstrijdig zijn.
3. Slechte interpreteerbaarheid: De interne redeneerstappen zijn vaak impliciet, wat het moeilijk maakt om bewijs te traceren of de geldigheid van een gegenereerd antwoord te verifiëren.

Conventionele retrieval-augmented generation (RAG)-methoden vertrouwen vaak op ongestructureerde tekstfragmenten of losjes verbonden feiten, die er niet in slagen de strikte relationele afhankelijkheden te behouden die vereist zijn voor multi-hop inferentie. Hoewel Knowledge Graphs (KG's) gestructureerde triples bieden voor expliciete redenering, blijft het dynamisch construeren van compacte, query-relevante graafbewijzen om LLM's te sturen een openstaande uitdaging.

Methodologie: Het SGR-framework

Het paper stelt SGR (Stepwise Reasoning Enhancement) voor, een framework dat LLM's integreert met externe Knowledge Graphs door middel van de dynamische generatie van query-relevante subgrafen. Het framework werkt via vier primaire stadia:

1. Gestructureerde Subgraafgeneratie

In plaats van ruwe tekst te extraheren, zet SGR een invoervraag $q$ om in een gestructureerd schema $S_q = \{V_q, R_q, C_q\}$, waarbij:

• $V_q$: Gelinkte entiteiten geëxtraheerd uit de vraag.
• $R_q$: Kandidaat-relaties die deze entiteiten verbinden.
• $C_q$: Beperkingen (bijv. temporele, numerieke of type-restricties).

Met behulp van dit schema extraheert het systeem een compacte subgraaf $G_q$ uit een externe KG (opgeslagen in Neo4j). Het retrieval-proces breidt zich vanuit seed-entiteiten uit langs kandidaat-relaties, waarbij strikt wordt toegepast van beperkingen om irrelevante paden te filteren. Dit resulteert in een dichte, bewijsrijke subgraaf die uitsluitend relevante entiteit-relatiepaden bevat voor de query.

2. Stapgewijze Redeneringsverbetering

De LLM wordt gestuurd om stap voor stap te redeneren over het expliciete bewijs in $G_q$. In plaats van een antwoord direct te genereren vanuit parametrische kennis, doorloopt het model de subgraaf, waarbij het in elke stap bewijs selecteert om een interpreteerbaar redeneertraject te construeren. Niet-onderbouwde stappen worden gefilterd of krijgen een lagere betrouwbaarheidsscore.

3. Directe Redeneringsverbetering (Cypher-gebaseerd)

Om een sterke baseline van feitelijke gronding te bieden, vertaalt SGR het gegenereerde schema $S_q$ naar uitvoerbare Cypher-queries met behulp van een "Cypher LLM"-module.

• De query wordt uitgevoerd in Neo4j om kandidaat-antwoorden $A_c$ direct uit de graaf te halen.
• Dit transformeert natuurlijke taalredenering naar symbolische operaties, waardoor de zoekruimte wordt vernauwd en wordt gegarandeerd dat antwoorden geworteld zijn in de grafenstructuur.
• Een stap voor Antwoordvalidatie volgt, waarbij kandidaten worden gescoord op basis van graafconsistentie (bereikbaarheid in $G_q$) en semantische betrouwbaarheid (compatibiliteit met de vraag).

4. Collaboratieve Redeneringsintegratie

Om robuustheid te vergroten, aggregeert SGR antwoorden van meerdere redeneringspaden (zowel de Cypher-afgeleide paden als de door LLM gegenereerde paden).

• Voor elk pad $p_i$ wordt een betrouwbaarheidsscore $\omega_i$ berekend door een balans te vinden tussen modelvertrouwen ($\rho_i$) en graafconsistentie ($\eta_i$).
• Het uiteindelijke antwoord $\hat{a}$ wordt geselecteerd door de ondersteuning over alle paden te aggregeren, waarbij de voorkeur wordt gegeven aan antwoorden die ondersteund worden door meerdere paden met een hoog vertrouwen en een hoge graafconsistentie. Dit mechanisme onderdrukt ruisgevoelige voorspellingen van enkelvoudige paden.

Belangrijkste Bijdragen

1. Framework Voorstel: Introductie van SGR, een stapgewijs redeneringsframework dat externen subgrafen dynamisch genereert om LLM's te sturen bij kennisintensieve vraagbeantwoording.
2. Schema-gestuurde Strategie: Een nieuwe methode voor het extraheren van entiteiten, relaties en beperkingen om compact, gestructureerd bewijs te extraheren, waarmee verder wordt gegaan dan geïsoleerde tekstretrieval.
3. Collaboratief Mechanisme: Een ontwerp dat directe Cypher-gebaseerde redenering combineert met LLM-gebaseerde redenering, waarbij resultaten worden gevalideerd en geaggregeerd op basis van zowel modelvertrouwen als graafconsistentie.
4. Empirische Validatie: Uitgebreide experimenten die aantonen dat SGR de prestaties verbetert ten opzichte van standaard prompting en bestaande kennis-verrijkte baselines.

Experimentele Resultaten

Het framework werd geëvalueerd op vier benchmark-datasets: CWQ, WebQSP, GrailQA en KQA Pro. De studie vergeleken drie varianten (SGR/Cypher LLM, SGR/ChatGPT, SGR/GPT-4) met standaard prompting (IO, CoT) en baselines zoals StructGPT en Tree-of-Graphs.

• Prestatiewinst: SGR presteerde consequent beter dan standaard prompting-methoden. Zo verbeterde SGR/ChatGPT op CWQ de Hits@1 van 0.376 (IO Prompt) naar 0.578 en de nauwkeurigheid naar 0.526.
• State-of-the-Art Vergelijking: Op WebQSP bereikte SGR/GPT-4 een 0.826 Hits@1 en 0.808 nauwkeurigheid, waarmee het de beste Hits@1-resultaten evenaarde en de hoogste nauwkeurigheid behaalde van alle geteste methoden. Op GrailQA bereikte het 0.756 Hits@1 en 0.703 nauwkeurigheid.
• Ablatie-studies: Het verwijderen van ofwel de schema-sturing of de Neo4j-retrieval resulteerde in significante prestatiedalingen. Bijvoorbeeld, op CWQ zorgde het verwijderen van schema-prompts ervoor dat de Hits@1 van SGR/ChatGPT daalde van 0.578 naar 0.400. Dit bevestigt dat zowel de schema-sturing als de externe graafretrieval cruciaal zijn voor de effectiviteit van het framework.

Betekenis en Claims

Het paper claimt dat SGR de "black box"-aard van LLM-redenering aanpakt door expliciet, verifieerbaar relationeel bewijs te leveren. Door dynamisch subgrafen te genereren, slaagt het framework erin om:

• De feitelijke gronding te verbeteren door redenering te verankeren in gestructureerde triples in plaats van in het parametrische geheugen.
• De interpreteerbaarheid te vergroten door het redeneepad traceerbaar te maken via de graaf.
• De robuustheid te verhogen via collaboratieve integratie, waardoor het risico op niet-onderbouwde of gehalucineerde antwoorden wordt verminderd.

De auteurs concluderen dat dynamisch gegenereerde externe subgrafen een levensvatbare en effectieve methode zijn om de nauwkeurigheid, robuustheid en transparantie van LLM-gebaseerde redenering in complexe, multi-hop scenario's te verbeteren.

Beperkingen

Het paper erkent verschillende beperkingen:

• Afhankelijkheid van KG-kwaliteit: De prestaties zijn afhankelijk van de dekking en nauwkeurigheid van de externe knowledge graph; ontbrekende of ruisgevoelige feiten kunnen leiden tot onjuiste redenering.
• Extractiefouten: Fouten in entity linking, relatie-identificatie of de constructie van het schema kunnen doorwerken naar de subgraafretrieval en de uiteindelijke antwoorden.
• Omvang van de Subgraaf: Het bepalen van de optimale grootte van de subgraaf is uitdagend; kleine subgrafen kunnen bewijs missen, terwijl grote subgrafen ruis introduceren.
• Computationele Kosten: De extra stappen van schema-generatie, Cypher-querying en pad-integratie verhogen de inferentiekosten in vergelijking met directe prompting.