💬 NLP

Test-Time Verification for Text-to-SQL via Outcome Reward Models

Dit artikel introduceert GradeSQL, een framework dat Outcome Reward Models (ORMs) gebruikt als geleerde semantische scorers om de betrouwbaarheid van Text-to-SQL te verbeteren, waarbij wordt aangetoond dat verificatie op basis van ORM significant beter presteert dan traditionele heuristische methoden zoals execution-based Best-of-N en Majority Voting op de BIRD- en Spider-benchmarks.

Oorspronkelijke auteurs: Mattia Tritto, Giuseppe Farano, Dario Di Palma, Gaetano Rossiello, Fedelucio Narducci, Dharmashankar Subramanian, Tommaso Di Noia

Gepubliceerd 2026-07-01

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Mattia Tritto, Giuseppe Farano, Dario Di Palma, Gaetano Rossiello, Fedelucio Narducci, Dharmashankar Subramanian, Tommaso Di Noia

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een zeer slimme, maar soms overmoedige chef (de AI) vraagt om een specif Cook specifiek gerecht te bereiden op basis van een recept dat je in gewone taal beschrijft. De chef weet hoe hij moet koken, maar soms krijgt hij de ingrediënten fout of haalt hij de stappen door elkaar.

In de wereld van computers wordt dit Text-to-SQL genoemd: het vertalen van een menselijke vraag naar een databasequery (een reeks instructies voor een computerdatabase). Het probleem is dat als de chef zelfs maar een klein foutje maakt, de computer je het verkeerde antwoord geeft, of helemaal niets.

De Oude Manier: "Gokken en Controleren"

Meestal vraagt het systeem aan de chef om het gerecht 32 keer te bereiden (het genereren van 32 verschillende SQL-queries). Daarna moet het de beste uitkiezen.

De oude methoden om de winnaar te kiezen zijn als volgt:

Meerderheidsstemming: "Wie heeft het gerecht het vaakst bereid?" Als 20 chefs zeggen "voeg zout toe" en 12 zeggen "voeg suiker toe", neemt het systeem aan dat "zout" juist is. Maar wat als het recept eigenlijk suiker nodig had en de meerderheid simpelweg dezelfde fout maakte?
Executie Succes: "Wie heeft de pan daadwerkelijk aan de praat gekregen?" Als een query zonder fouten wordt uitgevoerd, kiest het systeem deze. Maar een query kan perfect draaien en je toch de verkeerde data geven (zoals een taart serveren terwijl je om soep vroeg).

Deze methoden vertrouwen op eenvoudige, oppervlakkige aanwijzingen (heuristieken) in plaats van echt te begrijpen of het gerecht correct is.

De Nieuwe Manier: De "GradeSQL" Voedselcriticus

Dit artikel introduceert een nieuw systeem genaamd GradeSQL. In plaats van alleen stemmen te tellen of te controleren of de pan werkt, hebben ze een gespecialiseerde Voedselcriticus getraind (een Outcome Reward Model of ORM).

Zo werkt het GradeSQL-systeem, stap voor stap:

1. De Kookles (Training)
Eerst moet het systeem de Critic leren wat "goed" en "slecht" is.

Het neemt een vraag en vraagt de hoofdchef (de AI) om 32 verschillende versies van het gerecht te bereiden.
Vervolgens voert het alle 32 gerechten uit tegen de "Gouden Standaard" (het juiste antwoord).
Als een gerecht exact smaakt als de Gouden Standaard, geeft de Critic een Hoge Score. Als het anders smaakt, krijgt het een Lage Score.
De Critic leert van deze voorbeelden om de smaak van een correcte query te herkennen, en niet alleen of de boel is vastgelopen.

2. De Proefsessie (Inference)
Nu vraagt een echte gebruiker een vraag:

De chef bereidt 32 nieuwe versies van het gerecht.
In plaats van alleen te controleren of ze werken, proeft de Critic elk van hen.
De Critic geeft elk gerecht een score op basis van hoe goed het overeenkomt met de bedoeling van de vraag.
Het systeem kiest het gerecht met de hoogste score.

Waarom is dit beter?

Het paper heeft dit getest op twee enorme databases met vragen (genaamd BIRD en Spider). Ze ontdekten dat de Critic veel beter was in het herkennen van het juiste antwoord dan de oude methoden ("stemmen tellen" of "is het gecrasht?").

De Analogie: Stel je een meerkeuzevraag voor. De oude methode kiest het antwoord dat het vaakst voorkomt of dat geen typefout bevat. De nieuwe methode (GradeSQL) leest de vraag en het antwoord daadwerkelijk door om te zien of ze logisch bij elkaar passen.
De Resultaten: Bij moeilijke vragen hielp de Critic het systeem om het juiste antwoord ongeveer 4% vaker te vinden op de BIRD-dataset en 2% vaker op de Spider-dataset. Hoewel 2-4% klein lijkt, is het in de wereld van AI een enorme verbetering, vooral voor de moeilijkste vragen waar de oude methoden meestal opgeven.

Belangrijkste Punten

Het is een "Geleerde" Rechter: De Critic volgt niet alleen regels; de Critic heeft geleerd wat een correcte SQL-query is door te oefenen op duizenden voorbeelden.
Geen Mens Nodig: Het systeem heeft zichzelf geleerd hoe het een criticus moet zijn door automatisch te controleren welke antwoorden werkten, zodat er geen mensen handmatig huiswerk hoefden te nakijken.
Het Schaalt: Hoe meer opties (kandidaten) de chef genereert, hoe beter de Critic presteert. De oude methoden lopen vast en stoppen met verbeteren, maar de Critic wordt steeds slimmer naarmate hij meer keuzes heeft om uit te kiezen.

Kortom, GradeSQL is als het inhuren van een professionele voedselcriticus om het beste gerecht uit een partij van 32 te kiezen, in plaats van alleen maar het publiek te vragen of te controleren of het fornuis aan staat. Het maakt de AI betrouwbaarder wanneer de vragen ingewikkeld worden.

Technische Samenvatting: Test-Time Verificatie voor Text-to-SQL via Outcome Reward Models

Probleemstelling

De betrouwbaarheid van Large Language Models (LLM's) bij gestructureerde redeneertaken, specifweg Text-to-SQL, blijft een kritieke uitdaging. Hoewel LLM's aanzienlijk zijn geavanceerd, worstelen ze vaak met complexe queries die betrokken zijn bij multi-table joins, geneste subqueries en subtiele beperkingen. Huidige strategieën voor test-time inferentie, zoals Best-of-N (BoN) sampling en Majority Voting, proberen dit te mitigeren door meerdere kandidaat SQL-queries te genereren en de beste te selecteren. Echter, deze methoden vertrouwen op heuristische signalen—voornamelijk executie-succes (wordt de query zonder fouten uitgevoerd?) of outputfrequentie (geven meerdere queries hetzelfde resultaat terug?).

De auteurs stellen dat deze heuristieken slechts grove proxies zijn voor semantische correctheid. Naarmate de kandidaatsets groeien, verzadigen deze signalen vaak en falen ze om te differentiëren tussen semantisch geldige en ongeldige queries, met name wanneer meerdere onjuiste queries succesvol worden uitgevoerd maar verkeerde resultaten teruggeven, of wanneer semantisch equivalente queries verschillende syntactische structuren hebben. Er is behoefte aan een geleerd verificatiemechanisme dat kandidaten kan scoren op basis van taakspecifieke semantische afstemming in plaats van oppervlakkige executie-metrieken.

Methodologie: Het GradeSQL Framework

Om het tekort aan gelabelde data dat vereist is voor het trainen van verifiers in gestructureerde taken aan te pakken, introduceren de auteurs GradeSQL, een schaalbaar framework voor het trainen van Outcome Reward Models (ORM's). In tegenstelling tot Process Reward Models (PRM's) die tussenliggende stappen scoren, wijzen ORM's scalaire scores toe aan uiteindelijke outputs. Het framework werkt in drie stadia:

Kandidaatgeneratie: Gegeven een natuurlijke taalvraag en een database-schema, produceert een generator LLM een diverse set van $N$ kandidaat SQL-queries met behulp van stochastische decodingstrategieën. Deze diversiteit is cruciaal om de verifier bloot te stellen aan een breed scala aan correcte formuleringen en bijna-fouten.
Geautomatiseerde Data-labeling: In plaats van handmatige annotatie labelt het framework kandidaten via executie-equivalentie. Elke kandidaat wordt uitgevoerd tegen de database. Als de resultaatset overeenkomt met die van de gold-standard query ( $R(c_j) = R(y_{gold})$ ), wordt de kandidaat gelabeld als "Correct"; anders wordt deze gelabeld als "Incorrect". Queries die executiefouten veroorzaken, worden weggegooid. Dit creëert een grootschalige, automatisch gelabelde dataset voor verifier-training.
Supervised Fine-Tuning (SFT): Een verifier LLM wordt gefinetuned (met behulp van LoRA) als een binaire autoregressieve classifier. De input bestaat uit het schema, de vraag en een kandidaat query, en het model wordt getraind om de waarschijnlijkheid van het "Yes"-token (dat correctheid aangeeft) te voorspellen.

Inference Pipeline: Tijdens test-time produceert de generator $N$ kandidaten. De getrainde ORM scoort elke kandidaat op basis van de waarschijnlijkheid van het "Yes"-token. De kandidaat met de hoogste score wordt geselecteerd, waarbij geleerd semantisch scoren de heuristische selectie vervangt.

Belangrijkste Bijdragen

Het paper levert drie primaire bijdragen:

ORM-gebaseerde Verificatie voor Text-to-SQL: De studie past Outcome Reward Models aan als geleerde semantische scorers voor test-time kandidaatselectie in gestructureerde querygeneratie, en demonstreert hun toepasbaarheid buiten hun traditionele gebruik bij alignment en redeneringstaken.
Schaalbaar Data Curatie Pipeline: De auteurs stellen GradeSQL voor, een geautomatiseerd framework dat kandidaat SQL-queries genereert en labelt via executie-equivalentie. Dit maakt het mogelijk om taakspecifieke ORM's te trainen zonder de noodzaak van dure handmatige annotatie.
Empirische Analyse van Test-Time Verificatie: Een systematische evaluatie over meerdere open-source LLM-families (waaronder Qwen, Granite, Llama en OmniSQL) en benchmarks (BIRD en Spider) laat zien dat ORM-gebaseerde selectie consequent beter presteert dan heuristische baselines.

Experimentele Resultaten

De aanpak werd geëvalueerd op de BIRD en Spider benchmarks met behulp van meerdere generator-modellen. Belangrijkste bevindingen zijn:

Prestatiewinst: ORM-gebaseerde selectie behaalde consequent een hogere Execution Accuracy (EX) dan Majority Voting en executie-gebaseerde Best-of-N.
- Op BIRD dev bereikte ORM 68,90%, een winst van +5,01% ten op toe over de baseline ( $N=1$ ) en presteerde beter dan Majority Voting (+3,06%) en executie-gebaseerde BoN (+2,15%).
- Op Spider test bereikte ORM 87,47%, waarmee het Majority Voting (85,47%) en executie-gebaseerde BoN (85,14%) overtrof.
Schalen met Kandidaatsets: In tegenstelling tot heuristische methoden die vroeg verzadigen, bleef de ORM-prestatie verbeteren naarmate de omvang van de kandidaatpool ( $N$ ) toenam, waarbij het de oracle upper bound benaderde die wordt gedefinieerd door Pass@N. Dit geeft aan dat ORM's effectief profiteren van toegenomen test-time compute.
Robuustheid: De methode toonde consistente verbeteringen over verschillende generator-families en model-schalen. De voordelen van ORM-gebaseerde selectie bleven bestaan, zelfs wanneer grotere generators (tot 32B parameters) werden gebruikt.
Trainingsdynamiek:
- Dataset Imbalans: Hoewel de gegenereerde datasets ongebalanceerd waren (bijv. ~69% correct in Spider), leidde het trainen op gebalanceerde subsets (50/50) niet tot degradatie van de prestaties en verbeterde het in sommige gevallen de prestaties terwijl de trainingskosten werden verlaagd.
- Modelgrootte: Het vergroten van de ORM-omvang voorbij 7B parameters leverde slechts marginale en inconsistente verbeteringen op, wat suggereert dat lichtgewicht ORM's een gunstige balans bieden tussen prestaties en efficiëntie.
- Prompt Design: Prompts die de verifier direct blootstellen aan de SQL-structuur ("SQL-Only") leverden de beste resultaten vergeleken met instructie-stijl of data-alleen prompts.

Betekenis en Claims

Het paper claimt dat geleerde verificatie een eenvoudige, effectieve en schaalbare alternatief biedt voor heuristische test-time selectiestrategieën voor Text-to-SQL. De betekenis van dit werk ligt in het aantonen dat:

Executie-gebaseerde labeling voldoende is om effectieve verifiers te trainen voor gestructureerde taken, waardoor de barrière van handmatige annotatie wordt weggenomen.
Semantische discriminatie mogelijk is tijdens de inferentie zonder de generator te wijzigen of extra interactie met de omgeving te vereisen buiten de initiële kandidaatgeneratie.
ORM's bijzonder effectief zijn voor complexe queries waar heuristische signalen falen, wat een principiële manier biedt om de ambiguïteit en structurele complexiteit die inherent zijn aan Text-to-SQL aan te pakken.

De auteurs hanteren een bescheiden toon en erkennen dat de absolute winsten gematigd zijn (2–5%) en dat de aanpak vertrouwt op executie-equivalentie als een proxy voor semantische correctheid, wat mogelijk geen onderscheid maakt tussen semantisch equivalente maar syntactisch verschillende queries of beloningen voor spookmatchen. Het werk richt zich op het verbeteren van de selectie van kandidaten in plaats van de generatie-capaciteit zelf.