స్థానిక GPU లేకుండా GR00T ఇన్ఫరెన్స్ అమలు చేయండి

ఒక Raspberry Pi ఒక సీరియల్ బస్ ద్వారా నడపడానికి మరియు రెండు USB కెమెరాల నుండి ఫ్రేమ్‌లను లాగడానికి సరిపోతుంది. మూడు బిలియన్ పారామీటర్ల ను అమలు చేయడానికి ఇది సరిపోదు: NVIDIA యొక్క README ప్రకారం GR00T N1.7 ఇన్ఫరెన్స్ కోసం 16 GB లేదా అంతకంటే ఎక్కువ VRAM ఉన్న ఒక GPU అవసరం. మీ ఫైన్-ట్యూన్ చేయబడిన చెక్‌పాయింట్ ఆర్మ్‌పై కార్డ్ కొనుగోలు చేయకుండా ఏమి చేస్తుందో చూడటానికి, పాలసీని అద్దె క్లౌడ్ GPUలో ఉంచండి, రోబోట్ లూప్‌ను USB పోర్ట్‌లు ఉన్న మెషీన్‌లో ఉంచండి మరియు నెట్‌వర్క్ ద్వారా అబ్జర్వేషన్‌లు మరియు యాక్షన్ చంక్‌లను పంపండి.

ఇది పనిచేస్తుంది, ఇది ఉచితం కాదు, మరియు ధర పనుల అంతటా సమానంగా విస్తరించి లేదు. క్రింద: NVIDIA యొక్క స్వంత పాలసీ సర్వర్, lerobot యొక్క అసైన్క్ స్టాక్, మీ అప్‌లింక్ తగినంత వేగంగా ఉందో లేదో ముందుగానే చెప్పే అంకగణితం మరియు ప్లాట్‌ఫారమ్ మార్గం. ఇవన్నీ Isaac-GR00T మెయిన్ బ్రాంచ్ (N1.7 GA) మరియు lerobot 0.6.1కి వ్యతిరేకంగా 23 ఆగస్టు 2026న తనిఖీ చేయబడ్డాయి.

పాలసీ రోబోట్ మెషీన్‌పై ఎందుకు సరిపోదు

AY-Robots శిక్షణ ఇవ్వగల ఐదు పాలసీలలో రెండు వర్క్‌స్టేషన్ కార్డ్‌లో నడుస్తాయి, మూడు నడవవు. ది క్రింద ఉన్న కాలమ్ ప్రతి చర్య దశకు సంబంధించినది, మరియు అది మీ నెట్‌వర్క్ రౌండ్ ట్రిప్‌తో పోటీపడే సంఖ్య.

దీన్ని ఒక నిర్ణయంగా చదవండి, కేవలం సాధారణ విషయంగా కాదు. ACT 20 ms ప్రతి అడుగుకు రోబోట్ మెషీన్‌లో నడుస్తుంది మరియు మీరు దాని గురించి మళ్ళీ ఆలోచించరు. Pi0.5 485 ms వద్ద, ఒక ప్యాకెట్ మీ భవనం నుండి బయలుదేరడానికి ముందే మూడింట ఒక వంతు సెకను గడిచిపోయింది. పాలసీ పోలిక మరియు GR00T N1.7 vs Pi0.5 ఖచ్చితత్వ కోణాన్ని జోడిస్తాయి.

ఇప్పటికే ఉన్న రెండు క్లయింట్-సర్వర్ స్టాక్‌లు

Isaac-GR00T ఒక ZeroMQ రిక్వెస్ట్-రిప్లై సర్వర్‌ను పంపుతుంది; lerobot అసమకాలిక ఇన్ఫరెన్స్ చుట్టూ నిర్మించిన gRPC సర్వర్‌ను పంపుతుంది. రెండూ ఒక GR00Tని అంగీకరిస్తాయి చెక్‌పాయింట్. lerobot మద్దతు ఇచ్చే పాలసీ జాబితా async_inference/constants.py అనేది act, smolvla, diffusion, tdmpc, vqbet, pi0, pi05 మరియు groot; దాని రోబోట్ జాబితా so100_follower, so101_follower, bi_so_follower మరియు omx_follower.

సీరియలైజేషన్ వరుస అది కనిపించే దానికంటే ఎక్కువ ముఖ్యమైనది. GR00T యొక్క MsgSerializer ఆబ్జెక్ట్-డేటాటైప్ ఎన్‌డిఅర్రే పేలోడ్‌లను రెండు దిశలలోనూ తిరస్కరిస్తుంది, ఎందుకంటే msgpack_numpy వాటిని పికిల్‌కు అప్పగిస్తుంది. lerobot బదులుగా పికిల్ చేస్తుంది: policy_server.py అభ్యర్థన డేటాపై pickle.loadsను పిలుస్తుంది, robot_client.py అది పంపే పరిశీలనను పికిల్ చేస్తుంది. విశ్వసనీయ LANలో సమర్థనీయం, పోర్ట్ ఇంటర్నెట్ నుండి అందుబాటులో ఉన్న తర్వాత సమర్థనీయం కాదు.

మార్గం A: NVIDIA యొక్క స్వంత GR00T పాలసీ సర్వర్

ఇది SO-100 మరియు SO-101 హార్డ్‌వేర్ కోసం NVIDIA డాక్యుమెంట్ చేసిన మార్గం, మరియు మీ చెక్‌పాయింట్ examples/finetune.sh నుండి --embodiment-tag NEW_EMBODIMENTతో వచ్చినట్లయితే ఉపయోగించాల్సిన మార్గం. ఈ దశలు అప్‌స్ట్రీమ్ README వదిలివేసిన వాటిని జోడిస్తాయి: పోర్ట్‌ను ఇతరులందరికీ బహిర్గతం చేయకుండా రోబోట్‌కు చేర్చడం.

1. 1
   అద్దెకు తీసుకున్న GPU బాక్స్‌లో GR00Tని ఇన్‌స్టాల్ చేయండి

   సబ్‌మాడ్యూల్స్ అవసరం, మరియు క్లోన్ చేయడానికి ముందు git-lfs ఉండాలి లేదా demo_dataలోని పారక్వెట్ ఫైల్‌లు పాయింటర్‌లుగా వస్తాయి. flash-attn మరియు TensorRT డిఫాల్ట్ ఇన్‌స్టాల్‌తో వస్తాయి. కొత్త పాడ్ ఇమేజ్‌పై ఉన్న సమస్య: torchcodec 0.8.0 మాత్రమే మద్దతు ఉన్న వీడియో బ్యాకెండ్ మరియు FFmpeg 4 నుండి 7 వరకు మాత్రమే లోడ్ చేస్తుంది. Ubuntu 25.10 మరియు 26.04 FFmpeg 8ని కలిగి ఉంటాయి, కాబట్టి Could not load libtorchcodecతో GR00T విఫలమవుతుంది. 8 కంటే తక్కువ FFmpegని ఇన్‌స్టాల్ చేసి, దాని లైబ్రరీలను LD_LIBRARY_PATHలో ఉంచండి.

   bash

   sudo apt install git-lfs && git lfs install
   curl -LsSf https://astral.sh/uv/install.sh | sh
   sudo apt-get update && sudo apt-get install -y ffmpeg
   
   git clone --recurse-submodules https://github.com/NVIDIA/Isaac-GR00T
   cd Isaac-GR00T
   uv sync --python 3.12
   uv run python -c "import gr00t; print('GR00T installed successfully')"

2. 2
   గేటెడ్ బ్యాక్‌బోన్‌కు వ్యతిరేకంగా ప్రామాణీకరించండి

   ప్రతి GR00T N1.7 చెక్‌పాయింట్, మీ స్వంత ఫైన్-ట్యూన్‌తో సహా, మొదటిసారి ఉపయోగించినప్పుడు గేటెడ్ nvidia/Cosmos-Reason2-2Bని లోడ్ చేస్తుంది. మోడల్ పేజీలో యాక్సెస్ కోసం అభ్యర్థించండి మరియు పాడ్‌లో లాగిన్ చేయండి, లేకపోతే GatedRepoErrorతో లోడింగ్ విఫలమవుతుంది.

   bash

   uv run huggingface-cli login
   # or:  export HF_TOKEN=<your_token>

3. 3
   పాలసీ సర్వర్‌ను ప్రారంభించండి

   --model-pathను మీ చెక్‌పాయింట్ డైరెక్టరీకి సూచించండి; ఆ మార్గంలో సర్వర్ --modality-config-pathను విస్మరిస్తుంది, ఇది రీప్లే మార్గంలో మాత్రమే చదవబడుతుంది. --model-pathను వదిలివేసి, బదులుగా --dataset-path మరియు --execution-horizonను ReplayPolicy కోసం పాస్ చేయండి, ఇది రికార్డ్ చేయబడిన చర్యలను రీప్లే చేస్తుంది, వైరింగ్ పనిచేస్తుందని నిరూపించడానికి ఇది చౌకైన మార్గం.

   bash

   uv run python gr00t/eval/run_gr00t_server.py \
     --model-path /workspace/so100_finetune/checkpoint-10000 \
     --embodiment-tag NEW_EMBODIMENT \
     --device cuda:0 \
     --host 127.0.0.1 --port 5555

4. 4
   పోర్ట్ 5555ను రోబోట్ మెషీన్‌కు టన్నెల్ చేయండి

   పైన పేర్కొన్న విధంగా, లూప్‌బ్యాండ్‌కు బైండ్ చేయండి మరియు SSH లేదా WireGuard-శైలి మెష్ ద్వారా పోర్ట్‌ను తీసుకువెళ్లండి. ఇది ZeroMQ సాకెట్ అందించని ఎన్‌క్రిప్షన్ మరియు ప్రామాణీకరణను సుమారు ఒక మిల్లీసెకనుకు అందిస్తుంది.

   bash

   # on the robot machine
   ssh -N -L 5555:127.0.0.1:5555 root@<pod-host> -p <pod-ssh-port>
   
   # sanity check that something answers
   nc -vz 127.0.0.1 5555

5. 5
   సర్వోల పక్కన రోబోట్ క్లయింట్‌ను అమలు చేయండి

   క్లయింట్‌కు దాని స్వంత uv వాతావరణం అవసరం: అది శిక్షణ స్టాక్‌ను కాకుండా lerobot యొక్క రోబోట్ డ్రైవర్‌లను కోరుకుంటుంది. eval_so100.py so100_follower, so101_follower మరియు koch_followerలను దిగుమతి చేస్తుంది, కాబట్టి మీ ఆర్మ్‌కు సరిపోయే --robot.typeను పాస్ చేయండి (అప్‌స్ట్రీమ్ README so101_followerను ఉపయోగిస్తుంది). కెమెరా కీలు శిక్షణకు సరిపోలాలి: అడాప్టర్ సరిగ్గా front మరియు wristలను చదువుతుంది, మరియు వాటిని మార్చడం వలన పాలసీకి తప్పు వీక్షణ కనిపిస్తుంది.

   bash

   cd gr00t/eval/real_robot/SO100
   uv sync
   uv pip install --no-deps -e ../../../../
   
   uv run --no-sync python eval_so100.py \
     --robot.type=so100_follower \
     --robot.port=/dev/ttyACM0 \
     --robot.id=orange_follower \
     --robot.cameras="{ front: {type: opencv, index_or_path: 6, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
     --policy_host=127.0.0.1 \
     --policy_port=5555 \
     --lang_instruction="pick up the red block and put it in the bin"

మార్గం B: లెరోబోట్ అసమకాలిక ఇన్‌ఫరెన్స్

లెరోబోట్ ఒక విభిన్న సమస్యను పరిష్కరిస్తుంది. మోడల్ ఆలోచిస్తున్నప్పుడు రోబోట్‌ను నిరోధించడానికి బదులుగా, సర్వర్ తదుపరి భాగాన్ని లెక్కిస్తున్నప్పుడు క్లయింట్ ఇప్పటికే ఉన్న క్యూ ద్వారా అడుగులు వేస్తూ ఉంటుంది. ఇది యాక్షన్ చంకింగ్ మరింత ముందుకు తీసుకెళ్లబడింది, స్మోల్‌విఎల్‌ఎతో పరిచయం చేయబడిన అసమకాలిక స్టాక్. ఇది GR00T చెక్‌పాయింట్‌తో కూడా పనిచేస్తుంది.

# GPU machine
pip install -e ".[async]"
python -m lerobot.async_inference.policy_server \
     --host=127.0.0.1 \
     --port=8080

# robot machine, after tunnelling 8080
python -m lerobot.async_inference.robot_client \
    --server_address=127.0.0.1:8080 \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower_so100 \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 1, width: 640, height: 480, fps: 30}}" \
    --task="pick up the red block and put it in the bin" \
    --policy_type=groot \
    --pretrained_name_or_path=<user>/my_groot_finetune \
    --policy_device=cuda \
    --actions_per_chunk=50 \
    --chunk_size_threshold=0.5 \
    --debug_visualize_queue_size=True

సర్వర్ ఖాళీగా ప్రారంభమవుతుంది: క్లయింట్ యొక్క మొదటి హ్యాండ్‌షేక్ చెప్పే వరకు అది ఏ పాలసీని అందిస్తుందో దానికి తెలియదు, ఇది అద్దెకు తీసుకున్న పాడ్‌లో సౌకర్యవంతంగా ఉంటుంది. చేయి సజావుగా కదులుతుందో లేదో నిర్ణయించే రెండు నాబ్‌లు actions_per_chunk మరియు chunk_size_threshold (లెరోబోట్ డాక్యుమెంట్లు రెండవదాన్ని g అని పిలుస్తాయి, స్మోల్‌విఎల్‌ఎ పేపర్ తర్వాత), మరియు డాక్యుమెంట్ చేయబడిన విలువలు మరియు షిప్ చేయబడిన విలువలు సరిపోలడం లేదు.

మీ లింక్ తగినంత వేగంగా ఉందో లేదో నిర్ణయించే అంకగణితం

ప్రజలు దీన్ని దాటవేసి, ఆపై ఒక రోజు గడుపుతారు . దీనికి రెండు నిమిషాలు పడుతుంది మరియు ఇది దాదాపు ఎల్లప్పుడూ నిర్ణయాత్మకమైనది.

NVIDIA యొక్క వ్యాఖ్యానించబడిన అబ్జర్వేషన్ డిక్ట్ eval_so100.py వైర్‌పై ఏమి జరుగుతుందో చెబుతుంది: uint8లో (480, 640, 3) ఆకారంలో రెండు శ్రేణులు, ఆరు జాయింట్ ఫ్లోట్‌లు, ఒక భాషా స్ట్రింగ్. అది ఒక్కో ఫ్రేమ్‌కు 921,600 బైట్లు, రెండు కెమెరాలకు 1,843,200 బైట్లు, సుమారు 14.7 Mbit, మరియు ఏ స్టాక్ కూడా దీన్ని JPEG-కంప్రెస్ చేయదు. తిరిగి వచ్చే చంక్ కొన్ని డజన్ల 6 ఫ్లోట్‌ల దశలు. మీ అప్‌లోడ్ ప్రతిదీ నిర్ణయిస్తుంది, మీ డౌన్‌లోడ్ కాదు.

మీరు సరిపోవాల్సిన బడ్జెట్

The GR00T SO-100 client is synchronous: it calls policy.get_action(obs), executes the first action_horizon steps of the chunk at 30 FPS, then calls again. Chunk size and horizon are different numbers: NVIDIA's deployment guide recommends an action chunk size of 16, at least 32 when combined with real-time chunking, while eval_so100.py ships an execution horizon of 8. Eight steps at 30 FPS is 267 ms of motion per call, and everything else has to fit inside that.

observation upload   14.7 Mbit / 100 Mbit/s   = 147 ms
network round trip                            =  30 ms
model inference (AY-Robots figure, N1.7)      = 152 ms
action chunk return + deserialize             =  ~2 ms
                                                -------
total per call                                  331 ms

budget at action_horizon = 8   ->  267 ms   FAIL, arm pauses ~64 ms per chunk
budget at action_horizon = 16  ->  533 ms   fits, with headroom
budget at action_horizon = 32  -> 1067 ms   fits, observations now ~1 s stale

Raising the horizon is the blunt fix and not a free one: the arm acts on an observation that is now old. The principled fix is real-time chunking, which computes the next chunk while the current one runs, freezes the actions guaranteed to execute and inpaints the rest; the RTC paper reports it as robust to inference delay with no retraining. Check where that stands first. NVIDIA marks RTC experimental, a low-level model primitive reachable through action_head.get_action(..., options={"rtc_overlap_steps": ..., "rtc_frozen_steps": ...}), not wired into Gr00tPolicy or the server-client path, where options is unused, with no tests and no example. Over a policy server you get asynchronous execution, not RTC.

నమ్మే ముందు కొలవండి

పైన ఉన్న ప్రతి సంఖ్య ఒక అంచనా. నాలుగు ఆదేశాలు దానిని కొలతగా మారుస్తాయి, పని చేయని పనికి పాడ్-గంటను కేటాయించే ముందు వీటిని అమలు చేయడం విలువైనది.

1. 1
   ముడి రౌండ్ ట్రిప్‌ను పొందండి

   పాడ్‌కు వ్యతిరేకంగా, CDNకి కాదు. సగటుకు ఎంత దగ్గరగా ఉందో విచలనాన్ని కూడా అంత దగ్గరగా గమనించండి: జెట్టర్ ఒక ఆర్మ్‌ను తడబడేలా చేస్తుంది, సగటు లేటెన్సీ కాదు.

   bash

   ping -c 50 <pod-host>
   # the mdev column is the number that predicts stutter

2. 2
   మీరు కలిగి ఉన్న అప్‌లింక్‌ను కొలవండి, మీరు చెల్లించే దానిని కాదు

   నివాస అప్‌లోడ్ సాధారణంగా డౌన్‌లోడ్‌లో కొంత భాగం మాత్రమే ఉంటుంది, మరియు పైన ఉన్న బ్యాండ్‌విడ్త్ పట్టికలో అది ఆ సంఖ్యే.

   bash

   # on the pod
   iperf3 -s
   
   # on the robot machine, -R omitted so this measures upload
   iperf3 -c <pod-host> -t 30

3. 3
   క్లయింట్ యొక్క స్వంత లేటెన్సీ లాగ్‌ను చదవండి

   LeRobot రోబోట్ క్లయింట్ ప్రతి చంక్‌కు సర్వర్-టు-క్లయింట్ లేటెన్సీ మరియు డీసీరియలైజేషన్ సమయాన్ని లాగ్ చేస్తుంది. రూట్ Bలో మీకు బాహ్య టూలింగ్ అవసరం లేదు.

   text

   Received action chunk for step #240 | Latest action: #232 |
     Incoming actions: 240:289 |
     Network latency (server->client): 187.44ms |
     Deserialization time: 3.10ms

4. 4
   యాక్షన్ క్యూ ఖాళీ అవ్వడాన్ని గమనించండి

   --debug_visualize_queue_size=Trueని పాస్ చేయండి మరియు క్లయింట్ రన్‌టైమ్‌లో క్యూ పరిమాణాన్ని ప్లాట్ చేస్తుంది. అది పదేపదే సున్నాకి చేరితే మీరు బడ్జెట్ అయిపోయినట్లే: fpsని తగ్గించండి, actions_per_chunkని పెంచండి, లేదా chunk_size_thresholdని పెంచండి, తద్వారా పరిశీలనలు తరచుగా బయటకు వెళ్తాయి.

   bash

   python -m lerobot.async_inference.robot_client \
       ... \
       --debug_visualize_queue_size=True

రిమోట్ ఇన్ఫరెన్స్ నిజంగా దేనికి ఉపయోగపడుతుంది

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

మీరు స్వయంగా చేయడం vs AY-రోబోట్స్‌లో చేయడం

రిమోట్ ఇన్‌ఫరెన్స్ సెషన్ ఎంత ఖర్చవుతుంది

రెండు సంఖ్యలు ముఖ్యమైనవి: కార్డ్ యొక్క గంట రేటు, మరియు మీరు దానిని ఎంతకాలం నడుపుతారు. మొదటిది ప్రచురించబడింది; రెండవది ప్రజలను ఆశ్చర్యపరుస్తుంది.

ఈ ధరలు 23 ఆగస్టు 2026న రన్‌పాడ్ ధరల పేజీ నుండి చదవబడ్డాయి, మరియు స్పాట్ మార్కెట్లు మారుతూ ఉంటాయి. AY-Robots బదులుగా మొత్తం రన్‌ను కోట్ చేస్తుంది: A100 లేదా H100 శ్రేణిలో గంటకు 1.20 నుండి 2.00 USD చొప్పున 3 నుండి 6 గంటలు, GR00T లేదా Pi0.5 రన్‌కు సుమారు 4 నుండి 12 USD; 24 GB శ్రేణిలో గంటకు 0.30 నుండి 0.60 USD చొప్పున 2 నుండి 5 గంటలు, SmolVLA లేదా ACT కోసం 1 నుండి 3 USD. మీరు ఆపివేస్తేనే ఒక ఇన్ఫరెన్స్ సెషన్ శిక్షణ రన్‌ను ఖర్చులో అధిగమిస్తుంది, దీని కోసమే ఐడిల్ వాచ్‌డాగ్ ఉంది. చూడండి బిల్లింగ్ డాక్యుమెంట్లు మరియు ధరల పేజీ.

మీరు నెట్‌వర్క్‌ను లూప్‌లో ఉంచకూడదనుకుంటే

రిమోట్ ఇన్‌ఫరెన్స్ హార్డ్‌వేర్ సమస్యను పరిష్కరిస్తుంది మరియు లేటెన్సీ సమస్యను సృష్టిస్తుంది. కొన్నిసార్లు, మీ వద్ద ఉన్న హార్డ్‌వేర్‌కు సరిపోయే పాలసీ ఉత్తమ సమాధానం.

• ACT, సుమారు 80 M పారామీటర్లు మరియు ప్రతి చర్య దశకు 20 ms, కనీసం 50 ఎపిసోడ్‌లు, ఏదైనా 24 GB కార్డ్. పునరావృతమయ్యే సింగిల్-టాస్క్ సెటప్‌లో ఇది తరచుగా రిమోట్ 3 B మోడల్‌ను అధిగమిస్తుంది, ఎందుకంటే ఇది ప్యాకెట్ కోసం ఎప్పుడూ వేచి ఉండదు.
• SmolVLA, సుమారు 450 M పారామీటర్లు మరియు ప్రతి చర్య దశకు 245 ms, కనీసం 30 ఎపిసోడ్‌లు. ఇది ACTకి లేని భాషా కండిషనింగ్‌ను కలిగి ఉంటుంది, మరియు lerobot డాక్యుమెంట్లు దీనిని ఇన్‌ఫరెన్స్ సమయంలో సుమారు 2 GBగా పేర్కొన్నాయి, PI0కి సుమారు 14 GBతో పోలిస్తే.
• వ్యాపారంలో ఖచ్చితత్వ సగం కోసం ACT vs GR00T N1.7.

మధ్యేమార్గం కూడా ఉంది: క్లౌడ్‌లో శిక్షణ ఇవ్వండి, స్థానికంగా మూల్యాంకనం చేయండి. ఫైన్-ట్యూనింగ్కి 80 GB కార్డ్ అవసరం మరియు లేటెన్సీ గురించి పట్టించుకోదు, కాబట్టి SO-100లో GR00T N1.7కి శిక్షణ ఇవ్వడం రిమోట్‌గా వివాదాస్పదం కాదు. మూల్యాంకన లూప్‌కు మాత్రమే రియల్-టైమ్ పరిమితి ఉంటుంది; శిక్షణ డాక్యుమెంట్లు మరియు మోడల్-మరియు-ఆర్మ్ మ్యాట్రిక్స్ ఆ సగాన్ని కవర్ చేస్తాయి.

తరచుగా అడిగే ప్రశ్నలు

సంక్షిప్త వెర్షన్

3 B కోసం రిమోట్ ఇన్ఫరెన్స్ పాలసీ అనేది పరిష్కరించబడిన ఇంజనీరింగ్ సమస్య, దీనికి పరిష్కరించబడని భౌతిక సమస్య జతచేయబడింది. ఇంజనీరింగ్ రెండు ఆదేశాలు మరియు ఒక SSH టన్నెల్. భౌతికశాస్త్రం ఏమిటంటే, 1.8 MB పరిశీలన మరొక దేశంలోని GPUకి చేరుకోవాలి మరియు చేయి చర్యలు అయిపోకముందే తిరిగి రావాలి. ఏదైనా అద్దెకు తీసుకునే ముందు అంకగణితం చేయండి, పాత పరిశీలనను తట్టుకునే పనిని ఎంచుకోండి మరియు లింక్ మెరుగుపడుతుందని ఆశించకుండా ఎగ్జిక్యూషన్ హోరిజోన్‌ను పెంచండి.

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