Synthetische data voor robotbeleid: Waar simulatie helpt

Elke paar maanden komt iemand erachter dat het handmatig opnemen van vijftig afleveringen met de hand langzaam is, en vraagt of een simulator ze in plaats daarvan zou kunnen produceren. Het is een terechte vraag. Het eerlijke antwoord heeft drie delen: gegenereerde data helpt wel, het vervangt de echte opnames niet, en de verhouding tussen die twee feiten hangt volledig af van het soort synthetische data dat je bedoelt.

Deze pagina behandelt wat het gepubliceerde werk daadwerkelijk heeft gemeten, wat je vandaag kunt uitvoeren op een goedkope arm zoals de SO-100, en waar de sim-naar-echt-kloof de winsten tenietdoet. De korte versie, voordat we in detail treden: de systemen die de grootste vermenigvuldigers rapporteren, vermenigvuldigen een kleine set van echte menselijke demonstraties. Ze nemen de noodzaak daarvan niet weg.

Vier verschillende dingen worden synthetische data genoemd

Voordat we getallen vergelijken, is het de moeite waard om de families te scheiden, want een paper dat een 100x vermenigvuldiger rapporteert en een paper dat een succeswinst van 5 punten rapporteert, beschrijven vaak dezelfde pijplijn vanuit verschillende perspectieven. De rode draad is dat iets in de LeRobot dataset werd geproduceerd door een machine in plaats van opgenomen van een fysieke arm. Wat verschilt, is welk deel.

Alleen de eerste drie zijn synthetische data in de zin die dit artikel bedoelt. De vierde is het vermelden waard omdat deze in hetzelfde gesprek wordt meegenomen en verreweg het goedkoopste item op de lijst is. Als je de augmentaties waarmee je trainer wordt geleverd nog niet hebt ingeschakeld, doe dat dan voordat je een simulator installeert.

Wat de gepubliceerde cijfers werkelijk zeggen

Hier is de bewijsbasis, met de cijfers zoals de bronnen ze vermelden in plaats van zoals de persberichten ze samenvatten. Elke rij hieronder komt van een paper of projectpagina gelezen op 23 augustus 2026.

Het patroon bij elke eerlijke ablatie is hetzelfde. Synthetische data verbreedt de dekking goedkoop. Het creëert geen informatie over je grijper, je servozakking, je verlichting of je tafelhoogte die niet ergens in de echte demonstraties aanwezig was. Als je beleid faalt omdat de eindeffector een halve seconde te laat sluit, kan geen enkele gesimuleerde variatie dit oplossen. Dat is een grijper timingprobleem in de echte opnames.

Eén bevinding van MimicGen is de moeite waard om mee te nemen naar je eigen opnamesessies, omdat het ingaat tegen het gebruikelijke advies. Het project genereerde twee datasets op Square D2, één gevoed met 10 demo's van een menselijke operator van betere kwaliteit en één met 10 demo's van een operator van mindere kwaliteit, beide afkomstig uit de robomimic multi-human Square dataset. Beleidslijnen die op elk van deze datasets waren getraind, behaalden vergelijkbare resultaten, wat de auteurs interpreteerden als een teken dat in het grootschalige dataregime de datakwaliteit misschien niet zo veel uitmaakt. Lees goed, dat is een uitspraak over de tien startdemonstraties, niet over je vijftig echte afleveringen. Het betekent dat een enigszins rommelige startset niet hetgene is dat tussen jou en een bruikbare gegenereerde dataset staat. Het betekent niet dat de echte afleveringen waarop je meetraint rommelig kunnen zijn, want dat zijn degenen die de informatie bevatten die de simulator niet heeft.

De sim-naar-echt kloof, concreet

De kloof wordt meestal besproken als één enkele grootheid, wat niet nuttig is. Het zijn minstens vijf afzonderlijke mismatches, en deze hebben verschillende groottes op een hobbyarm van 110 tot 150 EUR dan op een Franka.

• Contact en wrijving. Isaac Lab stelt duidelijk dat, gegeven dezelfde hardware en dezelfde Isaac Sim- en PhysX-versie, de simulatie reproduceerbaar is, maar dat de resultaten variëren tussen verschillende hardwareconfiguraties als gevolg van drijvende-komma precisie- en afrondingsfouten, en dat PhysX geen determinisme garandeert voor scènes met niet-rigide lichamen zoals stof of zachte lichamen.
• Aansturing. Een Feetech STS3215 bus servo die op 7.4 V draait, zakt door onder belasting, heeft speling en verandert van gedrag naarmate hij opwarmt. Het MJCF-model voor de SO-101 ontleent zijn motorparameters aan een ongerelateerd project in plaats van ze op uw arm te identificeren.
• Rendering. Cameraruis, rolling shutter, automatische belichting en de exacte tint van uw tafel zijn niet in de render opgenomen. Dit is de helft van de kloof die Cosmos-Transfer1 moest dichten: de workflow voor robotica-augmentatie brengt één synthetisch robotica-voorbeeld in kaart naar meerdere realistische voorbeelden van segmentatie, diepte- of randconditionering.
• Timing. Een simulator stapt met een vaste snelheid. Een echte controlelus doet dat niet, en het model zelf kost 20 tot 485 ms per actiestap, afhankelijk van welke u hebt gekozen. Zie inferentielatentie.
• Objectstatistieken. Gesimuleerde scènes worden bemonsterd uit een distributie die iemand heeft opgeschreven. Uw keukentafel niet.

Wat een gesimuleerde SO-100 daadwerkelijk weet over uw arm

Dit is het deel dat beslist of iets van het bovenstaande uw weekend waard is, en de eerste verrassing is dat de SO-100 en de SO-101 niet gelijk worden bediend. De SO-ARM100 repository van TheRobotStudio bewaart zijn simulatie-assets onder Simulation/. De SO100-map bevat één enkel URDF-bestand en niets anders. De SO101-map bevat zowel URDF- als MuJoCo-bestanden: scene.xml, so101_new_calib.xml, so101_old_calib.xml, de bijbehorende URDF's en een joints_properties.xml. Als u een fysicamodel wilt in plaats van een kinematische keten, dan wilt u de SO-101 bestanden.

Ze zijn gegenereerd met de onshape-to-robot plugin vanuit een CAD-model ontworpen in Onshape, wat betekent dat de kinematica en de visuele meshes net zo goed zijn als de CAD. De dynamica is een ander verhaal, en de README van de repository is openhartig over drie dingen. Botsingsmeshes van de basis zijn verwijderd vanwege problematisch botsingsgedrag tijdens simulatie en planning. De eigenschappen van de STS3215-motor zijn aangepast van het Open Duck Mini-project in plaats van gemeten op een SO-101. En de LeRobot grijperconventie, waarbij 0 volledig gesloten is en 100 volledig open, is expliciet nog niet weerspiegeld in de URDF- en MuJoCo-bestanden. Elk van deze punten is een plek waar een beleid dat puur in dat model is getraind, anders zal presteren op uw bureau.

Domeinrandomisatie, en wat het niet oplost

Het standaardantwoord op de kloof is om te stoppen met proberen de werkelijkheid te evenaren en in plaats daarvan te trainen over een distributie die breed genoeg is zodat de werkelijkheid erin valt. Tobin en collega's toonden de sterke versie hiervan in 2017: een objectdetector die alleen getraind was op gesimuleerde beelden met niet-realistische willekeurige texturen, zonder enige pre-training op echte beelden, lokaliseerde echte objecten met een nauwkeurigheid van 1.5 cm en bleef robuust tegen afleiders en gedeeltelijke occlusies.

Isaac Lab hanteert hetzelfde idee als de gebeurtenistermen die u aan een omgevingsconfiguratie koppelt. Dit zijn de knoppen, met hun werkelijke functienamen in isaaclab.envs.mdp, zodat u ze kunt nalezen in plaats van te gissen.

Hier is de beperking, en het is degene waar mensen over struikelen. Randomisatie verbreedt de distributie die het beleid heeft gezien binnen het model dat u hebt gebouwd. Het kan geen fysiek effect introduceren dat de simulator niet representeert. Als PhysX de speling en thermische doorzakking van uw STS3215-servo's niet modelleert, leert het randomiseren van hun stijfheid het beleid niets over speling. Daarom is een arm die onder een met simulatie getraind beleid geen randomisatiebudgetprobleem. Het is een modelleringsprobleem.

Het handmatige pad: gegevens genereren in Isaac Lab

Isaac Gym is verouderde software. NVIDIA's eigen pagina heeft de titel "Isaac Gym - Nu Afgeschreven" en stelt dat ontwikkelaars het mogen downloaden en blijven gebruiken, maar dat het niet langer wordt ondersteund, en verwijst in plaats daarvan naar Isaac Lab. Als je de geschiedenis wilt weten, hebben we beide behandeld: en . Voor nieuw werk in 2026, begin bij Isaac Lab.

1. 1
   Installeer Isaac Sim en Isaac Lab

   De pip-installatiepagina vermeldt dat de instructies voor Isaac Sim 5.X zijn, wat Python 3.11 vereist. De bronkloon geeft je de scripts die de volgende stappen nodig hebben.

   bash

   pip install "isaacsim[all,extscache]==5.1.0" \
       --extra-index-url https://pypi.nvidia.com
   
   git clone https://github.com/isaac-sim/IsaacLab.git --branch main
   cd IsaacLab
   sudo apt install cmake build-essential
   ./isaaclab.sh --install
   
   # smoke test
   ./isaaclab.sh -p scripts/tutorials/00_sim/create_empty.py

2. 2
   Neem ongeveer tien menselijke demonstraties op

   De Isaac Lab-documentatie is specifiek: ongeveer 10 succesvolle demonstraties zijn vereist om de volgende stappen te laten slagen. De tips zijn even specifiek. Houd demonstraties kort, neem een direct pad in plaats van langs willekeurige assen te bewegen, en pauzeer niet, omdat het voor een beleid niet duidelijk is waarom en wanneer te pauzeren.

   bash

   ./isaaclab.sh -p scripts/tools/record_demos.py \
       --task Isaac-Stack-Cube-Franka-IK-Rel-v0 \
       --device cpu \
       --teleop_device spacemouse \
       --dataset_file ./datasets/dataset.hdf5 \
       --num_demos 10

3. 3
   Markeer de subtaakgrenzen

   Mimic splitst de invoerdemonstraties in subtaken, zodat het de segmenten opnieuw kan timen en richten. De --auto vlag doet dit zonder menselijke tussenkomst voor taken die automatische annotatie definiëren; zonder deze pauzeer je met B, ga je verder met N en markeer je een grens met S. Merk op dat de taak-ID een -Mimic achtervoegsel krijgt.

   bash

   ./isaaclab.sh -p scripts/imitation_learning/isaaclab_mimic/annotate_demos.py \
       --device cpu \
       --task Isaac-Stack-Cube-Franka-IK-Rel-Mimic-v0 \
       --auto \
       --input_file ./datasets/dataset.hdf5 \
       --output_file ./datasets/annotated_dataset.hdf5

4. 4
   Genereer de vermenigvuldigde dataset

   Dit is de stap die 10 verandert in 1000. Mimic past een booleaans succescriterium toe op elke kandidaat en behoudt alleen degenen die de taak hebben voltooid, dus het aantal uitvoer is lager dan het aantal pogingen. De documentatie schat het succespercentage van kandidaten zo hoog als 70 procent in eenvoudige gevallen en onder 1 procent voor moeilijke taken en complexe robots: ongeveer 50 procent voor de Franka kubusstapel, en 65 tot 80 procent voor de GR1T2 pick and place, waarbij 1000 demo's 18 tot 40 minuten duren (19 minuten op een RTX ADA 6000 met 80 procent).

   bash

   ./isaaclab.sh -p scripts/imitation_learning/isaaclab_mimic/generate_dataset.py \
       --device cpu \
       --num_envs 10 \
       --generation_num_trials 1000 \
       --headless \
       --input_file ./datasets/annotated_dataset.hdf5 \
       --output_file ./datasets/generated_dataset.hdf5

5. 5
   Converteer HDF5 naar een LeRobot-dataset

   Alles hierboven produceert robomimic-geflavoured HDF5, en Isaac Lab core levert geen eigen LeRobot-converter: de documentatie zegt alleen dat je de gegenereerde dataset naar LeRobot-formaat kunt converteren. Twee projecten leveren de eigenlijke converter. IsaacLab-Arena levert een op GR00T gerichte converter die volledig wordt aangestuurd door een YAML-configuratie, en LeIsaac levert zijn eigen paar voor de SO-101 route (zie hieronder).

   bash

   # IsaacLab-Arena, GR00T LeRobot format
   python isaaclab_arena_gr00t/lerobot/convert_hdf5_to_lerobot.py \
       --yaml_file isaaclab_arena_gr00t/lerobot/config/gr1_manip_config.yaml

Waarom generatiepogingen mislukken, en wat te veranderen

Een kandidaat-succespercentage dat schommelt tussen 70 procent en minder dan 1 procent is geen mysterie, en Isaac Lab documenteert de veelvoorkomende valkuilen in plaats van u te laten gissen. Elk van deze valkuilen is iets wat u tijdens het opnemen controleert, daarom loont het om deze lijst te lezen voordat u de tien seed-demonstraties opneemt, in plaats van na de eerste teleurstellende generatierun.

• Demonstraties zijn te lang. Een langere tijdshorizon is moeilijker voor een beleid om te leren. Begin dicht bij het eerste object en minimaliseer beweging.
• Demonstraties zijn niet vloeiend. Onregelmatige beweging is moeilijk voor een beleid om te ontcijferen, en betere teleoperatiehardware levert betere gegevens op: de documentatie stelt duidelijk dat een SpaceMouse beter is dan een toetsenbord.
• Pauzes. Pauzes zijn moeilijk te leren, omdat het voor een beleid niet duidelijk is waarom en wanneer er gepauzeerd moet worden. Houd de beweging vloeiend.
• Te veel subtaken. Meer subtaken betekenen meer aan elkaar plakken tussen trajectsegmenten, wat resulteert in minder vloeiende beweging en een lager generatie-succespercentage. Annoteer grenzen waar de arm waarschijnlijk nergens mee zal botsen.
• Geen actieruis. Actieruis maakt de resulterende beleidsregels robuuster.
• Opname te strak afgesneden. Als de opname stopt op het exacte frame waarop de succesvoorwaarde wordt geactiveerd, wordt deze mogelijk niet opnieuw geactiveerd tijdens het afspelen. Laat een buffer aan het einde.
• Niet-deterministische herhaling. Fysica in Isaac Lab is niet deterministisch reproduceerbaar over env.reset, dus sommige menselijke demo's falen bij herhaling. Verzamel meer dan u nodig heeft en behoud degenen die de annotatie overleven. Alles wat in een door Mimic gegenereerd HDF5-bestand terechtkomt, is een succesvolle demo en kan worden gebruikt voor training, zelfs als de herhaling later mislukt.

De interpolatiestap tussen aan elkaar geplakte subtaken heeft zijn eigen afstemknop, en het aantal interpolatiestappen dat u nodig heeft, schaalt met hoe snel de robot beweegt en hoe breed de object-reset-distributie is. Een complexe taak met een grote reset-distributie laat grotere gaten tussen segmenten, wat meer interpolatiestappen vereist om als continue beweging te verschijnen. Als uw gegenereerde video's de arm tussen fasen zien schokken, is dat de parameter om naar te kijken voordat u de seed-demo's de schuld geeft.

Dezelfde pipeline op een SO-101, met de echte leiderarm

Dit is de interessante voor iedereen die deze pagina leest, omdat het de enige open pijplijn is die een in Isaac Lab plaatst en je deze kunt besturen met de fysieke leiderarm die je al bezit. LeIsaac, versie 0.4.0 op het moment van schrijven, is de officiële simulatiespeeltuin voor imitatie-leren, geïntegreerd in LeRobot's EnvHub. De compatibiliteitstabel vermeldt drie werkende combinaties; de nieuwste combineert Isaac Sim 5.1 met Isaac Lab v2.3.0, CUDA 12.8, PyTorch 2.7.0 en Python 3.11, en de documentatie beveelt Isaac Sim 5.0 of nieuwer aan voor kaarten uit de 50-serie.

git clone https://github.com/LightwheelAI/leisaac.git --recursive
conda create -n leisaac python=3.11 && conda activate leisaac
conda install -c "nvidia/label/cuda-12.8.1" cuda-toolkit
pip install -U torch==2.7.0 torchvision==0.22.0 \
  --index-url https://download.pytorch.org/whl/cu128
pip install "isaacsim[all,extscache]==5.1.0" --extra-index-url https://pypi.nvidia.com
sudo apt install cmake build-essential
cd leisaac/dependencies/IsaacLab && ./isaaclab.sh --install && cd ../..
pip install -e source/leisaac
pip install -e "source/leisaac[lerobot]"
pip install numpy==1.26.0

Als dat eenmaal is ingesteld, bestuurt de leiderarm op /dev/ttyACM0 de gesimuleerde volger en neemt direct op naar HDF5. De lus is dezelfde die je al kent van echte opnames, alleen is de volger een star lichaam in PhysX.

python scripts/environments/teleoperation/teleop_se3_agent.py \
    --task=LeIsaac-SO101-PickOrange-v0 \
    --teleop_device=so101leader \
    --port=/dev/ttyACM0 \
    --num_envs=1 \
    --device=cuda \
    --enable_cameras \
    --record \
    --dataset_file=./datasets/dataset.hdf5

De meeste van deze ID's bestaan ook als een -Direct-v0 variant, en python scripts/environments/list_envs.py toont de huidige lijst. Je kunt ook de HDF5-omweg volledig overslaan en het LeRobot-formaat schrijven tijdens teleoperatie door drie vlaggen toe te voegen. Twee kanttekeningen komen uit de documentatie zelf: de recorder slaat automatisch de eerste 5 frames van elke episode over om instabiliteit door initiële toestanden te voorkomen, en het kan lichte vertragingen veroorzaken bij teleoperatie, wat precies het soort dingen zijn dat stilletjes het karakter van je demonstraties verandert. Het spoelt ook alleen episodes door die de taak als succesvol heeft gemarkeerd.

python scripts/environments/teleoperation/teleop_se3_agent.py \
    --task=LeIsaac-SO101-PickOrange-v0 \
    --teleop_device=so101leader \
    --port=/dev/ttyACM0 \
    --num_envs=1 --device=cuda --enable_cameras --record \
    --use_lerobot_recorder \
    --lerobot_dataset_repo_id=<your-user>/<dataset-name> \
    --lerobot_dataset_fps=30

De vermenigvuldigingsstap wordt vervolgens uitgevoerd op die opnames. LeIsaac omvat Isaac Lab Mimic in vier commando's, omdat Mimic trajecten generaliseert vanuit eind-effector- en objectposities: converteer de acties in de gewrichtsruimte naar IK-gebaseerde acties, annoteer, genereer, en converteer vervolgens terug naar de gewrichtsruimte.

python scripts/mimic/eef_action_process.py \
  --input_file ./datasets/mimic-lift-cube-example.hdf5 \
  --output_file ./datasets/processed_mimic-lift-cube-example.hdf5 \
  --to_ik --headless

python scripts/mimic/annotate_demos.py --device cuda \
  --task LeIsaac-SO101-LiftCube-Mimic-v0 \
  --input_file ./datasets/processed_mimic-lift-cube-example.hdf5 \
  --output_file ./datasets/annotated_mimic-lift-cube-example.hdf5 \
  --enable_cameras

python scripts/mimic/generate_dataset.py --device cuda \
  --num_envs 1 --generation_num_trials 10 \
  --input_file ./datasets/annotated_mimic-lift-cube-example.hdf5 \
  --output_file ./datasets/generated_mimic-lift-cube-example.hdf5 \
  --enable_cameras

python scripts/mimic/eef_action_process.py \
  --input_file ./datasets/generated_mimic-lift-cube-example.hdf5 \
  --output_file ./datasets/final_generated_mimic-lift-cube-example.hdf5 \
  --to_joint --headless

Converteer vervolgens naar LeRobot. Dit is de stap waar de formaatregel van het platform van toepassing is, en LeIsaac levert toevallig precies de twee converters die je nodig hebt: isaaclab2lerobot.py schrijft LeRobot v2, wat de GR00T-laders gebruiken, en isaaclab2lerobotv3.py schrijft v3 voor Pi0.5, SmolVLA en ACT. De twee scripts accepteren identieke argumenten, maar pinnen verschillende lerobot-versies, en alleen succesvolle episodes worden geconverteerd.

pip install lerobot==0.3.3
pip install numpy==1.26.0

python scripts/convert/isaaclab2lerobot.py \
    --task_name=LeIsaac-SO101-PickOrange-v0 \
    --repo_id=<your-user>/so101_pick_orange_sim \
    --hdf5_root=./datasets \
    --hdf5_files=dataset.hdf5

Twee routes naar een getraind beleid

Video-wereldmodellen: de nieuwste laag, en het minst gemeten

Het idee achter DreamGen is dat een video-generatief model, aangepast aan de beoogde robot-embodiment, plausibele episodes kan bedenken in scènes die je nooit hebt bezocht. De pijplijn heeft vier fasen: fine-tunen van het video-wereldmodel, genereren van fotorealistische synthetische robotvideo's, herstellen van pseudo-actiesequenties met een latent actiemodel of een inverse dynamica-model, en vervolgens het trainen van het robotbeleid op het resultaat. NVIDIA's GR00T-dreams repository implementeert precies dat.

Het belangrijkste resultaat is reëel en het overwegen waard: teleoperatiedata van slechts één pick-and-place-taak in één omgeving produceerden 22 nieuwe gedragingen op een humanoïde, in zowel bekende als onbekende omgevingen. Het voorbehoud is even reëel en bevindt zich in de derde fase.

Co-training is het recept dat daadwerkelijk winst oplevert

Als je één operationele les uit de literatuur haalt, neem dan deze. De sim-en-echt co-training studie (Maddukuri en collega's, 2025) had als doel een eenvoudig recept te vinden voor het gebruik van simulatiegegevens om visie-gebaseerde robotmanipulatietaken op te lossen, over twee domeinen, een robotarm en een humanoïde, en de conclusie is dat je traint op een mix. Simulatiegegevens verbeterden de taakprestaties in de echte wereld met gemiddeld 38 procent, en het artikel is expliciet dat dit zelfs gold bij opmerkelijke verschillen tussen de simulatie- en de echte wereldgegevens.

Die laatste clausule is belangrijker dan de 38 procent. Het betekent dat de simulatie geen perfecte digitale tweeling hoeft te zijn om nuttig te zijn, mits de echte gegevens in de mix aanwezig zijn om het te verankeren. Sim-alleen overdracht is de dure weg: hetzelfde artikel stelt dat het trainen van een beleid uitsluitend in simulatie en het overdragen ervan naar de echte wereld vaak aanzienlijke menselijke inspanning vereist om de kloof met de werkelijkheid te overbruggen. Co-training slaat het grootste deel van die inspanning over door het beleid nooit te vragen de kloof zelf te dichten.

Praktisch gezien betekent co-training op dit platform één ding: plaats beide sets afleveringen in dezelfde LeRobot dataset met consistente cameratoetsen, consistente gewrichtsvolgorde en consistente eenheden, en voer vervolgens een normale fijnafstemming. Er is geen knop voor het menggewicht in het trainingsformulier. Als je een 3:1 sim-naar-echt verhouding wilt, druk je dat uit door het aantal afleveringen van elk dat je in de dataset plaatst.

De goedkoopste winst uit simulatie is geen trainingsdata

Het is evaluatie. Het uitvoeren van tientallen echte proeven per taak om twee te vergelijken kost een dag armtijd, en de arm wijkt af tussen de proeven. SIMPLER (Li en collega's, 2024) bouwde gesimuleerde omgevingen met als doel het scoren van echte beleidsregels in plaats van deze te trainen, en mat vervolgens hoe goed de sim-ranking de echte voorspelt. Eén enkele SIMPLER-omgeving rendert met 3.500 simulatiestappen per seconde op een consumenten RTX 4090 met een resolutie van 640 bij 512, wat bij een simulatie frequentie van 500 Hz een 7x versnelling is ten opzichte van echte evaluatie.

Dit zijn gemiddelden over drie Google Robot taakgroepen voor zes veelvoorkomende open-source checkpoints: drie RT-1 checkpoints in verschillende trainingsfasen, RT-1-X, RT-2-X en Octo-Base. De echte kant heeft geen uniform aantal proeven, wat de moeite waard is om te weten voordat u het citeert: 75 proeven voor het oppakken van een colablikje, 60 voor het verplaatsen naar de buurt, 54 voor de taken 'lade openen en sluiten' en 27 voor de langere taak 'lade en appel'. De vergelijking met validatie MSE is het nuttige deel. Modelselectie op basis van validatieverlies rangschikt deze checkpoints slecht, en een Pearson r van 0.924 onder visuele matching betekent dat als een checkpoint beter scoort in SIMPLER, het zeer waarschijnlijk beter scoort op de testbank. Dat is een herhaalbaar nachtelijk scorebord, en het vereist niet dat u iets gelooft over sim-naar-echt trainings overdracht.

Als je de bredere context wilt over wat deze benchmarknummers je wel en niet vertellen over een , hebben we dat afzonderlijk beschreven in .

Waar dit platform je niet bij helpt

Duidelijkheid over de grens bespaart iedereen tijd. AY-Robots is een platform voor opname, training en serving. Het bevat geen simulator.

• Geen Isaac Lab, geen MimicGen, geen wereldmodel, geen scène-authoring. Als je gegenereerde data wilt, genereer je die elders en breng je het resultaat mee.
• De trainers verbruiken LeRobot datasets en niets anders. Een simulator export moet worden geconverteerd voordat het een invoer is, en het moet de juiste versie zijn: v2.0 of v2.1 voor GR00T N1.5 en N1.7, v3.0 voor Pi0.5, SmolVLA en ACT.
• GR00T's fine-tuning entry point is een tyro CLI die geen seed blootlegt, dus GR00T-runs zijn niet bit-voor-bit reproduceerbaar. Als je een zorgvuldige sim-versus-real ablatie uitvoert, is dat een echte beperking. lerobot's eigen standaard seed is 1000, en de ACT, SmolVLA en Pi0.5 formulieren leggen wel een seed-veld bloot.
• Graniëntaccumulatie wordt alleen daadwerkelijk toegepast voor de twee GR00T trainers. Voor Pi0.5 en SmolVLA bestaat het veld in het formulier, maar lerobot 0.5.1 heeft geen dergelijke flag, dus het doet niets.
• Inference moet naast de servo's zitten voor snelle taken. De besturingslus is 20 tot 485 ms per actiestap, afhankelijk van het model, en het toevoegen van round trips via het openbare internet verandert een werkend beleid in een aarzelend beleid. Remote inference is haalbaar voor langzame pick-and-place, niet voor snelle reactieve bewegingen.

Een budget dat je kunt verdedigen

Zet de twee paden naast elkaar met de cijfers die elk daadwerkelijk publiceert, en de beslissing neemt zichzelf meestal voor een single-task project op een goedkope arm.

Voor een eerste beleid op een SO-100, neem op. De en brengen u naar een geserveerd checkpoint voor de prijs van een kop koffie, en u zult de echte helft hebben van elke toekomstige co-trainingsmix. Grijp naar de simulator wanneer u een werkende basislijn en een specifieke generalisatiefout kunt benoemen, zoals een beleid dat .

Een recept dat het bewijs respecteert

1. 1
   Neem eerst de echte basislijn op

   30 afleveringen voor SmolVLA, 50 voor ACT, GR00T N1.7 en Pi0.5. Train één keer. Waar dat beleid ook faalt, is uw specificatie voor de synthetische gegevens.

2. 2
   Benoem de generalisatiefout

   Objecthouding? Verlichting? Tafelhoogte? Afleiders? Een andere formulering van de instructie? Synthetische data is goed in precies één van deze tegelijk, en nutteloos als u niet kunt zeggen welke.

3. 3
   Kies de goedkoopste familie die het dekt

   Variatie in houding en lay-out: trajectvermenigvuldiging. Verlichting en textuur: eerst beeldaugmentatie, daarna wereldmodel. Volledig nieuwe scènes: physics rollouts, en accepteer de modelleringskosten.

4. 4
   Genereer, en gooi dan agressief weg

   Generatiepogingen mislukken, en Isaac Lab's eigen succespercentage van kandidaten varieert van 70 procent tot minder dan 1 procent, afhankelijk van de taak. Bewaar alleen succesvolle, taakvoltooiende trajecten, en bekijk een steekproef als video voordat u de batch vertrouwt.

   bash

   python scripts/mimic/generate_dataset.py --device cuda \
       --num_envs 8 --generation_num_trials 500 \
       --input_file ./datasets/annotated.hdf5 \
       --output_file ./datasets/generated.hdf5 --enable_cameras

5. 5
   Co-train, vervang niet

   Voeg de gegenereerde afleveringen samen met de echte in één LeRobot dataset met identieke cameratoetsen en gewrichtsvolgorde. Het cijfer van 38 procent is een co-training cijfer.

6. 6
   Evalueer op de echte arm, en alleen daar

   Gesimuleerde evaluatie is een goed rangschikkingssignaal (Pearson r 0.924 in SIMPLER's visuele-matching opstelling), maar het is niet de acceptatietest. Voer het checkpoint uit op de testbank voordat u het gelooft.

Als u liever begint met een checklist voor de echte opnames zelf, behandelt cameraplaatsing, implicaties en de faalmodi die een dataset onbruikbaar maken. Details over het formaat zelf vindt u in , en de hyperparameterkant in .