De openbare datasetdirectory van AY-Robots met LeRobot datasets opgenomen op SO-100 klasse armen
DatasetsOpen X-EmbodimentDROIDSO-100LeRobot

DROID, BridgeData V2 en Open X gebruiken op een SO-100

AY-Robots ResearchAugust 23, 202618 min leestijd

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

DROIDBridgeData V2Open X-Embodiment
RobotFranka Panda, 7 DoF, Robotiq 2F-85WidowX 250, 6 DoF, ~4,000 USD rig22 embodiments, 60 datasets, 34 labs
Schaal76k trajectories, 350 hours60,096 trajectories1M+ trajectories, 527 skills
Diversiteit564 scenes, 84 tasks, 50 collectors24 environments, 13 skills160,266 tasks, 21 institutions
Samenstellingvolledig telebediend50.365 telebediend, 9.731 gescriptper bronlab
Besturingsfrequentie15 Hz5 Hzvarieert, 3 fps en hoger
Camera's2 x ZED 2 extern, 1 x ZED Mini polstot 4, de meeste afleveringen alleen de vastewat het lab ook gebruikte
Ruwe download1,7 TB RLDS, 8,7 TB ruwe stereoJPEG-archievenper-dataset TFDS buckets
Het toegangspunt is de LeRobot-conversie, niet de oorspronkelijke bucket

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 AY-Robots datasetmap met een lijst van openbare LeRobot-datasets met afleveringentellingen en taakbeschrijvingen
De openbare datasetmap op /directory: datasets al in LeRobot-vorm, al passend bij een ondersteunde arm.

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.

python
# 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-D
Links: LeRobot's SO follower, uit src/lerobot/robots/so_follower/so_follower.py. Rechts: openpi's DROID policy input. Zes tegen acht.

Een 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.

EigenschapOXE, DROID en Bridge in LeRobot-vormSO-100 in LeRobot
Actievector7-D: x, y, z, roll, pitch, yaw, grijper6-D: één doelpositie per motor
Staatvector8-D, met een opvulslot (google_robot gebruikt een quaternion)6-D, één per motor
FrameCartesisch, niet uitgelijnd over datasetsgewrichtsruimte, per-arm kalibratie
Absoluut of relatiefbeide, bepaald door het bronlababsolute doelposities
Eenhedengenormaliseerd per dataset, daarna gediscretiseerdgraden standaard (use_degrees=True), anders -100 tot 100
Stille storingeen delta gelezen als een absolute waardeeen ongekalibreerde arm
De 7D Cartesische vector is de conventie van de converter, niet die van DROID

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 val die een dag opslokt

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.

  1. 1
    Haal de 100-afleveringen sample op, niet de volledige 1.7 TB

    2 GB is genoeg om de structuur te zien.

    bash
    pip install gsutil tensorflow tensorflow-datasets
    gsutil -m cp -r gs://gresearch/robotics/droid_100 ~/tensorflow_datasets/
  2. 2
    Converteer RLDS naar LeRobot-vorm

    openx2lerobot omvat de standaard OXE-transformaties en annoteert het robottype en de controlefrequentie. De README plaatst dit in convert.sh.

    bash
    git 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
  3. 3
    Lees meta/info.json voordat je iets anders doet

    Dit bestand bepaalt of de rest van je dag werkt.

    bash
    python -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'])"
  4. 4
    Probeer 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.

    bash
    lerobot-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.

Hardcode robot_type niet om de controle te omzeilen

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.

Openbare cross-embodiment gegevens over een SO-100 project
Voordelen
  • 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.
Afwegingen
  • 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 modelWordt overgedragen?Waarom
Visie-encoderJa, sterkObjecten en scènes zijn embodiment-onafhankelijk
TaalverankeringJaInstructies zijn tekst, geen geometrie
Cross-modale fusieMeestalRicht zich op het object dat in de prompt wordt genoemd
Proprioceptie-encoderNeeInvoerdimensie en gewrichtssemantiek verschillen
ActiehoofdNeeGetraind op een 7-D Cartesische ruimte waarin u zich niet bevindt
NormalisatiestatistiekenNee, en gevaarlijkVreemde 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.

BeleidParametersMin. afleveringenDatasetformaatGPU-klasseInferentieBasis checkpoint
GR00T N1.7~3 B, ~40 M getraind in fine-tuning50LeRobot v2.0 or v2.1A100 or H100 80 GB152 ms per stapnvidia/GR00T-N1.7-3B
GR00T N1.5~3 B50LeRobot v2.0 or v2.1A100 or H100 80 GB165 msnvidia/GR00T-N1.5-3B
Pi0.5~3 B, PaliGemma-backbone50LeRobot v3.0A100 or H100 80 GB485 mslerobot/pi05_base
SmolVLA~450 M30LeRobot v3.0RTX 4090 or any 24 GB245 mslerobot/smolvla_base
ACT~80 M50LeRobot v3.0RTX 4090 or any 24 GB20 msgeen, 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 .

The AY-Robots recording tutorial page showing the steps to capture a LeRobot dataset from a teleoperation session
De opname-handleiding op /learn/record-your-first-dataset: de stap die openbare data niet kan vervangen.

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.

  1. 1
    Install LeRobot with the extras the scripts need

    The record and train entry points each declare their own extra.

    bash
    pip install 'lerobot[core_scripts]'   # lerobot-record
    pip install 'lerobot[training]'      # lerobot-train
    pip install gsutil tensorflow tensorflow-datasets
  2. 2
    Get a small, known-good slice

    100 DROID episodes, 2 GB.

    bash
    gsutil -m cp -r gs://gresearch/robotics/droid_100 ~/tensorflow_datasets/
  3. 3
    Convert to LeRobot form

    Writes the unified 8-D state and 7-D action, annotating robot type and control frequency.

    bash
    python openx_rlds.py \
        --raw-dir ~/tensorflow_datasets/droid_100/1.0.0 \
        --local-dir ~/lerobot_droid100 \
        --repo-id you/droid100_lerobot \
        --use-videos
  4. 4
    Check 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.

    bash
    python src/lerobot/scripts/convert_dataset_v21_to_v30.py \
        --repo-id=you/droid100_lerobot
  5. 5
    Record your own episodes

    Defaults: 30 fps, 60 s per episode, 60 s reset, 50 episodes. The teleoperator type is so100_leader.

    bash
    lerobot-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"
  6. 6
    Fine-tune on your data only

    Weights from public data, actions from your own. Do not mix the datasets.

    bash
    lerobot-train \
      --policy.path=lerobot/smolvla_base \
      --dataset.repo_id=you/so100_pick_block \
      --policy.device=cuda \
      --batch_size=4 \
      --steps=20000
Where the time actually goes

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.

De downloadpagina van de AY-Robots desktopclient, de client die LeRobot-formaat datasets opneemt vanuit een teleoperatiesessie
De desktopclient op /download schrijft LeRobot-datasets direct vanuit een teleoperatiesessie, waarbij RLDS-conversie wordt omzeild.

Wat elk pad kost

PadOpslagMenselijke tijdGPU-kostenKans dat het je arm beweegt
Geconverteerde DROID alleen392 GBdagen van conversie4 to 12 USDzeer laag, verkeerde actieruimte
DROID samengevoegd met je afleveringenbeideblocked by validate_all_metadatan/ageen, het draait niet
SmolVLA, 30 tot 50 eigen afleveringeneen paar GB100 min opname1 to 3 USDhoog
GR00T N1.7, 50 eigen afleveringeneen paar GB100 min opname4 to 12 USDhoog
ACT vanaf nul, 50 eigen afleveringeneen paar GB100 min opname1 to 3 USDhoog, 20 ms inferentie
DROID-voorbeeld als testfixture2 GBeen middagone short runhoog, 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.

Een redelijk standaardplan

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 desktopclient
Kan 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.

Ready for high-quality robotics data?

AY-Robots connects your robots to skilled operators worldwide.

Get Started