දේශීය 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 සමඟ 2026 අගෝස්තු 23 දින පරීක්ෂා කරන ලදී.

ප්‍රතිපත්තිය රොබෝ යන්ත්‍රයට නොගැලපෙන්නේ ඇයි

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 වස්තු-දත්ත වර්ගයේ ndarray payloads දෙපැත්තටම ප්‍රතික්ෂේප කරයි, මන්ද msgpack_numpy එසේ නොමැති නම් ඒවා pickle වෙත ලබා දෙනු ඇත. lerobot ඒ වෙනුවට pickles භාවිතා කරයි: policy_server.py අමතයි pickle.loads ඉල්ලීම් දත්ත මත, robot_client.py එය යවන නිරීක්ෂණය pickles කරයි. විශ්වාසදායී LAN එකක ආරක්ෂා කළ හැකි නමුත්, අන්තර්ජාලයෙන් port එකට ප්‍රවේශ විය හැකි වූ පසු ආරක්ෂා කළ නොහැක.

මාර්ගය A: NVIDIA හිම GR00T ප්‍රතිපත්ති සේවාදායකය

මෙය SO-100 සහ SO-101 දෘඪාංග සඳහා NVIDIA විසින් ලේඛනගත කර ඇති මාර්ගය වන අතර, ඔබගේ checkpoint examples/finetune.sh සමග --embodiment-tag NEW_EMBODIMENT වලින් පැමිණියේ නම් භාවිතා කළ යුතු මාර්ගයයි. මෙම පියවර මගින් upstream README හි නොමැති දේ එකතු කරයි: port එක අන් අයට නිරාවරණය නොකර robot වෙත ලබා ගැනීම.

1. 1
   කුලියට ගත් GPU පෙට්ටියේ GR00T ස්ථාපනය කරන්න

   Submodules අවශ්‍ය වන අතර, clone කිරීමට පෙර git-lfs තිබිය යුතුය, නැතහොත් demo_data හි parquet ගොනු pointers ලෙස පැමිණේ. flash-attn සහ TensorRT පෙරනිමි ස්ථාපනය සමඟ පැමිණේ. නව pod image එකක ඇති ගැටලුව: torchcodec 0.8.0 යනු සහාය දක්වන එකම වීඩියෝ backend එක වන අතර FFmpeg 4 සිට 7 දක්වා පමණක් load කරයි. Ubuntu 25.10 සහ 26.04 FFmpeg 8 සමඟ පැමිණෙන අතර, එබැවින් GR00T Could not load libtorchcodec සමඟ අසාර්ථක වේ. 8 ට අඩු FFmpeg එකක් ස්ථාපනය කර එහි libraries 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
   gated backbone එකට එරෙහිව සත්‍යාපනය කරන්න

   ඔබගේම fine-tune ඇතුළුව සෑම GR00T N1.7 checkpoint එකක්ම, පළමු භාවිතයේදී gated nvidia/Cosmos-Reason2-2B load කරයි. model page එකෙන් ප්‍රවේශය ඉල්ලා pod එකට log in වන්න, නැතහොත් loading GatedRepoError සමඟ අසාර්ථක වේ.

   bash

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

3. 3
   ප්‍රතිපත්ති සේවාදායකය ආරම්භ කරන්න

   ඔබගේ checkpoint directory එකට --model-path යොමු කරන්න; එම path එකේදී server එක --modality-config-path නොසලකා හරිනු ඇත, එය replay path එකේදී පමණක් කියවනු ලැබේ. --model-path අතහැර දමා, ඒ වෙනුවට --dataset-path සහ --execution-horizon ලබා දෙන්න, එවිට ReplayPolicy එකක් මගින් පටිගත කරන ලද ක්‍රියා නැවත ධාවනය කරයි, එය wiring ක්‍රියා කරන බව ඔප්පු කිරීමට ඇති ලාභම ක්‍රමයයි.

   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
   port 5555 robot යන්ත්‍රයට tunnel කරන්න

   ඉහත පරිදි, loopback වෙත bind කර, SSH හෝ WireGuard-style mesh හරහා port එක රැගෙන යන්න. එය ZeroMQ socket එකට නොමැති සංකේතනය සහ සත්‍යාපනය සපයයි, එය ආසන්න වශයෙන් මිලි තත්පරයක් සඳහා වේ.

   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
   servos අසල robot client එක ධාවනය කරන්න

   client එකට තමන්ගේම uv environment එකක් අවශ්‍යයි: එයට අවශ්‍ය වන්නේ lerobot හි robot drivers මිස training stack එක නොවේ. eval_so100.py මගින් so100_follower, so101_follower සහ koch_follower import කරයි, එබැවින් ඔබගේ arm එකට ගැලපෙන --robot.type ලබා දෙන්න (upstream README එක so101_follower භාවිතා කරයි). කැමරා keys training සමඟ ගැලපිය යුතුය: adapter එක front සහ wrist හරියටම කියවයි, ඒවා මාරු කිරීමෙන් policy එකට වැරදි දසුනක් පෙන්වයි.

   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: lerobot අසමමුහුර්ත අනුමානය

lerobot වෙනස් ගැටලුවක් විසඳයි. මොඩලය සිතන අතරතුර රොබෝවරයා අවහිර කරනවා වෙනුවට, සේවාදායකය ඊළඟ කොටස ගණනය කරන අතරතුර සේවාදායකයා දැනටමත් ඇති පෝලිම හරහා ඉදිරියට යයි. මෙය ක්‍රියා ඛණ්ඩනය තවදුරටත් ගෙන යන ලද, SmolVLA සමඟ හඳුන්වා දුන් අසමමුහුර්ත ස්ථරයයි. එය 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 (lerobot ලේඛන දෙවැන්න SmolVLA පත්‍රිකාවෙන් පසු g ලෙස හඳුන්වයි), සහ ලේඛනගත අගයන් සහ නිකුත් කරන ලද අගයන් එකඟ නොවේ.

ඔබේ සබැඳිය ප්‍රමාණවත් තරම් වේගවත්ද යන්න තීරණය කරන ගණිතය

මිනිසුන් මෙය මඟහැර දමා දවසක් ගත කරන්නේ . එයට විනාඩි දෙකක් ගත වන අතර එය සෑම විටම පාහේ තීරණාත්මක වේ.

NVIDIA හි eval_so100.py හි අදහස් දැක්වූ නිරීක්ෂණ ශබ්දකෝෂය මඟින් වයරය හරහා යන්නේ කුමක්දැයි කියයි: uint8 හි (480, 640, 3) හැඩයෙන් යුත් අරා දෙකක්, සන්ධි ෆ්ලෝට් හයක්, භාෂා ස්ට්‍රින් එකක්. එය එක් රාමුවකට බයිට් 921,600 ක්, කැමරා දෙකක් සඳහා බයිට් 1,843,200 ක්, ආසන්න වශයෙන් 14.7 Mbit ක් වන අතර, කිසිදු ස්ටැක් එකක් එය JPEG සම්පීඩනය නොකරයි. ආපසු එන කොටස ෆ්ලෝට් 6 කින් යුත් පියවර දුසිම් කිහිපයකි. ඔබේ උඩුගත කිරීම සියල්ල තීරණය කරයි, ඔබේ බාගත කිරීම නොවේ.

ඔබට ඇතුළත් කිරීමට ඇති අයවැය

GR00T SO-100 සේවාදායකය සමමුහුර්ත වේ: එය policy.get_action(obs), පළමු action_horizon කොටසේ පියවර 30 FPS වේගයෙන් ක්‍රියාත්මක කර, නැවත අමතයි. කොටසේ ප්‍රමාණය සහ ක්ෂිතිජය වෙනස් අගයන් වේ: NVIDIA හි යෙදවුම් මාර්ගෝපදේශය ක්‍රියා කොටසේ ප්‍රමාණය 16 ක් ලෙස නිර්දේශ කරයි, තත්‍ය කාලීන කොටස්කරණය සමඟ ඒකාබද්ධ කළ විට අවම වශයෙන් 32 ක්, eval_so100.py ක්‍රියාත්මක කිරීමේ ක්ෂිතිජය 8 ක් ලෙස සපයයි. 30 FPS වේගයෙන් පියවර අටක් යනු එක් ඇමතුමකට චලනය 267 ms වන අතර, අනෙක් සියල්ල ඒ තුළට ගැලපිය යුතුය.

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

ක්ෂිතිජය ඉහළ නැංවීම යනු සරල විසඳුමක් වන අතර එය නොමිලේ ලැබෙන්නක් නොවේ: අත දැන් පැරණි නිරීක්ෂණයක් මත ක්‍රියා කරයි. මූලික විසඳුම වන්නේ තත්‍ය කාලීන කොටස්කරණයයි, එය වත්මන් කොටස ක්‍රියාත්මක වන අතරතුර ඊළඟ කොටස ගණනය කරයි, ක්‍රියාත්මක කිරීමට සහතික වූ ක්‍රියා කැටි කර ඉතිරිය වර්ණ ගන්වයි; RTC පත්‍රිකාව වාර්තා කරන්නේ එය නැවත පුහුණු කිරීමකින් තොරව අනුමාන ප්‍රමාදයට ඔරොත්තු දෙන බවයි. එය මුලින්ම පවතින්නේ කොතැනදැයි පරීක්ෂා කරන්න. NVIDIA RTC පර්යේෂණාත්මක ලෙස සලකුණු කරයි, එය පහළ මට්ටමේ ආකෘති ප්‍රාථමිකයක් වන අතර එය action_head.get_action(..., options={"rtc_overlap_steps": ..., "rtc_frozen_steps": ...}) හරහා ළඟා විය හැකි නමුත් Gr00tPolicy හෝ සේවාදායක-සේවාදායක මාර්ගයට සම්බන්ධ කර නොමැත, එහිදී options භාවිතයට නොගෙන ඇත, පරීක්ෂණ හෝ උදාහරණ නොමැත. ප්‍රතිපත්ති සේවාදායකයක් හරහා ඔබට ලැබෙන්නේ අසමමුහුර්ත ක්‍රියාත්මක කිරීම මිස RTC නොවේ.

විශ්වාස කිරීමට පෙර එය මැන බලන්න

ඉහත සෑම අංකයක්ම අනාවැකියකි. විධානයන් හතරක් එය මිනුමක් බවට පත් කරයි, කිසිදා ක්‍රියාත්මක නොවන කාර්යයක් සඳහා pod-hour එකක් කැප කිරීමට පෙර ක්‍රියාත්මක කිරීම වටී.

1. 1
   අමු වට-සංචාරය ලබා ගන්න

   CDN එකකට එරෙහිව නොව, pod එකට එරෙහිව. සාමාන්‍යය මෙන්ම අපගමනයද සමීපව නිරීක්ෂණය කරන්න: සාමාන්‍ය ප්‍රමාදය නොව, jitter මගින් අතක් පැකිලීමට ලක් කරයි.

   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 රොබෝ සේවාදායකයා සෑම chunk එකක් සඳහාම server-to-client ප්‍රමාදය සහ deserialization කාලය සටහන් කරයි. මාර්ගය 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

දුරස්ථ අනුමානය ඇත්ත වශයෙන්ම හොඳ කුමක් සඳහාද

සෑම කථාංගයකම එකම ස්ථානයක දුරස්ථ ධාවනයක් බාධා ඇති කරන්නේ නම්, ජාලය බොහෝ විට හේතුව නොවේ. සෑම විටම එකම සන්ධි කෝණයකදී ප්‍රතිපත්තියක් පැකිලීම සාමාන්‍යයෙන් දත්ත ගැටලුවකි; අසාර්ථක-ක්‍රම පිටු, විශේෂයෙන් එක් සැකසුමක පමණක් ක්‍රියා කරන ප්‍රතිපත්තියක් සහ අලාභය අඩු වන නමුත් ප්‍රතිපත්තිය කිසිවක් නොකරයි.

ඔබ විසින්ම කිරීම එදිරිව AY-Robots මත කිරීම

දුරස්ථ අනුමාන කිරීමේ සැසියක පිරිවැය

අංක දෙකක් වැදගත් වේ: කාඩ්පතේ පැයක ගාස්තුව සහ ඔබ එය කොපමණ කාලයක් ක්‍රියාත්මක කිරීමට ඉඩ හරිනවාද යන්න. පළමුවැන්න ප්‍රකාශයට පත් කර ඇත; දෙවැන්න මිනිසුන් පුදුමයට පත් කරයි.

මෙම ගාස්තු 2026 අගෝස්තු 23 දින Runpod හි මිලකරණ පිටුවෙන් ලබාගත් අතර, වෙළඳපොළ මිල වෙනස් වේ. 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 දක්වා. අනුමාන සැසියක් පුහුණු ධාවනයකට වඩා පිරිවැය අතින් වාසිදායක වන්නේ ඔබ එය නැවැත්වුවහොත් පමණි, ඒ සඳහා idle watchdog භාවිතා වේ. බලන්න බිල්පත් ලේඛන සහ මිලකරණ පිටුව.

ඔබ ජාලය ලූපයේ තබා ගැනීමට අකමැති නම්

දුරස්ථ අනුමානය දෘඪාංග ගැටලුවක් විසඳන අතර ප්‍රමාද ගැටලුවක් ඇති කරයි. සමහර විට වඩා හොඳ පිළිතුර වන්නේ ඔබ සතුව ඇති දෘඪාංගවලට ගැලපෙන ප්‍රතිපත්තියකි.

• ACT, දළ වශයෙන් 80 M පරාමිති සහ එක් ක්‍රියාකාරී පියවරකට 20 ms, අවම වශයෙන් 50 episodes, ඕනෑම 24 GB කාඩ්පතක්. පුනරාවර්තන තනි කාර්ය සැකසුමකදී එය බොහෝ විට දුරස්ථ 3 B මාදිලියක් පරදවයි, මන්ද එය කිසි විටෙකත් පැකට්ටුවක් සඳහා රැඳී නොසිටින බැවිනි.
• SmolVLA, දළ වශයෙන් 450 M පරාමිති සහ එක් ක්‍රියාකාරී පියවරකට 245 ms, අවම වශයෙන් 30 episodes. එය ACT හි නොමැති භාෂා තත්ත්වයන් රඳවා ගනී, තවද lerobot docs වලට අනුව එය අනුමාන කාලය තුළ 2 GB පමණ වන අතර PI0 සඳහා දළ වශයෙන් 14 GB වේ.
• ACT vs GR00T N1.7 වෙළඳාමේ නිරවද්‍යතා අර්ධය සඳහා.

මැද මාවතක් ද ඇත: cloud හි පුහුණු කරන්න, දේශීයව ඇගයීම කරන්න. සඳහා 80 GB කාඩ්පතක් අවශ්‍ය වන අතර ප්‍රමාදය ගැන තැකීමක් නොකරයි, එබැවින් දුරස්ථව සිදු කිරීම මතභේදාත්මක නොවේ. තත්‍ය කාලීන සීමාවක් ඇත්තේ ඇගයීම් ලූපයට පමණි; සහ එම අර්ධය ආවරණය කරයි.

නිතර අසන ප්‍රශ්න

කෙටි සාරාංශය

3 B ප්‍රතිපත්තියක් සඳහා දුරස්ථ inference යනු විසඳා ඇති ඉංජිනේරු ගැටලුවක් වන අතර, නොවිසඳුණු භෞතික විද්‍යා ගැටලුවක් ඊට අමුණා ඇත. ඉංජිනේරු විද්‍යාව යනු විධාන දෙකක් සහ SSH tunnel එකකි. භෞතික විද්‍යාව නම්, අතේ ක්‍රියාකාරකම් අවසන් වීමට පෙර 1.8 MB නිරීක්ෂණයක් වෙනත් රටක GPU එකකට ළඟා වී ආපසු පැමිණිය යුතුය. යමක් කුලියට ගැනීමට පෙර ගණනය කිරීම් කරන්න, යල් පැන ගිය නිරීක්ෂණයක් ඉවසා සිටින කාර්යයක් තෝරන්න, සහ link එක වැඩි දියුණු වේ යැයි බලාපොරොත්තු වෙනවාට වඩා execution horizon එක වැඩි කරන්න.

ඔබ තවමත් දත්ත කට්ටලයක් පටිගත කර නොමැති නම්, ඔබේ පළමු දත්ත කට්ටලය පටිගත කරන්න සහ SO-100 සැකසුම් මාර්ගෝපදේශය මුලින්ම පැමිණේ, තවද LeRobot දත්ත කට්ටල ආකෘතිය ඇතුළත් කිරීම මඟින් රෙකෝඩරය ලියන දේ පැහැදිලි කරයි. පසුබිම වන්නේ දෘශ්‍ය-භාෂා-ක්‍රියා ආකෘති සහ ප්‍රවාහ-ගැලපෙන ප්‍රතිපත්ති කාර්යය; අරීනා ඇතුළත් කිරීම සෑම මිණුම් සලකුණු අංකයක්ම මූලාශ්‍රයකට සම්බන්ධ කරයි.