Resource-Efficient Iterative LLM-Based NAS with Feedback Memory

Deze paper introduceert een kostenefficiënte, iteratieve Neural Architecture Search-methode die gebruikmaakt van gespecialiseerde, niet-finetuned large language models en een historische feedbackgeheugen om binnen een enkele consumer GPU compacte en hoogpresterende beeldclassificatie-architecturen te ontwerpen zonder cloud-infrastructuur.

De kern

Stel je voor dat je een architect bent die een nieuw type huis moet ontwerpen. In het verleden moesten mensen (of slimme computers) duizenden variaties van dit huis tekenen, bouwen, bewonen en weer afbreken om te zien welke het beste werkt. Dit kostte enorme hoeveelheden geld, tijd en energie.

Deze paper introduceert een slimme, goedkope manier om dit te doen, met behulp van een Artificial Intelligence (AI) die we een "LLM" noemen. Hier is hoe het werkt, vertaald naar alledaagse taal:

1. De Slimme Architect en de Twee Hoeden

In plaats van één enorme AI die alles moet doen, hebben de onderzoekers een systeem bedacht met twee rollen, alsof je één persoon bent die twee verschillende hoeden opzet:

• De Bouwmeester (Code Generator): Deze AI schrijft het ontwerp (de code) voor het neurale netwerk. Hij is gespecialiseerd in het bouwen van de structuur.
• De Kritische Ooggetuige (Prompt Improver): Deze AI kijkt naar het resultaat van de bouwmeester. Als het huis instort of deuren niet werken, analyseert deze AI waarom dat gebeurde en schrijft een briefje met tips voor de volgende keer.

2. Het Geheim: De "Herinneringskoffer" (Feedback Memory)

Dit is het belangrijkste nieuwe idee in de paper. Veel andere AI-systemen vergeten hun fouten. Als ze een slecht ontwerp maken, gooien ze het weg en proberen ze iets nieuws, alsof ze nooit hebben gefaald.

De onderzoekers hebben een herinneringskoffer ingebouwd.

• Stel je voor dat je een schrijver bent die een boek schrijft. Als je een hoofdstuk schrijft dat niet werkt, gooi je het niet weg. Je schrijft op: "Ik dacht dat de deur links zou werken, maar hij viel uit. Volgende keer doe ik hem rechts."
• De AI houdt een kleine koffer bij met de laatste 5 pogingen.
• In deze koffer staan drie dingen per poging:
  1. Wat ging er mis? (Het probleem)
  2. Wat was de oplossing? (De suggestie)
  3. Wat was het resultaat? (Ging het beter of slechter?)

Door alleen naar deze laatste 5 stappen te kijken, blijft de "koffer" niet te vol (zodat de AI niet verward raakt), maar heeft hij genoeg informatie om niet dezelfde fouten te herhalen.

3. De "Snelle Test" (Proxy Training)

Normaal duurt het maanden om een nieuw AI-model volledig te trainen. Dat is te duur voor dit experiment.
In plaats daarvan gebruiken ze een snelle test: ze laten het model slechts één dag (één epoch) werken.

• Het is alsof je een auto niet een jaar laat rijden om te zien of hij goed is, maar je hem één keer laat racen op een korte baan.
• Als hij in die korte rit al snel is, is de kans groot dat hij ook goed is voor de lange rit. Dit bespaart enorm veel tijd en energie.

4. De Resultaten: Van Nul tot Helden

De AI begon met willekeurige ontwerpen die vaak faalden of slecht presteerden. Maar door dit cirkelproces (bouwen -> testen -> leren van fouten -> opnieuw bouwen) gebeurde er magie:

• De start: De AI begon met een nauwkeurigheid van ongeveer 28% (alsof het raden was).
• Het eindresultaat: Na duizenden pogingen op één enkele computer (een gewone gaming-kaart, geen supercomputer) steeg dit naar 71%.
• De kosten: Dit hele proces duurde ongeveer 18 uur op één computer. Vroeger kostte dit duizenden dagen aan rekenkracht.

Waarom is dit zo belangrijk?

Stel je voor dat je in een kleine garage woont en je wilt een raceauto bouwen. Vroeger had je een fabriek nodig. Nu kun je het zelf doen met een simpele toolbox, omdat je AI-assistent slim genoeg is om uit zijn eigen fouten te leren zonder dat je hem hoeft te "herprogrammeren" (fine-tunen).

Samengevat in één zin:
De onderzoekers hebben een slimme, goedkope cyclus bedacht waarbij een AI als een leraar fungeert die zijn eigen fouten noteert in een klein notitieboekje, zodat hij steeds betere neurale netwerken kan ontwerpen zonder dat je een dure supercomputer nodig hebt.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "Resource-Efficient Iterative LLM-Based NAS with Feedback Memory", vertaald en samengevat in het Nederlands.

1. Het Probleem

Neurale Architectuur Search (NAS) automatiseert het ontwerpen van diepe neurale netwerken, maar traditionele methoden (zoals versterkingslering of evolutionaire algoritmen) zijn extreem rekenintensief en vereisen vaak duizenden GPU-dagen. Bestaande efficiëntere methoden beperken zich vaak tot vooraf gedefinieerde, discrete zoekruimtes (bijv. cel-gebaseerde structuren), wat de creativiteit en flexibiliteit van het ontwerp beperkt.

Recente benaderingen met Large Language Models (LLMs) kunnen direct uitvoerbare Python-code genereren, maar deze werken vaak als "single-shot" (eenmalige generatie) zonder iteratieve verbetering op basis van evaluatie-resultaten. Bovendien missen veel bestaande LLM-optimizers een mechanisme om mislukkingen systematisch te leren, waardoor cruciale leerinformatie verloren gaat.

2. Methodologie

De auteurs stellen een gesloten lus-pijplijn voor die LLMs gebruikt om convolutionele neurale netwerken (CNN's) iteratief te genereren, evalueren en verfijnen op één consumentengpu (RTX 4090), zonder fine-tuning van de LLM zelf.

De pijplijn bestaat uit drie kerncomponenten:

• Code Generator: Een instructie-getuned LLM (bijv. DeepSeek-Coder, Qwen2.5, GLM-5) genereert uitvoerbare PyTorch-code voor een neurale architectuur. De prompt bevat de taakspecificatie, de beste huidige implementatie en suggesties voor verbetering.
• Evaluator: De gegenereerde code wordt gevalideerd en getraind voor één epoch op een dataset (CIFAR-10, CIFAR-100, ImageNette) om een snelle proxy-accuraatheid te verkrijgen. Dit dient als rangschikkings-signaal zonder de kosten van volledige training.
• Prompt Improver met Historische Feedbackgeheugen: Dit is het centrale innovatieve onderdeel. In plaats van alleen de beste resultaten te onthouden, behoudt het systeem een sliding window van de laatste K=5 verbeterpogingen.
  • Elke geschiedenisentry is een gestructureerde diagnostische triple: (1) geïdentificeerd probleem, (2) voorgestelde modificatie, (3) resultaat (succesvolle accuraatheid of type fout).
  • Dit volgt het Markov-eigenschap: de volgende beslissing hangt af van de huidige beste architectuur en een begrensd venster van recente geschiedenis, niet van de volledige traject. Dit voorkomt context-overloop en zorgt voor een constante promptgrootte.
  • Fouten als leersignalen: Code-executiefouten worden behandeld als "first-class" leersignalen in plaats van te worden weggegooid.

Dual-LLM Specialisatie: Om de cognitieve last te verlagen, worden twee rollen onderscheiden: een Code Generator voor het synthetiseren van code en een Prompt Improver voor diagnostisch redeneren. Omdat beide deels dezelfde VRAM delen met de modeltraining, wordt de zoektocht impliciet gefavoriseerd naar compacte, hardware-efficiënte modellen.

3. Belangrijkste Bijdragen

1. Iteratieve Gesloten LUS: Een NAS-pijplijn die architecturen progressief verbetert via code-generatie, evaluatie en prompt-verfijning, in tegenstelling tot eenmalige generatie.
2. Historische Feedbackgeheugen: Een mechanisme dat een sliding window van mislukkingen en successen bijhoudt, waardoor de LLM kan leren van foutpatronen en herhaling van mislukte strategieën kan vermijden.
3. Gestructureerde Foutmodellering: Het gebruik van diagnostische triples maakt het mogelijk voor de LLM om causale relaties te leren tussen ontwerpbeslissingen en uitkomsten, zelfs bij hoge foutpercentages (5-99%).
4. Resource-efficiëntie: Demonstratie dat frozen LLMs van ≤7B parameters effectief NAS kunnen uitvoeren op één consumentengpu (RTX 4090) in ongeveer 18 uur voor 2000 iteraties, zonder cloud-infrastructuur of fine-tuning.

4. Resultaten

De methode werd geëvalueerd met drie verschillende LLMs (DeepSeek-Coder-6.7B, Qwen2.5-7B, GLM-5) op drie datasets. De prestaties werden gemeten aan de hand van de proxy-accuraatheid na één epoch.

• CIFAR-10:
  • DeepSeek-Coder-6.7B: Verbeterde van 28,2% naar 69,2%.
  • Qwen2.5-7B: Verbeterde van 50,0% naar 71,5% (hoogste piek, maar lagere succesratio).
  • GLM-5: Verbeterde van 43,2% naar 62,0% (hoogste stabiliteit en succesratio).
• CIFAR-100 & ImageNette: Alle modellen toonden statistisch significante verbeteringen (Spearman correlatie tot 0,75), hoewel de succesratio varieerde per model en datasetcomplexiteit.
• Efficiëntie: Een volledige zoektocht van 2000 iteraties kostte ongeveer 18 GPU-uren op één RTX 4090.
• Ablatiestudie: Zonder het historische feedbackgeheugen of referentie-architecturen stagneerde de zoektocht of degradeerde deze, wat aantoont dat het onthouden van fouten essentieel is voor iteratieve verbetering.

5. Betekenis en Impact

Dit paper positioneert LLM-gedreven NAS als een praktische, reproduceerbare en budgetvriendelijke methode voor onderzoekers met beperkte hardware.

• Toegang tot Edge-Deployments: Door de beperkte VRAM te delen tussen de LLM en de training, worden automatisch compacte en hardware-efficiënte modellen ontdekt die geschikt zijn voor randapparatuur.
• Onbeperkte Zoekruimte: In tegenstelling tot traditionele NAS die vastzitten in vooraf gedefinieerde cellen, opereert deze methode in een open code-ruimte, wat leidt tot echt nieuwe en creatieve architecturale patronen.
• Leer van Mislukkingen: De benadering van het systematisch modelleren van fouten als leerinformatie is een fundamentele verschuiving ten opzichte van eerdere methoden die alleen naar "elite" resultaten keken.
• Democratisering van NAS: Het bewijst dat zelfs kleine, niet-gefine-tuned LLMs (<7B parameters) krachtige zoekagenten kunnen zijn als ze worden uitgerust met een gestructureerde, iteratieve feedbacklus, waardoor NAS toegankelijk wordt zonder dure cloud-infrastructuur.