SO-100 క్లాస్ ఆర్మ్‌లపై రికార్డ్ చేయబడిన LeRobot డేటాసెట్‌లను చూపుతున్న AY-Robots పబ్లిక్ డేటాసెట్ డైరెక్టరీ
డేటాసెట్‌లుOpen X-EmbodimentDROIDSO-100LeRobot

SO-100 పై DROID, BridgeData V2 మరియు Open X లను ఉపయోగించడం

AY-Robots ResearchAugust 23, 202618 నిమిషాల పఠనం

DROID, BridgeData V2 మరియు Open X-Embodiment లు 6 మరియు 7-DoF ఆర్మ్‌లపై 7-D ఎండ్-ఎఫెక్టర్ చర్యలుగా మార్చబడతాయి. ఒక SO-100 6 జాయింట్ పొజిషన్‌లను తీసుకుంటుంది. ఏమి బదిలీ అవుతుంది, ఏమి కాదు, బదులుగా ఏమి చేయాలి.

సంక్షిప్త వివరణ

  • మూడింటి LeRobot బిల్డ్‌లు ఒకే సంప్రదాయాన్ని పంచుకుంటాయి: 7-D ఎండ్-ఎఫెక్టర్ చర్య [x, y, z, roll, pitch, yaw, gripper] మరియు ప్యాడ్ స్లాట్‌తో కూడిన 8-D స్థితి. SO-100 ఆరు అబ్సొల్యూట్ జాయింట్ పొజిషన్‌లను తీసుకుంటుంది.
  • ఆ 7-D వెక్టర్ కన్వర్టర్ యొక్క కళాఖండం: DROID యొక్క స్వంత RLDS యాక్షన్ ఫీల్డ్ 6 జాయింట్ వెలాసిటీలు ప్లస్ ఒక గ్రిప్పర్ పొజిషన్, యాక్షన్_డిక్ట్‌లో కార్టేసియన్ వ్యూతో.
  • నాలుగు క్లాక్‌లు: DROID 15 fps, BridgeData V2 5 fps, google_robot స్లైస్ 3 fps, SO-100 రికార్డింగ్ 30 fps వద్ద.
  • మీరు వాటిని మీ స్వంత డేటాతో విలీనం చేయలేరు. fps, robot_type లేదా ఫీచర్‌లలో ఏదైనా మొదటిది భిన్నంగా ఉంటే validate_all_metadata లోపం చూపుతుంది, మరియు ఈ మూడు భిన్నంగా ఉంటాయి.
  • బదిలీ అయ్యేది ప్రీట్రైన్డ్ వెయిట్స్, ఎపిసోడ్‌లు కాదు. ఓపెన్-సోర్స్ డేటా pi0 యొక్క ప్రీ-ట్రైనింగ్ మిశ్రమంలో 9.1 శాతం.
  • వాటి చౌకైన నిజమైన ఉపయోగం ఒక టెస్ట్ ఫిక్చర్: 2 GB, 100-ఎపిసోడ్ DROID నమూనా, ఇది మీరు వారాంతంలో రికార్డ్ చేయడానికి ముందు మీ పైప్‌లైన్‌ను నిరూపిస్తుంది.

Google Cloud బకెట్‌లో మిలియన్-ట్రాజెక్టరీ పబ్లిక్ డేటాసెట్ ఉంది మరియు డెస్క్‌పై 110 నుండి 150 EUR ఖర్చుతో కూడిన విడిభాగాలతో ఒక SO-100 ఉంది. మొదటిది రెండవదానికి ఎందుకు నేర్పించదు? ఇది పాక్షికంగా చేయగలదు, కానీ బదిలీ ప్రజలు ఆశించిన చోట దాదాపుగా జరగదు, మరియు సులభంగా కనిపించే భాగం అస్సలు పని చేయదు.

తరువాత ఏమిటి: DROID, BridgeData V2 మరియు Open X-Embodiment లోపల ఏముంది, ఇక్కడ ప్రతి ఒక్కటి తక్కువ-ధర 5-DoF ఆర్మ్‌తో ఎలా సరిపోతుంది, మరియు దానికి బదులుగా ఏమి చేయాలి. క్రింద ఉన్న ప్రతి సంఖ్య అది చెందిన పేపర్, డేటాసెట్ కార్డ్ లేదా సోర్స్ ఫైల్ నుండి వచ్చింది.

మూడు డేటాసెట్‌లు వాస్తవానికి ఏమి కలిగి ఉన్నాయి

DROIDBridgeData V2Open X-Embodiment
రోబోట్Franka Panda, 7 DoF, Robotiq 2F-85WidowX 250, 6 DoF, ~4,000 USD రిగ్22 ఎంబోడిమెంట్లు, 60 డేటాసెట్‌లు, 34 ల్యాబ్‌లు
స్కేల్76k ట్రాజెక్టరీలు, 350 గంటలు60,096 ట్రాజెక్టరీలు1M+ ట్రాజెక్టరీలు, 527 నైపుణ్యాలు
వైవిధ్యం564 దృశ్యాలు, 84 పనులు, 50 కలెక్టర్లు24 వాతావరణాలు, 13 నైపుణ్యాలు160,266 పనులు, 21 సంస్థలు
కూర్పుఅన్నీ టెలిఆపరేటెడ్50,365 టెలిఆపరేటెడ్, 9,731 స్క్రిప్టెడ్ప్రతి మూల ల్యాబ్ ప్రకారం
నియంత్రణ రేటు15 Hz5 Hzమారుతూ ఉంటుంది, 3 fps పైకి
కెమెరాలు2 x ZED 2 బాహ్య, 1 x ZED Mini మణికట్టు4 వరకు, చాలా ఎపిసోడ్‌లలో స్థిరమైనది మాత్రమేల్యాబ్ ఉపయోగించినది ఏదైనా
రా డౌన్‌లోడ్1.7 TB RLDS, 8.7 TB రా స్టీరియోJPEG ఆర్కైవ్‌లుప్రతి-డేటాసెట్ TFDS బకెట్‌లు
ఎంట్రీ పాయింట్ LeRobot మార్పిడి, అసలు బకెట్ కాదు

కొద్దిమంది మాత్రమే ఇప్పటికీ 1.7 TB RLDS TFRecordsని డౌన్‌లోడ్ చేసుకుంటున్నారు. కమ్యూనిటీ సంస్థ IPEC-COMMUNITY Open X-Embodimentలో ఎక్కువ భాగాన్ని AV1 వీడియోతో LeRobot డేటాసెట్ రూపంలో తిరిగి ప్రచురించింది, ఇక్కడ DROID 392 GBకి చేరుకుంటుంది. మీరు పని చేసే వెర్షన్ అది, మరియు దాని meta/info.jsonని ముందుగా చదవాలి.

DROID

మూడింటిలో అత్యంత ప్రామాణీకరించబడినది. అన్ని చోట్లా ఒకే రిగ్: Robotiq 2F-85 గ్రిప్పర్, రెండు సర్దుబాటు చేయగల ZED 2 స్టీరియో కెమెరాలు మరియు మణికట్టు ZED Miniతో కూడిన Franka Panda, Meta Quest 2 కంట్రోలర్‌లతో టెలిఆపరేట్ చేయబడింది, Polymetis ద్వారా 15 Hz వద్ద జాయింట్ మరియు ఎండ్-ఎఫెక్టర్ స్పేస్‌లో రికార్డ్ చేయబడింది. భాషా లేబుల్‌లు తర్వాత tasq.ai ద్వారా వచ్చాయి, ప్రతి ఎపిసోడ్‌కు మూడు వరకు.

  • 76k ట్రాజెక్టరీలు, 350 గంటలు, 564 దృశ్యాలు, 84 పనులు, మూడు ఖండాలలో 50 కలెక్టర్లు.
  • ముఖ్య ఫలితం సహ-శిక్షణ, స్వతంత్ర శిక్షణ కాదు: ఇన్-డొమైన్ ప్రదర్శనలతో 50/50 కలిపిన బ్యాచ్‌లు తదుపరి ఉత్తమ పద్ధతిని పంపిణీలో 22 శాతం సంపూర్ణ విజయం, దాని వెలుపల 17 శాతం అధిగమించాయి.
  • IPEC-COMMUNITY/droid_lerobot: 92,233 ఎపిసోడ్‌లు, 27,044,326 ఫ్రేమ్‌లు, franka, 15 fps, codebase_version v2.0, 180x320 వద్ద మూడు AV1 స్ట్రీమ్‌లు, 392 GB.
  • 2 GB, 100-ఎపిసోడ్‌ల డీబగ్గింగ్ నమూనా gs://gresearch/robotics/droid_100 వద్ద ఉంది. అక్కడి నుండి ప్రారంభించండి.

BridgeData V2

ఒక హాబీ సెటప్‌కు దగ్గరగా: ఒక WidowX 250 6-DoF ఆర్మ్, 24 వాతావరణాలలో మరియు 13 నైపుణ్యాలలో 5 Hz వద్ద 60,096 ట్రాజెక్టరీలు. కూర్పును గమనించండి: 50,365 నిపుణుల టెలిఆపరేటెడ్ ప్రదర్శనలు ప్లస్ 9,731 యాదృచ్ఛిక స్క్రిప్టెడ్ పిక్-అండ్-ప్లేస్ పాలసీ నుండి, కాబట్టి సుమారు 16 శాతం మానవ ప్రదర్శన కాదు, ఇది దీనికి ముఖ్యమైనది అనుకరణ అభ్యాసం నాణ్యత. సాధారణ డౌన్‌లోడ్, IPEC-COMMUNITY/bridge_orig_lerobot, 53,192 ఎపిసోడ్‌లు మరియు 1,893,026 ఫ్రేమ్‌లు 5 fps వద్ద, robot_type widowx: పేపర్ యొక్క 60,096 కంటే తక్కువగా నివేదిస్తుంది, కాబట్టి దేనినీ ఉటంకించకుండా meta/info.json నుండి సంఖ్యను చదవండి.

Open X-Embodiment

అదే అర్థంలో డేటాసెట్ కాదు: 34 ల్యాబ్‌ల నుండి 60 ఇప్పటికే ఉన్న రోబోట్ డేటాసెట్‌లు ఒక RLDS సేకరణలోకి పూల్ చేయబడ్డాయి, ఇది 22 ఎంబోడిమెంట్‌లు మరియు పది లక్షలకు పైగా ట్రాజెక్టరీలను కవర్ చేస్తుంది. BridgeData V2 దానిలో bridge_orig గా ఉంది; google_robot స్లైస్, fractal20220817_data, 3 fps వద్ద 87,212 ఎపిసోడ్‌లుగా మారుతుంది.

ఈ పూలింగ్ పేపర్ స్పష్టంగా పేర్కొన్న ఒక హెచ్చరికను కలిగి ఉంది. RT-X ప్రయోగాల కోసం రచయితలు ప్రతి మూలాన్ని 7-DoF ఎండ్-ఎఫెక్టర్ చర్యగా మారుస్తారు, కానీ డేటాసెట్‌ల అంతటా కోఆర్డినేట్ ఫ్రేమ్‌లను సమలేఖనం చేయరు మరియు ప్రతి రోబోట్ యొక్క అసలు నియంత్రణ పథకం ప్రకారం చర్య విలువలను సంపూర్ణ లేదా సాపేక్ష స్థానాలు లేదా వేగంగా అనుమతిస్తారు. వారి ముగింపు: ఒకే చర్య వెక్టర్ వేర్వేరు రోబోట్‌లకు చాలా భిన్నమైన కదలికలను ప్రేరేపించవచ్చు.

The AY-Robots dataset directory listing public LeRobot datasets with episode counts and task descriptions
The public dataset directory at /directory: datasets already in LeRobot form, already matching a supported arm.

నాలుగు భాగాలుగా అసమతుల్యత

ఎంబోడిమెంట్ మిస్‌మ్యాచ్‌ను సాధారణంగా ఒక అస్పష్టమైన సమస్యగా పరిగణిస్తారు. ఇవి నాలుగు రకాలు, అవి వేర్వేరుగా విఫలమవుతాయి, మరియు రెండింటిని స్క్రిప్టింగ్ ద్వారా పరిష్కరించలేము.

1. డిగ్రీస్ ఆఫ్ ఫ్రీడమ్

ఒక SO-100 ఐదు ఆర్మ్ జాయింట్‌లు మరియు ఒక గ్రిప్పర్‌ను కలిగి ఉంటుంది. మోటార్‌లుగా లెక్కించినప్పుడు అది 6-DoF ఆర్మ్, మరియు SmolVLA పేపర్ దానిని అలా పిలుస్తుంది; పొజిషనింగ్ మెకానిజంగా లెక్కించినప్పుడు అది 5-DoF, మరియు LeRobot దాని ఇన్వర్స్-కైనమాటిక్స్ డాక్‌స్ట్రింగ్‌లో దానిని అలా పిలుస్తుంది, ఇది 5-DOF SO-101లో సాఫ్ట్-ఓరియంటేషన్ IKని వివరిస్తుంది, ఇక్కడ మణికట్టు ఓరియంటేషన్‌ను పాక్షికంగా మాత్రమే ట్రాక్ చేస్తుంది. ఒక Franka ఏడు పొజిషనింగ్ జాయింట్‌లను కలిగి ఉంటుంది. ఆ అంతరం ఏ భంగిమలు ఉన్నాయో నిర్ణయిస్తుంది: 5-DoF ఆర్మ్ సాధారణంగా ఒకేసారి ఏకపక్ష స్థానం మరియు ధోరణిని చేరుకోదు, కాబట్టి సాల్వర్ అది చేరుకోగల దగ్గరి స్థానాన్ని తిరిగి ఇస్తుంది, ఇది ప్రదర్శించిన దాని నుండి భిన్నమైన కదలిక. నేపథ్యం: డిగ్రీస్ ఆఫ్ ఫ్రీడమ్.

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
ఎడమ: LeRobot యొక్క SO ఫాలోవర్, src/lerobot/robots/so_follower/so_follower.py నుండి. కుడి: openpi యొక్క DROID పాలసీ ఇన్‌పుట్. ఆరుకు ఎనిమిదికి వ్యతిరేకంగా.

కాబట్టి, సిద్ధంగా ఉన్న DROID చెక్‌పాయింట్ షార్ట్‌కట్ కాదు. ఫిజికల్ ఇంటెలిజెన్స్ pi05_droidని gs://openpi-assets/checkpoints/pi05_droid వద్ద పంపుతుంది, మరియు దాని విస్తృతిని ప్రశంసించే అదే README, ఈ నిపుణుల చెక్‌పాయింట్లు మీ సెటప్‌కు సాధారణీకరించకపోవచ్చని హెచ్చరిస్తుంది. దాని స్థితి ఎనిమిది ఫ్రాంకా జాయింట్ నంబర్‌లు మరియు దాని చిత్ర కీలు exterior_image_1_left మరియు wrist_image_left. ఏ ఫ్లాగ్ కూడా దానిని ఆరు-మోటార్ SO-100 కమాండ్‌గా మార్చదు.

2. యాక్షన్ వెక్టర్ వాస్తవానికి ఏమి చెబుతుంది

డైమెన్షనాలిటీ కంటే లోతుగా. LeRobot మార్పిడులలో, మూడు కూడా గ్రిప్పర్ కార్టేసియన్ స్పేస్‌లో ఎక్కడికి వెళ్లాలో చెబుతాయి. ఒక SO-100 ఆరు సర్వోలు ఎక్కడికి వెళ్లాలో చెబుతుంది. మార్చడానికి కైనమాటిక్ మోడల్ మరియు సాల్వర్ అవసరం, రీషేప్ కాదు.

లక్షణంLeRobot రూపంలో OXE, DROID మరియు బ్రిడ్జ్LeRobotలో SO-100
యాక్షన్ వెక్టర్7-D: x, y, z, రోల్, పిచ్, యావ్, గ్రిప్పర్6-D: ప్రతి మోటారుకు ఒక లక్ష్య స్థానం
స్టేట్ వెక్టర్8-D, ప్యాడ్ స్లాట్‌తో (google_robot క్వాటర్నియన్‌ను ఉపయోగిస్తుంది)6-D, ప్రతి మోటారుకు ఒకటి
ఫ్రేమ్కార్టేసియన్, డేటాసెట్‌లలో అమర్చబడలేదుజాయింట్ స్పేస్, ప్రతి-చేతి క్రమాంకనం
సంపూర్ణ లేదా సాపేక్షఏదైనా, మూల ల్యాబ్ ద్వారా నిర్ణయించబడుతుందిసంపూర్ణ లక్ష్య స్థానాలు
యూనిట్లుప్రతి డేటాసెట్‌కు సాధారణీకరించబడింది, ఆపై వివిక్తీకరించబడిందిడిఫాల్ట్‌గా డిగ్రీలు (use_degrees=True), లేకపోతే -100 నుండి 100
నిశ్శబ్ద వైఫల్యంసంపూర్ణంగా చదవబడిన డెల్టాక్రమాంకనం చేయని చేయి
7-D కార్టేసియన్ వెక్టర్ అనేది కన్వర్టర్ యొక్క కన్వెన్షన్, DROID యొక్కది కాదు

openx2lerobot README, అది మార్చే ప్రతి డేటాసెట్ కోసం ఏకీకృత 8-డైమెన్షనల్ స్టేట్ మరియు 7-డైమెన్షనల్ యాక్షన్‌ను డాక్యుమెంట్ చేస్తుంది, అక్కడి నుండే pad స్లాట్ వస్తుంది. DROID యొక్క స్వంత RLDS స్కీమా భిన్నంగా ఉంటుంది: దాని టాప్-లెవల్ action అనేది 6 జాయింట్ వెలాసిటీలు ప్లస్ 1 గ్రిప్పర్ పొజిషన్తో కూడిన 7-వెక్టర్, action_dict కింద cartesian_position, cartesian_velocity, joint_position మరియు joint_velocity ఉంటాయి. openpi జాయింట్-స్పేస్ వీక్షణను చదువుతుంది, LeRobot బిల్డ్ మీకు కార్టేసియన్ వీక్షణను అందిస్తుంది. రెండూ ఆరు అబ్సొల్యూట్ సర్వో యాంగిల్స్ కావు.

LeRobot తప్పిపోయిన భాగాన్ని అందిస్తుంది: SO ఫాలోవర్‌లో InverseKinematicsEEToJoints మరియు ForwardKinematicsJointsToEE స్టెప్స్‌తో కూడిన కైనమాటిక్స్ ప్రాసెసర్ ఉంది. దీని కీలు ee.x, ee.y, ee.z ప్లస్ రొటేషన్ వెక్టర్ ee.wx, ee.wy, ee.wz మరియు ee.gripper_pos, కాబట్టి ఓరియంటేషన్ ఎన్‌కోడింగ్ కూడా ఫైల్స్‌లోని రోల్-పిచ్-యా నుండి భిన్నంగా ఉంటుంది. IK స్టెప్ orientation_weightను తీసుకుంటుంది, డిఫాల్ట్ 0.01, దీని డాక్‌స్ట్రింగ్ అండర్-యాక్చుయేటెడ్ ఆర్మ్స్‌పై పొజిషన్-ఓన్లీ IK కోసం 0.0 సెట్ చేయమని చెబుతుంది. మీరు బ్రిడ్జ్‌ను నిర్మించవచ్చు, కానీ అప్పుగా తీసుకున్న ప్రతి యాక్షన్ యొక్క ఓరియంటేషన్ సగం అంచనాగానే ఉంటుంది.

3. కంట్రోల్ రేట్

DROID 15 Hz, BridgeData V2 5 Hz, google_robot స్లైస్ 3 fps; pi0 రచయితలు తమ మిశ్రమంలోని ఓపెన్-సోర్స్ భాగాన్ని 2 మరియు 10 Hz మధ్య తక్కువ-ఫ్రీక్వెన్సీ కంట్రోల్‌గా వివరిస్తారు. LeRobot యొక్క DatasetRecordConfig డిఫాల్ట్‌గా fps 30, episode_time_s 60, reset_time_s 60, num_episodes 50. 5 Hz డేటాపై శిక్షణ పొందిన ఒక ఒక యాక్షన్ 200 ms కవర్ చేస్తుందని తెలుసుకుంది. దానిని 30 Hz వద్ద రీప్లే చేస్తే ఆర్మ్ నెమ్మదిగా కదులుతుంది; అమాయకంగా రీశాంపిల్ చేస్తే గ్రిప్పర్ మూసుకునే ఫ్రేమ్‌ను మీరు చెరిపివేస్తారు. ఇది తో కూడా సరిగా పనిచేయదు: 100-స్టెప్ చంక్ 5 Hz వద్ద 20 సెకన్లు, 30 Hz వద్ద 3.3 సెకన్లు.

4. కెమెరాలు

BridgeData V2 ప్రతి 50 ట్రాజెక్టరీలకు రెండు కెమెరా భంగిమలను యాదృచ్ఛికం చేసింది, మరియు దాని ప్రాజెక్ట్ పేజీలో చాలా డేటా స్థిరమైన వీక్షణను మాత్రమే కలిగి ఉందని పేర్కొంది. DROID సర్దుబాటు చేయగల ZED 2 మౌంట్‌లను మరియు మణికట్టు ZED మినీని ఉపయోగించింది. మీరు కంటితో రెండు USB వెబ్‌క్యామ్‌లను ఉంచారు. కెమెరా భంగిమ అనేది ఒక ఇబ్బందికరమైన వేరియబుల్ కాదు ; ఇది విజువల్ ఎన్‌కోడర్ ఆధారపడిన వాటిలో చాలా భాగం, మరియు ఫైల్ ఫార్మాట్‌లో ఏదీ భంగిమలు భిన్నంగా ఉన్నాయని మీకు చెప్పదు.

ఒక రోజును తినే ఉచ్చు

భాగాలు అమలు చేయడానికి సరిపోయేంత బాగా సరిపోతాయి. డేటాసెట్ లోడ్ అవుతుంది, శిక్షణ ప్రారంభమవుతుంది, నష్టం తగ్గుతుంది, చెక్‌పాయింట్‌లు కనిపిస్తాయి, ఎటువంటి లోపాలు లేవు. అప్పుడు పాలసీ చేతిపై గుర్తించదగినది ఏమీ చేయదు మరియు మీరు మీ శిక్షణ స్క్రిప్ట్‌లో బగ్‌ను వేటాడటానికి ఒక రోజు గడుపుతారు. బగ్ లేదు: మీ గదిలో లేని రోబోట్ కోసం మోడల్ కార్టేసియన్ యాక్షన్ డిస్ట్రిబ్యూషన్‌ను నేర్చుకుంది. మీ హైపర్‌పారామీటర్‌ల వద్ద కాకుండా, నష్టం తగ్గుతుంది, పాలసీ ఏమీ చేయదు వద్ద ప్రారంభించండి.

మీరు డేటాను విలీనం చేయడానికి ప్రయత్నించినప్పుడు ఏమి జరుగుతుంది

స్పష్టమైన ప్రణాళిక ఏమిటంటే: కొన్ని వేల DROID ఎపిసోడ్‌లు ప్లస్ మీ 50ని కలపడం. LeRobot నిరాకరిస్తుంది, మరియు ఆ నిరాకరణ మూడు విభిన్న విషయాలను పేర్కొంటుంది.

  1. 1
    పూర్తి 1.7 TB కాకుండా, 100-ఎపిసోడ్ నమూనాను లాగండి.

    2 GB నిర్మాణం చూడటానికి సరిపోతుంది.

    bash
    pip install gsutil tensorflow tensorflow-datasets
    gsutil -m cp -r gs://gresearch/robotics/droid_100 ~/tensorflow_datasets/
  2. 2
    RLDS ను LeRobot రూపంలోకి మార్చండి.

    openx2lerobot OXE ప్రామాణిక మార్పులను చుట్టి, రోబోట్ రకం మరియు నియంత్రణ ఫ్రీక్వెన్సీని వివరిస్తుంది. README దీనిని 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
    మరేదైనా చేసే ముందు meta/info.json చదవండి.

    మీ మిగిలిన రోజు పని చేస్తుందో లేదో ఈ ఫైల్ నిర్ణయిస్తుంది.

    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
    విలీనం చేసి, లోపాన్ని చదవండి.

    merge ప్రతి డేటాసెట్‌ను లోడ్ చేస్తుంది, ఆపై validate_all_metadata జాబితాలోని మొదటి దానితో fps, robot_type మరియు features ను తనిఖీ చేస్తుంది, మొదటి సరిపోలని దానిపై లోపాన్ని పెంచుతుంది.

    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.

మీరు మొదట జాబితా చేసిన డేటాసెట్ నుండి రిఫరెన్స్ విలువలు వస్తాయి, అందుకే సందేశం DROID యొక్క 15 fps కాకుండా మీ 30 fps గురించి ఫిర్యాదు చేస్తుంది. fps ను సరిచేస్తే, మీరు robot_type తనిఖీని ఎదుర్కొంటారు; దానిని సరిచేస్తే, మీరు ఫీచర్ తనిఖీని ఎదుర్కొంటారు, చర్య కోసం 6కి వ్యతిరేకంగా 7. ఏ క్రమం కూడా ఆమోదించబడదు, మరియు sanity_check_dataset_robot_compatibility ద్వారా రికార్డు సమయంలో అదే గార్డు నడుస్తుంది.

తనిఖీని ఓడించడానికి robot_type ను హార్డ్‌కోడ్ చేయవద్దు.

ప్రస్తుత LeRobot మెయిన్‌లో so100_follower మరియు so101_follower రెండూ ఒకే భాగస్వామ్య SOFollowerRobotConfig పై నమోదు చేయబడ్డాయి, కాబట్టి నిజమైన రికార్డింగ్ నుండి వచ్చే స్ట్రింగ్ మీరు ఆశించినది కాకపోవచ్చు. మీ స్వంత meta/info.json నుండి దానిని చదవండి, మరియు మీరు నిలిపివేయవలసి వచ్చిన తనిఖీని మీకు ఏదో చెబుతున్న తనిఖీగా పరిగణించండి.

అసలు ఏమి బదిలీ అవుతుంది?

ఎపిసోడ్‌లు కాదు, వెయిట్‌లు. ప్రతి ఆధునిక జనరలిస్ట్ పాలసీ ప్రీట్రైనింగ్‌లో కొంత భాగాన్ని గ్రహించింది, మరియు మీరు విడుదలైన నుండి వారసత్వంగా పొందుతారు, దానిని సరిగ్గా చేయడానికి అవసరమైన కంప్యూట్ ఉన్న వ్యక్తులచే ఇప్పటికే సమన్వయం చేయబడింది. pi0 యొక్క పేపర్ నిష్పత్తి గురించి స్పష్టంగా ఉంది: దాని ప్రీ-ట్రైనింగ్ మిశ్రమంలో 9.1 శాతం, టైమ్‌స్టెప్‌లలో లెక్కించబడినది, OXE, Bridge v2 మరియు DROID తో సహా ఓపెన్-సోర్స్ డేటా. ఆ సంఖ్య pi0 యొక్కది; ప్రతి విక్రేత యొక్క మిశ్రమం భిన్నంగా ఉంటుంది.

SO-100 ప్రాజెక్ట్‌పై పబ్లిక్ క్రాస్-ఎంబోడిమెంట్ డేటా
ప్రయోజనాలు
  • విజువల్ మరియు భాషా ప్రయర్‌లు: ఎన్‌కోడర్ వేలకొలది వంటశాలలు మరియు మగ్‌లను చూసింది మరియు "ఎరుపు బ్లాక్" దేనిని సూచిస్తుందో తెలుసు.
  • మ్యానిప్యులేషన్ నిర్మాణంపై ఒక ప్రయర్: చేరుకోవడం, మూయడం, ఎత్తడం, రవాణా చేయడం, విడుదల చేయడం, సంఖ్యలు కానప్పటికీ ఎంబోడిమెంట్-స్వతంత్రంగా ఉంటుంది.
  • పరీక్ష కోసం తెలిసిన-మంచి డేటాసెట్. మీ పని 100 DROID ఎపిసోడ్‌లను ఓవర్‌ఫిట్ చేయలేకపోతే, సమస్య మీ సెటప్‌లో ఉంది.
  • రిఫరెన్స్ పాయింట్‌లు: చిన్న-స్థాయి డేటాసెట్ డొమైన్‌లలో RT-1-X అసలు పద్ధతి లేదా RT-1 కంటే 50 శాతం ఎక్కువ సగటు విజయ రేటును సాధించింది, మరియు RT-2-X ఉద్భవిస్తున్న నైపుణ్యాలపై RT-2ని సుమారు 3x అధిగమించింది.
పరిమితులు
  • ఉపయోగపడే చర్య పర్యవేక్షణ లేదు. 7-D కార్టేసియన్ టార్గెట్ 6-D జాయింట్ కమాండ్ కాదు.
  • కెమెరా-పోజ్ బదిలీ లేదు, మరియు డేటాలో ఏదీ పోజ్‌లు భిన్నంగా ఉన్నాయని మీకు చెప్పదు.
  • టైమింగ్ బదిలీ లేదు: 30 fps రికార్డర్‌కు వ్యతిరేకంగా 3, 5 మరియు 15 fps సోర్స్‌లు.
  • గ్రిప్పర్ బదిలీ లేదు. Robotiq 2F-85 మరియు STS3215 పై ముద్రించిన దవడ బలం, స్ట్రోక్ మరియు డైనమిక్స్‌లో విభిన్నంగా ఉంటాయి.
  • దాని రచయితలకు కూడా స్కేల్ మాత్రమే సరిపోలేదు: పెద్ద-డేటాసెట్ డొమైన్‌లలో RT-1-X ఆ డేటాసెట్‌పై మాత్రమే శిక్షణ పొందిన RT-1ని అధిగమించలేదు.
  • మీకు అవసరమైన మీ స్వంత ఎపిసోడ్‌ల సంఖ్యలో తగ్గింపు లేదు.
మోడల్ యొక్క లేయర్బదిలీ అవుతుందా?ఎందుకు
Vision encoderఅవును, బలంగావస్తువులు మరియు దృశ్యాలు ఎంబోడిమెంట్-స్వతంత్రంగా ఉంటాయి
Language groundingఅవునుసూచనలు టెక్స్ట్, జ్యామితి కాదు
Cross-modal fusionఎక్కువగాప్రాంప్ట్‌లో పేర్కొన్న వస్తువుపై దృష్టి సారిస్తుంది
Proprioception encoderలేదుఇన్‌పుట్ డైమెన్షన్ మరియు జాయింట్ సెమాంటిక్స్ విభిన్నంగా ఉంటాయి
Action headలేదుమీరు లేని 7-D కార్టేసియన్ స్పేస్‌లో శిక్షణ పొందింది
Normalisation statisticsలేదు, మరియు ప్రమాదకరంవిదేశీ గణాంకాలు ప్రతి కమాండ్‌ను మారుస్తాయి

ఇది ఎందుకంటే SmolVLA తక్కువ-ధర ఆర్మ్‌పై భిన్నంగా ప్రవర్తిస్తుంది. దీని పేపర్ హగ్గింగ్ ఫేస్ నుండి 481 కమ్యూనిటీ డేటాసెట్‌లను ఎంచుకుంటుంది, ఇవి ఎంబోడిమెంట్ రకం, ఎపిసోడ్ కౌంట్, డేటా నాణ్యత మరియు ఫ్రేమ్ కవరేజ్ ద్వారా ఫిల్టర్ చేయబడ్డాయి: 22.9K ఎపిసోడ్‌లు, 10.6M ఫ్రేమ్‌లు, నిజమైన SO-100 మరియు SO-101 ఆర్మ్‌లపై మూల్యాంకనం చేయబడ్డాయి. చిన్నది మరియు సరిపోలినది పెద్దది మరియు సరిపోలని దానిని అధిగమిస్తుంది. దీనిపై పోల్చండి ACT against SmolVLA.

తీసుకోవలసిన మూడు మార్గాలు

మార్గం A: ఇప్పటికే డేటాను స్వీకరించిన చెక్‌పాయింట్ నుండి ఫైన్-ట్యూన్ చేయండి

చాలా మంది దీనిని తీసుకోవాలి. మీరు DROID లేదా Open X-Embodiment ను ఎప్పుడూ తాకరు: క్రాస్-ఎంబోడిమెంట్ డేటాను ఇప్పటికే గ్రహించిన ప్రీట్రైనింగ్ ఉన్న పాలసీని ఎంచుకోండి, మీ స్వంత ఎపిసోడ్‌లను రికార్డ్ చేయండి, ఫైన్-ట్యూన్ చేయండి.

పాలసీపారామీటర్లుకనీస ఎపిసోడ్‌లుడేటాసెట్ ఫార్మాట్GPU శ్రేణిఇన్‌ఫరెన్స్బేస్ చెక్‌పాయింట్
GR00T N1.7~3 B, ~40 M ఫైన్-ట్యూనింగ్‌లో శిక్షణ పొందింది50LeRobot v2.0 or v2.1A100 or H100 80 GB152 ms per stepnvidia/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 msఏదీ లేదు, మొదటి నుండి

ACT అనేది నిజాయితీ గల అంచు కేసు: బేస్ మోడల్ లేదు, కాబట్టి పబ్లిక్ డేటా ఏదీ దానిని చేరుకోదు. ఇది స్వయంచాలకంగా ప్రతికూలత కాదు, ఎందుకంటే ప్రతి చర్య దశకు 20 ms వద్ద, వేగవంతమైన లూప్‌ను మూసివేయగల ఐదు మోడల్‌లలో ఇది ఒక్కటే, ACT పేజీ వివరించినట్లు. పనిని బట్టి ఎంచుకోండి ఐదు మోడల్‌ల పోలిక, GR00T N1.7 వర్సెస్ Pi0.5, మరియు 85 మోడల్‌లలో 332 బెంచ్‌మార్క్ ఫలితాలు అరేనాలో.

మార్గం B: DROIDని టెస్ట్ ఫిక్చర్‌గా ఉపయోగించండి

100-ఎపిసోడ్ నమూనా ఈ నెలలో మీరు డౌన్‌లోడ్ చేసుకునే ఉత్తమ 2 GB, మరియు శిక్షణ కోసం కాదు. ఇది మీకు సరైనదని తెలిసిన డేటాసెట్. దానిపై మీ కన్వర్టర్, లోడర్ మరియు చిన్న GPU పనిని అమలు చేయండి; విఫలమైన ఏదైనా చౌకగా ఉన్నప్పుడు కనుగొనబడిన మౌలిక సదుపాయాల బగ్. NVIDIA అదే విధంగా పెద్ద ఎత్తున చేస్తుంది: GR00T N1.7 కార్డ్ సింప్లర్‌ఎన్విలో బ్రిడ్జ్ మరియు ఫ్రాక్టల్, DROID మరియు LIBERO కోసం నాలుగు పోస్ట్-ట్రైన్డ్ వేరియంట్‌లను జాబితా చేస్తుంది.

మార్గం C: మీ స్వంతంగా, ఉద్దేశపూర్వకంగా రికార్డ్ చేయండి

ముప్పై నుండి యాభై ఎపిసోడ్‌లు 76,000 పక్కన చిన్నదిగా అనిపిస్తుంది, మీ చేతి, మీ కెమెరాలు మరియు మీ టేబుల్‌తో మీవి మాత్రమే ఉన్నాయని మీరు గుర్తుంచుకునే వరకు. LeRobot డిఫాల్ట్‌ల ప్రకారం, 50 ఎపిసోడ్‌లు 100 నిమిషాల వాల్ క్లాక్ సమయం. చూడండి మీ మొదటి డేటాసెట్‌ను రికార్డ్ చేయండి, SO-100 డేటా సేకరణ మరియు డేటా నాణ్యత గైడ్.

టెలిఆపరేషన్ సెషన్ నుండి LeRobot డేటాసెట్‌ను క్యాప్చర్ చేయడానికి దశలను చూపుతున్న AY-Robots రికార్డింగ్ ట్యుటోరియల్ పేజీ
రికార్డింగ్ వాక్‌త్రూ /learn/record-your-first-dataset వద్ద: పబ్లిక్ డేటా భర్తీ చేయలేని దశ.

పబ్లిక్ డేటా నుండి పని చేసే పాలసీకి చేరుకోవడానికి రెండు మార్గాలు

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.

The AY-Robots desktop client download page, the client that records LeRobot-format datasets from a teleoperation session
The desktop client at /download writes LeRobot datasets directly from a teleop session, sidestepping RLDS conversion.

ప్రతి మార్గం ఎంత ఖర్చవుతుంది

మార్గంనిల్వమానవ సమయంGPU ఖర్చుమీ చేయి కదిలే అవకాశం
మార్చబడిన DROID మాత్రమే392 GBమార్పిడి రోజులు4 to 12 USDచాలా తక్కువ, తప్పు చర్య స్థలం
మీ ఎపిసోడ్‌లతో DROID విలీనం చేయబడిందిరెండుvalidate_all_metadata ద్వారా నిరోధించబడిందిn/aఏమీ లేదు, అది నడవదు
SmolVLA, 30 నుండి 50 సొంత ఎపిసోడ్‌లుకొన్ని GB100 నిమిషాల రికార్డింగ్1 to 3 USDఎక్కువ
GR00T N1.7, 50 సొంత ఎపిసోడ్‌లుకొన్ని GB100 నిమిషాల రికార్డింగ్4 to 12 USDఎక్కువ
మొదటి నుండి ACT, 50 సొంత ఎపిసోడ్‌లుకొన్ని GB100 నిమిషాల రికార్డింగ్1 to 3 USDఎక్కువ, 20 ms inference
పరీక్ష ఫిక్చర్‌గా DROID నమూనా2 GBఒక మధ్యాహ్నంఒక చిన్న పరుగుఎక్కువ, ధ్రువీకరణగా

అసమానత ఇక్కడే ఉంది: ఎక్కువ డేటాను తీసుకునే మార్గం చాలా ఖరీదైనది మరియు మీ చేతిని కదిలించే అవకాశం తక్కువ. మీ స్వంత రెండు గంటల లోపు టెలిఆపరేషన్ ఇతరుల ఫ్రాంకా యొక్క టెరాబైట్ కంటే మెరుగైనది. ఇంకా చేయి లేదా? /live సైన్అప్ లేకుండా భౌతిక SO-100ని ప్రసారం చేస్తుంది. అప్పుడు మీ మొదటి పాలసీని శిక్షణ ఇవ్వండి, మరియు నిర్దిష్ట గైడ్ కోసం SO-100లో SmolVLA.

సహేతుకమైన డిఫాల్ట్ ప్రణాళిక

2 GB DROID నమూనాను డౌన్‌లోడ్ చేయండి మరియు మీ పైప్‌లైన్‌ను నిరూపించడానికి దాన్ని ఉపయోగించండి. మిగిలిన 1.7 TBని విస్మరించండి. స్థిర కెమెరాలతో ఒక పని యొక్క 50 ఎపిసోడ్‌లను రికార్డ్ చేయండి. మొదట SmolVLAని ఫైన్-ట్యూన్ చేయండి, ఎందుకంటే 24 GB కార్డ్‌లో కనీసం 30 ఎపిసోడ్‌లతో ఇది పునరావృతం చేయడానికి చౌకైనది, ఆపై అదే డేటాపై GR00T N1.7ని ప్రయత్నించండి. బెంచ్‌మార్క్‌పై కాకుండా, మీ పనిపై పోల్చండి.

మీ చేతికి ఇప్పటికే సరిపోయే డేటాసెట్‌లను రికార్డ్ చేయండి

డెస్క్‌టాప్ క్లయింట్ టెలిఆప్ సెషన్ నుండి నేరుగా LeRobot-ఫార్మాట్ డేటాసెట్‌లను వ్రాస్తుంది: సరైన చేయి, సరైన ఫ్రేమ్ రేట్, సరైన యాక్షన్ స్పేస్. RLDS మార్పిడి లేదు, రీమ్యాపింగ్ లేదు.

డెస్క్‌టాప్ క్లయింట్‌ను పొందండి
నేను DROIDలో పాలసీని శిక్షణ ఇచ్చి, దానిని నా SO-100లో అమలు చేయవచ్చా?

నేరుగా కాదు. LeRobot బిల్డ్‌లో DROID చర్యలు 15 fps వద్ద ఫ్రాంకా పాండాపై 7-D ఎండ్-ఎఫెక్టర్ ఆదేశాలు; ముడి RLDSలో అవి 6 జాయింట్ వేగాలు ప్లస్ ఒక గ్రిప్పర్ స్థానం. SO-100 6 అబ్సొల్యూట్ జాయింట్ స్థానాలను తీసుకుంటుంది. మీకు ఇన్వర్స్-కినిమాటిక్స్ లేయర్ అవసరం, అప్పుడు కూడా 5-DoF మణికట్టు ఏకపక్ష 6-DoF భంగిమలను పునరుత్పత్తి చేయదు.

నేను DROID లేదా Bridge ఎపిసోడ్‌లను నా స్వంత SO-100 ఎపిసోడ్‌లతో కలపవచ్చా?

లేదు. validate_all_metadata ఒకే fps, robot_type మరియు ఫీచర్ స్కీమాను కోరుతుంది మరియు మొదటి సరిపోలని దానిపై ValueErrorను పెంచుతుంది. మూడు విభిన్నంగా ఉంటాయి: 30కి వ్యతిరేకంగా 15 లేదా 5 fps, మీ చేతికి వ్యతిరేకంగా franka లేదా widowx, 6కి వ్యతిరేకంగా 7 యాక్షన్ ఆకారాలు. తనిఖీని పాస్ చేయడానికి మెటాడేటాను తిరిగి వ్రాయడం సెమాంటిక్స్‌ను సరిచేయదు.

తక్కువ-ధర చేతికి Open X-Embodiment పనికిరాదా?

లేదు, కానీ దాని విలువ ప్రీట్రైన్డ్ వెయిట్స్ ద్వారా మీకు చేరుతుంది, ఎపిసోడ్‌ల ద్వారా కాదు. OXE, Bridge v2 మరియు DROIDతో సహా ఓపెన్-సోర్స్ డేటాసెట్‌లు pi0 యొక్క ప్రీ-ట్రైనింగ్ మిశ్రమంలో 9.1 శాతం, మరియు NVIDIA Bridge, Fractal, DROID మరియు LIBEROపై పోస్ట్-ట్రైన్ చేయబడిన GR00T N1.7 వేరియంట్‌లను పంపుతుంది. మీరు చేయలేనిది ఏమిటంటే ఆ ఎపిసోడ్‌లను మీ స్వంత రికార్డింగ్‌కు జోడించడం.

పబ్లిక్ క్రాస్-ఎంబోడిమెంట్ డేటా నుండి ఏ పాలసీ ఎక్కువగా ప్రయోజనం పొందుతుంది?

Pi0.5 మరియు GR00T మోడల్‌లు అత్యధిక క్రాస్-ఎంబోడిమెంట్ ప్రీట్రైనింగ్‌ను కలిగి ఉంటాయి, కానీ SmolVLA తరచుగా తక్కువ-ధర చేతిపై ఉత్తమంగా పనిచేస్తుంది: దాని ప్రీట్రైనింగ్ సెట్ 481 కమ్యూనిటీ డేటాసెట్‌లు, 22.9K ఎపిసోడ్‌లు మరియు 10.6M ఫ్రేమ్‌లు, నిజమైన SO-100 మరియు SO-101 చేతులపై మూల్యాంకనం చేయబడింది. ACT దీనికి విరుద్ధం: బేస్ మోడల్ లేదు, ప్రతి యాక్షన్ స్టెప్‌కు 20 ms.

నాకు నిజంగా ఎన్ని ఎపిసోడ్‌లు అవసరం?

SmolVLA కోసం 30, GR00T N1.7, GR00T N1.5, Pi0.5 మరియు ACT కోసం 50. LeRobot యొక్క డిఫాల్ట్‌ల ప్రకారం ప్రతి ఎపిసోడ్‌కు 60 s మరియు 60 s రీసెట్ వద్ద, 50 ఎపిసోడ్‌లు 100 నిమిషాల వాల్ క్లాక్. అరువు తెచ్చుకున్న క్రాస్-ఎంబోడిమెంట్ డేటా ఆ సంఖ్యలను తగ్గించదు.

Sources

Ready for high-quality robotics data?

AY-Robots connects your robots to skilled operators worldwide.

Get Started