ALADIN: Accuracy-Latency-Aware Design-space Inference Analysis for Embedded AI Accelerators

Dit paper introduceert ALADIN, een framework voor nauwkeurigheids- en latentiebewuste ontwerpruimte-analyse dat de prestaties van gemengd-precisie kwantiseringsneuronale netwerken op ingebouwde AI-accelerators evalueert zonder fysieke implementatie, waardoor de ontwikkelingstijd en -kosten aanzienlijk worden verlaagd.

De kern

Stel je voor dat je een enorm complex recept hebt voor een perfecte taart (een kunstmatige intelligentie of AI). Dit recept is zo gedetailleerd dat het een heel professionele keuken met dure apparatuur nodig heeft om te maken. Maar nu wil je die taart maken in een kleine, compacte keukenkastje op een camping (een slimme camera, een drone of een medisch apparaatje).

Het probleem? Je hebt niet genoeg ruimte, geen krachtige oven en je moet de taart binnen een paar seconden klaar hebben, anders is het eten koud (het systeem moet real-time werken).

Dit is precies het probleem dat het onderzoeksteam van de Scuola Superiore Sant'Anna in Pisa probeert op te lossen met hun nieuwe tool, ALADIN.

Hier is hoe het werkt, vertaald in alledaagse taal:

1. Het Dilemma: Snelheid, Smaak en Ruimte

Wanneer je een AI-model op een klein apparaatje wilt laten draaien, moet je drie dingen in balans houden:

• Smaak (Nauwkeurigheid): Hoe goed is de taart? (Hoe goed herkent de AI een gezicht of een obstakel?)
• Snelheid (Latentie): Hoe snel is hij klaar? (Moet hij binnen een milliseconde reageren, bijvoorbeeld voor een zelfrijdende auto?)
• Ruimte (Hardware): Past hij in je keukenkastje? (Heb je genoeg geheugen en batterij?)

Normaal gesproken moeten ingenieurs dit uitproberen door het recept letterlijk in de campingkeuken te gaan bakken. Ze bouwen het, testen het, zien dat het te traag is, passen het recept aan, en proberen het opnieuw. Dit kost veel tijd, geld en batterijen.

2. De Oplossing: ALADIN (De Digitale Keukenchef)

ALADIN is als een super-simulatie die je op je laptop kunt draaien. Je hoeft het recept niet echt te bakken om te weten of het lukt.

In plaats van het echte apparaat te gebruiken, doet ALADIN het volgende:

1. Het Recept Analyseren: Het kijkt naar het digitale recept (het AI-model) en vraagt: "Wat als we de ingrediënten in kleinere porties verdelen?" (Dit noemen ze kwantisatie: van 32-bit getallen naar 4-bit of 8-bit getallen).
2. De Keuken Checken: Het kijkt naar de specificaties van je campingkeuken (het hardware-platform). Hoeveel planken (geheugen) heb je? Hoeveel koks (processors) werken er tegelijk?
3. De Proefbak: ALADIN "bakt" het recept virtueel. Het berekent precies hoe lang het duurt, hoeveel ruimte het inneemt en hoe lekker de taart nog smaakt, zonder dat er ook maar één calorie verbrand wordt.

3. De Magische Trucs (Hoe het werkt)

De auteurs gebruiken twee slimme trucs in hun simulatie:

• De "Look-Up Table" (Het Kookboek):
  Stel je voor dat je een taart moet maken en je moet elke keer zelf de exacte hoeveelheid suiker berekenen. Dat duurt lang.
  In plaats daarvan kun je een kookboek (een tabel) maken waar al de berekende hoeveelheden in staan. Je hoeft dan alleen maar te kijken: "Ah, voor 3 eieren heb ik 150 gram suiker nodig."

  • Voordeel: Het gaat supersnel.
  • Nadeel: Het boek wordt heel dik en zwaar (het kost veel geheugen).
    ALADIN helpt je te beslissen: "Is het de moeite waard om dat dikke boek mee te nemen, of moeten we gewoon sneller rekenen?"

• De "Im2Col" Transformatie (Het Opvouwen van de Tafel):
  Soms is het makkelijker om een ingewikkelde taart te maken door eerst alle ingrediënten op een grote tafel uit te leggen in een rechte lijn, in plaats van ze in een kring te verdelen. ALADIN ziet precies hoeveel ruimte die "grote tafel" nodig heeft in je kleine keukenkastje.

4. Waarom is dit zo belangrijk?

Zonder ALADIN zouden ingenieurs moeten gokken. Ze zouden zeggen: "Laten we proberen met 4-bit precisie." En dan blijkt dat het apparaat vastloopt omdat het geheugen vol zit, of dat het te traag is.

Met ALADIN kunnen ze zeggen:

"Als we dit deel van de taart met 4-bit maken en dat deel met 8-bit, en we gebruiken de 'kookboek-methode' voor de zware onderdelen, dan past het precies in de keukenkast, is hij 2 keer sneller, en smaakt hij nog steeds 95% even lekker."

Samenvattend

ALADIN is een ontwerptool voor slimme apparaten. Het helpt ingenieurs om de perfecte balans te vinden tussen een slimme AI en een klein, goedkoop apparaatje, zonder dat ze urenlang hoeven te experimenteren met echte hardware. Het is alsof je een architect bent die een huis ontwerpt en precies weet hoeveel meubels erin passen en hoe snel je erdoorheen kunt lopen, voordat er ook maar één baksteen is gelegd.

Dit bespaart tijd, geld en zorgt ervoor dat onze slimme gadgets in de toekomst sneller, slimmer en betrouwbaarder worden.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het artikel "ALADIN: Accuracy–Latency–Aware Design-Space Inference Analysis for Real-Time Embedded AI Accelerators", vertaald en samengevat in het Nederlands.

Titel

ALADIN: Een nauwkeurigheids- en latentiebewuste analyse van het ontwerpruimte voor inferentie in real-time embedded AI-versnellers

1. Het Probleem

De integratie van Deep Neural Networks (DNN's) in hulpbronbeperkte embedded systemen (zoals IoT-apparaten) introduceert complexe afwegingen tussen modelnauwkeurigheid, computatietijd (latentie) en hardware-beperkingen. Dit is vooral kritiek in real-time systemen (bijv. autonome voertuigen, medische apparatuur) waar voorspelbare en lage latentie essentieel is.

De huidige uitdagingen zijn:

• Hoge ontwikkelkosten: Het verkennen van trade-offs vereist vaak het implementeren en porten van modelconfiguraties naar de doelhardware, wat tijdrovende "trial-and-error"-cycli met zich meebrengt.
• Beperkte ontwerpruimte: Door de tijd en kosten van fysieke evaluaties kunnen slechts een klein deel van de mogelijke configuraties (bijv. verschillende quantisatiestrategieën, hardware-sizes) worden getest.
• Late hardware/software-co-design: Beslissingen over geheugengrootte en rekenunits worden vaak te laat in het ontwerpproces genomen, zonder kwantitatieve inzichten.
• Mixed-precision complexiteit: Het gebruik van gemengde precisie (verschillende bit-breedtes per laag) vergroot de ontwerpruimte exponentieel, wat het moeilijk maakt om bottlenecks te voorspellen zonder gedetailleerde simulatie.

2. Methodologie: Het ALADIN Framework

ALADIN is een raamwerk voor het analyseren van inferentie in Quantized Neural Networks (QNN's) met gemengde precisie, specifiek gericht op scratchpad-based AI-versnellers (geen cache-gebaseerde architecturen). Het framework werkt zonder de QNN fysiek op de doelhardware te hoeven deployen.

Het proces verloopt in drie hoofdfasen (zie Figuur 3 in het artikel):

1. Genereren van een implementatie-bewust model (Implementation-Aware Model):

   • Startpunt is een canoniek QONNX-model (een extensie van ONNX voor quantisatie).
   • Het model wordt verrijkt met implementatie-details, zoals de keuze voor berekeningsmethoden (bijv. Look-Up Tables (LUT) versus standaard MAC-bewerkingen, im2col-transformaties voor convoluties).
   • Hierbij worden resources zoals het aantal MAC's (Multiply-Accumulate), BOP's (Bit Operations) en geheugenvereisten per laag berekend op basis van de gekozen quantisatie (uniform/niet-uniform) en implementatiestrategie.

2. Omzetten naar een platform-bewust model (Platform-Aware Model):

   • Het implementatie-bewuste model wordt verder verfijnd met specifieke hardware-kenmerken van de doelplatform (bijv. aantal cores, grootte van L1/L2 scratchpad-geheugen, DMA-capaciteiten).
   • Operaties worden opgesplitst in sub-operaties die individueel kunnen worden gepland op de hardware.
   • Het framework analyseert of data past in het L1-scratchpad en simuleert data-overdrachten (DMA) tussen L3 (DRAM), L2 en L1 geheugen.

3. Validatie en Schedulering via Dory en GVSoC:

   • Het platform-bewuste model wordt gebruikt als input voor Dory, een tool die geoptimaliseerde C-code genereert voor embedded platforms.
   • Deze code wordt uitgevoerd op GVSoC, een cycle-accurate simulator voor RISC-V-based AI-platforms (zoals GAP8).
   • Uit de uitvoeringstraces worden exacte metingen gehaald: cyclus-tellingen, geheugengebruik en latentie.

Belangrijke technische aspecten:

• Im2col-transformatie: Conventionele convoluties worden omgezet naar matrixvermenigvuldiging om efficiënter te werken op embedded hardware.
• Look-Up Tables (LUT): Voor lage precisie (bijv. 2-4 bits) kunnen vermenigvuldigingen worden vervangen door LUT's om berekeningen te versnellen, ten koste van extra geheugen.
• Quantisatie-implementaties: Ondersteuning voor dyadische schaling (vermijden van deling), threshold-trees en LUT's voor niet-uniforme quantisatie.

3. Belangrijkste Bijdragen

• Framework voor Early-Stage Analyse: ALADIN stelt ontwikkelaars in staat om de trade-offs tussen nauwkeurigheid, latentie en resource-gebruik te evalueren op basis van het model alleen, zonder fysieke deploy.
• Gedetailleerde Resource Modeling: Het framework berekent niet alleen het aantal bewerkingen, maar ook de exacte geheugenfootprint (inclusief overhead door im2col en LUT's) en de impact op data-overdrachten.
• Ondersteuning voor Mixed-Precision: Het kan complexe scenario's analyseren waarbij verschillende lagen verschillende bit-breedtes en implementatiestrategieën hebben.
• Hardware-Software Co-design: Het maakt het mogelijk om te testen hoe veranderingen in hardware (aantal cores, geheugengrootte) de prestaties beïnvloeden, wat helpt bij het dimensioneren van de hardware.

4. Resultaten en Evaluatie

De auteurs hebben ALADIN gevalideerd met MobileNetV1 op het GAP8-platform (RISC-V, 8 cores, scratchpad-geheugen). Drie verschillende configuraties (Case 1-3) met variërende precisie (2, 4, 8 bits) en implementaties (im2col vs. LUT) werden vergeleken.

Kernbevindingen:

• Dieptewijze vs. Standaard Convoluties: Dieptewijze convoluties hebben een hogere rekenlast (MAC's) maar een veel kleiner geheugenfootprint. Dit maakt ze zeer geschikt voor LUT-gebaseerde implementaties.
• LUT en Geheugenoverhead: Hoewel LUT's berekeningen versnellen, groeit de grootte exponentieel met de bit-breedte. Bij 4-bit en 2-bit quantisatie bleek dat LUT's in sommige gevallen een bottleneck veroorzaakten door concurrente toegang tot het kleine L1-geheugen door meerdere cores, wat de verwachte snelheidswinst tenietdeed.
• Hardware-Optimalisatie: Door een grid-search uit te voeren (variatie in aantal cores en L2-geheugen) bleek dat:
  • Voor geheugen-intensieve lagen, het verhogen van het aantal cores boven een bepaald punt (4 cores) geen extra winst gaf.
  • In deze gevallen was het vergroten van het L2-geheugen cruciaal om data-reuse te maximaliseren en dure DMA-transfers te verminderen.
• Accuraatheid van de Voorspelling: De door ALADIN voorspelde cyclus-tellingen en geheugengebruik correleerden sterk met de resultaten van de GVSoC-simulatie, wat aantoont dat het framework betrouwbare voorspellingen doet.

5. Betekenis en Impact

ALADIN biedt een krachtig instrument voor systeemarchitecten en embedded ontwikkelaars om:

• Ontwikkeltijd te verkorten: Door het elimineren van fysieke trial-and-error cycli in de vroege ontwerpfase.
• Real-time constraints te garanderen: Door nauwkeurige voorspellingen van inferentie-latentie te maken, kunnen deadlines worden geverifieerd voordat de hardware gebouwd is.
• Geoptimaliseerde co-design: Het stelt ontwikkelaars in staat om de hardware (geheugen, cores) en software (quantisatie, scheduling) gelijktijdig te optimaliseren voor specifieke AI-workloads.
• Inzicht in verborgen bottlenecks: Het onthult subtiele problemen, zoals geheugenconcurrentie bij LUT-gebruik, die moeilijk te detecteren zijn zonder een dergelijk gedetailleerd analysemodel.

Kortom, ALADIN vult een cruciale kloof in de toolchain voor embedded AI door een brug te slaan tussen abstracte modeloptimalisatie en concrete hardware-implementatie, met een sterke focus op real-time en resource-constraints.