💻 computer science

GPU-Accelerated Genetic Programming for Symbolic Regression with Beagle Framework

Dit paper presenteert Beagle, een nieuw GPU-versneld framework voor symbolische regressie dat aanzienlijk sneller presteert dan toonaangevende CPU-gebaseerde systemen zoals StackGP en PySR, zoals aangetoond door benchmarks op de Feynman-dataset.

Oorspronkelijke auteurs: Nathan Haut, Ilya Basin, Marzieh Kianinejad, Ruchika Gupta, Elijah Smith, Zachary Perrico, Wolfgang Banzhaf

Gepubliceerd 2026-03-16

📖 4 min leestijd☕ Koffiepauze-leesvoer

CC BY 4.0

Oorspronkelijke auteurs: Nathan Haut, Ilya Basin, Marzieh Kianinejad, Ruchika Gupta, Elijah Smith, Zachary Perrico, Wolfgang Banzhaf

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 enorme bibliotheek hebt, vol met miljoenen verschillende recepten. Je doel is om één specifiek recept te vinden dat precies beschrijft hoe de natuur werkt – bijvoorbeeld hoe een appel valt of hoe licht zich gedraagt. Dit is wat Symbolische Regressie doet: het zoekt naar wiskundige formules die data verklaren.

Het probleem? Het vinden van het juiste recept in die bibliotheek is als het zoeken naar een naald in een hooiberg, maar dan met een bibliotheek die elke seconde groter wordt. Traditionele computers (zoals de CPU's in je laptop) zijn als een slimme kok die recepten één voor één probeert. Ze zijn goed, maar ze kunnen niet snel genoeg zijn als de bibliotheek te groot wordt.

Hier komt Beagle in beeld.

Wat is Beagle?

Beagle is een nieuw computerprogramma dat is ontworpen om dit zoekproces te versnellen. In plaats van één slimme kok, gebruikt Beagle een superkeuken met duizenden koks die allemaal tegelijk werken. Deze "koks" zijn de krachtige grafische kaarten (GPU's) die normaal gesproken in computerspelletjes worden gebruikt om mooie beelden te maken.

De auteurs van dit paper (Nathan Haut en zijn team) hebben Beagle getest om te zien of deze "superkeuken" echt beter presteert dan de traditionele methoden.

Hoe werkt het? (De Analogie)

De Bibliotheek (Genetische Programmering):
Het programma begint met een willekeurige verzameling recepten (formules). Het test ze, kijkt welke het beste werken, en laat de "slechtste" recepten verdwijnen. De "goede" recepten worden geknipt en gemixt om nieuwe, betere recepten te maken. Dit proces heet Genetische Programmering.
De Koks (GPU vs. CPU):
- De traditionele methode (CPU): Stel je voor dat je één kok hebt die 100 recepten moet testen. Hij doet er lang over.
- De Beagle-methode (GPU): Beagle heeft duizenden koks. Ze kunnen 100 recepten op exact hetzelfde moment testen. In plaats van uren te wachten, is het resultaat er in seconden.
De Speciale Recepten (Fitness Functies):
Om te weten of een recept goed is, moet je het vergelijken met de werkelijkheid.
- Punt-voor-punt: "Dit getal moet 5 zijn, en jij gaf 5. Perfect."
- Correlatie (De nieuwe truc): Soms is het niet belangrijk dat elk getal exact klopt, maar dat de trend klopt. Als de echte data stijgt en jouw recept stijgt ook, is dat goed, zelfs als de getallen iets afwijken. Beagle gebruikt deze slimme "trend-check" om sneller de juiste richting op te vinden.
De "Dode" Recepten (NaN's):
Soms geven formules geen getal, maar iets als "niet-bestaand" (bijvoorbeeld je probeert de wortel te nemen van een negatief getal). Andere programma's gooien deze recepten direct weg. Beagle is slimmer: het kijkt of de echte data ook "niet-bestaand" was op dat punt. Als dat zo is, is het recept juist goed! Dit helpt Beagle om formules te vinden die andere programma's over het hoofd zien.

Wat hebben ze ontdekt?

De auteurs hebben Beagle laten strijden tegen twee andere bekende programma's: StackGP en PySR. Ze hebben dit gedaan met een tijdslimiet: "Wie vindt in 10 of 30 minuten het meeste juiste formules?"

Het resultaat: Beagle won met gemak.
De cijfers: In een test met 100 moeilijke natuurkundige formules (de Feynman-dataset), kon Beagle met de "trend-check" (correlatie) in 10 minuten 82 problemen oplossen. De andere programma's haalden er ongeveer 64 tot 65.
De schaal: Omdat Beagle zo snel is, kan het werken met miljoenen recepten tegelijk. De andere programma's werken meestal met slechts een paar honderd. Het is het verschil tussen een kleine visvijver en een hele oceaan aan mogelijkheden.

Waarom is dit belangrijk?

Vroeger duurde het zoeken naar deze formules dagen of weken, of het was gewoon te duur. Met Beagle kunnen onderzoekers en ingenieurs binnen een uur (of zelfs minuten) complexe formules vinden die de wereld om ons heen beschrijven.

Het is alsof je van een fiets bent gegaan op een Formule 1-auto. Je komt niet alleen veel sneller aan, maar je kunt ook veel zwaardere ladingen (grote zoekruimtes) verplaatsen. Dit opent de deur voor nieuwe ontdekkingen in wetenschap en techniek, omdat het zoeken naar de "juiste formule" nu haalbaar wordt voor iedereen met een moderne computer.

Kortom: Beagle is een krachtige, snelle motor die genetische programmering naar een nieuw niveau tilt, waardoor we sneller de geheimen van de natuur kunnen ontcijferen.

Probleemstelling

Genetisch Programmeren (GP) is een evolutionair algoritme dat populaties van programma's manipuleert om oplossingen te vinden voor complexe problemen, zoals Symbolische Regressie (SR). SR heeft als doel wiskundige expressies te vinden die gegevens beschrijven, wat waardevol is voor interpretatie in wetenschappelijke domeinen.

Het fundamentele probleem bij GP is de enorme rekenkracht die vereist is voor de herhaalde cycli van evaluatie, variatie en selectie. Traditionele CPU-gebaseerde systemen worden vaak beperkt door hun rekenvermogen, vooral bij het evalueren van grote populaties en complexe fitness-functies. Hoewel Graphics Processing Units (GPUs) al lang worden gebruikt voor Deep Learning, is hun toepassing op GP nog niet volledig geoptimaliseerd voor alle aspecten van evolutionaire zoektochten, zoals het efficiënt beheren van enorme populaties en het minimaliseren van overhead bij data-uitwisseling tussen CPU en GPU.

Methodologie

De auteurs introduceren Beagle, een nieuw open-source framework voor symbolische regressie dat specifiek is ontworpen om de rekenkracht van GPUs (en CPU's) te benutten. De benchmarking werd uitgevoerd op het Feynman Symbolic Regression Dataset, een standaardbenchmark bestaande uit 100 fysische vergelijkingen.

De Beagle Framework Architectuur:

Taal en Bibliotheek: Beagle is geschreven in C# en maakt gebruik van de ILGPU-bibliotheek. Dit biedt directe toegang tot CUDA-instructies op het laagste niveau, in plaats van via hogere-niveau bibliotheken, wat de prestaties maximaliseert.
GPU-CPU Splitsing:
- De GPU is verantwoordelijk voor de evolutionaire runs en de evaluatie van fitness-functies.
- De CPU behandelt selectie, geboorte/sterfte-cycli en mutaties.
- Om de overhead van data-overdracht te minimaliseren, worden individuen in batches (bijv. 512 of 1024 fitness-cases per individu) naar de GPU gestuurd. Elk CUDA-blok vertegenwoordigt één organisme, en elke thread binnen dat blok een fitness-case.
Populatiebeheer: Beagle kan populaties van miljoenen individuen verwerken. Om de bottleneck van het sorteren van grote populaties te omzeilen, gebruikt Beagle een Monte-Carlo-geïnspireerde selectiestrategie. In plaats van de hele populatie te sorteren, wordt een willekeurige steekproef van 100 individuen gesorteerd om percentielen te bepalen voor de hele populatie. Dit maakt schaalbaarheid mogelijk.
Fitness-functies: Het paper test twee soorten fitness-functies:
1. Point-to-Point (P2P): Vergelijkt modeluitvoer met doelwaarden punt voor punt (vergelijkbaar met RMSE).
2. Correlatie-functie: Gebaseerd op de correlatiecoëfficiënt ( $r$ ) tussen model en doel. Deze functie is rekenintensiever maar kan de zoekefficiëntie verbeteren. Beagle is uniek in zijn vermogen om NaN-waarden (niet-aantallen) in de fitness-functie te hanteren door individuen te belonen die NaN's op dezelfde locaties genereren als de trainingsdata.
Vergelijking: De prestaties van Beagle werden vergeleken met StackGP (een Python-gebaseerd stack-gebaseerd GP-systeem) en PySR (een populaire Python/Julia-bibliotheek), allemaal onder dezelfde tijdslimieten (10 en 30 minuten).

Belangrijkste Bijdragen

Introductie van Beagle: Een nieuw framework dat GP succesvol mapt naar GPU-hardware, met ondersteuning voor heterogene computing-omgevingen.
Schaalbaarheid: Het vermogen om populaties van miljoenen individuen efficiënt te verwerken door het minimaliseren van geheugenfragmentatie (geen garbage collection voor individuen) en het gebruik van een innovatieve selectiemethode.
GPU-geoptimaliseerde Correlatie-functie: Het succesvol implementeren en evalueren van een complexere correlatie-fitness-functie op de GPU, wat leidt tot betere zoekresultaten ondanks de hogere rekentijd per evaluatie.
Omgaan met NaN's: Een unieke aanpak waarbij het framework NaN-waarden in de trainingsdata en modeluitvoer actief gebruikt voor selectie, in plaats van ze te negeren of te straffen.
Uitgebreide Benchmarking: Een rigoureuze vergelijking tegen state-of-the-art systemen (StackGP en PySR) op de Feynman-dataset onder strikte tijdslimieten.

Resultaten

De experimenten werden uitgevoerd op hardware met Intel Xeon CPUs en NVIDIA V100 GPUs. Beagle kreeg toegang tot 4 CPU-kernen en 2 GPUs, terwijl StackGP (single-threaded) slechts 1 CPU-kern kreeg en PySR 4 CPU-kernen.

Prestaties op 10 minuten:
- Beagle (met correlatie-functie) loste 82 van de 100 problemen op in de "typische" run (waarbij 50%+ van de 10 runs een oplossing vond).
- Beagle (P2P) loste 66 problemen op.
- StackGP loste 65 problemen op.
- PySR loste 64 problemen op.
- In de "beste" run (minstens één succesvolle run) behaalde Beagle (corr) 89 oplossingen.
Prestaties op 30 minuten:
- Beagle (corr) bleef de leider met 84 typische oplossingen en 91 beste oplossingen.
- Beagle (P2P) volgde met 74 typische oplossingen.
- PySR en StackGP presteerden lager dan Beagle.
Impact van NaN-handling: In een specifiek experiment met kwadratische vergelijkingen waarbij het domein werd verruimd om imaginaire getallen (die naar NaN worden omgezet) toe te staan, vond Beagle in alle 10 runs een perfecte oplossing. Zowel StackGP als PySR slaagden erin geen enkele perfecte oplossing te vinden in deze setting, wat aantoont dat het hanteren van NaN-locaties cruciaal is voor het vinden van oplossingen in bepaalde domeinen.

Betekenis en Conclusie

Het paper demonstreert dat GPU-versnelling een game-changer is voor Genetisch Programmeren. Beagle overtreft bestaande CPU-gebaseerde systemen aanzienlijk, zelfs onder zeer korte tijdslimieten (10-30 minuten).

De belangrijkste inzichten zijn:

Efficiëntie: Door het gebruik van GPUs en het minimaliseren van CPU/GPU-overhead, kunnen GP-systemen veel grotere zoekruimtes verkennen in minder tijd.
Populatiegrootte: Het vermogen om populaties van miljoenen individuen te beheren, opent nieuwe mogelijkheden voor diversiteit in de zoektocht, wat moeilijk te bereiken is met CPU-systemen.
Fitness-functie keuze: Hoewel de correlatie-functie per evaluatie trager is, compenseert de verbeterde zoekefficiëntie dit ruimschoots, wat leidt tot betere eindresultaten.
Toekomstperspectief: De resultaten suggereren dat GP met GPU-ondersteuning een haalbare en krachtige methode wordt voor praktische toepassingen waar tijdslimitten en interpretatie belangrijk zijn, zoals in de natuurkunde en materiaalkunde.

Kortom, Beagle bewijst dat het combineren van moderne GPU-architectuur met slimme algoritmen voor populatiebeheer en fitness-evaluatie leidt tot een significant superieure prestatie in symbolische regressie.