🤖 machine learning

SparsePixels: Efficient Convolution for Sparse Data on FPGAs

Het artikel introduceert SparsePixels, een op FPGA gebaseerd framework dat constante latentie-inferentie bereikt voor ijle data door selectief alleen op actieve pixels te rekenen, waarbij een 73-voudige versnelling wordt aangetoond ten opzichte van standaard dichte CNN's voor de identificatie van neutrino-interacties met minimaal prestatieverlies.

Oorspronkelijke auteurs: Ho Fung Tsoi, Dylan Rankin, Vladimir Loncar, Philip Harris

Gepubliceerd 2026-06-30

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Ho Fung Tsoi, Dylan Rankin, Vladimir Loncar, Philip Harris

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Het Probleem: De "Drukke Bij" vs. Het "Lege Veld"

Stel je voor dat je een beveiliger bent in een enorm stadion (de FPGA-chip) en je de taak hebt om elke stoel op de tribunes te controleren om te zien of er iemand een kaartje vasthoudt (het verwerken van een afbeelding).

In een standaard computersysteem moet de bewaker elke rij aflopen, elke stoel controleren en vragen: "Is er hier iemand?", zelfs als 99% van de stoelen leeg is. Dit is hoe standaard AI (Convolutional Neural Networks) meestal werkt: het scant de volledige afbeelding, pixel voor pixel, ongeacht of er iets interessants in zit.

In experimenten uit de deeltjesfysica (zoals bij CERN of neutrino-detectoren) zijn de "afbeeldingen" vaak enorme rasters met data, maar de eigenlijke "actie" (zoals een spoor van een deeltje) vindt slechts plaats op een paar kleine, verspreide plekken. Het is alsoals zoeken naar één mier in een veld zo groot als een voetbalstadion. Als de bewaker elk grassprietje moet controleren, duurt het heel lang. In deze experimenten moeten beslissingen worden genomen in microseconden (miljoenste seconden). Als de bewaker te lang doet over het controleren, wordt de gebeurtenis voor altijd gemist.

De Oplossing: De "Slimme Verkenner" (SparsePixels)

De auteurs van dit paper hebben een nieuw systeem ontwikkeld genaamd SparsePixels. In plaats van een bewaker te sturen om elke stoel te controleren, sturen ze een Slimme Verkenner.

Zo werkt de Verkenner:

De Snelle Scan: De Verkenner doet eerst een supersnelle ronde door het stadion. Ze controleren niet elke stoel; ze kijken alleen naar beweging of ruis.
De Korte Lijst: Zodra ze een stoel spotten met een persoon (een "actieve pixel"), schrijven ze de locatie op een korte lijst. De lege stoelen negeren ze volledig.
Het Gerichte Werk: De Verkenner neemt vervolgens deze korte lijst van alleen de interessante stoelen en doet de gedetailleerde analyse op precies die paar plekken.

Omdat de Verkenner alleen werkt op de weinige stoelen waar daadwerkelijk mensen in zitten, wordt de klus ongelooflijk snel geklaard.

De Magische Truk: Constante Snelheid

Het slimste deel van dit systeem is dat de snelheid altijd hetzelfde is, ongeacht hoe leeg het stadion is.

Standaard AI: Als het stadion voor 99% leeg is, loopt de bewaker nog steeds de hele route af. Als het stadion voor 100% vol is, loopt de bewager de hele route af. De tijd varieert op basis van de menigte.
SparsePixels: Het systeem heeft een regel: "We zullen nooit meer dan 20 stoelen controleren."
- Als de afbeelding 5 interessante plekken heeft, controleert het systeem 5 plekken en vult de lijst aan met "dummy"-plekken om tot 20 te komen.
- Als de afbeelding 15 interessante plekken heeft, controleert het 15 plekken en vult aan tot 20.
- Als er 20 plekken zijn, controleert het er 20.

Omdat het systeem altijd exact dezelfde hoeveelheid werk verricht (het controleren van maximaal 20 plekken), is de tijd die nodig is om klaar te zijn constant. Het maakt er niet uit of de input "sparse" (ijdel/gespreid) of dicht is; de "initiation interval" (de tijd tussen het verwerken van de ene afbeelding en de volgende) verandert nooit. Dit is cruciaal voor de strikte tijdsvereisten van de deeltjesfysica.

De Resultaten: 73 keer sneller

De onderzoekers hebben dit getest op een FPGA (een gespecialiseerde computerchip die in deze experimenten wordt gebruikt) met echte data van neutrino-detectoren.

De Oude Manier (Standaard CNN): Om een enkele afbeelding van een neutrino-interactie te verwerken, deed het standaard systeem er ongeveer 48,6 microseconden over.
De Nieuwe Manier (SparsePixels): Door slechts minder dan 1% van de pixels te bekijken (de actieve pixels), voltooide het nieuwe systeem dezelfde taak in 0,665 microseconden.

Dat is een versnelling van 73 keer.

Ze ontdekten ook dat terwijl het nieuwe systeem 99% van de data negeerde, het niet veel "intelligentie" verloor. Het verloor slechts een klein beetje nauwkeurigheid (minder dan 2%), een kleine prijs voor een machine die 73 keer sneller is.

Samenvattende Analogie

Denk aan het lezen van een boek om een specifiek woord te vinden.

Standaard CNN: Je leest elke letter op elke pagina, zelfs de lege marges en de ruimtes tussen de woorden, om er zeker van te zijn.
SparsePixels: Je scant de pagina snel, vindt de woorden die eruitzien alsoals ze het doelwit kunnen bevatten, en leest alleen die specifieke woorden. De rest van de pagina negeer je volledig.

Het paper bewijst dat voor "sparse" data (waarbij het grootste deel van de afbeelding lege ruimte is), deze "scannen en focussen"-methode computers in staat stelt om beslissingen te nemen die snel genoeg zijn om het tempo van de snelste experimenten in het universum bij te houden.

Technische Samenvatting: SparsePixels: Efficiënte Convolutie voor Sparse Data op FPGA's

1. Probleemstelling

Standaard Convolutionele Neurale Netwerken (CNN's) die op Field-Programmable Gate Arrays (FPGA's) worden ingezet voor deeltjesfysica-experimenten, lijden vaak aan hoge inferentielatentie en lange initiatie-intervallen. Deze inefficiëntie ontstaat doordat standaard convolutie vereist dat elke inputpixel dens wordt verwerkt, ongeacht of de pixel semantische informatie bevat. In veel moderne detectorapplicaties, zoals muon-tracking in gaskamers of neutrino-identificatie in Liquid Argon Time Projection Chambers (LArTPC's), is de inputdata ruimtelijk 'sparse' (ijjl). Zo kan een muon-spoor bijvoorbeeld minder dan 0,3% van een 2D-afbeelding beslaan, en neutrino-sporen in LArTPC's kunnen zelfs slechts 0,01% niet-nul pixels hebben.

Huidige FPGA-implementaties, zoals die met behulp van de hls4ml-bibliotheek, vertrouwen doorgaans op streaming Input/Output (I/O) om de beperkingen in resources te beheersen. Hoewel streaming het resourcegebruik vermindert, verwerkt het pixels sequentieel, wat leidt tot latenties die lineair schalen met de grootte van de afbeelding (bijvoorbeeld het scannen van duizenden lege pixels). Dit maakt standaard CNN's onhaalbaar voor real-time triggersystemen in experimenten met hoge-energiefysica, die beslissingslatenties in het microseconde- of zelfs sub-microsecondebereik vereisen om botsingsfrequenties van 40 MHz te kunnen verwerken.

Bestaande methoden voor sparse convolutie voor GPU's (bijv. MinkowskiEngine, SpConv) laten de actieve pixels over lagen heen vaak "dileren" (uitdijen), wat de computationele kosten verhoogt, of ze vertrouwen op onregelmatige datastromen die resulteren in een input-afhankelijke runtime. In systemen met strikte latentiebounds is een variabele runtime onacceptabel.

2. Methodologie: Het SparsePixels Framework

De auteurs introduceren SparsePixels, een framework ontworpen om sparse convolutie op FPGA's te implementeren met behoud van een constante, input-onafhankelijke runtime. De kernfilosofie is om selectief alleen een kleine, vooraf gespecificeerde subset van actieve pixels te behouden en te berekenen, terwijl de rest wordt genegeerd, zodat het totale aantal operaties vast blijft voor elke input.

2.1 Kernarchitectuur

Het framework bestaat uit vijf gespecialiseerde sparse lagen ontworpen voor High-Level Synthesis (HLS):

Sparse Input Reduction: De eerste laag identificeert actieve pixels (die een drempelwaarde overschrijden) en extraheert deze naar compacte arrays. Om data-afhankelijke schrijfassressen (die scheduling-problemen in HLS veroorzaken) te vermijden, gebruiken de auteurs een recursieve binaire reductieboom. Dit hardware-efficiënte schema scant de input volgens een vast patroon om twee arrays te vullen: een feature-array (afeat) en een coördinaat-hash-array (ahash). Het aantal behouden pixels wordt begrensd door een hyperparameter, $N_{max}^{active}$ .
Sparse Convolution: Deze laag voert een sparsity-behoudende convolutie uit. Cruciaal is dat een outputpixel alleen wordt berekend als de corresponderende inputpixel op dezelfde locatie actief is. Dit voorkomt de "dillatie" van de actieve set die bij andere sparse methoden wordt gezien. Het algoritme iterereert over de vaste grootte van de sparse arrays in plaats over het volledige beeldraster. Het aantal iteraties hangt af van $N_{max}^{active}$ , niet van de kernelgrootte $K$ , aangezien kernelposities worden bepaald via offset-controles in plaats van expliciete loops over alle $K^2$ posities.
Sparse Activation: Past elementwijze niet-lineariteit toe op de sparse feature-array.
Sparse Pooling: Downsampled de sparse representatie door coördinaten in kaart te brengen en features te accumuleren voor pixels die in dezelfde pool terechtkomen.
Sparse Flattening: Zet de uiteindelijke sparse representatie terug om naar een dense array voor verbinding met standaard dense lagen (MLP).

2.2 Implementatiedetails

Constante Runtime: Omdat het systeem werkt met arrays van een vaste grootte ( $N_{max}^{active}$ ), die zijn opgevuld met ongeldige flags als de input minder actieve pixels heeft, is de inferentielatentie onafhankelijk van de werkelijke input-sparsity.
Training: Er is een Python-bibliotheek ontwikkend om deze sparse CNN's te trainen met behulp van Quantization-Aware Training (QAT) met QKeras als backend. De training simuleert het HLS-gedrag, inclusief de vaste $N_{max}^{active}$ restrictie.
Hardware Target: Het ontwerp richt zich op AMD/Xilinx Alveo FPGA's (xcu250) met gebruik van Vitis HLS, werkend op 200 MHz.

3. Belangrijkste Bijdragen

Sparse Convolution Methode: Een nieuwe benadering voor FPGA's die adaptief actieve pixels selecteert maar een vast computationeel budget afdwingt ( $N_{max}^{active}$ ), wat een constante latentie garandeert ongeacht de input-sparsity.
Proof-of-Concept Implementatie: Een demonstratie van significante FPGA-inferentiesnelwinsten op ruimtelijk sparse beelddata met vergelijkbare modelprestaties als standaard CNN's.
Open-Source Tooling: Een publiekelijk vrijgegeven Python-bibliotheek voor het trainen van sparse CNN's en C++ HLS-modules voor deployment, wat de adoptie binnen de deeltjesfysica-gemeenschap vergemakkelijkt.

4. Experimentele Resultaten

De auteurs evalueerden SparsePixels op drie datasets: een gesparsifieerde MNIST-variant, MicroBooNE neutrino-detectie, en LHC jet flavor tagging. De modellen waren compact (~4k parameters) en werden vergeleken met standaard CNN-baselines geïmplementeerd met stream I/O.

Prestaties vs. Latentie: Op de MicroBooNE-dataset (63×63 afbeeldingen, ~4k pixels) had een standaard 8-bit CNN een inferentietijd van 48,665 µs (9.733 klokcycli) nodig. De SparsePixels "sparse-large" variant (berekening op slechts 20 actieve pixels, <1% van de input) behaalde een inferentietijd van 0,665 µs (133 klokcycli). Dit vertegenwoordigt een 73× versnelling met een verwaarloosbaar prestatieverlies (<2% daling in ROC AUC).
Schaalbaarheid: Vergelijkbare versnellingen werden waargenomen voor MNIST (tot 41×) en LHC jet tagging (tot 112×).
Resource Gebruik: Hoewel sparse CNN's meer resources gebruiken (door loop unrolling voor parallellisme) dan streaming standaard CNN's, blijft het resourcegebruik ruim binnen de on-chip budgetten (bijv. ~20% van de LUT's voor de grootste modellen).
Initiatie-interval (II): De II voor sparse CNN's wordt uitsluitend bepaald door de sparse input reduction laag (de eerste laag), aangezien de daaropvolgende lagen parallel opereren op de vaste-grootte sparse arrays.

5. Betekenis en Beperkingen

Betekenis:
De paper stelt dat SparsePixels de implementatie van CNN's in ultra-lage-latentie regimes (sub-microseconde) mogelijk maakt die vereist zijn voor moderne deeltjesfysica triggers, waar standaard CNN's momenteel onhaalbaar zijn vanwege de latentie. Door een kleine, controleerbare hoeveelheid nauwkeurigheid in te ruilen voor enorme snelheidswinsten, maakt het framework geavanceerdere online algoritmen mogelijk voor experimenten zoals de High-Luminosity LHC.

Beperkingen en Toekomstig Werk:

Parallellisatie Beperkingen: De huidige implementatie voert loops volledig uit (unrolling) om latentie te minimaliseren, wat de maximale inputgrootte en modelcomplexiteit beperkt vanwege uitputting van de FPGA-resources. Toekomstig werk beoogt flexibele controle over parallellisatie te introduceren om latentie tegenover resource-efficiëntie af te wegen.
Hyperparameter Tuning: De keuze voor $N_{max}^{active}$ is momenteel empirisch. De auteurs stellen voor om deze parameter (en potentieel de drempelwaarde) in toekomstige versies trainbaar te maken.
Quantisatie: De huidige backend gebruikt uniforme per-layer quantisatie. Toekomstige upgrades plannen het adopteren van High-Granularity Quantization (HGQ) voor fijnere controle.

De auteurs concluderen dat SparsePixels een levensvatbaar pad biedt voor efficiënte datareading in experimenten met microseconde-niveau latentie-eisen, waarmee de kloof wordt overbrugd tussen de behoefte aan complexe ML-modellen en de strikte timing-restricties van real-time hardware-triggers.