உள்ளூர் 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 மில்லி விநாடிகள் ஒரு படிக்கு ரோபோ இயந்திரத்தில் இயங்குகிறது, அதைப் பற்றி நீங்கள் மீண்டும் ஒருபோதும் சிந்திக்க மாட்டீர்கள். Pi0.5 485 மில்லி விநாடிகளில் ஒரு பாக்கெட் உங்கள் கட்டிடத்தை விட்டு வெளியேறுவதற்கு முன்பு ஒரு வினாடியில் மூன்றில் ஒரு பங்கைச் செலவழித்துள்ளது. கொள்கை ஒப்பீடு மற்றும் 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 இல்லையெனில் அவற்றை பிக்கிளுக்கு அனுப்பும். லெரோபோட் அதற்கு பதிலாக பிக்கிள் செய்கிறது: 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 இல் உள்ள parquet கோப்புகள் பாயிண்டர்களாக வரும். flash-attn மற்றும் TensorRT இயல்புநிலை நிறுவலுடன் வருகின்றன. புதிய பாட் இமேஜில் உள்ள சிக்கல்: torchcodec 0.8.0 மட்டுமே ஆதரிக்கப்படும் வீடியோ பேக்கெண்ட் மற்றும் FFmpeg 4 முதல் 7 வரை மட்டுமே ஏற்றுகிறது. உபுண்டு 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 ஐ புறக்கணிக்கிறது, இது ரீப்ளே பாதையில் மட்டுமே படிக்கப்படுகிறது. பதிவுசெய்யப்பட்ட செயல்களை ரீப்ளே செய்யும் ReplayPolicy க்காக --model-path ஐ தவிர்த்து, அதற்கு பதிலாக --dataset-path மற்றும் --execution-horizon ஐ அனுப்பவும், இது வயரிங் வேலை செய்கிறது என்பதை நிரூபிக்க மலிவான வழி.

   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 சூழல் தேவை: அது லெரோபோட்டின் ரோபோ டிரைவர்களை விரும்புகிறது, பயிற்சி ஸ்டேக்கை அல்ல. 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: 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 (லெரோபோட் ஆவணங்கள் இரண்டாவது ஒன்றை 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

ஹொரைசனை உயர்த்துவது ஒரு நேரடியான தீர்வு, ஆனால் இலவசமானது அல்ல: கை இப்போது பழையதாகிவிட்ட ஒரு அவதானிப்பின் அடிப்படையில் செயல்படுகிறது. கொள்கை ரீதியான தீர்வு நிகழ்நேர துண்டாக்கம் (real-time chunking), இது தற்போதைய துண்டு இயங்கும்போது அடுத்த துண்டைக் கணக்கிடுகிறது, செயல்படுத்த உத்தரவாதம் அளிக்கப்பட்ட செயல்களை முடக்குகிறது மற்றும் மீதமுள்ளவற்றை நிரப்புகிறது; RTC கட்டுரை இது எந்த மறுபயிற்சியும் இல்லாமல் அனுமான தாமதத்திற்கு வலுவானது என்று தெரிவிக்கிறது. அது எங்கு நிற்கிறது என்பதை முதலில் சரிபார்க்கவும். NVIDIA RTC ஐ ஒரு சோதனை அம்சமாக, ஒரு குறைந்த-நிலை மாதிரி ப்ரிமிட்டிவ் ஆகக் குறிக்கிறது, இது action_head.get_action(..., options={"rtc_overlap_steps": ..., "rtc_frozen_steps": ...}), Gr00tPolicy அல்லது சர்வர்-கிளையன்ட் பாதையில் இணைக்கப்படவில்லை, அங்கு options பயன்படுத்தப்படாமல், சோதனைகள் மற்றும் எடுத்துக்காட்டு இல்லாமல் உள்ளது. ஒரு கொள்கை சர்வர் வழியாக நீங்கள் ஒத்திசைவற்ற செயலாக்கத்தைப் பெறுவீர்கள், RTC அல்ல.

நம்புவதற்கு முன் அளவிடவும்

மேலே உள்ள ஒவ்வொரு எண்ணும் ஒரு கணிப்பு. நான்கு கட்டளைகள் அதை ஒரு அளவீடாக மாற்றுகின்றன, ஒருபோதும் வேலை செய்யாத ஒரு பணிக்கு ஒரு pod-hour ஐ ஒதுக்குவதற்கு முன் இதை இயக்குவது மதிப்பு.

1. 1
   மூல சுற்றுப் பயணத்தைப் பெறுங்கள்

   CDN க்கு எதிராக அல்ல, pod க்கு எதிராக. சராசரியைப் போலவே விலகலையும் உன்னிப்பாகக் கவனியுங்கள்: சராசரி தாமதம் அல்ல, நடுக்கம் ஒரு கையைத் தடுமாறச் செய்கிறது.

   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-Robots-ல் செய்வது

ஒரு ரிமோட் இன்ஃபரன்ஸ் அமர்வின் செலவு என்ன

இரண்டு எண்கள் முக்கியம்: கார்டின் மணிநேர கட்டணம், மற்றும் அதை எவ்வளவு நேரம் இயங்க விடுகிறீர்கள் என்பது. முதல் எண் வெளியிடப்பட்டது; இரண்டாவது மக்களை ஆச்சரியப்படுத்துகிறது.

இந்த கட்டணங்கள் ஆகஸ்ட் 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-க்கு இல்லாத மொழி கண்டிஷனிங்கை வைத்திருக்கிறது, மேலும் லெரோபோட் ஆவணங்கள் இதை இன்ஃபரன்ஸ் நேரத்தில் சுமார் 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 தரவுத்தொகுப்பு வடிவம் பதிவுசெய்பவர் என்ன எழுதுகிறார் என்பதை விளக்குகிறது. பின்னணி பார்வை-மொழி-செயல் மாதிரி மற்றும் ஃப்ளோ-மேட்சிங் கொள்கை வேலை; அரங்கம் நுழைவு ஒவ்வொரு பெஞ்ச்மார்க் எண்ணையும் ஒரு மூலத்துடன் இணைக்கிறது.