💻 computer science

ADSEQ: A delay-aware autograd-compatible framework for spike-event delivery in SNNs

Dit artikel introduceert ADSEQ, een geheugenefficiënt, autograd-compatibel framework dat exacte gradiëntgebaseerde training van Spiking Neural Networks met vertragingen mogelijk maakt door gebruik te maken van spike-eventqueues, terwijl het aantoont dat optimale queue-implementatiestrategieën aanzienlijk variëren over CPU-, GPU-, TPU- en LPU-hardwareplatforms.

Oorspronkelijke auteurs: Lennart P. L. Landsmeer, Amirreza Movahedin, Said Hamdioui, Christos Strydis

Gepubliceerd 2026-07-08

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Lennart P. L. Landsmeer, Amirreza Movahedin, Said Hamdioui, Christos Strydis

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

Stel je voor dat je een gigantisch, chaotisch feest probeert te organiseren met duizenden gasten (neuronen) die constant briefjes naar elkaar sturen (spikes). Het probleem? Deze briefjes komen niet direct aan. Sommige doen er een paar seconden over, andere een paar minuten, en de tijd die het kost varieert enorm afhankelijk van wie de brief stuurt en hoe ver de brief moet reizen.

Dit is het probleem waar wetenschappers voor staan bij het simuleren van Spiking Neural Networks (SNN's) — computermodellen die proberen te nabootsen hoe onze hersenen werken. Om deze modellen te trainen (ze te leren), moet de computer precies weten hoe het veranderen van de "levertijd" van een briefje het uiteindelijke resultaat beïnvloedt. Dit wordt het berekenen van een gradiënt genoemd.

De paper introduceert een nieuw hulpmiddel genaamd ADSEQ om de hoofdpijn van deze vertraagde briefjes op te lossen, terwijl de wiskunde rekenbaar blijft voor computers.

Hier is de uitsplitsing van wat ze hebben gedaan, met behulp van eenvoudige analogieën:

1. Het Probleem: De "Lost in Translation" Levering

In het verleden simuleerden computers deze hersennetwerken op twee manieren, die beide gebreken hadden:

De "Smoothie"-aanpak: Om de wiskunde eenvoudig te maken, veranderden sommige simulators de scherpe, plotselinge "briefjes" in een gladde, continue stroom vloeistof. Dit maakte de wiskunde werkbaar, maar vernietigde de efficiëntie. Het is alsoals proberen individuele regendruppels te tellen door het totale volume van een plas water te meten; je verliest de specifieke timinginformatie die het systeem efficiënt maakt.
De "Rigide Doos"-aanpak: Andere simulators gebruikten specifieke, eenvoudige dozen (zoals een ringbuffer) om de briefjes vast te houden. Deze waren snel, maar konden geen complexe vertragingen of verschillende soorten neuronen aan. Ze waren als een lopende band die alleen werkt als elk pakketje exact 5 seconden na het vorige aankomt.

De Kloof: Niemand had een systeem dat complexe, variabele vertragingen kon aanpakages (sommige briefjes duren 2ms, andere 50ms) terwijl de computer nog steeds efficiënt van fouten kon leren (gradiënten berekenen).

2. De Oplossing: ADSEQ (De Slimme Koeriersdienst)

De auteurs bouwden ADSEQ (AutoDifferentiable Spike-Event Queues). Denk aan dit als een super slimme koeriersdienst die elk type pakket en elke levertijd kan afhandelen, en nog steeds een perfect bonnetje bijhoudt voor de boekhouder (de gradiëntberekenaar).

De Magische Truk (Custom Gradients): Normaal gesproken, als je een pakket in een doos legt en het later weer uithaalt, vergeet de computer precies wanneer het erin ging. ADSEQ gebruikt een speciale "magische kwitantie" (wiskundige afgeleiden) die binnenin het pakket reist. Zelfs als het pakket een lange tijd in een wachtrij staat, onthoudt de kwitantie precies hoe de vertagingstijd het uiteindelijke resultaat heeft beïnvloed. Dit stelt de computer in staat om te leren hoe hij de levertijden kan aanpassen om het netwerk slimmer te maken.
De Wachtrij (Queue): Ze bouwden een gereedschapskist met verschillende soorten "wachtkamers" (queues) voor deze briefjes. Sommige zijn eenvoudige rijen (FIFO), andere zijn prioriteitenlijsten (Heaps), en weer andere zijn circulaire banen (Ring Buffers).

3. De Race: Welke Wachtkamer is het Beste?

De auteurs testten deze verschillende wachtkamers op vier verschillende soorten "supercomputers" (AI-accelerators) om te zien welke het snelst was. Het blijkt dat één maat niet voor iedereen geldt.

De CPU (De Klassieke Kantoormedewerker):
- Beste Queue: Tree-gebaseerde of FIFO-rijen.
- Waarom: De CPU is goed in het stap voor stap volgen van instructies. Hij houdt van georganiseerde rijen waar hij items van een lijst kan afvinken.
De GPU (De Parallelle Fabriek):
- Beste Queue: Ring Buffers (voor kleine taken) of FIFO (voor enorme taken).
- Waarom: GPU's zijn als fabrieken met duizenden arbeiders die tegelijkertijd dezelfde taak uitvoeren. Ze houden van circulaire banen waar iedereen in sync beweegt. Echter, als de fabriek te druk wordt, werkt een eenvoudige rij (FIFO) beter om verkeersopstoppingen te voorkomen.
De TPU (De Gespecialiseerde Sorteermachine):
- Beste Queue: Gesorteerde Arrays.
- Waarom: De TPU heeft een speciale "sorteermachine" die direct in de hardware is ingebouwd. Het maakt niet uit hoe rommelig de stapel briefjes is; de TPU kan ze direct sorteren. Dus de beste strategie is gewoon een stapel maken en de machine het laten sorteren.
De LPU (De Deterministische Trein):
- Beste Queue: Deterministische Dataflow.
- Waarom: Deze computer draait als een trein op een vast spoor. Hij haat verrassingen of vertakkende paden. Hij heeft een schema nodig waarbij elk briefje op een voorspelbare tijd aankomt.

4. De "Pakket Weggooien" Optie

Soms wordt de wachtkamer te vol. De auteurs lieten zien dat je het systeem kunt programmeren om sommige briefjes te verwijderen (droppen) als de wachtrij vol is.

De Afweging: Het verwijderen van briefjes maakt de simulatie veel sneller (minder geheugengebruik), maar het is iets minder nauwkeurig. Het is als een druk postkantoor dat brieven weggooit wanneer de bakken vol zijn om de lijn in bewegend te houden. De paper laat zien dat je dit kunt afstemmen: gooi er een paar weg om snelheid te besparen, of houd ze allemaal voor perfecte nauwkeurigheid.

Samenvatting

De paper zegt niet alleen "we hebben een snellere hersensimulator gemaakt." Het zegt: "We hebben een flexibele toolkit gebouwd (ADSEQ) die computers laat leren van vertraagde signalen, en we hebben bewezen dat de beste manier om deze signalen te organiseren volledig afhangt van het type computerchip dat je gebruikt."

Heb je een standaard computer, gebruik dan een rij.
Heb je een videokaart, gebruik dan een cirkel of een rij.
Heb je een Google TPU, gebruik dan een sorteerstapel.

Dit stelt wetenschappers in staat om realistischere hersenmodellen te bouwen en AI sneller te trainen, zonder vast te lopen in de wiskunde van "wanneer kwam dat signaal aan?"

Technische Samenvatting: ADSEQ – Een vertragingsbewust, autograd-compatibel framework voor spike-event levering in SNN's

Probleemstelling
Efficiënte simulatie en gradiëntgebaseerde training van Spiking Neural Networks (SNN's) en hersenmodellen vereisen het afhandelen van ijle (sparse) spike-transmissie, met name bij het integreren van heterogene synaptische vertragingen. Huidige benaderingen kampen met een dichotomie:

Geheugeninefficiëntie: Simulaties gebaseerd op Machine Learning (ML) bibliotheken vertrouwen vaak op surrogate gradients (bijv. SuperSpike) om de discontinuïteit van spikes te behandelen. Hoewel effectief voor vereenvoudigde modellen, zetten surrogate gradients ijle spike-events om in dichte, continue-time signalen. Wanneer vertragingen worden geïntroduceerd, moeten deze dichte signalen worden gebufferd, wat de voordelen van ijle data tenietdoet en geheugenbottlenecks creëert.
Gebrek aan Generalisatie: Bestaande exact-gradient methoden (bijv. EventProp) zijn grotende-ende beperkt tot vereenvoudigde neuronmodellen (zoals Leaky Integrate-and-Fire) en specifieke parametersets. Ze slagen er vaak niet in om te generaliseren naar biofysisch realistische modellen of willekeurige wachtrijstructuren die vereist zijn voor volledige hersensimulaties.
Hardware Mismatch: Er is een gebrek aan begrip over welke spike-event wachtrij datastructuren (bijv. ringbuffers, heaps, FIFO's) optimaal presteren over diverse AI-acceleratorarchitecturen (von Neumann CPU's, GPU's, TPU's en deterministische dataflow LPUs), vooral wanneer ze gecombineerd worden met differentieerbare operaties.

Methodologie
De auteurs introduceren ADSEQ (AutoDifferentiable Spike-Event Queues), een framework ontworpen om exacte, vertragingsbewuste gradiëntberekening mogelijk te maken binnen moderne ML-bibliotheken (specifiek JAX).

Wiskundige Formulering: De kernbijdrage is de afleiding van impliciete afgeleiden voor spike-event levering. Door de Implicit Function Theorem toe te passen op de spike detectieconditie ( $v_{pre}(t_{pre}) = v_{th}$ $v_{p r e} (t_{p r e}) = v_{t h}$ ), leiden de auteurs de gradiënt van de spike-tijd met betrekking tot modelparameters ( $\theta$ $θ$ ) en synaptische vertragingen ( $d$ $d$ ) af.
- Ze generaliseren de EventProp-vergelijkingen om vertragingsgradiënten op te nemen: $dt_{post}/d\theta = dt_{pre}/d\theta + dd/d\theta$ .
- Ze leiden de gradiënt-update af voor postsynaptische staat variabelen ( $x$ ) bij aankomst van een spike, rekening houdend met de vertraging: $\partial x^+/\partial \theta = \partial x^-/\partial \theta + (1/\tau) \cdot \partial t_{post}/\partial \theta$ .
Implementatie via Custom Gradients: Om deze afleidingen te integreren in het automatische differentiatiesysteem (autograd) van JAX, implementeren de auteurs custom Jacobian-Vector Product (JVP) operatoren. Deze custom gradiënten worden geïnjecteerd in de enqueue() en pop() operaties van diverse wachtrij datastructuren. Dit stelt de autograd engine in staat om gradiënten correct te propageren door de tijd-vertraagde spike-events zonder dat handmatige backpropagation-afleidingen nodig zijn voor complexe neuronmodellen (bijv. Hodgkin-Huxley).
Wachtrij Varianten: Het framework implementeert een reeks differentieerbare wachtrijstructuren, waaronder:
- Ring Buffers: Standaard en verlieslatende (lossy) varianten (het optellen van spikes of het laten vallen ervan).
- FIFO Structuren: First-In-First-Out wachtrijen met capaciteitslimieten.
- Tree/Heap Structuren: Binaire heaps en tournament trees voor het afhandelen van heterogene vertragingen.
- Gesorteerde Arrays: Arrays die de volgorde behouden via sorteeroperaties.
- Bit-level Structuren: Geoptimaliseerd voor scenario's met enkele spikes.
Lossy Mechanismen: Het framework bevat "lossy" wachtrij-implementaties die bewust spikes laten vallen wanneer de capaciteit wordt overschreden, wat een instelbare trade-off tussen prestaties en nauwkeurigheid mogelijk maakt.

Belangrijkste Bijdragen

Autodifferentieerbare Formulering: Een gegeneraliseerde wiskundige formulering voor exacte spike-event gradiënten die zowel neuronparameters als synaptische vertragingen ondersteunt, compatibel met willekeurige neuronmodellen.
ADSEQ Library: Een collectie differentieerbare wachtrij datastructuren geïmplementeerd in JAX met custom gradiënten, wat het gebruik van ijle spike-opslag in gradiëntgebaseerde training mogelijk maakt.
Cross-Accelerator Benchmarking: Een uitgebreide evaluatie van deze wachtrijstructuren over vier verschillende hardware-architecturen:
- CPU (Intel i7): Von Neumann architectuur.
- GPU (NVIDIA H100): Parallelle verwerking met coalesced memory access.
- TPU (Google TPU v4): Tensor en Sparse Cores met dedicated sorting units.
- LPU (Groq LPU): Deterministische dataflow architectuur zonder control flow branching.
Spike Drop Analyse: Kwantificering van de spike-drop rates voor lossy wachtrijen, wat data biedt voor het ontwerpen van simulators met controleerbare nauwkeurigheidsrestricties.

Resultaten
De benchmarking resultaten onthullen dat de optimale wachtrijstructuur sterk afhankelijk is van de hardware-architectuur en de workload kenmerken:

CPU: Tree-gebaseerde (Binary Heap) en FIFO-gebaseerde wachtrijen presteren het best, waarschijnlijk door lagere overhead en efficiënte afhandeling van conditionele logica in von Neumann architecturen.
GPU: Ring buffers excelleren voor kleinere netwerken en workloads die in de cache passen. Echter, voor grotere netwerken schalen FIFO-structuren gunstiger door verminderde druk op het geheugen.
TPU: Sort-gebaseerde implementaties (Sorted Arrays) presteren aanzienlijk beter dan andere methoden. Dit wordt toegeschreven aan de dedicated Sparse Cores van de TPU, die hardware-versnelde sorteerunits bevatten.
LPU: Deterministische dataflow scheduling bevoordeelt structuren die divergente control flow vermijden.
Scaling: Naarmate het aantal wachtrijen toeneemt, degradeert de CPU-prestatie snel vergeleken met accelerators. Echter, voor kleinschalige simulaties waarbij de data in lokale caches past, blijven CPU's competitief.
Training vs. Inference: Training (parameter tuning) is aanzienlijk computationeel en geheugentechnisch intensiever dan inference. Forward AD is merkbaar trager dan reverse AD in bepaalde configuraties, wat suggereert dat hybride methoden zoals checkpointing nodig zijn.

Betekenis en Claims
Het artikel claimt dat ADSEQ een fundament legt voor schaalbare, herbruikbare componenten voor autograd-compatibele SNN-simulaties die vertragingen bevatten, toepasbaar op zowel kunstmatige als biologisch realistische netwerken.

Generalisatie: In tegen tegenstelling tot eerdere exact-gradient methoden die beperkt zijn tot LIF-modellen, ondersteunt ADSEQ complexe biofysische modellen (bijv. Hodgkin-Huxley door de wachtrij als een differentieerbare primitief te behandelen.
Hardware Bewustzijn: Het werk demonstreert dat "one-size-fits-all" wachtrijstrategieën suboptimaal zijn. De keuze van een datastructuur moet in lijn zijn met de onderliggende accelerator-architectuur (bijv. het gebruik van sort-gebaseerde structuren voor TPU's en heaps voor CPU's).
Toekomstige Integratie: De auteurs suggereren dat hun aanpak traditionele hersensimulatoren (die momenteel een gebrek aan gradiëntondersteuning hebben) in staat kan stellen om netwerkbrede gradiënten te integreren door neuronmodellen aan te passen zodat ze naast spikes ook float-gecodeerde gradiëntberichten verzenden, waardoor de kloof tussen traditionele neurowetenschappelijke simulators en moderne ML-frameworks wordt overbrugd.

Het artikel concludeert dat hoewel ML-bibliotheken vaak traditionele datastructuren zoals FIFOs en trees verwaarlozen ten gunste van vereenvoudigde arrays, deze structuren aanzienlijke waarde hebben voor specifieke hardware en vertragingsgeconstreinde scenario's, wat een pad biedt naar efficiëntere en realistischere SNN-training.