
DROID, BridgeData V2 en Open X-Embodiment converteren naar 7-D eind-effector acties op 6- en 7-DoF armen. Een SO-100 accepteert 6 gewrichtsposities. Wat overdraagbaar is, wat niet, en wat in plaats daarvan te doen.
De korte versie
- •De LeRobot builds van alle drie delen één conventie: een 7-D end-effector actie [x, y, z, roll, pitch, yaw, gripper] en een 8-D toestand met een pad slot. Een SO-100 neemt zes absolute gewrichtsposities.
- •Die 7-D vector is het artefact van de converter: DROID's eigen RLDS actieveld bestaat uit 6 gewrichtssnelheden plus een grijperpositie, met de Cartesiaanse weergave in action_dict.
- •Vier klokken: DROID 15 fps, BridgeData V2 5 fps, de google_robot slice 3 fps, een SO-100 opname op 30 fps.
- •Je kunt ze niet samenvoegen met je eigen data. validate_all_metadata geeft een foutmelding bij de eerste van fps, robot_type of features die verschilt, en alle drie verschillen.
- •Wat overdraagbaar is, zijn voorgedefinieerde gewichten, geen episodes. Open-source data is 9.1 procent van pi0's pre-trainingsmengsel.
- •Het goedkoopste echte gebruik ervan is een testopstelling: een bewezen goede 2 GB, 100-episode DROID-sample die je pipeline bewijst voordat je een weekend opneemt.
Er is een openbare dataset met een miljoen trajecten op een Google Cloud bucket en een SO-100 op het bureau die 110 tot 150 EUR aan onderdelen kostte. Waarom kan de eerste de tweede niet leren? Gedeeltelijk wel, maar bijna geen van de overdracht gebeurt waar mensen het verwachten, en het deel dat het gemakkelijkst lijkt, werkt helemaal niet.
Wat volgt: wat er in DROID, BridgeData V2 en Open X-Embodiment zit, waar elk botst met een goedkope 5-DoF arm, en wat je in plaats daarvan moet doen. Elk getal hieronder komt uit het paper, de datasetkaart of het bronbestand waartoe het behoort.
Wat de drie datasets daadwerkelijk bevatten
| DROID | BridgeData V2 | Open X-Embodiment | |
|---|---|---|---|
| Robot | Franka Panda, 7 DoF, Robotiq 2F-85 | WidowX 250, 6 DoF, ~4,000 USD rig | 22 embodiments, 60 datasets, 34 labs |
| Schaal | 76k trajectories, 350 hours | 60,096 trajectories | 1M+ trajectories, 527 skills |
| Diversiteit | 564 scenes, 84 tasks, 50 collectors | 24 environments, 13 skills | 160,266 tasks, 21 institutions |
| Samenstelling | volledig telebediend | 50.365 telebediend, 9.731 gescript | per bronlab |
| Besturingsfrequentie | 15 Hz | 5 Hz | varieert, 3 fps en hoger |
| Camera's | 2 x ZED 2 extern, 1 x ZED Mini pols | tot 4, de meeste afleveringen alleen de vaste | wat het lab ook gebruikte |
| Ruwe download | 1,7 TB RLDS, 8,7 TB ruwe stereo | JPEG-archieven | per-dataset TFDS buckets |
Weinig mensen downloaden nog steeds 1,7 TB aan RLDS TFRecords. De community-organisatie IPEC-COMMUNITY heeft het grootste deel van Open X-Embodiment opnieuw gepubliceerd in LeRobot dataset-vorm met AV1-video, waarbij DROID uitkomt op 392 GB. Dat is de versie waarmee u zult werken, en de meta/info.json is wat u als eerste moet lezen.
DROID
De meest gestandaardiseerde van de drie. Eén opstelling overal: een Franka Panda met een Robotiq 2F-85 grijper, twee verstelbare ZED 2 stereocamera's en een pols-ZED Mini, telebediend met Meta Quest 2 controllers, opgenomen via Polymetis op 15 Hz in zowel gewrichts- als eindeffector ruimte. Taallabels kwamen later via tasq.ai, tot drie per aflevering.
- 76k trajecten, 350 uur, 564 scènes, 84 taken, 50 verzamelaars op drie continenten.
- Het belangrijkste resultaat is co-training, geen op zichzelf staande training: batches die 50/50 gemengd zijn met in-domain demonstraties verslaan de op één na beste methode met 22 procent absolute succes in distributie, 17 procent daarbuiten.
- IPEC-COMMUNITY/droid_lerobot: 92,233 episodes, 27,044,326 frames, franka, 15 fps, codebase_version v2.0, three AV1 streams at 180x320, 392 GB.
- Een 2 GB, 100-episode debugging sample bevindt zich op gs://gresearch/robotics/droid_100. Begin daar.
BridgeData V2
Het dichtst bij een hobby-opstelling: een WidowX 250 6-DoF arm, 60.096 trajecten verdeeld over 24 omgevingen en 13 vaardigheden bij 5 Hz. Let op de samenstelling: 50.365 door experts geteleopereerde demonstraties plus 9.731 van een gerandomiseerde gescripte pick-and-place policy, dus ongeveer 16 procent is geen menselijke demonstratie, wat van belang is voor imitatieleren kwaliteit. De gebruikelijke download, IPEC-COMMUNITY/bridge_orig_lerobot, rapporteert 53.192 episodes en 1.893.026 frames bij 5 fps, robot_type widowx: minder dan de 60.096 van het artikel, dus lees het aantal uit meta/info.json in plaats van een van beide te citeren.
Open X-Embodiment
Geen dataset in de gebruikelijke zin: 60 bestaande robotdatasets van 34 laboratoria samengevoegd tot één RLDS-collectie, die 22 uitvoeringen en meer dan een miljoen trajecten omvat. BridgeData V2 bevindt zich erin als bridge_orig; de google_robot-slice, fractal20220817_data, wordt omgezet naar 87.212 afleveringen met 3 fps.
De samenvoeging brengt een voorbehoud met zich mee dat het artikel expliciet vermeldt. Voor de RT-X experimenten zetten de auteurs elke bron om in een 7-DoF eindeffectoractie, maar lijnen ze de coördinatenstelsels niet uit over de datasets heen, en staan ze toe dat actiewaarden absolute of relatieve posities of snelheden zijn, per het oorspronkelijke besturingsschema van elke robot. Hun conclusie: dezelfde actievector kan zeer verschillende bewegingen veroorzaken voor verschillende robots.

De mismatch, in vier delen
Mismatches in belichaming worden meestal behandeld als één vaag probleem. Het zijn er vier, ze falen op verschillende manieren, en twee zijn niet te verhelpen met scripting.
1. Vrijheidsgraden
Een SO-100 heeft vijf armgewrichten plus een grijper. Geteld als motoren is dat een 6-DoF arm, en het SmolVLA-paper noemt het zo; geteld als een positioneringsmechanisme is het 5-DoF, en LeRobot noemt het zo in zijn inverse-kinematica docstring, die soft-orientation IK beschrijft op de 5-DOF SO-101 waar de pols de oriëntatie slechts gedeeltelijk volgt. Een Franka heeft zeven positioneringsgewrichten. Die kloof bepaalt welke poses bestaan: een 5-DoF arm kan over het algemeen niet tegelijkertijd een willekeurige positie en oriëntatie bereiken, dus de oplosser retourneert het dichtstbijzijnde dat het kan, een andere beweging dan de gedemonstreerde. Achtergrond: vrijheidsgraden.
# src/lerobot/robots/so_follower/so_follower.py
motors = {
"shoulder_pan": Motor(1, "sts3215", norm_mode_body),
"shoulder_lift": Motor(2, "sts3215", norm_mode_body),
"elbow_flex": Motor(3, "sts3215", norm_mode_body),
"wrist_flex": Motor(4, "sts3215", norm_mode_body),
"wrist_roll": Motor(5, "sts3215", norm_mode_body),
"gripper": Motor(6, "sts3215", MotorNormMode.RANGE_0_100),
}
# action keys are "<motor>.pos"; send_action sync_writes them to
# "Goal_Position" -> a 6-D ABSOLUTE JOINT POSITION command
# openpi/src/openpi/policies/droid_policy.py
def make_droid_example() -> dict:
return {
"observation/exterior_image_1_left": np.random.randint(256, size=(224, 224, 3), dtype=np.uint8),
"observation/wrist_image_left": np.random.randint(256, size=(224, 224, 3), dtype=np.uint8),
"observation/joint_position": np.random.rand(7), # seven Franka joints
"observation/gripper_position": np.random.rand(1),
"prompt": "do something",
}
# state = concat(joint_position, gripper_pos) -> 8-DEen kant-en-klaar DROID checkpoint is dus geen kortere weg. Physical Intelligence levert pi05_droid op gs://openpi-assets/checkpoints/pi05_droid, en dezelfde README die de breedte ervan prijst, waarschuwt dat deze expert checkpoints mogelijk niet generaliseren naar uw setup. De staat ervan bestaat uit acht Franka gewrichtsnummers en de afbeeldingssleutels zijn exterior_image_1_left en wrist_image_left. Geen enkele vlag verandert dat in een zes-motorige SO-100 commando.
2. Wat de actievector daadwerkelijk zegt
Dieper dan dimensionaliteit. In de LeRobot conversies zeggen alle drie waar de grijper naartoe moet, in Cartesische ruimte. Een SO-100 zegt waar zes servo's naartoe moeten. Converteren vereist een kinematisch model en een oplosser, geen herschikking.
| Eigenschap | OXE, DROID en Bridge in LeRobot-vorm | SO-100 in LeRobot |
|---|---|---|
| Actievector | 7-D: x, y, z, roll, pitch, yaw, grijper | 6-D: één doelpositie per motor |
| Staatvector | 8-D, met een opvulslot (google_robot gebruikt een quaternion) | 6-D, één per motor |
| Frame | Cartesisch, niet uitgelijnd over datasets | gewrichtsruimte, per-arm kalibratie |
| Absoluut of relatief | beide, bepaald door het bronlab | absolute doelposities |
| Eenheden | genormaliseerd per dataset, daarna gediscretiseerd | graden standaard (use_degrees=True), anders -100 tot 100 |
| Stille storing | een delta gelezen als een absolute waarde | een ongekalibreerde arm |
De openx2lerobot README documenteert een uniforme 8-dim toestand en 7-dim actie voor elke dataset die het converteert, wat de oorsprong is van de pad slot. DROID's eigen RLDS-schema verschilt: de top-level action is een 7-vector van 6 gewrichtssnelheden plus 1 grijperpositie, met cartesian_position, cartesian_velocity, joint_position en joint_velocity onder action_dict. openpi leest de gewrichtsruimte-weergave, de LeRobot-build geeft je de Cartesische. Geen van beide is zes absolute servostanden.
LeRobot levert wel het ontbrekende stuk: de SO follower heeft een kinematica-processor met InverseKinematicsEEToJoints en ForwardKinematicsJointsToEE stappen. De sleutels zijn ee.x, ee.y, ee.z plus een rotatievector ee.wx, ee.wy, ee.wz en ee.gripper_pos, dus zelfs de oriëntatie-codering verschilt van de roll-pitch-yaw in de bestanden. De IK-stap gebruikt een orientation_weight, standaard 0.01, waarvan de docstring aangeeft om 0.0 in te stellen voor positie-alleen IK op onder-aangedreven armen. Je kunt de brug bouwen, maar de oriëntatiehelft van elke geleende actie blijft benaderd.
3. Besturingsfrequentie
DROID is 15 Hz, BridgeData V2 5 Hz, de google_robot slice 3 fps; de auteurs van pi0 beschrijven het open-source deel van hun mix als laagfrequente besturing tussen 2 en 10 Hz. LeRobot's DatasetRecordConfig stelt standaard fps 30, episode_time_s 60, reset_time_s 60, num_episodes 50 in. Een getraind op 5 Hz data leerde dat één actie 200 ms beslaat. Speel het af op 30 Hz en de arm kruipt; hersampleer naïef en je smeert het frame uit waar de grijper sluit. Het interageert ook slecht met : een 100-staps chunk is 20 seconden bij 5 Hz, 3.3 bij 30 Hz.
4. Camera's
BridgeData V2 randomiseerde twee cameraposes elke 50 trajecten, en de projectpagina vermeldt dat de meeste gegevens sowieso alleen het vaste zicht bevatten. DROID gebruikte verstelbare ZED 2-bevestigingen plus een ZED Mini aan de pols. Je hebt twee USB-webcams die op het oog zijn gepositioneerd. Camerapositie is geen hinderlijke variabele voor een ; het is veel van waar de visuele encoder op focuste, en niets in het bestandsformaat vertelt je dat de poses verschillen.
De onderdelen passen goed genoeg in elkaar om te draaien. De dataset laadt, de training start, het verlies daalt, checkpoints verschijnen, er zijn geen fouten. Dan doet het beleid niets herkenbaars met de arm en besteed je een dag aan het zoeken naar een bug in je trainingsscript. Er is geen bug: het model heeft een Cartesiaanse actiedistributie geleerd voor een robot die niet in jouw kamer bestaat. Begin bij verlies daalt, beleid doet niets, niet bij je hyperparameters.
Wat gebeurt er als je de gegevens toch probeert samen te voegen
Het voor de hand liggende plan is om te concateneren: een paar duizend DROID-afleveringen plus jouw 50. LeRobot weigert, en de weigering noemt de drie dingen die verschillen.
- 1Haal de 100-afleveringen sample op, niet de volledige 1.7 TB
2 GB is genoeg om de structuur te zien.
bashpip install gsutil tensorflow tensorflow-datasets gsutil -m cp -r gs://gresearch/robotics/droid_100 ~/tensorflow_datasets/ - 2Converteer RLDS naar LeRobot-vorm
openx2lerobot omvat de standaard OXE-transformaties en annoteert het robottype en de controlefrequentie. De README plaatst dit in convert.sh.
bashgit clone https://github.com/Tavish9/any4lerobot.git cd any4lerobot/openx2lerobot python openx_rlds.py \ --raw-dir ~/tensorflow_datasets/droid_100/1.0.0 \ --local-dir ~/lerobot_droid100 \ --repo-id you/droid100_lerobot \ --use-videos - 3Lees meta/info.json voordat je iets anders doet
Dit bestand bepaalt of de rest van je dag werkt.
bashpython -c "import json;d=json.load(open('meta/info.json'));\ print(d['codebase_version'], d['robot_type'], d['fps']);\ print(d['features']['action']['shape'], d['features']['observation.state']['shape'])" - 4Probeer de samenvoeging en lees de foutmelding
merge laadt elke dataset, waarna validate_all_metadata de fps, robot_type en features controleert tegen de eerste in de lijst, en een fout genereert bij de eerste afwijking.
bashlerobot-edit-dataset \ --new_repo_id you/mixed \ --operation.type merge \ --operation.repo_ids "['you/droid100_lerobot', 'you/my_so100_task']" # ValueError: Same fps is expected, but got fps=30 instead of 15.
De referentiewaarden komen van de dataset die je als eerste hebt vermeld, daarom klaagt het bericht over jouw 30 fps in plaats van DROID's 15. Corrigeer de fps en je stuit op de robot_type-controle; corrigeer die en je stuit op de feature-controle, 7 tegen 6 voor de actie. Geen enkele volgorde komt erdoorheen, en dezelfde controle wordt uitgevoerd tijdens het opnemen via sanity_check_dataset_robot_compatibility.
Op de huidige LeRobot main zijn so100_follower en so101_follower beide geregistreerd op één gedeelde SOFollowerRobotConfig, dus de string van een echte opname is niet noodzakelijkerwijs degene die je verwacht. Lees deze uit je eigen meta/info.json, en beschouw een controle die je moest uitschakelen als een controle die je iets vertelde.
Dus wat wordt er eigenlijk overgedragen?
Gewichten, geen episodes. Elk modern generalistisch beleid heeft er een deel van geabsorbeerd tijdens de voorbereiding, en wanneer u fine-tunen van een uitgebracht checkpoint erft u het al verzoend door mensen met de rekenkracht om het correct te doen. Het artikel van pi0 is openhartig over het aandeel: 9,1 procent van de voorbereidingsmix, geteld in tijdstappen, bestaat uit open-source gegevens, waaronder OXE, Bridge v2 en DROID. Dat cijfer is van pi0; de mix van elke leverancier verschilt.
- Visuele en taal priors: de encoder heeft duizenden keukens en mokken gezien en weet waarnaar "het rode blok" verwijst.
- Een prior over manipulatiestructuur: benaderen, sluiten, optillen, transporteren, loslaten, embodiment-onafhankelijk, zelfs als de getallen dat niet zijn.
- Een bekende, goede dataset voor testen. Als uw taak 100 DROID-episodes niet kan overfitten, ligt het probleem bij uw setup.
- Referentiepunten: in kleinschalige datasetdomeinen behaalde RT-1-X een 50 procent hogere gemiddelde succesratio dan de originele methode of RT-1, en RT-2-X versloeg RT-2 met ongeveer 3x op opkomende vaardigheden.
- Geen bruikbare actiesupervisie. Een 7-D Cartesisch doel is geen 6-D gewrichtscommando.
- Geen overdracht van cameraposes, en niets in de gegevens vertelt u dat de poses verschillen.
- Geen timingoverdracht: 3, 5 en 15 fps bronnen tegen een 30 fps recorder.
- Geen grijperoverdracht. Een Robotiq 2F-85 en een geprinte bek op een STS3215 verschillen in kracht, slag en dynamiek.
- Schaal alleen was niet genoeg, zelfs niet voor de auteurs: in de domeinen met grote datasets versloeg RT-1-X geen RT-1 die alleen op die dataset was getraind.
- Geen vermindering van het aantal eigen episodes dat u nodig heeft.
| Laag van het model | Wordt overgedragen? | Waarom |
|---|---|---|
| Visie-encoder | Ja, sterk | Objecten en scènes zijn embodiment-onafhankelijk |
| Taalverankering | Ja | Instructies zijn tekst, geen geometrie |
| Cross-modale fusie | Meestal | Richt zich op het object dat in de prompt wordt genoemd |
| Proprioceptie-encoder | Nee | Invoerdimensie en gewrichtssemantiek verschillen |
| Actiehoofd | Nee | Getraind op een 7-D Cartesische ruimte waarin u zich niet bevindt |
| Normalisatiestatistieken | Nee, en gevaarlijk | Vreemde statistieken verschuiven elk commando |
Dit is waarom SmolVLA zich anders gedraagt op een goedkope arm. De paper selecteert 481 community datasets van Hugging Face, gefilterd op type belichaming, aantal afleveringen, datakwaliteit en frame-dekking: 22.9K afleveringen, 10.6M frames, geëvalueerd op echte SO-100 en SO-101 armen. Klein en passend verslaat groot en niet-passend. Vergelijk op ACT tegen SmolVLA.
Drie paden die de moeite waard zijn
Pad A: fine-tunen vanaf een checkpoint dat de data al heeft verwerkt
De meeste mensen zouden deze moeten kiezen. Je raakt DROID of Open X-Embodiment nooit aan: kies een beleid waarvan de voor-training al cross-embodiment data heeft geabsorbeerd, neem je eigen afleveringen op, fine-tune.
| Beleid | Parameters | Min. afleveringen | Datasetformaat | GPU-klasse | Inferentie | Basis checkpoint |
|---|---|---|---|---|---|---|
| GR00T N1.7 | ~3 B, ~40 M getraind in fine-tuning | 50 | LeRobot v2.0 or v2.1 | A100 or H100 80 GB | 152 ms per stap | nvidia/GR00T-N1.7-3B |
| GR00T N1.5 | ~3 B | 50 | LeRobot v2.0 or v2.1 | A100 or H100 80 GB | 165 ms | nvidia/GR00T-N1.5-3B |
| Pi0.5 | ~3 B, PaliGemma-backbone | 50 | LeRobot v3.0 | A100 or H100 80 GB | 485 ms | lerobot/pi05_base |
| SmolVLA | ~450 M | 30 | LeRobot v3.0 | RTX 4090 or any 24 GB | 245 ms | lerobot/smolvla_base |
| ACT | ~80 M | 50 | LeRobot v3.0 | RTX 4090 or any 24 GB | 20 ms | geen, vanaf nul |
ACT is het eerlijke randgeval: geen basismodel, dus geen van de openbare gegevens bereikt het ooit. Niet automatisch een nadeel, aangezien het met 20 ms per actiestap de enige van de vijf is die een snelle lus kan sluiten, zoals de ACT-pagina uiteenzet. Kies per taak met behulp van alle vijf vergeleken, GR00T N1.7 tegen Pi0.5, en de 332 benchmarkresultaten van 85 modellen in de arena.
Pad B: gebruik DROID als testopstelling
De 100-afleveringen-sample is de beste 2 GB die je deze maand zult downloaden, en niet voor training. Het is een dataset waarvan je weet dat deze correct is. Voer je converter, loader en een korte GPU-taak erop uit; alles wat faalt, is een infrastructuurfout die is gevonden toen het nog goedkoop was. NVIDIA doet hetzelfde op schaal: de GR00T N1.7-kaart vermeldt vier nader getrainde varianten, voor Bridge en Fractal in SimplerEnv, DROID en LIBERO.
Pad C: neem je eigen data op, weloverwogen
Dertig tot vijftig klinkt weinig naast 76.000 totdat je bedenkt dat die van jou de enige zijn met jouw arm, jouw camera's en jouw tafel. Met de standaardinstellingen van LeRobot zijn 50 afleveringen 100 minuten kloktijd. Zie , en .

Twee manieren om van openbare data tot een werkend beleid te komen
All of this runs on your own machine plus a rented GPU. Knowing the manual path matters because when something breaks you will know which layer broke.
- 1Install LeRobot with the extras the scripts need
The record and train entry points each declare their own extra.
bashpip install 'lerobot[core_scripts]' # lerobot-record pip install 'lerobot[training]' # lerobot-train pip install gsutil tensorflow tensorflow-datasets - 2Get a small, known-good slice
100 DROID episodes, 2 GB.
bashgsutil -m cp -r gs://gresearch/robotics/droid_100 ~/tensorflow_datasets/ - 3Convert to LeRobot form
Writes the unified 8-D state and 7-D action, annotating robot type and control frequency.
bashpython openx_rlds.py \ --raw-dir ~/tensorflow_datasets/droid_100/1.0.0 \ --local-dir ~/lerobot_droid100 \ --repo-id you/droid100_lerobot \ --use-videos - 4Check the version against your trainer
The converter README documents v3.0 output; the published IPEC-COMMUNITY datasets report v2.0. GR00T wants v2.0 or v2.1 and crashes on v3.0; Pi0.5, SmolVLA and ACT want v3.0. Mind the gap: the only conversion script on LeRobot main goes 2.1 to 3.0.
bashpython src/lerobot/scripts/convert_dataset_v21_to_v30.py \ --repo-id=you/droid100_lerobot - 5Record your own episodes
Defaults: 30 fps, 60 s per episode, 60 s reset, 50 episodes. The teleoperator type is so100_leader.
bashlerobot-record \ --robot.type=so100_follower \ --robot.port=/dev/ttyACM0 \ --robot.cameras="{front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \ --teleop.type=so100_leader \ --teleop.port=/dev/ttyACM1 \ --dataset.repo_id=you/so100_pick_block \ --dataset.num_episodes=50 \ --dataset.single_task="Pick up the red block and put it in the bowl" - 6Fine-tune on your data only
Weights from public data, actions from your own. Do not mix the datasets.
bashlerobot-train \ --policy.path=lerobot/smolvla_base \ --dataset.repo_id=you/so100_pick_block \ --policy.device=cuda \ --batch_size=4 \ --steps=20000
Not in training; the GPU job is hours. The conversion, the version mismatch and the moment you find your dataset is v2.0 and your trainer wants v3.0 are days. Read dataset rejected as v3 first.
The platform removes the GPU and pipeline plumbing. It does not remove the embodiment mismatch: point the trainer at a converted DROID dataset and you get a policy trained on Franka actions, exactly as you would locally.
- 1Pick a policy, not a dataset
The five trainable policies, with parameter counts, GPU tiers and latencies, are at /policies.
- 2Record with the desktop client
It writes LeRobot-format datasets, episodes, camera streams and joint states, straight out of a teleop session. No conversion step to get wrong.
- 3Or bring a dataset you already have
The training form accepts one from /directory, a Hugging Face repo id, or your own machine. A repo id means a converted OXE dataset will load, and the mismatch loads with it.
- 4Train on a rented GPU
The backend rents a card on a spot market by required VRAM. SmolVLA or ACT on 24 GB: 2 to 5 hours, about 1 to 3 USD. GR00T or Pi0.5 on A100 or H100: 3 to 6 hours, about 4 to 12 USD. See /pricing.
- 5Serve it back to the arm
/api/inference/pod auto-provisions a GPU pod serving the policy; the local client talks to that endpoint. Pods carry an idle watchdog and destroy themselves, so nothing keeps billing silently.
Inference has to sit next to the servos for fast tasks. The control loop is 20 to 485 ms per action step depending on the model, and public-internet round trips turn a working policy into a hesitant one. Remote inference is fine for slow pick-and-place, not fast reactive motion.
The platform helps with the boring parts: the right format for the right arm at the right frame rate, and no babysitting a spot instance. It helps with nothing else in this article.

Wat elk pad kost
| Pad | Opslag | Menselijke tijd | GPU-kosten | Kans dat het je arm beweegt |
|---|---|---|---|---|
| Geconverteerde DROID alleen | 392 GB | dagen van conversie | 4 to 12 USD | zeer laag, verkeerde actieruimte |
| DROID samengevoegd met je afleveringen | beide | blocked by validate_all_metadata | n/a | geen, het draait niet |
| SmolVLA, 30 tot 50 eigen afleveringen | een paar GB | 100 min opname | 1 to 3 USD | hoog |
| GR00T N1.7, 50 eigen afleveringen | een paar GB | 100 min opname | 4 to 12 USD | hoog |
| ACT vanaf nul, 50 eigen afleveringen | een paar GB | 100 min opname | 1 to 3 USD | hoog, 20 ms inferentie |
| DROID-voorbeeld als testfixture | 2 GB | een middag | one short run | hoog, als validatie |
De asymmetrie is het punt: het pad dat de meeste data leent, is het duurst en het minst waarschijnlijk om je arm te bewegen. Minder dan twee uur van je eigen teleoperatie verslaat een terabyte van iemand anders' Franka. Nog geen arm? /live streamt een fysieke SO-100 zonder aanmelding. Train dan je eerste beleid, en SmolVLA op SO-100 voor de specifieke handleiding.
Download de 2 GB DROID-voorbeeld en gebruik deze om je pipeline te bewijzen. Negeer de overige 1.7 TB. Neem 50 afleveringen van één taak op met vaste camera's. Fine-tune SmolVLA eerst, want met minimaal 30 afleveringen op een 24 GB kaart is het het goedkoopst om op te itereren, probeer daarna GR00T N1.7 op dezelfde data. Vergelijk op je eigen taak, niet op een benchmark.
Neem datasets op die al overeenkomen met je arm
De desktopclient schrijft LeRobot-formaat datasets rechtstreeks vanuit een teleop-sessie: de juiste arm, de juiste framerate, de juiste actieruimte. Geen RLDS-conversie, geen remapping.
Download de desktopclientKan ik een beleid trainen op DROID en het uitvoeren op mijn SO-100?▾
Niet direct. In de LeRobot-build zijn DROID-acties 7-D eind-effector commando's op een Franka Panda met 15 fps; in de ruwe RLDS zijn het 6 gewrichtssnelheden plus een grijperpositie. Een SO-100 neemt 6 absolute gewrichtsposities. Je zou een inverse-kinematica laag nodig hebben, en zelfs dan kan een 5-DoF pols geen willekeurige 6-DoF poses reproduceren.
Kan ik DROID- of Bridge-afleveringen mixen met mijn eigen SO-100-afleveringen?▾
Nee. validate_all_metadata vereist identieke fps, robot_type en feature schema en genereert een ValueError bij de eerste mismatch. Alle drie verschillen: 15 of 5 fps tegen 30, franka of widowx tegen je arm, actievormen van 7 tegen 6. Het herschrijven van metadata om de controle te doorstaan, lost de semantiek niet op.
Is Open X-Embodiment dan nutteloos voor een goedkope arm?▾
Nee, maar de waarde ervan bereikt je via voorgegetrainde gewichten, niet via afleveringen. Open-source datasets, waaronder OXE, Bridge v2 en DROID, vormen 9.1 procent van pi0's pre-training mix, en NVIDIA levert GR00T N1.7 varianten die post-getraind zijn op Bridge, Fractal, DROID en LIBERO. Wat je niet kunt doen, is die afleveringen toevoegen aan je eigen opname.
Welk beleid profiteert het meest van openbare cross-embodiment data?▾
Pi0.5 en de GR00T-modellen bevatten de meeste cross-embodiment pretraining, maar SmolVLA presteert vaak het beste op een goedkope arm: de pretraining set bestaat uit 481 community datasets, 22.9K afleveringen en 10.6M frames, geëvalueerd op echte SO-100 en SO-101 armen. ACT is het tegenovergestelde: geen basismodel, 20 ms per actiestap.
Hoeveel van mijn eigen afleveringen heb ik eigenlijk nodig?▾
30 voor SmolVLA, 50 voor GR00T N1.7, GR00T N1.5, Pi0.5 en ACT. Met LeRobot's standaardinstellingen van 60 s per aflevering en 60 s reset, zijn 50 afleveringen 100 minuten werkelijke tijd. Geleende cross-embodiment data verlaagt die aantallen niet.
Sources
- DROID: Een grootschalige robotmanipulatiedataset in het wild
- DROID docs: downloadgroottes en het RLDS-episodeschema
- BridgeData V2: Een dataset voor robotleren op schaal
- BridgeData V2 projectpagina: samenstelling en cameradekking
- Open X-Embodiment: Robotleerdatasets en RT-X-modellen
- Open X-Embodiment projectpagina
- google-deepmind/open_x_embodiment: datasetlijst en RT-1-X checkpoints
- any4lerobot: de openx2lerobot-converter en zijn uniforme 8-D toestand, 7-D actie
- IPEC-COMMUNITY/droid_lerobot: meta/info.json en repo-grootte
- IPEC-COMMUNITY/bridge_orig_lerobot: meta/info.json
- IPEC-COMMUNITY/fractal20220817_data_lerobot: de google_robot slice met 3 fps
- huggingface/lerobot: SO-volger, kinematica-processor, aggregeer- en opnameconfiguraties
- openpi: DROID beleidsinputs en de pi05_droid checkpoint
- pi0: Een visie-taal-actie-stroommodel voor algemene robotbesturing
- SmolVLA: Een visie-taal-actie-model voor betaalbare en efficiënte robotica
Sources
- DROID: A Large-Scale In-The-Wild Robot Manipulation Dataset
- DROID docs: download sizes and the RLDS episode schema
- BridgeData V2: A Dataset for Robot Learning at Scale
- BridgeData V2 project page: composition and camera coverage
- Open X-Embodiment: Robotic Learning Datasets and RT-X Models
- Open X-Embodiment project page
- google-deepmind/open_x_embodiment: dataset list and RT-1-X checkpoints
- any4lerobot: the openx2lerobot converter and its unified 8-D state, 7-D action
- IPEC-COMMUNITY/droid_lerobot: meta/info.json and repo size
- IPEC-COMMUNITY/bridge_orig_lerobot: meta/info.json
- IPEC-COMMUNITY/fractal20220817_data_lerobot: the google_robot slice at 3 fps
- huggingface/lerobot: SO follower, kinematics processor, aggregate and record configs
- openpi: DROID policy inputs and the pi05_droid checkpoint
- pi0: A Vision-Language-Action Flow Model for General Robot Control
- SmolVLA: A Vision-Language-Action Model for Affordable and Efficient Robotics
Ready for high-quality robotics data?
AY-Robots connects your robots to skilled operators worldwide.
Get Started