InstMeter: An Instruction-Level Method to Predict Energy and Latency of DL Model Inference on MCUs

Dit artikel introduceert InstMeter, een nauwkeurige en lineaire voorspeller voor energie- en latentiekosten van deep learning-modellen op microcontrollers die op instructieniveau werkt en aanzienlijk betere prestaties levert dan bestaande methoden met minder trainingsdata.

De kern

Stel je voor dat je een slimme horloge of een slimme oordopjes wilt bouwen die geluid herkennen of beelden kunnen zien. Om dit te laten werken zonder dat de batterij direct leeg is, moet je een heel klein, slim brein (een Deep Learning-model) op een heel klein computerchipje (een microcontroller of MCU) zetten.

Het probleem? Het is als het proberen te passen van een olifant in een jerrycan. Je moet precies weten hoeveel "ruimte" (energie) en "tijd" (snelheid) dat brein nodig heeft, voordat je het erop zet. Als je het verkeerd inschat, werkt je apparaat niet of gaat de batterij in een seconde op.

InstMeter: De slimme schattingsservice

Dit artikel introduceert InstMeter, een nieuwe manier om precies te voorspellen hoeveel energie en tijd zo'n slim brein nodig heeft. Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het oude probleem: Het raden van de olifant

Vroeger probeerden wetenschappers het gewicht van de olifant te schatten door te tellen hoeveel "poten" hij had (dit noemen ze MACs of vermenigvuldigingen).

• Het probleem: Het tellen van poten is niet genoeg. Een olifant kan op één been staan of op vier. Het hangt af van hoe hij loopt.
• De consequentie: Om de olifant goed te wegen, moesten ze duizenden olifanten meten om een patroon te vinden. Dat kostte enorm veel tijd en energie. Het was als proberen een recept te leren door duizenden keren te koken, in plaats van te weten hoe lang het koken duurt.

2. De oplossing van InstMeter: Kijk naar de hartslag

InstMeter kijkt niet naar de "poten" (de grote onderdelen), maar naar de hartslag van de chip: de klokcycli.

• De analogie: Stel je voor dat elke opdracht die de chip uitvoert, één tik van een klok is.
  • Als de chip een som maakt, tikt de klok 10 keer.
  • Als hij een getal opslaat, tikt hij 5 keer.
• InstMeter telt simpelweg hoeveel keer de klok moet tikken om het hele programma uit te voeren.
• Waarom is dit slim? Omdat het aantal tikken rechtstreeks samenhangt met hoeveel energie er wordt verbruikt en hoe lang het duurt. Het is een rechtlijnige relatie: meer tikken = meer energie en tijd. Geen ingewikkelde formules nodig!

3. De magische vertaler: Van recept naar keuken

Om te weten hoeveel tikken er nodig zijn, moet InstMeter twee dingen met elkaar verbinden:

1. Het recept (De broncode): Hier staat in mensentaal wat er moet gebeuren (bijvoorbeeld: "Herhaal dit 100 keer").
2. De keuken (De machinecode): Dit is wat de chip daadwerkelijk ziet, vol met vreemde tekens en instructies.

Het probleem is dat het recept vaak niet zegt hoe de chef-kok (de compiler) de ingrediënten bereidt. Soms snijdt hij alles in één keer, soms in stukjes.

• De oplossing van InstMeter: Ze hebben een slimme vertaler gebouwd die het recept en de keuken met elkaar vergelijkt. Ze kijken niet naar de woorden, maar naar de structuur (zoals de volgorde van stappen) en de vergelijkingen (zoals "als dit groter is dan dat").
• Hierdoor kunnen ze precies zeggen: "Als je dit recept op deze specifieke chip kookt, moet de klok precies 5.000 keer tikken."

4. Waarom is dit een doorbraak?

• Weinig data nodig: Om een oude methode te leren, moesten ze duizenden voorbeelden meten. Met InstMeter hebben ze er minder dan 10 nodig. Het is alsof je een nieuwe taal leert door slechts 10 zinnen te horen, in plaats van een heel woordenboek uit je hoofd te leren.
• Beter resultaat: De oude methoden maakten vaak grote fouten (soms 100% fout!). InstMeter maakt veel kleinere fouten (rond de 30% of minder).
• Werkt overal: Ze hebben het getest op verschillende chips (van ARM tot RISC-V), bij verschillende temperaturen (van koud tot warm), en met verschillende software-instellingen. Het werkt overal betrouwbaar.

Conclusie

InstMeter is als een slimme voorspeller die je vertelt: "Als je dit slimme brein op jouw horloge zet, duurt het 2 seconden en kost het precies zoveel batterij."

Dankzij deze methode kunnen ingenieurs nu veel sneller en slimmer de beste modellen vinden die precies in hun kleine, batterij-aangedreven apparaten passen, zonder dat ze urenlang hoeven te meten en te raden. Het maakt de weg vrij voor nog slimmere, energiezuinige gadgets in onze toekomst.

Technische samenvatting

Probleemstelling

Dieplerningsmodellen (DL) worden steeds vaker uitgevoerd op microcontrollers (MCU's), wat de ontwikkeling van compacte, intelligente apparaten mogelijk maakt. Een cruciale uitdaging bij het ontwerpen van deze modellen is het voldoen aan de strenge beperkingen van MCU's, zoals beperkt geheugen, lage energieconsumptie en lage latentie.

Om de beste architectuur te vinden binnen deze beperkingen, wordt vaak gebruikgemaakt van Neural Architecture Search (NAS). NAS vereist echter dat de energie- en latentiekosten van duizenden mogelijke modellen worden voorspeld. Bestaande state-of-the-art (SOTA) methoden voor deze voorspelling hebben twee grote tekortkomingen:

1. Hoge trainingskosten: Ze vereisen duizenden trainingsstalen (metingen) om nauwkeurige voorspellingen te doen.
2. Onnauwkeurigheid door niet-lineariteit: Ze gebruiken vaak grove proxies zoals het aantal 'multiply-accumulate' (MAC) operaties of modelparameters. Deze hebben een niet-lineaire relatie met de werkelijke energie en latentie, omdat ze geen rekening houden met compiler-optimalisaties, instructie-schedulering en specifieke implementatiedetails op het hardware-niveau.

Methodologie: InstMeter

De auteurs stellen InstMeter voor, een voorspeller op instructieniveau die de energie en latentie van DL-modellen op MCU's nauwkeurig schat door gebruik te maken van clock cycles (klokcycli) als fundamentele metric.

De kern van de methode is de transformatie van een niet-lineair probleem naar een lineair probleem. De auteurs stellen dat clock cycles een directe, lineaire relatie hebben met energie en latentie, in tegenstelling tot modelparameters.

Het proces bestaat uit twee hoofdfasen:

1. Instruction Profiling (Mapping Source naar Disassembly):

   • Het doel is om de C++ broncode van TFLM (TensorFlow Lite for Microcontrollers) operatoren te koppelen aan de gegenereerde disassembly-instructies.
   • Observatie: Bij het wijzigen van modelparameters (zoals batchgrootte of filtergrootte) verandert de structuur van de gegenereerde instructies niet; alleen de waarden van de loopvariabelen veranderen.
   • Techniek: De auteurs ontwikkelen een nieuw algoritme voor loop-level mapping. Omdat variablennamen in gecompileerde code vaak worden vervangen door dummy-variabelen, gebruiken ze een combinatie van:
     • Structurele kenmerken: Het genereren van Control Flow Graphs (CFG) voor zowel broncode als disassembly om de hiërarchie en relaties (subset, intersectie) tussen loops te analyseren.
     • Semantische kenmerken: Het gebruik van vergelijkingsoperatoren (zoals <, >, ==) die in zowel broncode als disassembly consistent voorkomen, zelfs als variablennamen veranderen.
   • Dit maakt het mogelijk om het aantal uitvoeringen van elke instructietype te berekenen zonder duizenden modellen te hoeven compileren en meten.

2. Data Collectie en Lineaire Voorspelling:

   • Zodra de instructielibrarie is opgebouwd, wordt het totale aantal clock cycles voor een nieuw model berekend door het aantal uitvoeringen van elke instructie te vermenigvuldigen met het aantal cycles per instructie (CPI).
   • De voorspelling volgt een eenvoudige lineaire vergelijking:
     $$E (\text{of } L) = a \cdot \text{Cycles} + b$$
     Waarbij $a$ de energie/tijd per cyclus is en $b$ een vaste overhead.
   • Om de parameters $a$ en $b$ te bepalen, is slechts een kleine dataset nodig (minder dan 10 trainingsstalen).

Belangrijkste Bijdragen

1. Paradigmaverschuiving: Het transformeren van energie- en latentieschatting van een niet-lineair naar een lineair probleem door gebruik te maken van clock cycles in plaats van modelparameters.
2. Nieuwe Mapping-techniek: Een innovatieve methode om broncode en disassembly-code op loop-niveau te koppelen, wat het mogelijk maakt om instructie-niveau details te combineren met loop-uitvoeringsgedrag zonder hoge overhead.
3. Uitgebreide Dataset: Het creëren van een nieuwe benchmark-dataset voor MCU's die 2125 modellen bevat, met ground-truth metingen voor energie en latentie. Deze dataset dekt diverse MCU-architecturen (ARM Cortex-M4, M7, M33 en RISC-V ESP32-C3), compiler-optimalisaties, GCC-versies, temperaturen en applicaties.
4. Superieure Prestaties: Het aantonen dat InstMeter met extreem weinig trainingsdata (5 stalen) aanzienlijk nauwkeuriger is dan bestaande methoden.

Resultaten

InstMeter is uitgebreid geëvalueerd en toont overtuigende resultaten ten opzichte van SOTA-methoden (zoals MAC-based predictors en nn-Meter):

• Nauwkeurigheid: InstMeter vermindert de voorspellingsfout voor energie met een factor 3 en voor latentie met een factor 6,5 ten opzichte van de beste bestaande methoden.
• Efficiëntie: InstMeter vereist 100x minder trainingsdata voor energievoorspelling en 10x minder voor latentievoorspelling dan SOTA-methoden.
  • Met slechts 5 trainingsstalen behoudt InstMeter een relatieve fout van onder de 30% voor 90% van de modellen.
  • Ter vergelijking: MAC-based methoden hebben 50x meer data nodig voor een fout van ~200%, en nn-Meter heeft 100x meer data nodig voor een fout van ~100%.
• Generalisatie: De methode werkt robuust over verschillende MCU's, compiler-optimalisaties (-Os, -O2), GCC-versies, temperaturen (21°C tot 43°C) en DVFS-instellingen.
• NAS-toepassing: In Neural Architecture Search-scenario's helpt InstMeter om modellen te vinden die dichter bij de energiebeperkingen liggen en een hogere inferentie-accuraatheid behouden dan modellen die zijn geselecteerd met andere voorspellers.

Betekenis en Impact

InstMeter biedt een fundamentele doorbraak in het efficiënt ontwerpen van dieplerningsmodellen voor edge devices. Door de afhankelijkheid van grote datasets en complexe niet-lineaire modellen te doorbreken, maakt het:

• Snellere NAS: Het mogelijk om duizenden architecturen te evalueren zonder de tijdsintensieve metingen op fysieke hardware.
• Betere Resource-gebruik: Het zorgt ervoor dat ontwerpers de energiebudgetten van batterijgestuurde apparaten optimaal benutten zonder de nauwkeurigheid te verliezen.
• Toegankelijkheid: Het openbaar maken van de broncode en de specifieke benchmark-datasets voor MCU's vult een belangrijke leemte in de gemeenschap, aangezien eerdere datasets voornamelijk gericht waren op krachtige processors (CPU/GPU).

Kortom, InstMeter bewijst dat door terug te gaan naar de laagste hardware-niveau (instructies en clock cycles), complexe voorspellingsproblemen kunnen worden vereenvoudigd tot lineaire relaties, wat leidt tot snellere, nauwkeurigere en datavriendelijkere ontwerpprocessen voor embedded AI.