
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 ఆర్మ్తో ఎలా సరిపోతుంది, మరియు దానికి బదులుగా ఏమి చేయాలి. క్రింద ఉన్న ప్రతి సంఖ్య అది చెందిన పేపర్, డేటాసెట్ కార్డ్ లేదా సోర్స్ ఫైల్ నుండి వచ్చింది.
మూడు డేటాసెట్లు వాస్తవానికి ఏమి కలిగి ఉన్నాయి
| DROID | BridgeData V2 | Open X-Embodiment | |
|---|---|---|---|
| రోబోట్ | Franka Panda, 7 DoF, Robotiq 2F-85 | WidowX 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 Hz | 5 Hz | మారుతూ ఉంటుంది, 3 fps పైకి |
| కెమెరాలు | 2 x ZED 2 బాహ్య, 1 x ZED Mini మణికట్టు | 4 వరకు, చాలా ఎపిసోడ్లలో స్థిరమైనది మాత్రమే | ల్యాబ్ ఉపయోగించినది ఏదైనా |
| రా డౌన్లోడ్ | 1.7 TB RLDS, 8.7 TB రా స్టీరియో | JPEG ఆర్కైవ్లు | ప్రతి-డేటాసెట్ TFDS బకెట్లు |
కొద్దిమంది మాత్రమే ఇప్పటికీ 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 ఎండ్-ఎఫెక్టర్ చర్యగా మారుస్తారు, కానీ డేటాసెట్ల అంతటా కోఆర్డినేట్ ఫ్రేమ్లను సమలేఖనం చేయరు మరియు ప్రతి రోబోట్ యొక్క అసలు నియంత్రణ పథకం ప్రకారం చర్య విలువలను సంపూర్ణ లేదా సాపేక్ష స్థానాలు లేదా వేగంగా అనుమతిస్తారు. వారి ముగింపు: ఒకే చర్య వెక్టర్ వేర్వేరు రోబోట్లకు చాలా భిన్నమైన కదలికలను ప్రేరేపించవచ్చు.

నాలుగు భాగాలుగా అసమతుల్యత
ఎంబోడిమెంట్ మిస్మ్యాచ్ను సాధారణంగా ఒక అస్పష్టమైన సమస్యగా పరిగణిస్తారు. ఇవి నాలుగు రకాలు, అవి వేర్వేరుగా విఫలమవుతాయి, మరియు రెండింటిని స్క్రిప్టింగ్ ద్వారా పరిష్కరించలేము.
1. డిగ్రీస్ ఆఫ్ ఫ్రీడమ్
ఒక SO-100 ఐదు ఆర్మ్ జాయింట్లు మరియు ఒక గ్రిప్పర్ను కలిగి ఉంటుంది. మోటార్లుగా లెక్కించినప్పుడు అది 6-DoF ఆర్మ్, మరియు SmolVLA పేపర్ దానిని అలా పిలుస్తుంది; పొజిషనింగ్ మెకానిజంగా లెక్కించినప్పుడు అది 5-DoF, మరియు LeRobot దాని ఇన్వర్స్-కైనమాటిక్స్ డాక్స్ట్రింగ్లో దానిని అలా పిలుస్తుంది, ఇది 5-DOF SO-101లో సాఫ్ట్-ఓరియంటేషన్ IKని వివరిస్తుంది, ఇక్కడ మణికట్టు ఓరియంటేషన్ను పాక్షికంగా మాత్రమే ట్రాక్ చేస్తుంది. ఒక Franka ఏడు పొజిషనింగ్ జాయింట్లను కలిగి ఉంటుంది. ఆ అంతరం ఏ భంగిమలు ఉన్నాయో నిర్ణయిస్తుంది: 5-DoF ఆర్మ్ సాధారణంగా ఒకేసారి ఏకపక్ష స్థానం మరియు ధోరణిని చేరుకోదు, కాబట్టి సాల్వర్ అది చేరుకోగల దగ్గరి స్థానాన్ని తిరిగి ఇస్తుంది, ఇది ప్రదర్శించిన దాని నుండి భిన్నమైన కదలిక. నేపథ్యం: డిగ్రీస్ ఆఫ్ ఫ్రీడమ్.
# 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కాబట్టి, సిద్ధంగా ఉన్న 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 |
| నిశ్శబ్ద వైఫల్యం | సంపూర్ణంగా చదవబడిన డెల్టా | క్రమాంకనం చేయని చేయి |
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.7 TB కాకుండా, 100-ఎపిసోడ్ నమూనాను లాగండి.
2 GB నిర్మాణం చూడటానికి సరిపోతుంది.
bashpip install gsutil tensorflow tensorflow-datasets gsutil -m cp -r gs://gresearch/robotics/droid_100 ~/tensorflow_datasets/ - 2RLDS ను LeRobot రూపంలోకి మార్చండి.
openx2lerobot OXE ప్రామాణిక మార్పులను చుట్టి, రోబోట్ రకం మరియు నియంత్రణ ఫ్రీక్వెన్సీని వివరిస్తుంది. README దీనిని 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 - 3మరేదైనా చేసే ముందు meta/info.json చదవండి.
మీ మిగిలిన రోజు పని చేస్తుందో లేదో ఈ ఫైల్ నిర్ణయిస్తుంది.
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'])" - 4విలీనం చేసి, లోపాన్ని చదవండి.
merge ప్రతి డేటాసెట్ను లోడ్ చేస్తుంది, ఆపై validate_all_metadata జాబితాలోని మొదటి దానితో fps, robot_type మరియు features ను తనిఖీ చేస్తుంది, మొదటి సరిపోలని దానిపై లోపాన్ని పెంచుతుంది.
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.
మీరు మొదట జాబితా చేసిన డేటాసెట్ నుండి రిఫరెన్స్ విలువలు వస్తాయి, అందుకే సందేశం DROID యొక్క 15 fps కాకుండా మీ 30 fps గురించి ఫిర్యాదు చేస్తుంది. fps ను సరిచేస్తే, మీరు robot_type తనిఖీని ఎదుర్కొంటారు; దానిని సరిచేస్తే, మీరు ఫీచర్ తనిఖీని ఎదుర్కొంటారు, చర్య కోసం 6కి వ్యతిరేకంగా 7. ఏ క్రమం కూడా ఆమోదించబడదు, మరియు sanity_check_dataset_robot_compatibility ద్వారా రికార్డు సమయంలో అదే గార్డు నడుస్తుంది.
ప్రస్తుత LeRobot మెయిన్లో so100_follower మరియు so101_follower రెండూ ఒకే భాగస్వామ్య SOFollowerRobotConfig పై నమోదు చేయబడ్డాయి, కాబట్టి నిజమైన రికార్డింగ్ నుండి వచ్చే స్ట్రింగ్ మీరు ఆశించినది కాకపోవచ్చు. మీ స్వంత meta/info.json నుండి దానిని చదవండి, మరియు మీరు నిలిపివేయవలసి వచ్చిన తనిఖీని మీకు ఏదో చెబుతున్న తనిఖీగా పరిగణించండి.
అసలు ఏమి బదిలీ అవుతుంది?
ఎపిసోడ్లు కాదు, వెయిట్లు. ప్రతి ఆధునిక జనరలిస్ట్ పాలసీ ప్రీట్రైనింగ్లో కొంత భాగాన్ని గ్రహించింది, మరియు మీరు విడుదలైన నుండి వారసత్వంగా పొందుతారు, దానిని సరిగ్గా చేయడానికి అవసరమైన కంప్యూట్ ఉన్న వ్యక్తులచే ఇప్పటికే సమన్వయం చేయబడింది. pi0 యొక్క పేపర్ నిష్పత్తి గురించి స్పష్టంగా ఉంది: దాని ప్రీ-ట్రైనింగ్ మిశ్రమంలో 9.1 శాతం, టైమ్స్టెప్లలో లెక్కించబడినది, OXE, Bridge v2 మరియు DROID తో సహా ఓపెన్-సోర్స్ డేటా. ఆ సంఖ్య pi0 యొక్కది; ప్రతి విక్రేత యొక్క మిశ్రమం భిన్నంగా ఉంటుంది.
- విజువల్ మరియు భాషా ప్రయర్లు: ఎన్కోడర్ వేలకొలది వంటశాలలు మరియు మగ్లను చూసింది మరియు "ఎరుపు బ్లాక్" దేనిని సూచిస్తుందో తెలుసు.
- మ్యానిప్యులేషన్ నిర్మాణంపై ఒక ప్రయర్: చేరుకోవడం, మూయడం, ఎత్తడం, రవాణా చేయడం, విడుదల చేయడం, సంఖ్యలు కానప్పటికీ ఎంబోడిమెంట్-స్వతంత్రంగా ఉంటుంది.
- పరీక్ష కోసం తెలిసిన-మంచి డేటాసెట్. మీ పని 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 ఫైన్-ట్యూనింగ్లో శిక్షణ పొందింది | 50 | LeRobot v2.0 or v2.1 | A100 or H100 80 GB | 152 ms per step | 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 | ఏదీ లేదు, మొదటి నుండి |
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 డేటా సేకరణ మరియు డేటా నాణ్యత గైడ్.

పబ్లిక్ డేటా నుండి పని చేసే పాలసీకి చేరుకోవడానికి రెండు మార్గాలు
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.

ప్రతి మార్గం ఎంత ఖర్చవుతుంది
| మార్గం | నిల్వ | మానవ సమయం | GPU ఖర్చు | మీ చేయి కదిలే అవకాశం |
|---|---|---|---|---|
| మార్చబడిన DROID మాత్రమే | 392 GB | మార్పిడి రోజులు | 4 to 12 USD | చాలా తక్కువ, తప్పు చర్య స్థలం |
| మీ ఎపిసోడ్లతో DROID విలీనం చేయబడింది | రెండు | validate_all_metadata ద్వారా నిరోధించబడింది | n/a | ఏమీ లేదు, అది నడవదు |
| SmolVLA, 30 నుండి 50 సొంత ఎపిసోడ్లు | కొన్ని GB | 100 నిమిషాల రికార్డింగ్ | 1 to 3 USD | ఎక్కువ |
| GR00T N1.7, 50 సొంత ఎపిసోడ్లు | కొన్ని GB | 100 నిమిషాల రికార్డింగ్ | 4 to 12 USD | ఎక్కువ |
| మొదటి నుండి ACT, 50 సొంత ఎపిసోడ్లు | కొన్ని GB | 100 నిమిషాల రికార్డింగ్ | 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
- DROID: పెద్ద ఎత్తున, సహజ వాతావరణంలో రోబోట్ మానిప్యులేషన్ డేటాసెట్
- DROID డాక్యుమెంట్లు: డౌన్లోడ్ పరిమాణాలు మరియు RLDS ఎపిసోడ్ స్కీమా
- BridgeData V2: పెద్ద ఎత్తున రోబోట్ లెర్నింగ్ కోసం ఒక డేటాసెట్
- BridgeData V2 ప్రాజెక్ట్ పేజీ: కూర్పు మరియు కెమెరా కవరేజ్
- Open X-Embodiment: రోబోటిక్ లెర్నింగ్ డేటాసెట్లు మరియు RT-X మోడల్స్
- Open X-Embodiment ప్రాజెక్ట్ పేజీ
- google-deepmind/open_x_embodiment: డేటాసెట్ జాబితా మరియు RT-1-X చెక్పాయింట్లు
- any4lerobot: openx2lerobot కన్వర్టర్ మరియు దాని ఏకీకృత 8-D స్థితి, 7-D చర్య
- IPEC-COMMUNITY/droid_lerobot: meta/info.json మరియు రెపో పరిమాణం
- IPEC-COMMUNITY/bridge_orig_lerobot: meta/info.json
- IPEC-COMMUNITY/fractal20220817_data_lerobot: 3 fps వద్ద google_robot స్లైస్
- huggingface/lerobot: SO ఫాలోవర్, కైనమాటిక్స్ ప్రాసెసర్, అగ్రిగేట్ మరియు రికార్డ్ కాన్ఫిగ్లు
- openpi: DROID పాలసీ ఇన్పుట్లు మరియు pi05_droid చెక్పాయింట్
- pi0: సాధారణ రోబోట్ నియంత్రణ కోసం ఒక విజన్-లాంగ్వేజ్-యాక్షన్ ఫ్లో మోడల్
- SmolVLA: సరసమైన మరియు సమర్థవంతమైన రోబోటిక్స్ కోసం ఒక విజన్-లాంగ్వేజ్-యాక్షన్ మోడల్
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