stratum: A System Infrastructure for Massive Agent-Centric ML Workloads

Dit paper introduceert Stratum, een nieuwe systeeminfrastructuur die de uitvoering van ML-pipelines ontkoppelt van de planning door autonome agenten, waardoor duizenden experimenten efficiënt kunnen worden uitgevoerd via een geoptimaliseerde Rust-runtime met een snelheidswinst tot 16,6 keer.

De kern

Stratum: De Slimme Regisseur voor AI-Expeditie

Stel je voor dat je een gigantische zoektocht organiseert naar de perfecte recept voor een nieuwe soep. Je hebt een team van duizenden koks (de AI-agenten) die elk hun eigen versie van het recept bedenken. Ze gebruiken allemaal dezelfde basis ingrediënten (de populaire Python-bibliotheken zoals Pandas en scikit-learn), maar ze proberen duizenden variaties: meer zout, minder uien, een andere kooktemperatuur.

Het probleem? In de huidige wereld werken deze koks alsof ze in een chaos zitten:

• Ze staan allemaal in dezelfde kleine keuken en blokkeren elkaar.
• Ze gooien ingrediënten weg die ze net hebben gekocht, terwijl een andere kok ze al had.
• Ze gebruiken handmatige lepels (Python) in plaats van industriële machines, waardoor het allemaal erg traag gaat.
• Als ze te hard werken, springt de keuken in brand (geheugenfouten) of stopt alles omdat er te veel mensen tegelijk aan het werk zijn.

Stratum is de oplossing voor dit probleem. Het is een nieuw, slim keukenbesturingssysteem dat speciaal is ontworpen voor deze enorme zoektochten.

Hier is hoe Stratum werkt, vertaald naar alledaagse taal:

1. De "Slimme Regisseur" (De Architectuur)

In plaats van dat elke AI-agent chaotisch zijn eigen recept draait, neemt Stratum de leiding.

• Het idee: Stratum kijkt naar alle duizenden recepten die de agents hebben bedacht en zegt: "Wacht even, jullie maken allemaal dezelfde soepbasis. Laten we dat maar één keer koken en dan delen."
• De analogie: Stel je voor dat Stratum een regisseur is die een film draait. In plaats van dat elke acteur (de AI) zijn eigen scène apart opneemt, regelt Stratum dat alle scènes die hetzelfde decor gebruiken, in één keer worden opgenomen. Dit bespaart enorm veel tijd.

2. De "Taalvertaler" (Integratie met Python)

De AI-agenten spreken de taal van de mens: Python. Ze willen geen nieuwe, moeilijke taal leren.

• Het probleem: Bestaande snelle systemen spreken een andere taal (zoals C++ of speciale code) die de AI niet kent.
• De oplossing: Stratum is een tolk. De AI-agenten blijven Python schrijven, maar Stratum vertaalt die code in de achtergrond naar een super-efficiënte "machine-taal" (geschreven in Rust, een taal die bekend staat om zijn snelheid).
• De analogie: Het is alsof je een gesprek voert met een vreemdeling in je eigen taal, maar hij heeft een briljante vertaler die zijn antwoorden direct omzet in de snelste manier om de boodschap over te brengen.

3. De "Superkeuken" (De Rust-runtime)

Python is handig, maar het is alsof je een Formule 1-auto bestuurt met een fietspedaal: het kan, maar het is niet snel genoeg voor duizenden koks tegelijk.

• De oplossing: Stratum heeft een eigen Rust-runtime. Dit is de krachtige motor onder de motorkap.
• De analogie: Stel je voor dat de Python-koks normaal gesproken met de hand moeten roeren. Stratum pakt hen en zet ze in een robotarm. De robotarm (Rust) kan duizenden potten tegelijk roeren zonder dat de koks (de Python-code) het zelf hoeven te doen. Hierdoor wordt het proces tot wel 16 keer sneller.

4. De "Slimme Voorraadkast" (Caching en Hergebruik)

In de huidige chaos gooien agents vaak dezelfde data weg en laden ze het opnieuw in.

• De oplossing: Stratum onthoudt alles. Als een AI-agent een stukje data al heeft verwerkt, zegt Stratum: "Die heb je gisteren al gedaan, hier is het resultaat, gebruik het opnieuw."
• De analogie: Het is alsof je een slimme voorraadkast hebt. Als je al een pot tomatensoep hebt gekookt, hoef je niet opnieuw te beginnen. Je haalt de pot uit de kast, verwarmt hem op en voegt alleen de nieuwe kruiden toe. Stratum zorgt ervoor dat deze "potjes" (tussenresultaten) veilig bewaard blijven en direct beschikbaar zijn.

Waarom is dit belangrijk?

Vroeger deden datawetenschappers dit werk zelf, stap voor stap. Nu doen AI-agenten het voor ons, maar ze zijn zo snel en druk dat de huidige computersystemen het niet aankunnen. Ze worden overbelast, worden traag en verspillen energie.

Stratum is de brug tussen de dromen van de AI (die duizenden ideeën per seconde bedenkt) en de realiteit van de hardware (die niet oneindig snel kan werken). Het zorgt ervoor dat deze AI-agenten niet vastlopen in een file, maar als een goed georganiseerd leger razendsnel de beste oplossingen vinden.

Kort samengevat:
Stratum is de verkeersleider die zorgt dat de duizenden AI-autootjes niet in de file staan, maar op een slimme, snelle en efficiënte manier hun bestemming bereiken, zonder dat ze hun eigen besturing (Python) hoeven te veranderen.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "stratum: A System Infrastructure for Massive Agent-Centric ML Workloads [Vision]", geschreven in het Nederlands.

1. Het Probleem: De mismatch tussen Agent-ML en bestaande systemen

De snelle opkomst van Large Language Models (LLMs) heeft geleid tot een nieuw type werklast: agente pipeline-search. In deze workflow genereren autonome of semi-autonome agenten, valideren en optimaliseren ze volledige data science-pipelines. Deze agenten opereren voornamelijk binnen het populaire Python-ecosysteem (met bibliotheken zoals Pandas en scikit-learn) en vertonen een sterk explorerend gedrag.

Dit leidt tot de volgende uitdagingen:

• Schaal en Redundantie: Agenten genereren duizenden pipeline-varianten per seconde. Omdat elke iteratie vaak slechts kleine wijzigingen bevat (bijv. 16% van de code), is er sprake van enorme redundantie in berekeningen en data-laden.
• Inefficiëntie van het Python-ecosysteem: Bestaande Python-ML-bibliotheken zijn ontworpen voor menselijke, interactieve en sequentiële workflows. Ze missen een unificerende uitvoeringslaag voor geoptimaliseerde, holistische berekening. Python zelf is niet ontworpen voor hoge prestaties en hoge concurrentie (beperkt door de Global Interpreter Lock - GIL).
• Gebrek aan geïntegreerde systemen: Bestaande high-performance ML-systemen (zoals SystemML of OptiML) vereisen vaak specifieke domeinspecifieke talen (DSL's) die niet compatibel zijn met LLM-agenten, of ze focussen op te smalle werklastklassen. Systemen zoals Ray of Dask bieden parallelisme, maar missen holistische optimalisatie en compiler-technieken.
• Resource-gebruik: Het huidige "naïeve" paralleliseren leidt tot out-of-memory (OOM) fouten, onderbenutting van CPU/GPU-resources en hoge serialisatiekosten door het starten van veel onafhankelijke Python-processen.

2. Methodologie: De Stratum Architectuur

Om dit probleem op te lossen, stellen de auteurs stratum voor: een systeeminfrastructuur die de uitvoering van pipelines ontkoppelt van de planning en redenering van de agent. Stratum fungeert als een tussenlaag die agent-genereren code omzet in geoptimaliseerde uitvoeringsgrafieken.

De kernarchitectuur bestaat uit de volgende componenten:

• Declaratieve Abstractie (DAG): Stratum gebruikt de bibliotheek skrub als instappunt. Het vertaalt heterogene Python-pipelines (Pandas, scikit-learn, PyTorch, UDF's) naar een vertraagd geëvalueerd Directed Acyclic Graph (DAG). Hierbij worden operaties omgezet in semantisch expliciete operatoren (DataOps), waardoor data-afhankelijkheden en controleflow duidelijk worden.
• Logische Optimizer:
  • Metadata Collectie: Het systeem verzamelt metadata over operatoren (type, bronbibliotheek, structuur, data-karakteristieken).
  • Rewrites: Op basis van deze metadata worden logische herschrijvingen toegepast, zoals Common Subexpression Elimination (CSE), predicate pushdown, en het vermijden van onnodige kopieën binnen Pandas.
  • Operator Lowering: Complexe operatoren (zoals cross-validatie of TableVectorizer) worden opgebroken in fijnmazige, onafhankelijke operatoren om de optimalisatieruimte te vergroten.
• Operator Selectie: Stratum biedt meerdere fysieke implementaties voor elke logische operator. Het kiest dynamisch de meest efficiënte implementatie op basis van kostenramingen en hardware-beperkingen (bijv. kiezen tussen scikit-learn, Polars, of een native Rust-implementatie).
• Rust Backend: Een kerninnovatie is een Rust-based runtime. Veel veelgebruikte operatoren in Python zijn traag door type-conversies en het GIL. Stratum implementeert deze operatoren in Rust met zero-copy data-toegang en expliciete geheugencontrole. Deze kernels geven de GIL vrij, waardoor echte multithreading mogelijk is.
• Runtime Optimalisaties:
  • Parallelisme: Een kosten-gedreven planner bepaalt intra- en inter-operator parallelisme om oversubscription te voorkomen.
  • Hergebruik van Intermediaten: Een cache-mechanisme (hash-map) slaat resultaten van operatoren op. Omdat agenten vaak vergelijkbare pipelines genereren, kunnen eerdere resultaten (zoals preprocessing) direct worden hergebruikt in plaats van opnieuw te worden berekend.

3. Belangrijkste Bijdragen

1. Analyse van Agente Werklasten: Het paper introduceert een representatief gebruiksscenario en analyseert de uitvoeringskenmerken, waarbij wordt aangetoond dat huidige systemen inefficiënt omgaan met de redundantie en dynamiek van agent-gestuurde zoektochten.
2. Systeemontwerp voor Agente ML: Het definieert een nieuw systeemparadigma dat Python-bibliotheken integreert met compiler- en runtime-technieken, specifiek ontworpen voor de schaal van agent-pipeline-search.
3. Stratum Architectuur: Een volledig geïntegreerde architectuur met een logische optimizer, operator-selectie, een Rust-backend en paralleliseringsplanning.
4. Agent-System Co-Design: Het paper stelt een visie voor waarin agents en het systeem samenwerken (bijv. door metadata te annoteren voor workload-aware optimalisaties), in plaats van dat uitvoering een "black box" is.
5. Prototype en Evaluatie: Een werkend prototype dat de haalbaarheid en prestaties van de benadering aantoont.

4. Resultaten

De auteurs hebben een prototype van stratum getest met een realistische werklast gegenereerd door de AIDE-agent (een ML-engineering agent) op een dataset van UK-huisprijzen.

• End-to-End Prestaties: Stratum bereikte een snelheidswinst van 16,6x ten opzichte van de basisimplementatie (sequentiële uitvoering door de agent).
• Vergelijking met Parallelle Baselines: Zelfs ten opzichte van een versie die gebruikmaakt van multiprocessor-parallelisme (Base_par), was Stratum 7,8x sneller. Dit komt omdat Base_par last heeft van hoge serialisatiekosten en geheugenoverhead, terwijl Stratum dit efficiënter beheert.
• Ablatie-studie: De bijdrage van individuele optimalisaties werd geanalyseerd:
  • Logische optimalisatie (CSE, herschrijvingen): +2,2x.
  • Operator-selectie (overschakelen naar native/Rust implementaties): +4,5x extra.
  • Inter-operator parallelisme: +10% extra.
• Conclusie: De resultaten bevestigen dat holistische optimalisatie (combinatie van compiler-technieken en efficient runtime) cruciaal is voor de schaalbaarheid van agente ML-werklasten.

5. Betekenis en Toekomstvisie

Dit paper markeert een verschuiving in hoe we ML-systemen ontwerpen. Het toont aan dat het traditionele Python-ecosysteem onvoldoende is voor de toekomstige schaal van autonome AI-agenten.

• Nieuwe Klasse Systemen: Er is een nieuwe klasse van data-systemen nodig die specifiek zijn ontworpen voor "agente pipeline search", in plaats van alleen voor menselijke interactie of statische batch-verwerking.
• Integratie van Talen: De succesvolle integratie van Python (voor gebruiksgemak en LLM-compatibiliteit) met Rust (voor prestaties) biedt een blauwdruk voor toekomstige ML-systemen.
• Toekomstige Richtingen: Het paper schetst richtingen voor multi-tenant cloud-diensten, "systeem-bewuste" agents die hun zoekstrategie aanpassen aan de systeemcapaciteiten, en verdere integratie met Deep Learning-workloads (DNN's).

Kortom, stratum biedt de noodzakelijke infrastructuur om de explosieve groei van agent-gestuurde data science mogelijk te maken zonder dat dit ten koste gaat van prestaties of resource-efficiëntie.