Spark-LLM-Eval: A Distributed Framework for Statistically Rigorous Large Language Model Evaluation

Dit paper introduceert Spark-LLM-Eval, een gedistribueerd framework op basis van Apache Spark dat schaalbare, statistisch rigoureuze evaluatie van grote taalmodellen mogelijk maakt door middel van data-parallellisme, betrouwbaarheidsintervallen en efficiënte caching.

De kern

Stel je voor dat je een nieuwe, super slimme robot (een "Large Language Model" of LLM) hebt gebouwd. Je wilt weten of hij echt slim is. Om dat te testen, geef je hem duizenden vragen: "Hoe maak ik een pannenkoek?", "Wat is de hoofdstad van Frankrijk?", "Schrijf een gedicht over regen."

In het verleden deden onderzoekers dit met een handvol vragen (bijvoorbeeld 1.000). Maar in de echte wereld, waar miljoenen mensen met de robot praten, is dat niet genoeg. Je moet hem testen op miljoenen vragen om te zien of hij echt goed werkt.

Het probleem?

1. Snelheid: Een enkele computer doet er eeuwen over om al die vragen te beantwoorden.
2. Kosten: Elke vraag kost geld (want je betaalt per gesprek met de robot). Als je alles opnieuw moet doen voor elke kleine verbetering, word je arm.
3. Betrouwbaarheid: Als je zegt "De robot is 73% goed", is dat dan echt goed? Of was het gewoon geluk? Je hebt statistische zekerheid nodig.

Spark-LLM-Eval is de oplossing die de auteur, Subhadip Mitra, heeft bedacht. Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Grote Team (De "Spark" Deel)

Stel je voor dat je een berg post moet sorteren. Als je dat alleen doet, duurt het dagen.
Spark-LLM-Eval is alsof je 100 postbezorgers (computers) tegelijkertijd op pad stuurt.

• De vragen worden in kleine stapeltjes verdeeld.
• Elke bezorger doet zijn eigen werk.
• Aan het einde komen ze allemaal terug en tellen ze hun resultaten bij elkaar op.
• Het resultaat: Wat voor één persoon een week duurt, doet dit team in een paar minuten. Het systeem schaalt perfect: meer computers = sneller resultaat.

2. De Slimme Opslagkast (Het "Delta Lake" Caching)

Dit is misschien wel het slimste stukje.
Stel je voor dat je de robot vraagt: "Hoe heet de hoofdstad van Frankrijk?" Hij antwoordt: "Parijs". Dit kost geld.
Vervolgens verander je je test: "Is Parijs de hoofdstad van Frankrijk?" (Een andere vraag, maar hetzelfde antwoord).
Zonder dit systeem zou je de robot opnieuw moeten vragen, en opnieuw betalen.

Spark-LLM-Eval heeft een slimme opslagkast (Delta Lake).

• Het onthoudt: "Ik heb deze vraag al eerder gesteld en het antwoord is 'Parijs'."
• Als je de test opnieuw doet (bijvoorbeeld om een andere manier te meten of de robot goed was), pakt hij het antwoord gewoon uit de kast.
• Het voordeel: Je betaalt geen cent voor het opnieuw vragen. Je kunt je test zo vaak als je wilt aanpassen zonder dat het je geld kost. Het is alsof je een recept hebt opgeschreven; je hoeft de ingrediënten niet opnieuw te kopen als je het gerecht wilt proeven.

3. De Statistiek (De "Waarheidszoeker")

Vaak zeggen mensen: "Mijn robot scoort 73%!" Maar is dat echt beter dan de concurrent die 71% scoort? Of is dat verschil gewoon toeval?
Dit systeem is niet tevreden met een simpel getal. Het doet alsof het een rechter is in een rechtbank:

• Het gebruikt betrouwbaarheidsintervallen: "We zijn 95% zeker dat de echte score ergens tussen 72% en 74% ligt."
• Het doet significantietests: "Is dit verschil echt belangrijk, of is het net alsof je een munt opgooit?"
• Hierdoor weet je zeker dat je robot echt beter wordt, en niet dat je gewoon geluk had.

4. De Rechter (LLM-as-Judge)

Soms is het antwoord niet simpel "ja" of "nee". Soms moet je een gedicht beoordelen. Wie doet dat?
Dit systeem gebruikt een andere, nog slimmere robot als rechter. Die leest het antwoord van je robot en zegt: "Dit is een 4 op 5 voor creativiteit."
Het systeem zorgt ervoor dat deze rechter ook snel en eerlijk werkt, en dat hij niet bevooroordeeld is (bijvoorbeeld door te langere antwoorden te prefereren).

Waarom is dit belangrijk?

Vroeger konden bedrijven alleen testen met kleine, simpele tests. Nu, met Spark-LLM-Eval, kunnen ze:

• Testen op miljoenen echte gebruikersvragen.
• Geld besparen door niet twee keer te betalen voor hetzelfde antwoord.
• Zeker weten dat hun robot echt betrouwbaar is, niet alleen toevallig goed.

Kort samengevat:
Spark-LLM-Eval is als het bouwen van een super-snel, goedkoop en uiterst nauwkeurig testlab voor slimme robots. Het verdeelt het werk over een heel team, hergebruikt oude antwoorden om geld te besparen, en gebruikt wiskunde om te bewijzen dat de robot echt slim is. En het beste van alles? Het is gratis open source, zodat iedereen het kan gebruiken.

Technische samenvatting

Probleemstelling

De snelle implementatie van Large Language Models (LLM's) in productieomgevingen heeft een urgente behoefte gecreëerd aan schaalbare evaluatie-infrastructuur. Bestaande evaluatieframeworks (zoals lm-evaluation-harness, RAGAS, DeepEval) zijn ontworpen voor academische benchmarks met datasets van enkele duizenden voorbeelden. Ze werken echter op één machine en gebruiken sequentiële verwerking of beperkte lokale parallelisatie.

Dit leidt tot drie hoofdproblemen bij het evalueren van modellen op de schaal van honderdduizenden of miljoenen voorbeelden (nodig voor real-world query-distributies, regressietests en gedetailleerde segmentanalyse):

1. Schaalbaarheid: Enkelsysteem-architecturen worden een bottleneck; verwerkingstijden worden onpraktisch lang.
2. Statistische Rigoor: Het rapporteren van enkelvoudige punt-schatters (bijv. "73,2% nauwkeurigheid") zonder betrouwbaarheidsintervallen of significantietests is misleidend. Het berekenen van statistische betrouwbaarheid (zoals bootstrap) vergt extra rekenkracht die de bottleneck verergert.
3. Kosten en Iteratie: Elke evaluatie vereist API-aanroepen. Het itereren op metriekdefinities (na het zien van eerste resultaten) vereist vaak het opnieuw draaien van alle inferenties, wat de kosten exponentieel laat stijgen.

Methodologie: Spark-LLM-Eval

De auteurs introduceren Spark-LLM-Eval, een gedistribueerd evaluatieframework dat native is gebouwd op Apache Spark. De kerninsight is dat LLM-evaluatie op voorbeeldniveau een "embarrassingly parallel" probleem is: elk prompt kan onafhankelijk worden verwerkt.

Het systeemarchitectuur bestaat uit vier fasen:

1. Prompt Voorbereiding: Omzetten van ruwe data naar modelinputs via Jinja2-sjablonen.
2. Gedistribueerde Inferentie:
   • Gebruik van Pandas UDF's (vectorized user-defined functions) voor efficiënte batch-verwerking.
   • Rate Limiting: Implementatie van een "token bucket"-algoritme per executor om API-limieten (requests per minute, tokens per minute) te respecteren zonder throttling.
   • Inference Engine Abstraction: Een gemeenschappelijke interface voor providers (OpenAI, Anthropic, Google) met ingebouwde retry-logica en token-telling.
3. Response Caching:
   • Een cachinglaag gebaseerd op Delta Lake die inferentie koppelt aan metriekberekening.
   • Cachesleutels zijn deterministisch (SHA-256 hash van prompt, model, provider, parameters).
   • Ondersteuning van verschillende modi: Enabled, Read-only, Write-only, Replay (geen API-calls, alleen cache), en Disabled.
   • Dit stelt gebruikers in staat om metriekdefinities te wijzigen zonder opnieuw te infereren ("Replay mode").
4. Statistische Aggregatie:
   • Berekening van betrouwbaarheidsintervallen (Confidence Intervals) voor elke metriek.
   • Gebruik van Bootstrap-methoden (Percentile en BCa) voor niet-normale verdelingen en analytische methoden (Wilson score, t-test) waar van toepassing.
   • Significantietests voor modelvergelijkingen: McNemar's test (binair), Paired t-test (continu/normal), Wilcoxon signed-rank (ordinaal/niet-normaal) en Bootstrap Permutation tests.

Belangrijkste Bijdragen

1. Lineaire Schaalbaarheid: Een architectuur die lineair schaalt met het clusterformaat, met een verwerkingssnelheid van >10.000 voorbeelden per minuut (beperkt door API-limieten, niet door compute).
2. Delta Lake Caching: Een systeem dat inferentie loskoppelt van metriekberekening, waardoor experimenten met nieuwe metrieken zonder extra API-kosten kunnen worden uitgevoerd.
3. Geïntegreerde Statistiek: Een framework dat standaard betrouwbaarheidsintervallen en geschikte significantietests levert, afhankelijk van het type metriek en steekproefgrootte.
4. Veelzijdige Metrieken: Ondersteuning voor lexische (Exact Match, BLEU), semantische (BERTScore, Embedding), LLM-as-Judge en RAG-specifieke metrieken (Faithfulness, Context Relevance).
5. Open Source & Integratie: Implementatie met ondersteuning voor meerdere providers en integratie met MLflow voor experiment-tracking.

Resultaten

Experimenten zijn uitgevoerd op een Databricks-cluster (2-16 executors) met datasets van 1.000 tot 100.000 voorbeelden.

• Throughput: Het systeem bereikte lineaire schaalbaarheid tot de globale API-rate limit werd bereikt (rond 8 executors).
  • 1 Executor: ~1.200 voorbeelden/min.
  • 8 Executors: ~9.800 voorbeelden/min.
  • Dit vertegenwoordigt een 21x snelheidswinst ten opzichte van een sequentiële single-threaded baseline.
• Kostenbesparing: Dankzij de "Replay mode" kon bij het itereren van metrieken (na een initiële run) 100% van de API-calls worden gemist. In een workflow met 50.000 voorbeelden en drie iteraties resulteerde dit in een kostenreductie van 75% en een tijdsbesparing van 69%.
• Statistische Validatie:
  • De BCa-bootstrap-methode bood de beste dekking (nabij 95%) voor gekromde verdelingen, zelfs bij kleinere steekproeven.
  • Significantietests (McNemar, t-test, Wilcoxon) behielden een Type I-foutrate van ongeveer 5% onder de null-hypothese.
• Kostenvergelijking: Voor 10.000 voorbeelden varieerden de kosten per provider van $1,50 (GPT-4o-mini) tot $34,50 (Claude 3.5 Sonnet), wat aantoont dat het gebruik van goedkopere modellen voor grootschalige regressietests haalbaar is.

Betekenis en Conclusie

Spark-LLM-Eval lost de praktische barrières op die rigoureuze evaluatie van LLM's op grote schaal belemmeren. Door de evaluatie te behandelen als een data-parallel probleem en gebruik te maken van de kracht van Apache Spark, biedt het framework:

• Schaalbaarheid: Het maakt evaluatie mogelijk op datasets die real-world query-distributies weerspiegelen, in plaats van alleen academische benchmarks.
• Statistische Betrouwbaarheid: Het verschuift de standaard van het rapporteren van punt-schatters naar het rapporteren van statistisch onderbouwde resultaten met betrouwbaarheidsintervallen.
• Kostenefficiëntie: Door caching en het scheiden van inferentie van evaluatie, wordt de kostenbarrière voor iteratief verbeteren van modellen verlaagd.

Het framework is beschikbaar als open source en richt zich op practitioners die modellen moeten valideren in complexe, productiesituaties waar standaard benchmarks ontoereikend zijn.