SO-100తో మీ మొదటి LeRobot డేటాసెట్‌ను రికార్డ్ చేయండి

ఒక SO-100 ఫాలోవర్, అదే డిజైన్‌తో కూడిన లీడర్ ఆర్మ్ మరియు రెండు USB కెమెరాలు ఒక మధ్యాహ్నంలో ఒక పాలసీని ఫైన్-ట్యూన్ చేయగలవు. అదే బెంచ్ ఫైల్ బ్రౌజర్‌లో ఆరోగ్యంగా కనిపించే అరవై ఎపిసోడ్‌లను సులభంగా ఉత్పత్తి చేయగలదు మరియు ఆరు గంటల GPU రన్‌ను వృథా చేయగలదు. తేడా చాలా అరుదుగా మోడల్‌లో ఉంటుంది; ఇది సర్వోలు మరియు పారేక్ ఫైల్ మధ్య ఏమి జరిగిందో దానిలో ఉంటుంది.

ఇది మాన్యువల్ మార్గం, ఆపై చిన్నది. ప్రతి కమాండ్ lerobot 0.6.1 నుండి వచ్చింది, ఇది 3 ఆగస్టు 2026న విడుదల చేయబడింది మరియు PyPIలో ప్రస్తుత వెర్షన్. ఇది కన్సోల్ ఎంట్రీ పాయింట్‌లకు మారింది, కాబట్టి python lerobot/scripts/control_robot.py నడిపే ట్యుటోరియల్‌లు ఇకపై లేని ఫైల్‌ను వివరిస్తాయి.

రికార్డింగ్ సెషన్ ఏమి సంగ్రహిస్తుంది

ఒక LeRobot డేటాసెట్ అనేది వీడియోల ఫోల్డర్ కాదు, కానీ వీడియోతో జతచేయబడిన సమయ-సూచిక పట్టిక: ప్రతి కంట్రోల్-లూప్ టిక్ ఆదేశించిన చర్య, అనుచరుడు చేరుకున్న స్థితి, ప్రతి కెమెరాకు ఒక ఫ్రేమ్, ఒక టైమ్‌స్టాంప్ మరియు సూచికలను కలిగి ఉన్న ఒక అడ్డు వరుసను వ్రాస్తుంది. పాలసీ ఆ నిలువు వరుసలను మాత్రమే చూస్తుంది. యొక్క స్కీమా lerobot/svla_so100_pickplace, దాని meta/info.json నుండి చదవబడింది.

జాయింట్లు main_shoulder_pan, main_shoulder_lift, main_elbow_flex, main_wrist_flex, main_wrist_roll మరియు main_gripper: SO-100 యొక్క ఆరు డిగ్రీస్ ఆఫ్ ఫ్రీడమ్. చర్య మరియు స్థితి ఒకే ఆకారాన్ని పంచుకుంటాయి ఎందుకంటే లీడర్-ఫాలోవర్ టెలిఆపరేషన్ ఒక లక్ష్యాన్ని మరియు ఒక అడుగు తర్వాత చేరుకున్న స్థానాన్ని రికార్డ్ చేస్తుంది. ఆ అంతరం సమాచారం: చేయి గురుత్వాకర్షణతో లేదా చిక్కుకున్న వస్తువుతో ఎక్కడ పోరాడిందో. ఆ స్ట్రింగ్‌లు ఆ డేటాసెట్‌కు చెందినవి. ఈరోజు 0.6.1తో రికార్డ్ చేయబడిన సెషన్ shoulder_pan.pos నుండి gripper.pos వరకు, బస్సులో 1 నుండి 6 వరకు ఐడిలను వ్రాస్తుంది: అదే ఆరు జాయింట్లు, విభిన్న కీలు, ఇది ఒక కాన్ఫిగ్ పేరు ద్వారా ఒక ఫీచర్‌ను అడ్రస్ చేసినప్పుడు ముఖ్యమైనది.

మీకు బెంచ్‌పై అవసరమైనవి

చేయి ఇంకా నిర్మించబడకపోతే, అది వేరే పని: ఇక్కడ ప్రారంభించండి SO-100 ప్రారంభించడం మరియు పూర్తి SO-100 సెటప్ గైడ్. మీరు ఇంకా ఏమీ కొనుగోలు చేయకపోతే, ముందుగా SO-100 వర్సెస్ SO-101 పోలిక చదవండి: SO-101 అనేది మెరుగైన వైరింగ్ మరియు గేర్-తొలగింపు దశ లేని కొత్త వెర్షన్, మరియు రికార్డింగ్ వర్క్‌ఫ్లో ఒకే విధంగా ఉంటుంది.

lerobot 0.6.1 ఇన్‌స్టాల్ చేయండి

conda create -y -n lerobot python=3.12
conda activate lerobot

# TorchCodec is the default video decoder and needs ffmpeg
conda install ffmpeg -c conda-forge

# core_scripts = dataset + hardware + viz extras (record, replay, calibrate)
# feetech     = SDK for the STS3215 bus servos in the SO-100
pip install 'lerobot[core_scripts,feetech]'

lerobot-info

అదనపు అంశాలు చాలా మందిని గందరగోళానికి గురిచేస్తాయి. pip install lerobot కేవలం కోర్ ML డిపెండెన్సీలను మాత్రమే ఇన్‌స్టాల్ చేస్తుంది, రోబోట్‌తో మాట్లాడేది ఏమీ కాదు. కోచ్ ఆర్మ్స్‌కు dynamixel బదులుగా feetech అవసరం. మీ షెల్ lerobot-record గురించి ఎప్పుడూ వినకపోతే, దీనికి కారణం ఇదే.

పోర్ట్‌లు, మోటార్ IDలు మరియు క్రమాంకనం

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

1. 1
   ప్రతి చేయి యొక్క USB పోర్ట్‌ను కనుగొనండి

   రెండు చేతులు ప్లగ్ ఇన్ చేసి అమలు చేయండి, ప్రాంప్ట్ చేసినప్పుడు మీరు గుర్తించే దానిని అన్‌ప్లగ్ చేయండి మరియు ఏ పోర్ట్ అదృశ్యమవుతుందో గమనించండి. Linuxలో మీకు sudo chmod 666 /dev/ttyACM0 అవసరం కావచ్చు.

   bash

   lerobot-find-port
   # Finding all available ports for the MotorsBus.
   # Ports before disconnecting: ['/dev/ttyACM0', '/dev/ttyACM1']
   # Remove the USB cable from your MotorsBus and press Enter when done.
   # The port of this MotorsBus is '/dev/ttyACM1'
   # Reconnect the USB cable.

2. 2
   మోటార్ IDలు మరియు బాడ్‌రేట్‌లను వ్రాయండి

   IDలు ఒక మోటారుకు ఒకసారి వ్రాయబడతాయి మరియు డాక్యుమెంటేషన్ ఎలా చేయాలో కఠినంగా ఉంటుంది: కంట్రోలర్ బోర్డుకు సరిగ్గా ఒక మోటారును కనెక్ట్ చేయండి, ఇంకా దేనికీ డేజీ-చైన్ చేయవద్దు. స్క్రిప్ట్ గ్రిప్పర్ కోసం ముందుగా అడిగి దానికి ID 6 ఇస్తుంది, ఆపై wrist_rollకు 5, shoulder_panకు 1 వరకు వెనుకకు నడుస్తుంది. అసెంబ్లీకి ముందు దీన్ని చేయండి.

   bash

   lerobot-setup-motors \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0
   
   lerobot-setup-motors \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1

3. 3
   రెండు చేతులను క్రమాంకనం చేయండి

   ప్రతి జాయింట్‌ను దాని పరిధి మధ్యలోకి తరలించండి, ఎంటర్ నొక్కండి, ఆపై ప్రతి దానిని దాని పూర్తి పరిధిలో స్వీప్ చేయండి. id ప్రొఫైల్ ఫైల్‌పేరు అవుతుంది.

   bash

   lerobot-calibrate \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_so100_follower
   
   lerobot-calibrate \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_so100_leader

4. 4
   ఏదైనా రికార్డ్ చేయడానికి ముందు టెలిఆపరేట్ చేయండి

   పైన పేర్కొన్న అన్నింటికీ ఆమోద పరీక్ష. టెలిఆపరేషన్ అస్థిరంగా, అద్దంలో ఉన్నట్లుగా, లేదా ఒక జాయింట్ అనుసరించకపోతే, రికార్డింగ్ దానిని 50 ఎపిసోడ్‌లలో భద్రపరుస్తుంది.

   bash

   lerobot-teleoperate \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM0 \
       --robot.id=my_so100_follower \
       --teleop.type=so100_leader \
       --teleop.port=/dev/ttyACM1 \
       --teleop.id=my_so100_leader \
       --display_data=true

పాలసీ ఏమి చూస్తుందో కెమెరాలు నిర్ణయిస్తాయి

lerobot-find-cameras opencv   # or: lerobot-find-cameras realsense

# --- Detected Cameras ---
# Camera #0:
#   Name: OpenCV Camera @ 0
#   Type: OpenCV
#   Id: 0
#   Backend api: AVFOUNDATION
#   Default stream profile:
#     Format: 16.0
#     Width: 1920
#     Height: 1080
#     Fps: 15.0

రెండు వీక్షణలు, అవి ఎక్కడ ఉన్నాయో ముఖ్యం: వర్క్‌స్పేస్‌ను కవర్ చేసే స్థిరమైన సీన్ కెమెరా, మరియు ఎండ్-ఎఫెక్టర్ దగ్గర ఉన్న రిస్ట్ కెమెరా గ్రిప్పర్ దేనిని తాకబోతుందో చూపిస్తుంది. LeRobot కమ్యూనిటీ-డేటాసెట్‌ల చెక్‌లిస్ట్ 480x640 / 720p లేదా అంతకంటే మెరుగైన రెండు వీక్షణలు, స్థిరమైన నేపథ్యం, తటస్థ స్థిరమైన లైటింగ్, మరియు లీడర్ ఆర్మ్ మరియు మానవ అవయవాలు ఫ్రేమ్ వెలుపల ఉండాలని కోరుతుంది. రికార్డింగ్ గైడ్ ఒక సాధారణ నియమాన్ని జోడిస్తుంది: కెమెరా చిత్రాలను మాత్రమే చూసి మీరు పనిని మీరే చేయగలగాలి.

రికార్డ్ కమాండ్ మరియు ప్రతి ఫ్లాగ్

HF_USER=$(NO_COLOR=1 hf auth whoami | awk -F': *' 'NR==1 {print $2}')

lerobot-record \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_so100_follower \
    --robot.cameras="{ top: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
    --teleop.type=so100_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_so100_leader \
    --display_data=true \
    --dataset.repo_id=${HF_USER}/so100_pick_cube \
    --dataset.single_task="Pick the red cube and drop it in the box" \
    --dataset.num_episodes=50 \
    --dataset.fps=30 \
    --dataset.episode_time_s=25 \
    --dataset.reset_time_s=10 \
    --dataset.streaming_encoding=true \
    --dataset.encoder_threads=2

క్రింద ఉన్న డిఫాల్ట్‌లు src/lerobot/configs/dataset.py మెయిన్ నుండి వచ్చాయి, ట్యుటోరియల్ నుండి కాదు. చాలా మంది ఊహించినవి కావు.

సెషన్ సమయంలో కీబోర్డ్ నియంత్రణ

• కుడి బాణం లేదా n: ఎపిసోడ్‌ను ముగించండి లేదా దశను ముందుగానే రీసెట్ చేయండి. మీరు ఎక్కువగా ఉపయోగించే కీ ఇది, ఎందుకంటే శుభ్రమైన పట్టుకు 25 సెకన్లు చాలా అరుదుగా అవసరం.
• ఎడమ బాణం లేదా r: ఎపిసోడ్‌ను విస్మరించండి మరియు మళ్లీ చేయండి. చెడ్డ టేక్ ఇప్పుడు ఏమీ ఖర్చు చేయదు, కానీ తర్వాత చాలా ఖర్చు అవుతుంది.
• Escape లేదా q: సెషన్‌ను ఆపండి, ఎన్‌కోడింగ్‌ను పూర్తి చేయండి, అప్‌లోడ్ చేయండి.
• ఇవి X11, Wayland మరియు హెడ్‌లెస్ SSH లలో పనిచేస్తాయి: గ్లోబల్ కీ బ్యాకెండ్ లేనప్పుడు, lerobot-record నియంత్రణ టెర్మినల్ నుండి అదే కీలను చదువుతుంది. బాణం సీక్వెన్స్‌లు విడిపోయే లాగీ SSH లింక్‌లలో కూడా అక్షరాలు పనిచేస్తాయి.
• కీబోర్డ్ టెలిఆపరేషన్ భిన్నంగా ఉంటుంది మరియు గ్లోబల్ బ్యాకెండ్ అవసరం: X11, Windows, లేదా Accessibilityతో macOS.

ఎన్ని ఎపిసోడ్‌లు, మరియు మంచి ఎపిసోడ్ ఎలా ఉంటుంది

రికార్డింగ్ గైడ్ మొదటి పని కోసం కనీసం 50 ఎపిసోడ్‌లను సూచిస్తుంది, ప్రతి వస్తువు స్థానానికి సుమారు 10. పాలసీ పేజీలు ప్రతి మోడల్‌కు కనీస సంఖ్యను జాబితా చేస్తాయి, దీని కంటే తక్కువ రన్ GPU సమయానికి విలువైనది కాదు.

మెరుగైన ప్రశ్న ఏమిటంటే, ఎన్ని మరియు దేనివి. రోబోటిక్ మానిప్యులేషన్ కోసం ఇమిటేషన్ లెర్నింగ్‌లో డేటా స్కేలింగ్ నియమాలు (లిన్ ఎట్ అల్., 2024) 40,000 కంటే ఎక్కువ ప్రదర్శనలను సేకరించి, 15,000 కంటే ఎక్కువ వాస్తవ-ప్రపంచ రోల్‌అవుట్‌లను నిర్వహించింది. సాధారణీకరణ వాతావరణాలు మరియు వస్తువుల సంఖ్యతో సుమారుగా పవర్-లా సంబంధాన్ని అనుసరించింది, మరియు ప్రతి వాతావరణం లేదా వస్తువుకు ఒక పరిమితిని దాటిన తర్వాత, అదనపు ప్రదర్శనలు తక్కువ ప్రభావాన్ని చూపాయి. ఒక బెంచ్‌పై: వస్తువును తరలించండి, లైటింగ్‌ను మార్చండి, క్యూబ్‌ను మార్చండి, ఒకే టేక్‌ను పునరావృతం చేయకుండా.

ఒక మంచి ఎపిసోడ్ బోరింగ్‌గా ఉంటుంది: పునరావృతమయ్యే హోమ్ పోజ్, ఒక పని పూర్తయింది, వస్తువు డబ్బాలో పడిన తర్వాత ముగిసింది, చెక్‌లిస్ట్ సిఫార్సు చేసిన 25 నుండి 50 అక్షరాలలో టాస్క్ స్ట్రింగ్. Pick the red cube and drop it in the box అనేది ఒక టాస్క్ స్ట్రింగ్; task1 అనేది చెక్‌లిస్ట్ స్పష్టంగా పేర్కొన్న యాంటీ-ప్యాటర్న్. అస్పష్టమైన ఉల్లేఖనాలు దాని సమస్యల జాబితాలో అగ్రస్థానంలో ఉన్నాయి, మరియు అవి కు చాలా ముఖ్యమైనవి, ఇక్కడ స్ట్రింగ్ ఒక మోడల్ ఇన్‌పుట్, ఫైల్‌నేమ్ కాదు.

డేటాసెట్‌ను నిశ్శబ్దంగా నాశనం చేసే లోపాలు

ఏదీ మినహాయింపును విసిరివేయదు. అన్నీ శిక్షణలోకి ప్రవేశిస్తాయి, చక్కగా కనిపించే లాస్ కర్వ్‌గా మరియు ఏమీ చేయని రోబోట్‌గా బయటపడతాయి. దృశ్యం సెట్ చేయబడినప్పుడు తనిఖీ చేయండి.

ఒక హెచ్చరిక: స్ట్రీమింగ్-ఎన్‌కోడింగ్ గైడ్ యొక్క పట్టిక డిఫాల్ట్‌ను ఇలా జాబితా చేస్తుంది True, అయితే మెయిన్‌లోని డేటాక్లాస్ ఇలా చదువుతుంది streaming_encoding: bool = False. డాక్యుమెంట్లు మరియు కోడ్ ఏకీభవించవు, కాబట్టి దీన్ని స్పష్టంగా సెట్ చేయండి; ఫ్లాగ్ ఆఫ్ చేయబడినప్పుడు lerobot ఎల్లప్పుడూ దీన్ని సిఫార్సు చేస్తూ ఒక సూచనను లాగ్ చేస్తుంది.

GPU అద్దెకు తీసుకునే ముందు డేటాసెట్‌ను తనిఖీ చేయండి

డాక్యుమెంట్ల నుండి అంగీకార పరీక్ష: వీడియో వ్యవధిని CLI నివేదించిన ఎపిసోడ్ వ్యవధితో పోల్చండి మరియు అడ్డు వరుసల సంఖ్య fps సార్లు వ్యవధికి సమానమని నిర్ధారించండి. మొత్తం మీద కాదు, ప్రతి ఎపిసోడ్‌కు.

from lerobot.datasets import LeRobotDataset

ds = LeRobotDataset("your-user/so100_pick_cube_20260823_141530")
print("fps:", ds.fps, "frames:", ds.num_frames)

# In v3.0 the per-episode records live in meta/episodes/ as chunked parquet:
# lengths, tasks and offsets into the shared parquet and mp4 shards.
# They load through the datasets stack, so this is a datasets.Dataset --
# use .column_names and integer indexing, not pandas .columns / .head().
eps = ds.meta.episodes
print(eps.column_names)
print(eps[0])

# Global feature statistics, including per-joint min and max.
# A joint whose min equals its max never moved. A joint sitting at a
# hard limit for most of the run is the one that will stall the policy.
print(ds.meta.stats["observation.state"])

ఆపై దానిని చూడండి. lerobot-dataset-viz కెమెరా వీక్షణల పక్కన జాయింట్ ట్రేస్‌లతో ఒక ఎపిసోడ్‌ను ఫ్రేమ్ బై ఫ్రేమ్ రీప్లే చేస్తుంది, Rerun లేదా Foxgloveలో. మార్చబడిన కెమెరాలు మరియు స్తంభింపచేసిన ఫ్రేమ్‌లు పది సెకన్లలో కనిపిస్తాయి. ప్రజలు ఈ దశను దాటవేస్తారు.

# Replay one episode with camera views and joint traces
lerobot-dataset-viz \
    --repo-id your-user/so100_pick_cube_20260823_141530 \
    --episode-index 0

# Foxglove instead, for a seekable, scrubbable timeline
lerobot-dataset-viz \
    --repo-id your-user/so100_pick_cube_20260823_141530 \
    --episode-index 0 \
    --display-mode foxglove

# Drop the episodes that did not survive review
lerobot-edit-dataset \
    --repo_id your-user/so100_pick_cube_20260823_141530 \
    --new_repo_id your-user/so100_pick_cube_clean \
    --operation.type delete_episodes \
    --operation.episode_indices "[3, 17, 41]"

v2.1 లేదా v3.0: రికార్డ్ చేసే ముందు నిర్ణయించుకోండి

v2.1 ప్రతి ఎపిసోడ్‌కు ఒక పార్కెట్ మరియు ఒక MP4ను రాసింది. v3.0 అనేక ఎపిసోడ్‌లను షేర్డ్ షార్డ్‌లలో కలుపుతుంది మరియు మెటాడేటా నుండి సరిహద్దులను పునర్నిర్మిస్తుంది, కాబట్టి info.json ఎపిసోడ్ నంబర్‌కు బదులుగా పాత్ టెంప్లేట్‌లను కలిగి ఉంటుంది, అవి: data/chunk-{chunk_index:03d}/file-{file_index:03d}.parquet అటువంటివి. దీనికి గల ప్రధాన కారణం తక్కువ, పెద్ద ఫైల్‌లు: వేగవంతమైన ప్రారంభం మరియు పెద్ద స్థాయిలో తక్కువ ఫైల్-సిస్టమ్ ఒత్తిడి.

# Upgrade an older v2.1 dataset to v3.0
python -m lerobot.scripts.convert_dataset_v21_to_v30 \
    --repo-id=your-user/so100_pick_cube

# By default it pushes the converted dataset back to the hub and tags it v3.0.
# To convert a local copy and keep it off the hub:
python -m lerobot.scripts.convert_dataset_v21_to_v30 \
    --repo-id=your-user/so100_pick_cube \
    --root=/path/to/dataset/directory \
    --push-to-hub=false

ఒకే డేటాసెట్‌కు రెండు మార్గాలు

డేటాసెట్ నుండి పాలసీకి

ఇక్కడ నడిచే ప్రతి ఇమిటేషన్ లెర్నింగ్‌కు యాభై శుభ్రమైన ఎపిసోడ్‌లు ఫీడ్ చేయబడతాయి. ACT మీ పనిపై మాత్రమే మొదటి నుండి శిక్షణ పొందుతుంది, సుమారు 80 మిలియన్ పారామీటర్లతో, ప్రతి చర్య దశకు సుమారు 20 ms పడుతుంది, వేగవంతమైన కదలికతో సౌకర్యవంతంగా ఉండే ఐదు వాటిలో ఇది ఒక్కటే. SmolVLA 24 GB కార్డ్‌లో సుమారు 450 మిలియన్ పారామీటర్లను కలిగి ఉంటుంది. GR00T N1.7 అనేది సుమారు 3 బిలియన్ పారామీటర్ల ఫౌండేషన్ మోడల్, ఇక్కడ ఫైన్-ట్యూనింగ్ సుమారు 40 మిలియన్ పారామీటర్లను తాకుతుంది, దీనికి A100 లేదా H100 అవసరం, మరియు ఆ v2.1 డేటాసెట్ కావాలి.

తరువాత, మీ కాంబినేషన్ కోసం గైడ్: ACT on SO-100, SmolVLA on SO-100 లేదా GR00T N1.7 on SO-100; మొదటి రన్ కోసం, మీ మొదటి పాలసీకి శిక్షణ ఇవ్వడం తక్కువ సమయం పడుతుంది. పాలసీ బెంచ్‌పై పనిచేసి, మీరు టేబుల్‌ను కదిలించిన వెంటనే కుప్పకూలిపోతే, అది డేటా సమస్య: పాలసీ ఒకే సెటప్‌లో మాత్రమే పనిచేస్తుంది మరియు అధిక-నాణ్యత VLA శిక్షణ డేటాను సేకరించడం వైవిధ్యాన్ని లోతుగా పరిశీలిస్తాయి.