🤖 machine learning

NeuronSoup: Evolving Asynchronous, Shared-Neuron Temporal Graphs without Backpropagation

NeuronSoup is een nieuwe neurale architectuur die een genetisch algoritme gebruikt om een asynchrone, gedeelde neuronale tijdsgrafiek te evolueren zonder backpropagation, waarbij een nauwkeurigheid van 85,9% op MNIST wordt bereikt door dynamische signaalinterferentie en adaptieve computationele diepte mogelijk te maken.

Oorspronkelijke auteurs: Subodh Kalia

Gepubliceerd 2026-07-17

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Subodh Kalia

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 een wereld voor waarin het oplossen van een puzzel niet vereist dat iedereen op exact hetzelfde moment zijn antwoord roept. In de wereld van kunstmatige intelligentie, specifiek een vakgebied genaamd "neuroevolutie", proberen wetenschappers computersystemen te bouien die meer leren zoals levende wezens. Traditionele AI, het soort dat je favoriete apps aandrijft, werkt als een rigide lopende band in een fabriek: data komt aan één kant binnen, wordt stap voor stap in perfecte unisono verwerkt, en verlaat de andere kant. Het is snel, maar het is inflexibel. Als de puzzel makkelijk is, draait de fabriek nog steeds op volle snelheid; als de puzzel moeilijk is, kan de fabriek vastlopen. De natuur is echter chaotisch en asynchroon. In een echt brein reizen signalen met verschillende snelheden, praten neuronen met elkaar in een chaotische soep van overlappende gesprekken, en besluit het brein hoe lang het over iets moet nadenken op basis van hoe lastig het is. Dit artikel stelt een gedurfde vraag: Kunnen we een digitaal brein bouwen dat geen centrale klok of een rigide lopende band nodig heeft, maar in plaats daarvan leert door een chaotisch, tijdsgebaseerd netwerk van verbindingen te evolueren?

Maak kennis met NeuronSoup, een nieuw soort computerarchitectuur die de lopende band inruilt voor een bruisende, asynchrone keuken. In plaats van lagen neuronen die in perfecte synchronisatie werken, gebruikt NeuronSoup een enorme poel van neuronen waar signalen ronddrijven als ingrediënten in een pruttelende pan. Hier is de magie: signalen passeren niet alleen; ze arriveren op verschillende tijdstippen. Als twee signalen op hetzelfde moment bij hetzelfde neuron aankomen, mengen ze zich. Als ze één na de ander aankomen, moet het tweede signaal omgaan met de "smaak" die de eerste heeft achtergelaten. Deze vermenging creëert een soort computationele interferentie, waarbij de timing van een signaal de betekenis van het volgende signaal verandert.

De onderzoekers hebben dit mengproces niet met de hand ontworpen. In plaats daarvan gebruikten ze een genetisch algoritme — een computerprogramma dat natuurlijke selectie nabootst — om het hele systeem te laten evolueren. Ze begonnen met een "genoom" (een lange lijst met getallen) dat 384 mogelijke paden definieerde waar signalen doorheen konden reizen, inclusief hoe snel ze zouden bewegen (vertragingen), hoe sterk ze zouden zijn (gewichten), en welke neuronen ze zouden bezoeken. Over 10.000 generaties van digitale evolutie ontdekte het systeem welke paden het moest behouden, welke het moest verwijderen, en hoe het de signalen moest timen zodat de "soep" het juiste antwoord produceerde.

Het resultaat is een netwerk dat verrassend efficiënt en verrassend slim is. Bij een test op een klassieke taak van het herkennen van handgeschreven cijfers (de MNIST-dataset), bereikte de geëvolueerde NeuronSoup een nauwkeurigheid van 85,9%. Dit deed het met een piepklein model dat slechts 115 KB aan geheugen in beslag neemt — kleiner dan één enkele foto met een hoge resolutie. Het netwerk ontdekte dat het slechts 204 actieve paden nodig had van de 384 die het kreeg, en het vond dat 156 van de verborgen neuronen zo nuttig waren dat ze tegelijkertijd door meerdere paden werden gedeeld. Sterker nog, één enkel neuron was tegelijkertijd druk bezig met het bedienen van 11 verschillende paden, optredend als een druk kruispunt waar verschillende stukjes bewijs botsten en samenkwamen.

Wat dit werkelijk uniek maakt, is dat het systeem uitvond wanneer het moest nadenken. Voor makkelijke cijfers namen de signalen korte, snelle paden en arriveerden ze snel, wat een snel antwoord gaf. Voor lastigere cijfers namen de signalen langere, kronkelende paden, waardoor ze later arriveerden om het antwoord te verfijnen. Het systeem paste zijn eigen "denktijd" aan op basis van de moeilijkheidsgraad van het probleem, zonder dat iemand dit aan het systeem vertelde.

De auteurs wijzen er zorgvuldig op dat dit geen wondermiddel is dat alle andere AI verslaat. Hun systeem is momenteel minder nauwkeurig dan de enorme, gradiënt-gebaseerde netwerken (zoals ResNet) die het veld domineren, die op dezelfde taak een nauwkeurigheid van meer dan 99% kunnen bereiken. Ze sluiten expliciet de mogelijkheid uit dat standaard "backpropagation" (de gebruikelijke manier waarop AI leert) hier zou kunnen werken, omdat de afhankelijkheid van het systeem van timing en discrete gebeurtenissen het onmogelijk maakt om de vloeiende wiskundige hellingen te berekenen die voor die methode nodig zijn. In plaats daarvan betogen zij dat genetische algoritmen het juiste instrument zijn, omdat ze de chaotische, niet-vloeiende aard van deze tijdsgebaseerde evolutie kunnen aanpakken.

Hoewel de nauwkeurigheid lager is, suggereert het artikel een krachtig alternatief: een manier om AI te bouwen die geen enorme grafische kaarten of rigide structuren nodig heeft. Omdat het systeem draait op eenvoudige, gebeurtenisgestuurde logica, zou het in de toekomst theoretisch op veel eenvoudigere, energiezuinige hardware kunnen draaien. De auteurs suggereren dat de echte overwinning niet alleen de score van 85,9% is, maar het feit dat een computer, beginnend met niets anders dan een willekeurige soep van verbindingen, zelfstandig een complexe, tijdsgevoelige strategie heeft geëvolueerd om problemen op te lossen. Het is een bewijs dat je een brein kunt bouwen dat in tijd denkt, en niet alleen in lagen.

Technische Samenvatting: NeuronSoup

Probleemstelling

Huidige deep learning-architecturen worden fundamenteel beperkt door de vereiste van differentiabele computationele grafen en backpropagation. Dit noodzaakt synchrone, laag-voor-laag verwerking met vaste computationele dieptes en statische topologieën die tijdens het ontwerp worden bepaald. Gevolgd wordt hierdoor door het feit dat deze modellen niet natuurlijk hun computationele diepte kunnen aanpassen aan de moeilijkheidsgraad van individuele inputs, een gebrek hebben aan inherente laterale interacties tussen verwerkingspaden (tenzij expliciet ontworpen via mechanismen zoals aandacht), en beperkt zijn tot continue, differentiabele operaties. Biologische neurale systemen werken daarentegen asynchroon, maken gebruik van gedeelde neuronen die hun staat over de tijd accumuleren, en passen de verwerkingsdiepte aan op basis van signaalcomplexiteit.

Dit artikel behandelt de uitdaging van het construeren van een bruikbare classifier die opereert zonder backpropagation, zonder vaste computationele diepte en zonder synchronisatie, terwijl het de beperkingen van bestaande neuroevolutionaire en spiking neural network (SNN) benaderingen aanpakt.

Methodologie: NeuronSoup Architectuur

De auteurs stellen NeuronSoup voor, een neurale computationele architectuur gebaseerd op asynchrone, door vertraging gemedieerde signaalpropagatie door een pool van gedeelde neuronen.

Kernmechanismen

Asynchrone Discrete-Event Simulatie: Het systeem verwerkt continu-gevalide signalen via een priority queue (min-heap). Events worden geordend op aankomsttijd, bepaald door geëvolueerde axonale vertragingen. Er is geen globale klok; computation vindt strikt plaats in de volgorde van de tijd.
Accumulatie van Gedeelde Neuronstaat: In tegenstelling tot traditionele netwerken waar neuronen onafhankelijk zijn of SNN's waar neuronen resetten, behouden verborgen neuronen in NeuronSoup een geaccumuleerde staat ( $a_n$ ). Wanneer meerdere paden door dezelfde verborgen neuron routeren, werkt het eerste aankomende signaal de staat bij. Opmerkelijke signalen komen vervolgens een gewijzigde staat tegen. De activatie wordt berekend als $\alpha = \tanh(a_n + b_n)$ , waarbij $a_n$ de som is van alle inkomende signalen. Dit creëert constructieve of destructieve interferentie op basis van de polariteit en aankomsttijd van het signaal.
Temporele Vertragingen als Computation: Vertragingen zijn geen ruis of regularisatie; ze zijn primaire functionele parameters die de volgorde van feature-combinatie bepalen. Korte vertragingen geven prioriteit aan hoog-betrouwbare features, terwijl langere vertragingen ervoor zorgen dat contextuele features later arriveren, waardoor de output na de initiële verwerking wordt gewijzigd.
Genoom Codering: De architectuur is gecodeerd in een plat, reëel genoom van 14.602 genen. Dit omvat:
- Path Blocks: 384 potentiële paden, elk gedefinieerd door 37 genen (actieve flag, input ID, output ID, en tot 8 hops, waarbij elke hop een target neuron, gewicht en delay gen heeft).
- Biases: Genen die biases coderen voor verborgen en output neuronen.
- Decoding: Genen in $[0, 1]$ worden in kaart gebracht naar operationele waarden (bijv. gewichten in $[-2, 2]$ , vertragingen in $[0.1, 5.0]$ ).

Optimalisatiestrategie

De auteurs betogen dat gradiënt-gebaseerde optimalisatie (backpropagation) niet toepasbaar is vanwege:

Discrete Topologie: Pad-activatie is een binaire beslissing (gedrempeld bij 0.5).
Niet-Differentiabele Ordening: Kleine veranderingen in vertraging kunnen de volgorde van event-verwerking omdraaien, wat leidt tot discontinue veranderingen in de output.
Variabele Graafgrootte: Het aantal te verwerken events hangt af van de input en configuratie, wat een vaste graaf-unrolling verhindert.

In plaats daarvan wordt een Genetisch Algoritme (GA) ingezet. De auteurs wijzen specifiek CMA-ES af (vanwege de $O(D^2)$ geheugen- en $O(D^3)$ computationele kosten voor $D=14,602$ ) en standaard operatoren zoals SBX of DE (die structurele coherentie vernietigen). Ze implementeren path-aware crossover, die volledige path blocks (37 genen) uitwisselt in plaats van individuele genen, waardoor functionele circuits behouden blijven. Mutatie past Gaussische ruis toe op continue waarden en flipt binaire flags.

Belangrijkste Bijdragen

Een Nieuw Computationeel Model: Een systeem waarbij temporele vertragingen de volgorde van computation dicteren, wat adaptieve diepte per sample mogelijk maakt zonder expliciete halting-policies.
Emergente Laterale Interactie: Demonstratie dat de accumulatie van gedeelde neuronen impliciete laterale inhibitie en excitatie tussen paden produceert zonder dat er cross-verbindingen handmatig zijn ontworkt.
Co-evolutie van Structuur en Parameters: Een plat genoom dat simultaan de topologie (welke paden/neuronen actief zijn), gewichten en temporele structuur evolueert.
Optimalisatie Analyse: Een rigoureuze argumentatie waarom Genetische Algoritmen de juiste tool zijn voor deze klasse problemen, waarbij specifiek het falen van CMA-ES op deze schaal en de noodzaak van block-aware recombinatie-operatoren wordt benadrukt om path-coherentie te behouden.
Modulaire Generalisatie: Een architectuur waarbij de taak uitsluitend wordt gedefinieerd door de input encoder en het aantal output neuronen, waarbij het evolutionaire proces de bedrading automatisch ontdekt.

Experimentele Resultaten

Het systeem werd geëvalueerd op 10-class MNIST cijferclassificatie met behulp van bevroren ResNet18 features (512-dimensionaal) als input.

Prestaties: Na 10.000 generaties bereikte het best geëvolueerde model 85,9% test nauwkeurigheid op een hold-out set van 1.000 samples.
Efficiëntie: Het getrainde model neemt slechts 115 KB in beslag (14.602 float64 waarden).
Structurele Kenmerken:
- Actieve Paden: 204 van de 384 mog르게 paden werden geactiveerd.
- Gedeelde Neuronen: 156 van de 266 gebruikte verborgen neuronen werden gedeeld door meerdere paden. Eén neuron nam deel aan 11 verschillende paden.
- Feature Selectie: Slechts 162 van de 512 input features werden benut.
- Computation: Inferentie omvat ongeveer 500–2.000 events per sample, wat minder dan 1.100 floating-point operaties per afbeelding vereist (vergeleken met ~1,8 miljard FLOPs voor ResNet-18).
Training: Het volledige trainingsproces (10.000 generaties) werd voltooid in ~2 uur en 51 minuten op een 12-core CPU, zonder dat een GPU nodig was.

Betekenis en Claims

Het artikel beweert dat NeuronSoup de levensvatbaarheid demonstreert van een fundamenteel ander computationeel paradigma: asynchrone temporele propagatie door een gedeelde, geëvolueerde graaf.

Overwinnen van Backpropagation Limieten: De architectuur bewijst dat nuttige classificatie kan ontstaan zonder differentieerbaarheid, vaste diepte of synchronisatie. Het adresseert de "vaste diepte" beperking van deep learning door van nature meer computation toe te wijzen aan moeilijke inputs via lange, vertraagde paden.
Emergente Structuur: Het systeem ontdekte complexe gedragingen—zoals gedeelde neuronen die fungeren als integratiehubs en temporele vertragingen die aandacht-achtige prioriteit creëren—uitsluitend door selectiedruk, zonder menselijke engineering van deze mechanismen.
Hardware Implicaties: De architectuur is inherent geschikt voor neuromorfische hardware en event-gestuurde systemen, wat orders van grootte meer energie-efficiëntie biedt vergeleken met synchrone matrix-vermenigvuldigingsarchitecturen.
Universaliteit: De auteurs stellen dat hetzelfde evolutionaire framework van toepassing is op arbitraire domeinen (audio, tekst, medische data) door simpelweg de encoder en het aantal output neuronen te veranderen, zonder dat een architecturale herontwerp nodig is.

Het artikel houdt een bescheiden standpunt aan met betrekking tot nauwkeurigheid, waarbij erkend wordt dat 85,9% lager is dan gradiënt-getrainde baselines (92–96%) op dezelfde features. Het argumenteert echter dat deze kloof de kosten reflecteert van gradiënt-vrije optimalisatie, en merkt op dat de convergentiecurve geen plateau vertoont en dat de expressiviteit van de architectuur theoretisch hoog is. De primaire bijdrage is de demonstratie van een levensvatbaar, niet-differentieerbaar, asynchroon computationeel model dat schaalt op standaard CPU-hardware en generaliseert over domeinen.