Seed2Scale: A Self-Evolving Data Engine for Embodied AI via Small to Large Model Synergy and Multimodal Evaluation

Each language version is independently generated for its own context, not a direct translation.

Stel je voor dat je een robot wilt leren om een keuken op te ruimen. Normaal gesproken moet je die robot duizenden keren zelf de bewegingen laten zien (zoals "pak die beker op" en "zet hem neer"). Dit is extreem tijdrovend, duur en vaak onmogelijk voor complexe taken.

Het artikel "Seed2Scale" (Zaad naar Schaal) introduceert een slimme oplossing voor dit probleem. Het is als een zelfgroeidend ecosysteem voor robotleren dat begint met slechts vier voorbeelden en die omzet in duizenden perfecte lessen.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. Het Grote Probleem: De "Data Honger"

Robotjes (zogenoemde Embodied AI) zijn hongerig naar data. Zonder duizenden voorbeelden van mensen worden ze niet slim. Bestaande methoden proberen dit op te lossen door bestaande video's te verdraaien of te kopiëren, maar dat voelt vaak als "kunstmatige" bewegingen die de robot in de war brengen. Het is alsof je iemand probeert te leren zwemmen door alleen maar foto's van zwemmers te laten zien, zonder dat ze ooit in het water springen.

2. De Oplossing: Een Drie-Acten Toneelstuk

Seed2Scale lost dit op met een slim team van drie acteurs die samenwerken:

Acteur 1: De "SuperTiny" Robot (De Vrijblijvende Verkenner)

Stel je een klein, supersnel robotje voor (noem het SuperTiny). Dit robotje is niet de allersterkste, maar het is extreem snel en goedkoop om te laten werken.

Wat doet het? Het krijgt slechts vier voorbeelden van een mens (bijvoorbeeld: "pak de citroen").
De truc: Omdat het zo klein is, kan het duizenden keren tegelijk proberen om die taak uit te voeren in een virtuele wereld. Het valt vaak, stoot tegen dingen aan, en doet het soms raar. Maar dat is oké! Het is een verkenner die de grenzen opzoekt.
Analogie: Het is als een kind dat in een zwembad plonsjes maakt. Het maakt veel fouten, maar leert snel door te proberen.

Acteur 2: De "VLM Verifier" (De Strenge Opleider)

Nu hebben we duizenden pogingen, maar de meeste zijn slecht. Als we die slechte pogingen gebruiken om de echte robot te leren, wordt de robot alleen maar dommer (een fenomeen dat "model collapse" heet).

Wat doet het? Hier komt een heel groot, slim AI-model (een VLM of Vision-Language Model) in beeld. Dit is onze strenge opleider.
De taak: Deze opleider kijkt naar elke video van het kleine robotje. Hij vraagt zich af: "Is dit een succes? Was de beweging soepel? Heeft het de taak echt goed gedaan?"
De filter: Hij geeft een score. Alleen de allerbeste pogingen (de "gouden" momenten) worden bewaard. De rest wordt direct weggegooid.
Analogie: Het is als een filmregisseur die duizenden takes bekijkt en alleen de perfecte opnames in de finale film gebruikt. Hij zorgt dat er geen "fouten" in de lesbrief komen.

Acteur 3: De "SmolVLA" (De Echte Leerling)

Dit is de robot die we uiteindelijk willen hebben.

Wat doet het? Deze robot leert alleen maar van de perfecte, door de opleider geselecteerde video's.
Het resultaat: Omdat hij alleen van de beste voorbeelden leert, wordt hij razendsnel slim. Hij kan taken uitvoeren die hij in het begin niet eens kende.

3. De Magie: De Zelfgroeicyclus

Het mooiste aan Seed2Scale is dat dit een cyclus is:

Het kleine robotje (SuperTiny) maakt duizenden pogingen.
De opleider (VLM) filtert de beste eruit.
De echte robot (SmolVLA) leert van die beste pogingen en wordt beter.
Die betere robot helpt nu weer om nog betere data te verzamelen voor de volgende ronde.

Het is als een gymzaal: Je begint met lichte gewichten (4 voorbeelden), traint je spieren, en gebruikt die nieuwe kracht om zwaardere gewichten op te tillen. Elke ronde word je sterker.

Wat is het resultaat?

De onderzoekers hebben getoond dat dit systeem werkt als een wonder:

Ze begonnen met slechts 4 voorbeelden.
Na een paar rondes van zelfleren, verbeterde de robot met 209% in zijn succesrate.
De robot kon taken doen (zoals blikken stapelen of een airfryer openmaken) die hij in het begin niet kon, en deed dit soepeler dan veel andere methoden.

Samenvattend

Seed2Scale is als een slimme tuin. Je plant slechts vier zaden (de menselijke voorbeelden). Je hebt een kleine tuinman (SuperTiny) die de grond omwoelt en duizenden zaden zaait. Een strenge tuinmeester (VLM) plukt alleen de mooiste bloemen. Die bloemen worden gebruikt om de volgende generatie planten nog mooier te maken. Uiteindelijk heb je een overvloedige tuin, zonder dat je duizenden zaden zelf had hoeven kopen.

Dit maakt het mogelijk om robots veel sneller en goedkoper slim te maken, zodat ze echt nuttig worden in onze huizen en fabrieken.

Each language version is independently generated for its own context, not a direct translation.

Hier is een gedetailleerde technische samenvatting van het paper "Seed2Scale: A Self-Evolving Data Engine for Embodied AI via Small to Large Model Synergy and Multimodal Evaluation" in het Nederlands.

Probleemstelling

De prestaties van Vision-Language-Action (VLA) modellen voor Embodied AI (robots die fysieke taken uitvoeren) zijn momenteel sterk afhankelijk van grote hoeveelheden hoogwaardige, door mensen gedemonstreerde trajecten. Dit creëert een kritieke "data-schaarste" bottleneck. Bestaande methoden voor geautomatiseerde data-generatie kampen met drie hoofdproblemen:

Beperkte exploratie: Data-augmentatiemethoden (zoals ruimtelijke transformaties) blijven vaak beperkt tot de "comfortzone" van de originele menselijke data en kunnen geen nieuwe actie-logica genereren.
Embodiment Gap: Het overbrengen van acties uit internetvideo's naar fysieke robots is moeilijk vanwege verschillen in hardware en dynamica.
Laag signaal-ruisverhouding (SNR) en Model Collapse: Geautomatiseerde datacollectie genereert vaak veel mislukte pogingen. Zonder effectieve kwaliteitscontrole verontreinigt deze "ruis" het trainingsdataset, wat leidt tot cumulatieve prestatiedalingen en uiteindelijk tot het instorten van het model (model collapse) tijdens zelf-iteratie.

Methodologie: Seed2Scale

Seed2Scale is een zelf-evoluerend data-engine dat de data-bottleneck doorbreekt door een heterogene synergie van modellen van verschillende schalen: "klein-model collectie, groot-model evaluatie en doel-model leren". Het proces start met slechts 4 menselijke demonstraties (seed data) en evolueert via een iteratieve lus.

Het systeem bestaat uit drie hoofdcomponenten:

SuperTiny (De Kleinschalige Collector):
- Een lichtgewicht VLA-model (48M parameters) dat is ontworpen als een gespecialiseerde data-collector.
- Het heeft een sterke inductieve bias, waardoor het robuust kan exploreren vanuit minimale seed-data zonder het overfit-risico van grotere modellen.
- Het gebruikt een heterogene encodering (ResNet-18 voor visie, T5-Small voor taal, MLP voor robottoestand) en een lichtgewicht Transformer-decoder.
- Door zijn lage inferentielatentie kan het massaal parallelle rollouts uitvoeren in gesimuleerde omgevingen, waardoor duizenden kandidaat-trajecten worden gegenereerd.
VLV-Agent (De Grootmodel Verifier):
- Een bevroren, voorgeprogrammeerd Vision-Language Model (Qwen3-VL, 32B parameters) fungeert als een "Vision-Language Verifier" (VLV).
- Deze agent fungeert als een geautomatiseerde beloningsfunctie. Het ontvangt de taakinstructie, het video-record van de poging en een referentievideo van de succesvolle seed-data.
- Het beoordeelt elk traject op kwaliteit en succes (score 0-10) en filtert mislukte of slechte pogingen. Dit voorkomt dat het systeem leert van fouten en breekt de vicieuze cirkel van model collapse.
SmolVLA (Het Doelmodel):
- Het uiteindelijke model dat wordt getraind op het gecurateerde, hoogwaardige dataset ( $D_{silver}$ ) dat door de VLV is gefilterd.
- Dit model wordt getraind met Conditional Flow Matching, een techniek die complexe actie-distributies leert door ruis om te zetten in gestructureerde actie-sequenties, wat robuuster is dan standaard behavior cloning.

Het Iteratieve Proces:
Het systeem start met 4 seed-trajecten. SuperTiny genereert nieuwe data, de VLV filtert deze, en de geselecteerde hoogwaardige data wordt toegevoegd aan de trainingsset voor de volgende iteratie. Dit proces herhaalt zich, waarbij de collectie en het doelmodel steeds beter worden.

Belangrijkste Bijdragen

Kostenefficiënte Zelf-Evoluerende Engine: Seed2Scale kan schaalbare data-generatie realiseren vanuit slechts 4 menselijke demonstraties, wat de afhankelijkheid van dure handmatige data-acquisitie drastisch vermindert.
VLM-Gestuurde Data-Curatie: Het introduceren van een groot VLM als verifier om mislukte trajecten te filteren en model collapse te voorkomen, wat essentieel is voor stabiele zelf-iteratie.
Heterogene Model Synergie: Het combineren van een klein, snel model voor exploratie en een groot, intelligent model voor evaluatie lost de afweging op tussen exploratie-efficiëntie en generalisatievermogen.
Empirische Validatie: Uitgebreide experimenten tonen aan dat het systeem schaalbaar is en dat de prestaties van het doelmodel consistent verbeteren met elke iteratie.

Resultaten

De experimenten zijn uitgevoerd op diverse robot-taken (o.a. keuken opruimen, airfryer manipuleren, blikken stapelen) met zowel de Agibot A2 als de GR-1 robot.

Prestatieverbetering: Met slechts 4 seed-demonstraties per taak bereikte het doelmodel een relatieve prestatieverbetering van 209,15%. Het succespercentage steeg gemiddeld van 22,18% naar 68,57%.
Vergelijking met Bestaande Methoden: Seed2Scale presteerde aanzienlijk beter dan bestaande augmentatiemethoden zoals MimicGen. Op de taak "Wheel Manipulation" was de verbetering +168,35% ten opzichte van MimicGen.
Kwaliteit van Trajecten: Seed2Scale genereerde trajecten die qua gladheid (Total Variation) en natuurlijkheid (Jerk) dicht bij menselijke demonstraties lagen, en zelfs minder trillingen vertoonden dan de originele menselijke data (waarschijnlijk doordat SuperTiny trillingen filtert).
Efficiëntie: De SuperTiny-collector is 3,6x sneller in inferentie dan Diffusion Policy-modellen (26,3 Hz vs 7,4 Hz), wat grote schaalbaarheid mogelijk maakt.
Ablatie Studies: Het verwijderen van de VLV-filtering leidde tot een drastische daling in prestaties, wat aantoont dat kwaliteitscontrole cruciaal is voor succesvolle zelf-evolutie.

Betekenis en Impact

Seed2Scale biedt een schaalbare en kosteneffectieve oplossing voor het data-probleem in Embodied AI. Het bewijst dat het niet nodig is om enorme datasets met menselijke annotaties te verzamelen om geavanceerde robotvaardigheden te leren. Door de synergie tussen kleine en grote modellen en het gebruik van multimodale evaluatie, kan het systeem autonoom hoogwaardige trainingsdata genereren. Dit opent de weg naar "Generalist Embodied AI" die complexe taken kan leren in diverse omgevingen zonder de beperkingen van menselijke data-acquisitie. De methode is een belangrijke stap naar robuuste, zelf-verbeterende robotsystemen.