Evolving Executable Pipeline Programs for AutoML with Language Models
LACE is een nieuw AutoML-framework dat een evolutionaire lus gebruikt die wordt gestuurd door een groot taalmodel om uitvoerbare Python-pipelineprogramma's te genereren en te evolueren, waarbij het een concurrerende nauwkeurigheid bereikt op 68 OpenML-taken terwijl het een superieure transparantie, bewerkbaarheid en zoekruimteflexibiliteit biedt in vergelijking met traditionele systemen.
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
In de wereld van de moderne data science wordt er steeds vaker van machines gevraagd om betekenis te geven aan rommelige, real-world informatie: voorspellen of een leningaanvrager zal terugbetalen, een ziekte diagnosticeren op basis van een spreadsheet met symptomen, of verkopen voorspellen op basis van eerdere trends. Om dit te doen, bouwen onderzoekers "pipelines", wat stapsgewijze instructies zijn die de data opschonen, een wiskundig model kiezen en dat model afstemmen totdat het goed presteert. Jarenlang waren de krachtigste instrumenten voor deze taak geautomatiseerde systemen die fungeren als een meesterkok met een vaste set ingrediënten. Deze systemen kunnen bekende voorverwerkingsstappen en leeralgoritmen combineren en afwisselen, waarbij ze de hoeveelheden aanpassen om de beste smaak te vinden. Echter, ze zijn strikt beperkt tot de voorraadkast die ze gekregen hebben; ze kunnen geen nieuw ingrediënt of een nieuwe kooktechniek uitvinden die buiten hun vooraf gedefinieerde lijst valt. Deze beperking betekent dat als de beste oplossing een structuur vereist die het systeem nog nooit heeft gezien, deze onontdekt zal blijven.
Een team van onderzoekers aan de Universiteit Leiden heeft nu een andere aanpak geïntroduceerd, een aanpak die het creëren van deze datapipelines niet behandelt als een selectie uit een menu, maar als het schrijven van een nieuw recept vanaf nul. Ze ontwikkelden een systeem genaamd LACE, dat een groot taalmodel gebruikt—een kunstmatige intelligentie die getraind is op enorme hoeveelheden tekst en code—om als een evolutionaire motor te fungeren. In plaats van te kiezen uit een vaste lijst met tools, vraagt LACE de AI om volledige, uitvoerbare computerprogramma's te schrijven die definiëren hoe gegevens worden verwerkt en voorspellingen worden gedaan. Het systeem test vervolgens deze programma's, leert van hun fouten en vraagt de AI om verbeterde versies te schrijven, waarbij deze cyclus wordt herhaald totdat er een zeer effectieve oplossing wordt gevonden. Het resultaat is een systeem dat niet alleen bestaande tools aanpast, maar ook geheel nieuwe structuren kan componeren, waarbij code wordt geproduceerd die menselijke experts direct kunnen lezen, begrijpen en aanpassen.
De onderzoekers testten deze methode op 68 verschillende classificatietaken voor data, variërend van kleine datasets met enkele honderden vermeldingen tot enorme collecties met bijna vijf miljoen rijen. Ze vergeleken LACE met verschillende gevestigde geautomatiseerde systemen en een reeks vaste, vooraf getrainde modellen. De resultaten toonden aan dat LACE, wanneer aangedreven door een specifiek taalmodel, even goed presteerde als de sterkste bestaande geautomatiseerde systemen en aanzienlijk beter dan oudere methoden. Cruciaal was dat hoewel sommige van de nieuwere vooraf getrainde modellen iets nauwkeuriger waren op de specifieke taken die zij konden afhandelen, zij er niet in slaagden te werken op veel van de grotere of complexere datasets in de testset. LACE daarentegen genereerde succesvol een werkende oplossing voor elke taak die het kreeg toegewezen.
Wat deze prestatie bijzonder opmerkelijk maakt, is de aard van de output. Traditionele geautomatiseerde systemen leveren vaak een "black box" op—een complex, aangepast object dat goed werkt maar moeilijk door een mens te inspecteren of te veranderen zonder diepe technische kennis van het softwareframework. LACE levert gewone Python-code op. Dit betekent dat een data scientist het uiteindelijke programma kan bekijken, precies kan zien hoe de data is schoongemaakt, welke modellen zijn gekozen en hoe ze zijn gecombineerd, en de code vervolgens kan bewerken om het verder te verbeteren of aan te passen voor een nieuw doel. De onderzoekers ontdekten dat de AI niet alleen bestaande patronen kopieerde; het evolueerde diverse oplossingen, waarbij het vaak verschillende soorten modellen op nieuwe manieren combineerde en aangepaste logica schreef om hun voorspellingen te mengen. In veel gevallen schreef de AI zijn eigen code om de outputs van meerdere modellen te mengen, een niveau van flexibiliteit dat vaste systemen niet gemakkelijk kunnen repliceren.
De studie adresseerde ook een veelvoorkomende zorg in AI-onderzoek: dat de AI simpelweg de antwoorden op de testvragen uit het hoofd leert omdat het deze tijdens zijn training al heeft gezien. Om dit te voorkomen, verzwegen de onderzoekers de namen en specifieële details van de datasets voor de AI, en gaven ze alleen een algemene beschrijving van de grootte en het type van de data. Ondanks dit gebrek aan specifieke kennis, vond het systeem nog steeds hoogpresterende oplossingen, wat suggereert dat het echt leerde hoe het effectieve pipelines kon construeren in plaats van antwoorden te reproduceren. De onderzoekers verifieerden verder dat de AI strikte regels volgde, zoals het niet gebruiken van verborgen interne zoekopdrachten om zijn eigen instellingen af te stemmen, waardoor werd gegarandeerd dat de verbeteringen voortkwamen uit het evolutionaire zoekproces zelf.
Een van de meest opvallende bevindingen was hoe snel het systeem verbeterde. Het eerste programma dat door de AI werd gegenereerd, was vaak gebrekkig of incompleet, maar naarmate het systeem iteraties uitvoerde, leerde het deze fouten te herstellen en de logica te verfijnen. Tegen de tijd dat het proces voltooid was, waren de uiteindelijke programma's niet alleen geldig, maar ook aanzienlijk nauwkeuriger dan de initiële pogingen. De onderzoekers observeerden dat het systeem de neiging had om bepaalde typen modellen te verkiezen, zoals boom-gebaseerde ensembles, maar dat het niet vastliep in één enkel patroon; het verkende een grote verscheidenheid aan structurele combinaties. Deze diversiteit suggereert dat het systeem in staat is om oplossingen te ontdekken die een mens misschien niet zou bedenken om te proberen, of die een rigide systeem nooit zou overwegen.
Het werk laat zien dat het behandelen van geautomatiseerd machine learning als een proces van het schrijven en evolueren van code een nieuwe horizon opent. Het gaat voorbij aan de beperking van een vaste bibliotheek van tools, waardoor het systeem zijn structuur kan aanpassen aan het specifieke probleem dat het voor zich heeft. Hoewel de computationele kosten voor het draaien van deze experimenten hoog waren, waarbij aanzienlijke tijd nodig was om duizenden kandidaat-programma's te genereren en te testen, suggereren de resultaten dat de mogelijkheid om transparante, bewerkbare en zeer effectieve code te produceren een waardevolle afweging is. De onderzoekers concluderen dat deze aanpak een veelbelovend pad biedt, waarbij de zoektocht naar de beste datapipeline wordt gedefinieerd door de creativiteit van de code zelf, in plaats door de beperkingen van een vooraf geselecteerde set componenten.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.