MobileKernelBench: Can LLMs Write Efficient Kernels for Mobile Devices?

Deze paper introduceert MobileKernelBench, een evaluatiekader dat aantoont dat huidige LLMs moeite hebben met het genereren van efficiënte kernels voor mobiele apparaten, en stelt MoKA voor, een multi-agent systeem dat de compilatiesuccesrate aanzienlijk verbetert en prestatieverbeteringen mogelijk maakt.

De kern

Stel je voor dat je een enorme, krachtige supercomputer hebt (zoals een AI die code schrijft) en je vraagt die om een heel klein, efficiënt motoronderdeel te ontwerpen voor een slimme telefoon. Dat is precies wat dit onderzoek doet.

Hier is een uitleg van het paper "MobileKernelBench: Can LLMs Write Efficient Kernels for Mobile Devices?" in simpele taal, met een paar creatieve vergelijkingen.

1. Het Probleem: De "Grote Bouwer" en de "Kleine Auto"

Stel je voor dat Large Language Models (LLMs) zoals ChatGPT of Claude supergetalenteerde architecten zijn. Ze kunnen prachtige gebouwen ontwerpen (code voor servers) die enorm groot en krachtig zijn.

Maar nu willen we die architecten vragen om een motor voor een racefiets te ontwerpen (de code die op je telefoon draait, een "kernel").

• Het probleem: De architecten zijn gewend aan gigantische bouwprojecten. Ze weten niet hoe ze een motor moeten bouwen die past in een fiets, die weinig energie verbruikt en die niet uit elkaar valt als je over een kassei rijdt.
• De uitkomst: Als je deze AI's gewoon vraagt om code te schrijven voor je telefoon, maken ze veel fouten. Ze "hallucineren" (verzonnen ze regels die niet bestaan) en hun code werkt vaak niet of is veel te traag. Het is alsof ze proberen een vrachtwagenmotor in een fiets te monteren.

2. De Oplossing: Een Nieuwe Testbaan (MobileKernelBench)

Omdat niemand eerder goed had gekeken of AI dit wel kon, hebben de onderzoekers een nieuwe testbaan gebouwd, genaamd MobileKernelBench.

• De Testbaan: Dit is geen simpele quiz. Het is een compleet laboratorium. Ze hebben 190 verschillende taken verzameld (zoals het verwerken van video, geluid of rekenen) die echt voorkomen op telefoons.
• De Automatische Test: Ze hebben een robotarm gebouwd die de code van de AI pakt, deze probeert te bouwen, hem op een echte telefoon (een Xiaomi) installeert en kijkt of het werkt en hoe snel het is.
• De Resultaten: De "gewone" AI's faalden zwaar. Meer dan de helft van hun code kon niet eens worden gebouwd (zoals een auto die niet start). En als het wel werkte, was het vaak niet sneller dan wat er al bestond.

3. De Held: MoKA (De Meester-Bouwer met een Team)

De onderzoekers dachten: "Oké, de AI is slim, maar hij werkt te eenzaam." Dus bedachten ze MoKA (Mobile Kernel Agent).

Stel je voor dat MoKA geen enkele architect is, maar een bouwteam van drie specialisten die samenwerken:

1. De Coder (De Bouwer): Schrijft de code.
2. De Debugger (De Kwaliteitscontroleur): Kijkt of de code fouten heeft. Als de motor niet start, zegt hij: "Ah, je hebt de verkeerde bout gebruikt!" en geeft de bouwer een nieuwe instructie.
3. De Accelerator (De Tuner): Als de motor wel start, zegt hij: "We kunnen hem sneller maken door de buizen anders te leggen." Hij zoekt naar manieren om de telefoon minder energie te laten verbruiken.

Het geheim van MoKA:
In plaats van één keer te proberen en hopen dat het goed is, werkt dit team in rondes.

• Ronde 1: Bouwen.
• Ronde 2: Controleren op fouten en repareren.
• Ronde 3: Verbeteren voor snelheid.
• En zo gaat het door totdat het perfect is.

Ze gebruiken ook een handboek (de code van de telefoon zelf) om te checken of ze de juiste regels volgen, zodat ze niet meer dingen verzonnen.

4. De Resultaten: Een Revolutie

Toen ze MoKA op de testbaan zetten, gebeurde er magie:

• Succes: Waar de gewone AI's faalden bij 54% van de taken, slaagde MoKA in 93,7% van de gevallen.
• Snelheid: 27,4% van de door MoKA geschreven code was sneller dan wat de menselijke experts al hadden gemaakt.

Conclusie: Waarom is dit belangrijk?

Vroeger dachten we dat AI alleen goed was voor simpele taken. Dit paper laat zien dat AI wel complexe, technische taken voor mobiele telefoons kan doen, maar alleen als we het de juiste tools geven.

• Zonder tools: De AI is als een genie dat in de war raakt in een kleine kamer.
• Met MoKA: De AI krijgt een team, een gereedschapskist en een plan. Dan wordt het een meesterbouwer die zelfs de beste menselijke ingenieurs kan verslaan.

Kortom: AI kan de toekomst van snelle en slimme telefoons helpen bouwen, zolang we het maar niet alleen laten, maar het een goed team geven om mee te werken.

Technische samenvatting

Titel: MobileKernelBench: Kunnen LLM's efficiënte kernels schrijven voor mobiele apparaten?

1. Het Probleem

Hoewel Large Language Models (LLM's) indrukwekkende prestaties laten zien in het genereren van code en zelfs geoptimaliseerde CUDA-kernels voor server-grade GPU's, blijft hun potentieel voor het genereren van kernels specifiek voor mobiele apparaten grotendeels onontdekt. De ontwikkeling van kernels voor mobiele AI-inferentie (on-device inference) verschilt fundamenteel van server-side ontwikkeling en kent drie kritieke uitdagingen:

• Compatibiliteitsprioriteit: Het doel is brede ondersteuning voor diverse trainingsframeworks, wat een enorme verscheidenheid aan operators vereist.
• Ingenieurscomplexiteit: Het mobiele ecosysteem is gefragmenteerd met heterogene backends (CPU, GPU, NPU) en architecturen, wat de ontwikkeling bemoeilijkt.
• Data-schaarste: Er is een gebrek aan hoogwaardige referentie-implementaties voor mobiele inferentieframeworks, wat leidt tot een "data-poor" omgeving die generalisatie voor LLM's moeilijk maakt.

Bestaande benchmarks richten zich voornamelijk op server-GPU's en algoritmische complexiteit, en missen systematische pipelines om gegenereerde kernels direct op mobiele apparaten te valideren.

2. Methodologie

De auteurs introduceren een uitgebreid evaluatiekader en een nieuw agent-systeem om deze kloof te overbruggen.

A. MobileKernelBench (Het Evaluatiekader)
Dit is het eerste benchmark-systeem dat is ontworpen voor cross-framework kernel-implementatie voor mobiele deploy.

• Dataset: Bevat 190 taken afgeleid van 95 primitieve operators (gebaseerd op ONNX Opset 20), gecategoriseerd in 12 typen (bijv. convolutie, matrix, reductie).
• Formaat: Gebruikt gepaarde (PyTorch, ONNX) testdata om cross-framework interoperabiliteit te garanderen.
• Geautomatiseerde Pipeline: Een end-to-end proces dat de kloof tussen host-ontwikkeling en device-verificatie overbrugt. De pipeline omvat:
  1. Automatische registratie van operators.
  2. Framework-compilatie (via CMake/NDK).
  3. Functionele verificatie (vergelijking met ONNX-baseline).
  4. Prestatiebenchmarking op een echt mobiel apparaat (Xiaomi 13 met Snapdragon 8 Gen 2).

B. MoKA (Mobile Kernel Agent)
Om de beperkingen van standaard LLM's te overwinnen, stellen de auteurs MoKA voor, een multi-agent systeem dat een "plan-and-execute" paradigma volgt:

• Coder: Genereert de initiële C++ code en past deze aan op basis van feedback.
• Debugger: Analyseert compilatiefouten en functionele fouten. Het gebruikt tools die bewust zijn van de repository-structuur om cross-file fouten en syntactische problemen op te lossen.
• Accelerator: Optimaliseert de prestaties van functioneel correcte kernels door bottlenecks te analyseren (bijv. geheugentoegang, threading) en optimalisatieplannen voor te stellen.
• Reflectieve Geheugen: Agents delen een geschiedenis van strategieën en uitkomsten om herhaling van fouten te voorkomen en effectieve paden te hergebruiken.

3. Belangrijkste Bijdragen

1. Eerste systematische studie die automatische kernelgeneratie uitbreidt naar het mobiele domein, met een analyse van de fundamentele verschillen tussen server- en mobiel-side ontwikkeling.
2. Introductie van MobileKernelBench: Een robuust systeem met een benchmark en een geautomatiseerde evaluatiepijplijn die compilatiesucces, functionele correctheid en on-device prestaties meet.
3. Ontwikkeling van MoKA: Een multi-agent framework dat autonoom navigeert door de complexiteit van API-gebruik en prestatieoptimalisatie in data-scarce omgevingen.
4. Uitgebreide experimenten: Een gedetailleerde analyse die aantoont dat standaard LLM's falen door hallucinaties en compilatiefouten, terwijl MoKA deze barrières effectief overwint.

4. Resultaten

De auteurs hebben uitgebreide tests uitgevoerd op het MobileKernelBench-platform met de MNN (Mobile Neural Network) framework op een CPU-backend.

• Prestaties van Standaard LLM's:

  • Zelfs de beste modellen (zoals Claude-Sonnet-4.5 en GPT-5) hebben een compilatiesuccesrate (CSR) van slechts ongeveer 47%.
  • De functionele correctheid (FCR) daalt sterk, vaak onder de 35%.
  • Slechts een klein percentage (minder dan 16,3%) bereikt prestaties die gelijk zijn aan of beter zijn dan de native implementatie; slechts 4,7% levert een significante snelheidswinst (>1,5x) op.
  • Standaard fine-tuning methoden (LoRA, GRPO) tonen slechts marginale verbeteringen, voornamelijk door het gebrek aan hoogwaardige trainingsdata voor dit specifieke domein.

• Prestaties van MoKA:

  • Compilatiesucces: Steeg naar 93,7%.
  • Functionele Correctheid: Steeg naar 75,3%.
  • Prestatiesnelheid: 27,4% van de gegenereerde kernels leverde een meetbare snelheidswinst op ten opzichte van de native bibliotheek (met een piek van 6,82x snelheidswinst in een case study voor de LayerNorm2D operator).
  • MoKA overtreft zowel de basismodellen als naive fine-tuning aanzienlijk, wat aantoont dat iteratieve feedback en agent-gestuurde optimalisatie superieur zijn aan statische training voor dit type taak.

5. Betekenis en Conclusie

Dit paper toont aan dat hoewel huidige LLM's worstelen met de hoge ingenieurscomplexiteit en data-schaarste van mobiele kernelontwikkeling, een agent-gestuurde aanpak (MoKA) deze beperkingen kan overwinnen.

De studie benadrukt dat voor gespecialiseerde domeinen met beperkte data, een systeem dat dynamisch context kan ophalen (via repository-tools) en iteratief kan redeneren (plan-and-execute), effectiever is dan het simpelweg fine-tunen van een model. De resultaten bieden een blauwdruk voor het automatiseren van high-performance engineering taken op randapparaten (edge devices) en openen de weg voor toekomstig onderzoek naar het genereren van volledige deploy-frameworks en low-level optimalisaties (zoals NEON en inline assembly) voor diverse hardware-architecturen.