Actions Speak Louder than Prompts: A Large-Scale Study of LLMs for Graph Inference

Dit onderzoek biedt een grootschalige evaluatie van de interactie tussen grote taalmodellen en grafdata, waarbij blijkt dat code-generatie de meest effectieve aanpak is voor diverse domeinen en grafstructuren, en dat deze methoden robuust presteren zelfs bij heterofiele netwerken.

De kern

Titel: Woorden zijn goed, maar code is beter: Hoe AI slimme netwerken begrijpt

Stel je voor dat je een enorme, ingewikkelde stad hebt. In deze stad zijn er miljoenen gebouwen (de knopen of nodes) en er lopen straten tussen hen (de lijnen of edges). Elke straat vertelt een verhaal, en elk gebouw heeft een ingewikkeld dossier met tekst erin.

De vraag is: Hoe kun je een kunstmatige intelligentie (een LLM) vertellen wat voor soort gebouw er op een specifiek adres staat? Is het een school? Een winkel? Of misschien een gevaarlijk pand?

Dit is wat onderzoekers van Microsoft en de Universiteit van Oxford hebben onderzocht. Ze wilden weten: wat is de beste manier om een AI te laten "kijken" naar zo'n netwerk?

Hier zijn de drie manieren waarop ze de AI hebben laten werken, vertaald naar simpele analogieën:

1. De "Lees-alle-boeken"-methode (Prompting)

Stel je voor dat je de AI een enorme stapel papier geeft. Je zegt: "Hier is het dossier van het gebouw, en hier zijn de dossiers van al zijn buren, en hun buren, en hun buren..."

• Het probleem: Als de stad groot is of de dossiers heel lang zijn, wordt die stapel papier zo hoog dat de AI er niet meer doorheen kan kijken. De AI raakt "verkeerd" (het token-budget is vol). Het is alsof je iemand probeert te vertellen wat er in een stad gebeurt door alles in één adem op te noemen. De persoon raakt de draad kwijt.

2. De "Telefoon-uit-je-mouw"-methode (Tool-use)

Nu geef je de AI een telefoon. De AI kan zelf beslissen: "Ik wil eerst het dossier van buurman A lezen, daarna de naam van buurman B opzoeken."

• Het voordeel: De AI hoeft niet alles in één keer te lezen. Het pakt alleen wat het nodig heeft.
• Het nadeel: Het is nog steeds een beetje traag en omslachtig. Elke keer dat de AI een nummer kiest, moet het wachten op de verbinding. Het is alsof je een detective bent die één voor één deuren moet openen in plaats van de sleutel te gebruiken.

3. De "Schrijf-een-programma"-methode (Graph-as-Code)

Dit is de winnaar in dit onderzoek. Hier geef je de AI niet alleen een telefoon, maar ook een gereedschapskist met een programmeertaal.
De AI schrijft een klein computerprogrammaletje dat zegt: "Ga naar gebouw X, check de buren, vergelijk de teksten, en geef het antwoord."

• Het voordeel: De AI doet dit niet stap-voor-stap met de menselijke taal, maar schrijft code die de computer direct en supersnel uitvoert. Het is alsof je de detective een drone geeft die de hele stad in één seconde scant en een rapport terugstuurt, in plaats van dat de detective zelf moet lopen.

---

Wat hebben ze ontdekt? (De grote lessen)

1. Code is de superkracht
De methode waarbij de AI code schrijft ("Graph-as-Code") werkt over het algemeen het beste. Vooral in grote steden met lange dossiers (zoals e-commerce of sociale media) wint deze methode het ruimschoots. De andere methoden raken snel de "woordlimiet" van de AI, maar de code-methode omzeilt dat probleem slim.

2. Het werkt zelfs als buren vreemd zijn
Soms zijn buren heel verschillend (in de vaktaal: heterofiel). Bijvoorbeeld: een rijke wijk grenst aan een arme wijk. Veel mensen dachten dat AI hierin faalt omdat het niet kan vertrouwen op "soort zoekt soort".

• De ontdekking: Nee! De AI, vooral met de code-methode, is slim genoeg om te kijken naar de inhoud van de dossiers en niet alleen naar wie de buren zijn. Het werkt zelfs in deze "vreemde" netwerken.

3. De AI past zich aan
De slimste methode (code) is als een waterdruppel: hij past zich aan de vorm van het vat aan.

• Als de tekst belangrijk is, kijkt de AI naar de tekst.
• Als de structuur (de straten) belangrijk is, kijkt hij naar de straten.
• Als de labels (de namen van de gebouwen) belangrijk zijn, kijkt hij daar naar.
  Hij gebruikt wat er het beste werkt, in plaats van altijd op dezelfde manier te proberen.

Conclusie voor de praktijk

Als je een AI wilt gebruiken om complexe netwerken (zoals fraude opsporen in bankzaken of producten aanbevelen in een webshop) te analyseren:

• Vergeet niet: Gewoon een lange tekst geven (prompting) werkt vaak niet meer als de data groot is.
• Gebruik: Laat de AI code schrijven om de data te analyseren. Het is sneller, slimmer en werkt zelfs als de gegevens onvolledig of verwarrend zijn.

Kortom: Woorden zijn goed, maar als je echt iets wilt bereiken in een complex netwerk, moet je de AI laten praten met code.

Technische samenvatting

Probleemstelling

Grote Taalmodellen (LLMs) worden steeds vaker ingezet voor machine learning-taken op tekstrijke grafen, zoals noden-classificatie in domeinen als fraudeopsporing en aanbevelingssystemen. Ondanks de groeiende interesse ontbreekt er echter een fundamenteel, principieel inzicht in de capaciteiten van LLMs bij het verwerken van grafdata. Bestaande onderzoek richt zich vaak op specifieke domeinen of taken, wat leidt tot een gebrek aan algemene richtlijnen. Er is onduidelijkheid over welke interactiestrategieën (prompting, tool-use, code-generatie) het beste werken onder verschillende omstandigheden, zoals:

• Grafstructuur: Homofiele (knooppunten van dezelfde klasse verbinden) versus heterofiele grafen.
• Feature-kenmerken: Korte versus zeer lange tekstuele attributen.
• Interactiemodus: Hoe de LLM toegang krijgt tot de grafdata.
• Token-beperkingen: Het risico dat contextvensters worden overschreden bij complexe grafen.

Het paper stelt dat het blind toepassen van LLMs op grafen kan leiden tot suboptimale resultaten en dat er een gecontroleerde, grootschalige evaluatie nodig is om de sterktes en zwaktes van verschillende benaderingen te kwantificeren.

Methodologie

De auteurs voeren een uitgebreide, gecontroleerde evaluatie uit waarbij ze de variabiliteit in zes cruciale dimensies ontleden:

1. Interactiestrategieën: Ze vergelijken drie hoofdmodi:
   • Prompting ($\phi_{prompt}$): Het serialiseren van de graf (k-hop buren) in een enkele tekstprompt. Varianten omvatten 0-hop, 1-hop, 2-hop en budget-gelimiteerde prompts.
   • GraphTool ($\phi_{tool}$): Een ReAct-stijl benadering waarbij de LLM iteratief acties uitvoert (bijv. "haal buren op", "haal tekst op") via een vast stel tools.
   • Graph-as-Code ($\phi_{code}$): De graf wordt weergegeven als een gestructureerde tabel (bijv. een Pandas DataFrame). De LLM genereert, executeert en redeneert over compacte code (Python/Pandas) om de data dynamisch te queryen.
2. Dataset-domeinen: Evaluatie over citation networks (Cora, PubMed), e-commerce (Products, Computers), web-link netwerken (Cornell, Texas) en sociale netwerken (Reddit, Instagram).
3. Structuur-regimes: Vergelijking tussen homofiele en heterofiele grafen.
4. Feature-kenmerken: Contrast tussen korte titels en lange beschrijvingen/profielen.
5. Modelconfiguratie: Testen van verschillende LLM-groottes (van Llama tot GPT-5) en redeneer-capaciteiten (met en zonder reasoning).
6. Afhankelijkheidsanalyse: Systematisch verwijderen van randen (edges), inkorten van tekst (features) en verwijderen van labels om te meten waarop de modellen vertrouwen.

Belangrijkste Bijdragen en Resultaten

1. Graph-as-Code presteert het beste, vooral bij complexe data
De studie toont aan dat Graph-as-Code over het algemeen de hoogste nauwkeurigheid behaalt. Dit is vooral waar bij grafen met lange tekstuele features of een hoog aantal buren (high-degree).

• Reden: Bij prompting wordt het token-budget snel overschreden wanneer veel buren en lange teksten in de prompt moeten worden opgenomen. Graph-as-Code omzeilt dit door alleen de noodzakelijke informatie selectief op te halen en te combineren via code, waardoor het contextvenster efficiënt wordt gebruikt.
• Resultaat: Op lange-text datasets (zoals photo en wiki-cs) presteert Graph-as-Code aanzienlijk beter dan prompting, dat vaak faalt door token-limieten.

2. Effectiviteit op heterofiele grafen
Een veelgehoorde aanname in de literatuur is dat LLM-methoden falen op heterofiele grafen (waar buren vaak een andere klasse hebben). Deze studie weerlegt dit.

• Resultaat: Alle interactiestrategieën (Prompting, Tool-use, Code) presteren effectief op heterofiele datasets. LLMs blijken in staat om niet-lokale cues en feature-gebaseerde informatie te gebruiken in plaats van alleen te vertrouwen op lokale stemmingsmechanismen (neighborhood voting).

3. Flexibiliteit en Robuustheid van Graph-as-Code
Door het systematisch verwijderen van randen, features en labels, ontdekten de auteurs dat Graph-as-Code flexibeler is dan prompting:

• Afhankelijkheid: Prompting is sterk afhankelijk van zowel structuur als labels; als deze worden verwijderd, stort de prestatie in. Graph-as-Code kan echter zijn afhankelijkheid verschuiven. Als randen worden verwijderd, kan het zich nog steeds baseren op features of labels, en vice versa.
• Robuustheid: Graph-as-Code is minder kwetsbaar voor ruis en gedeeltelijk ontbrekende data omdat het dynamisch kan beslissen welke informatie het meest informatief is voor een specifieke query.

4. Schaal en Redenering

• Modelgrootte: Grotere LLMs presteren consistent beter, maar de token-limiet van prompting blijft een fundamentele bottleneck, ongeacht de modelgrootte.
• Redenering: Het activeren van "reasoning"-modi (zoals Chain-of-Thought) verbetert de prestaties voor alle methoden, maar Graph-as-Code profiteert hier het meest van door complexe logica in code te vertalen.

5. Token-efficiëntie
De studie toont aan dat Graph-as-Code en GraphTool aanzienlijk minder tokens verbruiken dan prompting bij lange-text datasets. Prompting vereist vaak het inladen van de volledige context, terwijl de andere methoden iteratief en selectief data ophalen.

Significantie en Implicaties

De bevindingen van dit paper bieden praktische richtlijnen voor onderzoekers en practitioners:

1. Voorkeur voor Code-generatie: Voor tekstrijke grafen, vooral in real-world scenario's zoals e-commerce of sociale netwerken met lange profielen, is Graph-as-Code de superieure interactiemodus. Het biedt een betere balans tussen prestatie, token-efficiëntie en robuustheid.
2. Herdefiniëren van Heterofiele Uitdagingen: De conclusie dat LLMs ook goed werken op heterofiele grafen opent de deur voor bredere toepassingen van LLMs in gebieden waar traditionele GNN's (Graph Neural Networks) moeite hebben met lage homofie.
3. Adaptieve Strategie: De studie benadrukt dat er geen "one-size-fits-all" oplossing is. De keuze van de interactiemodus moet gebaseerd zijn op de eigenschappen van de graf (dichtheid, lengte van features). Graph-as-Code biedt de adaptiviteit om hier het beste mee om te gaan.
4. Toekomstige Ontwikkeling: Het paper suggereert dat de toekomst van LLM-graph reasoning ligt in het combineren van de redeneercapaciteiten van LLMs met programmatieke uitvoering, in plaats van het proberen te forceren van grafstructuren in statische prompts.

Kortom, de titel "Actions Speak Louder Than Prompts" vat de kern samen: het dynamisch uitvoeren van acties (via tools of code) om grafdata te benaderen, is effectiever dan het statisch presenteren van data in een prompt.