RocketStack: Level-aware Deep Recursive Ensemble Learning Architecture

Het paper introduceert RocketStack, een innovatieve architectuur voor diep recursief ensemble-leren die door middel van niveau-bewust pruning, regularisatie via Gaussische perturbaties en periodieke compressie, effectief tot tien stapelingsniveaus opschaling mogelijk maakt met sublineaire rekentijd en verbeterde nauwkeurigheid op diverse datasets.

De kern

🚀 Wat is RocketStack eigenlijk?

Stel je voor dat je een team van detectives hebt die een mysterie moeten oplossen.

• De gewone aanpak (Ensemble Learning): Je vraagt elke detective zijn eigen versie van de waarheid. Dan neem je die versies en laat je één "hoofdinspecteur" (een meta-model) beslissen wie het meest waarschijnlijk gelijk heeft. Dit werkt vaak goed, maar meestal stoppen ze na één of twee rondes.
• Het probleem: Als je dit proces te vaak herhaalt (dieper stacken), wordt het team te groot, te verward en te traag. De detectives beginnen elkaar te kopiëren (redundantie) en het hoofdinspecteur wordt overbelast door te veel informatie.

RocketStack is een slimme, nieuwe manier om dit team te organiseren. Het is als een onbemande ruimtevaartuig dat niet alleen hoger vliegt, maar ook slim omgaat met zijn brandstof en bemanning. Het kan tot wel 10 verdiepingen diep gaan zonder in elkaar te storten.

---

🛠️ Hoe werkt het? (De 3 Slimme Trucs)

RocketStack gebruikt drie hoofdstrategieën om diep te kunnen gaan zonder gek te worden:

1. Het "Pruning"-proces: De selectieve chef-kok 🍽️

Stel je voor dat je elke ronde een nieuwe ronde van detectives toevoegt. In een normaal team zouden ze allemaal blijven zitten, zelfs de slechtste.

• RocketStack doet anders: Na elke ronde kijkt de chef-kok naar de prestaties (de "OOF-scores"). De slechtste detectives worden ontslagen.
• De creatieve twist: Soms is de chef-kok te streng en ontslaat hij per ongeluk iemand die net even beter had kunnen zijn. Daarom voegt RocketStack een beetje "ruis" (stochastic noise) toe aan de scores. Het is alsof je de chef-kok een beetje laat twijfelen: "Misschien is deze detective wel net iets beter dan hij lijkt." Hierdoor blijft het team diverser en slimmer, in plaats van dat ze allemaal naar dezelfde oplossing rennen.

2. De "Feature Compression": De slimme koffer 🧳

Elke keer dat een detective een nieuw idee heeft, wordt dat een extra item in de koffer van het team. Als je 10 rondes doet, zit die koffer vol met onzin en dubbel werk.

• RocketStack lost dit op: In plaats van de koffer elke ronde te legen (wat te veel informatie kost), doet RocketStack dit periodiek (bijvoorbeeld na ronde 3, 6 en 9).
• De analogie: Het is alsof je op een lange reis elke paar dagen je koffer sorteert. Je gooit de oude kranten en lege flessen weg en houdt alleen de essentiële spullen over. Dit zorgt ervoor dat het team niet verzandt in rommel, maar wel blijft groeien in wijsheid.

3. De "Deep Dive": Waarom 10 verdiepingen? 🏢

De meeste systemen stoppen na 1 of 2 verdiepingen. RocketStack gaat tot 10.

• Het resultaat: Het is alsof je een gebouw bouwt. De eerste verdieping is sterk, maar naarmate je hoger komt, worden de muren dunner en de ramen kleiner (door de compressie). Toch blijkt dat de bovenste verdiepingen (rondes 7 tot 10) nog steeds waardevolle inzichten hebben die de onderkant niet zag. Het systeem leert continu bij, zonder dat het gebouw instort.

---

📊 Wat hebben ze ontdekt?

De onderzoekers hebben dit getest op 33 verschillende datasets (zoals medische gegevens, financiële risico's en technische defecten). Hier zijn de belangrijkste bevindingen in simpele taal:

1. Dieper is beter (maar niet te diep zonder regel): Als je gewoon blijft stapelen zonder te snoeien of te comprimeren, wordt het systeem traag en onnauwkeurig. Met RocketStack wordt de nauwkeurigheid echter steeds beter naarmate je dieper gaat.
2. De "Ruis" werkt: Het toevoegen van een beetje willekeur bij het ontslaan van detectives (de "Gaussian noise") zorgde ervoor dat het team stabieler bleef en op de lange termijn betere resultaten leverde. Het voorkomt dat het team te snel vastloopt op een verkeerd idee.
3. Periodiek sorteren is het beste: Het is beter om je koffer (de data) om de paar rondes te sorteren dan elke ronde. Als je elke ronde sorteert, gooi je soms waardevolle informatie weg die nog nodig was voor de volgende stap.
4. Geen perfecte start nodig: Je hoeft je detectives (de basis-modellen) niet eerst maandenlang te trainen en te optimaliseren. RocketStack kan zelfs werken met "gemiddelde" detectives en maakt ze in de loop van de 10 rondes toch supersterk. Dit bespaart enorm veel tijd en rekenkracht.

---

🏆 De conclusie: Waarom is dit belangrijk?

Vroeger dachten mensen dat "diepe" ensemble-systemen (veel lagen van modellen) te traag en te rommelig waren om te gebruiken. RocketStack bewijst het tegendeel.

Het is als een modulaire, slimme machine die:

• Zichzelf schoonhoudt (door te snoeien).
• Slim inpakt (door data te comprimeren).
• Zelfs beter wordt naarmate het langer werkt.

Het resultaat? Een systeem dat net zo goed (of zelfs iets beter) presteert als de allerbeste bestaande methoden, maar dan met minder rekenkracht en meer controle. Het opent de deur voor veel complexere en slimmere AI-systemen in de toekomst, zonder dat ze de hele computer nodig hebben om te werken.

Kortom: RocketStack is de manier om een team van experts te laten samenwerken tot in de oneindigheid, zonder dat ze elkaar gaan vergeten of de koffer volgooien met onzin. 🚀✨

Technische samenvatting

Probleemstelling

Hoewel ensemble-leren, en specifiek "stacking" (gestapelde generalisatie), een hoeksteen is van machine learning voor gestructureerde tabulaire data, blijft de toepassing ervan in de praktijk overwegend ondiep (meestal beperkt tot één of twee meta-lagen). De diepere adoptie van recursieve stacking wordt gehinderd door drie hoofdproblemen:

1. Feature-redundantie en -accumulatie: Naarmate voorspellingen door lagen worden doorgegeven, groeit de dimensionaliteit van de feature-ruimte explosief, wat leidt tot overfitting en slechte generalisatie.
2. Rekenkundige complexiteit: De trainingstijd en het geheugengebruik nemen exponentieel toe zonder gecoördineerde pruning (uitdunnen) of compressie.
3. Overfitting: Recursieve toepassing van niet-lineaire leerders verhoogt het risico op overfitting, vooral in scenario's met weinig data of zonder strikte cross-validatie-strategieën.

Bestaande methoden lossen deze problemen vaak op in geïsoleerde stappen of opereren slechts op ondiepe niveaus, waardoor er geen schaalbaar raamwerk bestaat voor echt diepe, recursieve ensemble-modellen.

Methodologie: RocketStack

Het artikel introduceert RocketStack, een modulaire architectuur voor recursief ensemble-leren die is ontworpen om tot 10 lagen diep te gaan. De kern van de methode ligt in een gebalanceerde aanpak van feature-fusie, compressie en model-pruning.

1. Architectuur en Fusie:

• Level 1: Voorspellingen van basis-learners (OOF-probabiliteiten) worden gefuseerd met de originele invoerfeatures.
• Volgende Levels: Zwakkere learners worden geleidelijk verwijderd. De OOF-voorspellingen van de overgebleven modellen worden gecombineerd met de gecomprimeerde feature-matrix van de vorige laag.

2. Dynamische Pruning (Uitdunnen):

• Modellen worden op elk niveau beoordeeld op basis van hun Out-of-Fold (OOF) scores.
• Deterministische Pruning: Modellen onder een dynamisch percentiel-drempelwaarde worden verwijderd.
• Stochastische Pruning (Kerninnovatie): Om te voorkomen dat het ensemble te vroeg convergeert naar een lokaal optimum, wordt Gaussian noise (ruis) toegevoegd aan de OOF-scores voordat de selectie plaatsvindt. Dit fungeert als een regularisatiemechanisme dat diversiteit behoudt in de diepere lagen. Twee ruisniveaus werden getest ($\lambda = 0.05$ en $\lambda = 0.1$).

3. Feature Compressie en Selectie:
Om de feature-ruimte beheersbaar te houden, worden drie strategieën getest:

• Geen compressie: Alle features worden behouden (baseline).
• Per-level compressie: Feature-selectie vindt op elke laag plaats.
• Periodieke compressie: Feature-selectie vindt alleen plaats op specifieke dieptes (lagen 3, 6 en 9).
  • Methoden: Simple, Fast, Efficient (SFE) filtering, Autoencoders (2-laags en 3-laags), en Attention-mechanismen.
  • De studie concludeert dat periodieke compressie superieur is aan per-level compressie, omdat het toelaat dat features zich eerst kunnen "accumuleren" voordat ze worden gereduceerd, wat de representatiekwaliteit verbetert.

4. Stack-of-Stacking:
Aan het einde van de pijplijn worden de geselecteerde meta-features van alle lagen samengevoegd tot één globale feature-matrix voor de finale voorspelling.

Belangrijkste Bijdragen

1. Schaalbare Diepte: Een modulaire architectuur die succesvol is getest tot 10 lagen diep, wat een significant vooruitgang is ten opzichte van de gebruikelijke 1-2 lagen.
2. Stochastische Pruning: Het introduceren van ruis in OOF-scores tijdens het selectieproces om vroegtijdige convergentie te voorkomen en de stabiliteit van het ensemble op diepe niveaus te vergroten.
3. Periodieke vs. Per-level Compressie: Het aantonen dat periodieke feature-selectie (op vaste intervallen) een betere afweging biedt tussen nauwkeurigheid, runtime en feature-groei dan continue compressie op elke laag.
4. Sublineaire Groei: RocketStack bereikt diepe recursieve stacking met sublineaire rekenkundige groei dankzij de combinatie van pruning en periodieke compressie.

Resultaten

De architectuur werd geëvalueerd op 33 datasets (23 binair, 10 multi-class) uit diverse domeinen (finance, healthcare, industrie, etc.).

• Nauwkeurigheid: Er werd een lineair gemengd-effect trendtest uitgevoerd die aantoonde dat de nauwkeurigheid consistent toeneemt met de diepte van het ensemble.
  • Op het diepste niveau (Level 10) overtrof RocketStack gevestigde diepe tabulaire baselines zoals Deep Forest en TabNet, zelfs zonder hyperparameter-optimalisatie (HPO) op de basismodellen.
  • In multi-class taken bereikte de beste configuratie (Periodieke Attention met lichte ruis) een nauwkeurigheid van 98.60%.
• Impact van Ruis: De toepassing van lichte Gaussian noise ($\lambda=0.05$) tijdens de pruning resulteerde in significante verbeteringen in stabiliteit en late-niveau winsten, vooral in combinatie met periodieke compressie.
• Hyperparameter Optimalisatie (HPO): Interessant genoeg bleek dat het toepassen van HPO op de basismodellen (Level 0) een initiële voorsprong gaf, maar dat de "niet-geoptimaliseerde" (untuned) RocketStack-configuratie deze voorsprong op diepere niveaus inhaalde en zelfs overtrof. Dit suggereert dat de architectuur zelf in staat is om niet-geoptimaliseerde signalen te verfijnen.
• Efficiëntie: Periodieke compressie zorgde voor aanzienlijke reducties in runtime en dimensionaliteit met een minimaal verlies aan nauwkeurigheid. Per-level compressie bleek vaak te agressief en leidde tot prestatieverlies.

Significantie en Conclusie

RocketStack biedt een fundamentele doorbraak in het veld van ensemble learning door diepe, recursieve stacking praktisch en schaalbaar te maken. Het lost het probleem van feature-bloat op door slimme, periodieke compressie en voorkomt overfitting door stochastische pruning.

De belangrijkste conclusie is dat diepte in ensemble learning niet noodzakelijk leidt tot degradatie, mits de architectuur "level-aware" is (bewust van de diepte) en dynamisch resources beheert. RocketStack biedt een modulaire, diepte-bewuste basis voor schaalbare besluitvorming en stelt onderzoekers in staat om de trade-off tussen complexiteit, runtime en nauwkeurigheid op een gecontroleerde manier te onderzoeken. Het bewijst dat een goed ontworpen, diep recursief ensemble zelfs zonder zware hyperparameter-tuning concurrentieel kan zijn met de meest geavanceerde deep learning-modellen voor tabulaire data.