Identifying and Mitigating Systemic Measurement Bias in Production LLM Inference Benchmarks

Technische Samenvatting: Het Identificeren en Mitigeren van Systematische Meetbias in Productie-LLM-Inferentiebenchmarks

1. Het Probleem: Systematische Meetbias bij Evaluatie met Hoge Concurrency

Naarmate Large Language Models (LLM's) de overgang maken van onderzoek naar productie, is het evalueren van prestaties volgens strikte Service Level Objectives (SLO's) cruciaal geworden. De paper identificeert echter een fundamenteel gebrek in de huidige benchmarkmethodieken: systematische meetbias veroorzaakt door de evaluatieclient zelf.

Standaard industriële tools (zoals vLLM Bench, SGLang benchmark, NVIDIA GenAI Perf) vertrouwen voornamelijk op single-process, Python asyncio-gedreven architecturen. Hoewel deze toereikend zijn voor testen met lage belasting, falen deze architecturen onder productie-schaal concurrentie (honderden tot duizenden Queries Per Second). De auteurs stellen dat de Python Global Interpreter Lock (GIL) een ernstige bottleneck aan de client-kant creëert. Wanneer een single-threaded eventloop probeert duizenden gelijktijdige tokenstreams te verwerken, nadert de benuttingsfactor verzadiging, waardoor client-kant wachttijden in de wachtrij naar oneindig neigen.

Omdat standaardbenchmarks latentie registreren bij tokenverwerking in plaats van bij netwerkaankomst, worden deze client-kant vertragingen ten onrechte geregistreerd als server-kant degradatie. Bijgevolg diagnosticeren practitioners meetartefacten vaak ten onrechte als infrastructuurfouten of bottlenecks van modelservers. Bovendien slagen traditionele metrieken zoals Time Per Output Token (TPOT) er niet in om de volledige computatiekosten van het serveren vast te leggen, met name door prefill-boetes en de impact van prefix-caching op initiële responstijden te negeren.

2. Methodologie: Wiskundige Modellering en Gedistribueerde Evaluatie

Om deze onnauwkeurigheden op te lossen, stellen de auteurs een rigoureus kader voor dat wiskundige modellering combineert met een nieuwe gedistribueerde evaluatiearchitectuur.

Wiskundige Modellering (M/G/1-wachtrij):
De auteurs modelleren de benchmarkclient als een M/G/1-wachtrij.

• Laat $\lambda$ de aankomstfrequentie van tokens van de server zijn.
• Laat $\mu$ de servicefrequentie van de Python eventloop zijn (deserialisatie- en opnamesnelheid).
• De benuttingsfactor is $\rho = \lambda / \mu$.
• Volgens de Pollaczek-Khinchine-formule, wanneer $\rho \to 1$, nadert de verwachte wachttijd in de interne wachtrij van de client ($W_q$) oneindig.
  Dit model toont wiskundig aan dat single-process clients Time to First Token (TTFT) en TPOT-metrieken kunstmatig opblazen naarmate de aanvraagfrequentie toeneemt, waardoor ze onbetrouwbaar worden voor productieprofilering.

Voorgestelde Oplossing: Multi-Process Kader (Inference Perf)
De paper introduceert Inference Perf, een open-source evaluatiesysteem ontworpen om client-kant bias te elimineren door middel van gedistribueerde lastverdeling:

• Architectuur: In plaats van één proces, start het kader $m$ geïsoleerde Python-processen die overeenkomen met de beschikbare vCPU's.
• Lastverdeling: De totale aankomstfrequentie $\lambda$ wordt verdeeld over $k$ processen, waardoor de benuttingsfactor per proces wordt gereduceerd tot $\rho_k = \lambda / (k\mu)$. Dit zorgt ervoor dat $\rho_k \ll 1$, waardoor client-kant wachtrijen verwaarloosbaar blijven.
• Continue Latentieprofilering: In plaats van statische metingen op één punt, genereert het kader Latentieprofielen door de last lineair of geometrisch te verhogen totdat structurele verzadiging wordt bereikt, waarmee het ware inflectiepunt van de hardwarecapaciteit wordt geïdentificeerd.

Nieuwe Metriek: Genormaliseerde Time Per Output Token (NTPOT)
Om het ontoereikende karakter van standaard latent metrieken aan te pakken, formaliseren de auteurs NTPOT, een samengestelde metriek die de end-to-end latentie over de outputsequentie amortiseert:
$$NTPOT_i = \frac{T^{(i)}_{queue} + (I_i \times T^{(i)}_{prefill}) + (N_i \times T^{(i)}_{decode})}{N_i}$$
Waarbij $I_i$ de inputlengte is, $N_i$ de outputlengte, en de termen respectievelijk wachttijd in de wachtrij, prefill-latentie en decode-latentie vertegenwoordigen. Deze metriek vangt robuust planningsvertragingen en prefill-boetes (cruciaal voor RAG-workflows) op, genormaliseerd naar de outputlengte, en biedt een verenigd beeld van de door de gebruiker waargenomen latentie.

3. Belangrijkste Bijdragen

De paper schetst drie primaire bijdragen:

1. Empirische Isolatie van Meetbias: Een kwantitatieve analyse die aantoont hoe single-process architecturen latent metrieken kunstmatig opblazen onder hoge concurrentie, gevalideerd door het modelleren van de client als een M/G/1-wachtrij.
2. Formalisatie van een Unificatie SLO-Metriek: De definitie van NTPOT, die prestatie-evaluatie standaardiseert door wachtrijconcurrentie en prefill-boetes op te nemen, en zo een nauwkeurigere weerspiegeling biedt van de end-user-ervaring dan geïsoleerde decode-metrieken.
3. Ontwerp van een Onbevooroordeeld Evaluatiekader: Het voorstellen en implementeren van een multi-process benchmarkmethodiek (via Inference Perf) die client-kant bias mitigeert, waardoor accurate profilering van LLM's mogelijk wordt op schalen die 5.000 QPS overstijgen.

4. Experimentele Resultaten

De auteurs voerden empirische evaluaties uit met de llm-d-inference-sim-simulator (die server-kant latentie van bijna nul heeft) om client-kant overhead te isoleren. Tests werden uitgevoerd op een 144-vCPU-instantie om hardware-bottlenecks uit te sluiten.

• Lasttrouw en Faalfrequentie:
  • Bij 1.000 QPS leden single-process tools (vLLM Bench, Inference X) aan catastrofale faalfrequentie, met verzadiging op respectievelijk 146 en 443 QPS.
  • De multi-process Inference Perf slaagde erin de volledige last van 1.000 QPS te handhaven zonder throttling.
  • Bij 5.000 QPS liepen single-process tools uit op tijd en faalden. Inference Perf verwerkte succesvol 4.998 QPS, wat een 7,2-voudig verschil in meetcapaciteit aantoont ten opzichte van single-process alternatieven bij 1.000 QPS.
• Latentie-opblazing:
  • In de 1.000 QPS-proef injecteerden single-process tools kunstmatige vertragingen variërend van 8 ms tot 58 seconden als gevolg van client-kant wachtrijen.
  • Daarentegen handhaafde Inference Perf een end-to-end overhead van slechts 0,63 milliseconden.
• Cross-Paradigma Validatie:
  • De multi-process Python-methodiek bereikte prestatie-pariteit met k6 (een Go-gebaseerde loadgenerator die native goroutines gebruikt), en slaagde erin 5.000 QPS te verwerken.
  • Dit bevestigt dat, hoewel de GIL van Python een beperking is, een gedistribueerde, multi-process architectuur het Python-LLM-ecosysteem veilig kan benutten voor evaluatie op productieschaal.

5. Betekenis en Claims

De paper beweert dat de huidige afhankelijkheid van single-process asyncio-benchmarks een "meetbias veroorzaakt door de waarnemer zelf" creëert, wat leidt tot verkeerd gedetecteerde infrastructuurfouten.

De betekenis van dit werk ligt in de overgang van beperkte micro-benchmarking naar onbevooroordeelde, gedistribueerde evaluatie. Door client-kant bottlenecks wiskundig te isoleren en NTPOT in te voeren, bieden de auteurs een kader dat:

• De accurate ontdekking van ware hardware-verzadigingspunten mogelijk maakt.
• Zorgt dat architecturale optimalisaties worden gedreven door reproduceerbare, wiskundig onderbouwde data in plaats van meetartefacten.
• Een rigoureuze standaard vestigt voor het evalueren van LLM-serving stacks op productieschalen (duizenden QPS), wat essentieel is naarmate AI-systemen de overgang maken van onderzoek naar kritieke infrastructuur.

De auteurs merken op dat, hoewel hun huidige kader vertrouwen stelt op verticale schaling (multi-core single nodes), toekomstig werk zich moet richten op multi-node gedistribueerde evaluatie om extreme drempels (bijv. >100.000 QPS) en niet-uniforme verkeerspatronen aan te kunnen.