உங்கள் சொந்த ரோபோ தரவில் Pi0.5 ஐ எவ்வாறு பயிற்சி செய்வது

Pi0.5 என்பது ஒரு கொள்கை ஒருபோதும் பார்த்திராத அறையில் வேலை செய்ய வேண்டியிருக்கும் போது நீங்கள் பயன்படுத்தும் மாதிரி. இது ஐந்து மாதிரிகளில் மிகவும் சிக்கலானது பயிற்சி செய்யக்கூடிய கொள்கைகள் இங்கு மேம்படுத்துவதற்கு கையால்: அப்ஸ்ட்ரீம் ரெப்போசிட்டரி முதலில் JAX ஐ அடிப்படையாகக் கொண்டது, LeRobot போர்ட் 0.6.0 இல் lerobot-record இலிருந்து வரிசைப்படுத்தலை நகர்த்தியது மற்றும் அடிப்படை நிறுவலை பயிற்சி செய்ய முடியாத அளவுக்கு சிறியதாக ஆக்கியது, மேலும் முழுமையான மேம்படுத்துதல் ஒரு 4090 இல் பொருந்தாது. கீழே: பாய்வு பொருத்தம் அனுமானத்தில் எவ்வளவு செலவாகிறது, இரண்டு கட்டளை வழிகள், மற்றும் முடிவு பயன்படுத்தக்கூடியதா என்பதை தீர்மானிக்கும் 485 ms எண்.

Pi0.5 உண்மையில் என்ன

Physical Intelligence அக்டோபர் 2024 இல் pi0 ஐ வெளியிட்டது: ஒரு பாய்வு பொருத்தம் பார்வை-மொழி-செயல் மாதிரி ஒரு முன்-பயிற்சி பெற்ற VLM இல்: 3 பில்லியன் அளவுருக்கள் கொண்ட PaliGemma மற்றும் புதிதாகத் தொடங்கப்பட்ட ஒரு 300M செயல் நிபுணர், மொத்தம் 3.3 பில்லியன். இந்த ஆய்வுக் கட்டுரை 7 ரோபோ உள்ளமைவுகள் மற்றும் 68 பணிகளில் 10,000 மணிநேரத்திற்கும் மேலான ரோபோ தரவுகளில் முன்-பயிற்சி பெற்றதாகக் கூறுகிறது. மேலும் pi0 கட்டுரை.

Pi0.5 (arXiv 2504.16054, 22 ஏப்ரல் 2025) அதே கட்டமைப்பைத் தக்கவைத்து, பயிற்சி முறையை மாற்றுகிறது: வலைத் தரவு, பொருள் கண்டறிதல், ரோபோவுக்குப் பயிற்சி அளிக்கும் மனிதர்களிடமிருந்து வாய்மொழி அறிவுறுத்தல்கள், துணைப் பணி லேபிள்கள், பல வீடுகளில் உள்ள ரோபோக்களிலிருந்து வரும் குறுக்கு-உருவத் தரவு. இதன் விளைவாக, பயிற்சித் தொகுப்பில் இல்லாத வீடுகளில் சமையலறைகளைச் சுத்தம் செய்யும் ஒரு ரோபோ உருவாகிறது. openpi README, தலைப்பில் இல்லாத ஒரு விவரத்தைச் சேர்க்கிறது: வெளியிடப்பட்ட pi0.5 அறிவுத் தனிமைப்படுத்தலுடன் (arXiv 2505.23705) பயிற்சி அளிக்கப்பட்டது.

ஃப்ளோ மேட்சிங் பயிற்சி மற்றும் ஊகத்தைப் பற்றி என்ன மாற்றுகிறது

ஒரு கொள்கை நீங்கள் SO-100 இல் பயிற்சி அளிக்கலாம், இது செயல்களை நேரடியாக (ACT) அல்லது அவற்றை டோக்கனைஸ் செய்து தானாகவே டிகோட் செய்கிறது (pi0-FAST). ஃப்ளோ மேட்சிங் இவை இரண்டையும் செய்யாது: இது சத்தத்தை ஒரு சுத்தமான செயல் துண்டு, பின்னர் அதை ஒருங்கிணைக்கிறது. pi0 ஆய்வுக் கட்டுரை 0.1 படி அளவில் 10 ஒருங்கிணைப்பு படிகளைப் பயன்படுத்துகிறது; LeRobot இன் pi05 உள்ளமைவு அதே num_inference_steps: int = 10 ஐக் கொண்டுள்ளது.

• பயிற்சி: இழப்பு ஒரு சத்தம் நிறைந்த செயல் துண்டுகளை மீண்டும் உருவாக்குகிறது. சரிசெய்ய டோக்கனைசர் இல்லை, உங்கள் மூட்டு கோணங்களை பிரித்தெடுக்க வேண்டியதில்லை.
• ஊகித்தல்: ஒரு துண்டுக்கு செயல் நிபுணர் வழியாக பத்து முன்னோக்கு பாஸ்கள் செலவாகும். இது கட்டமைப்பு ரீதியானது, சரிசெய்தல் பிரச்சனை அல்ல.
• வெளியீடு: 32 பரிமாணங்களின் தொடர்ச்சியான செயல்கள், உள்நாட்டில் திணிக்கப்பட்டு, உங்கள் ரோபோவின் பரிமாணங்களில் இழப்பு எடுக்கப்படுகிறது. ஒரு 6-DoF கை மற்றும் கிரிப்பர் 7 ஐப் பயன்படுத்துகிறது.

# openpi/src/openpi/models/pi0_config.py - the defaults every pi05 config inherits
@dataclasses.dataclass(frozen=True)
class Pi0Config(_model.BaseModelConfig):
    dtype: str = "bfloat16"
    paligemma_variant: _gemma.Variant = "gemma_2b"
    action_expert_variant: _gemma.Variant = "gemma_300m"

    action_dim: int = 32
    action_horizon: int = 50
    max_token_len: int = None      # 200 if pi05 else 48

    pi05: bool = False             # flips discrete_state_input to True

PaliGemma முதுகெலும்பு மற்றும் அதற்கு முன்னால் உள்ள வாயில்

PaliGemma (arXiv 2407.07726) என்பது Gemma-2B மொழி மாதிரியில் உள்ள ஒரு SigLIP-So400m விஷன் என்கோடர் ஆகும், இது சுமார் 3B அளவுருக்களைக் கொண்டது. Pi0.5 அதன் டோக்கனைசரை மரபுரிமையாகப் பெறுகிறது, மேலும் அந்த டோக்கனைசர் ஒரு கேடட் களஞ்சியத்தில் உள்ளது. முதல் ஓட்டம் இறப்பதற்கான பொதுவான வழி இதுதான், முதல் பயிற்சி படிநிலை.

தொடங்குவதற்கு முன்: தரவுத்தொகுப்பு வடிவம், எபிசோடுகள், வன்பொருள்

LeRobot இல் உள்ள Pi0.5 ஒரு LeRobot தரவுத்தொகுப்பு v3.0 அமைப்பில் படிக்கிறது, இது அக்டோபர் 2025 இல் lerobot 0.4.0 உடன் வந்தது: ஒரு Parquet மற்றும் MP4 கோப்பில் பல எபிசோடுகள், ஒரு கோப்பிற்கு ஒரு எபிசோட், கோப்புப் பெயர்களுக்குப் பதிலாக meta/episodes/ இல் எல்லைகளுடன். உடன் பதிவு செய்யவும் டெஸ்க்டாப் கிளையன்ட் அல்லது பின்பற்றவும் உங்கள் முதல் தரவுத்தொகுப்பை பதிவு செய்யவும் மற்றும் நீங்கள் அதைப் பெறுவீர்கள்.

# v2.1 -> v3.0, run against a dataset already on the Hub
python -m lerobot.scripts.convert_dataset_v21_to_v30 --repo-id=<HF_USER/DATASET_ID>

# aggregates episode-0000.parquet, episode-0001.parquet, ... -> file-0000.parquet
# aggregates episode-0000.mp4, episode-0001.mp4, ...         -> file-0000.mp4
# rewrites meta/episodes/* with per-episode lengths, tasks and offsets

Pi0.5-க்கு குறைந்தபட்சம் 50 எபிசோடுகள் தேவை என்று தளம் விரும்புகிறது, இது GR00T மற்றும் ACT-க்கு சமமானதாகும். முன்-பயிற்சி முக்கிய வேலையைச் செய்கிறது, எனவே 50 சுத்தமான எபிசோடுகள் 200 ஒழுங்கற்ற எபிசோடுகளை விட சிறந்தவை. இதற்குப் புதியவரா? இதனுடன் தொடங்கவும் தரவு சேகரிப்பு வழிகாட்டி

வழி A: openpi களஞ்சியத்துடன் நுண்-சரிசெய்தல் (fine-tune)

குறிப்புச் செயலாக்கம்: முதலில் JAX, Ubuntu 22.04 இல் மட்டுமே சோதிக்கப்பட்டது, கொடிகளை (flags) விட உள்ளமைவுப் பொருள்கள் (config objects) மூலம் இயக்கப்படுகிறது. PyTorch பாதை செப்டம்பர் 2025 இல் வந்தது, LIBERO இல் சரிபார்க்கப்பட்டது. மூன்று படிகள்: உங்கள் தரவை மாற்றுதல், உள்ளமைவை வரையறுத்தல், பயிற்சி செய்தல் மற்றும் சேவை செய்தல்.

1. 1
   குளோன் செய்து நிறுவுதல்

   openpi ஆனது uv ஐப் பயன்படுத்துகிறது. GIT_LFS_SKIP_SMUDGE என்பது LeRobot ஐ LFS ப்ளாப்கள் இல்லாமல் ஒரு சார்புநிலையாக வர அனுமதிக்கும்.

   bash

   git clone --recurse-submodules git@github.com:Physical-Intelligence/openpi.git
   cd openpi
   
   GIT_LFS_SKIP_SMUDGE=1 uv sync
   GIT_LFS_SKIP_SMUDGE=1 uv pip install -e .

2. 2
   உங்கள் தரவை ஒரு LeRobot தரவுத்தொகுப்பாக மாற்றுதல்

   அப்ஸ்ட்ரீம் LIBERO மற்றும் DROID க்கான மாற்றிகளை (converters) வழங்குகிறது, மேலும் நீங்கள் ஒன்றை மாற்றியமைக்க வேண்டும் என்று எதிர்பார்க்கிறது. முக்கிய வேலை, விசை மேப்பிங் ஆகும்.

   bash

   uv run examples/libero/convert_libero_data_to_lerobot.py --data_dir /path/to/your/data

3. 3
   ஒரு பயிற்சி உள்ளமைவைச் சேர்த்தல்

   உள்ளமைவுகள் (Configs) src/openpi/training/config.py இல் உள்ள TrainConfig உள்ளீடுகள் ஆகும். இது pi05_droid_finetune ஐ மாற்றியமைக்கிறது, எடை ஏற்றும் கருவி (weight loader) pi05_base ஐ நோக்கி சுட்டிக்காட்டப்பட்டுள்ளது.

   python

   TrainConfig(
       name="pi05_so100",
       model=pi0_config.Pi0Config(
           pi05=True,
           action_dim=32,        # pi05 is trained with 32-dim actions
           action_horizon=16,
       ),
       # Copy LeRobotLiberoDataConfig in the same file and rewrite the key
       # mapping for your camera names, then reference your copy here.
       data=LeRobotLiberoDataConfig(
           repo_id="your_hf_username/my_so100_dataset",
           base_config=DataConfig(prompt_from_task=True),
       ),
       weight_loader=weight_loaders.CheckpointWeightLoader(
           "gs://openpi-assets/checkpoints/pi05_base/params"
       ),
       batch_size=32,
       num_train_steps=20_000,
   )

4. 4
   சாதாரண புள்ளிவிவரங்களைக் கணக்கிடுதல்

   தரவுத்தொகுப்பிற்கு எதிராக அல்லாமல், உள்ளமைவுப் பெயருக்கு எதிராக இயங்குகிறது. இதைத் தவிர்ப்பது இங்கு ஏற்படும் பொதுவான முதல் தோல்வியாகும்.

   bash

   uv run scripts/compute_norm_stats.py --config-name pi05_so100

5. 5
   பயிற்சி செய்தல்

   இந்த மாறி JAX ஆனது இயல்புநிலை 75 சதவீதத்திற்குப் பதிலாக 90 சதவீத GPU நினைவகத்தைப் பயன்படுத்த அனுமதிக்கிறது. 80 GB கார்டில், இது இயக்கம் நீடிக்குமா என்பதைத் தீர்மானிக்கிறது.

   bash

   XLA_PYTHON_CLIENT_MEM_FRACTION=0.9 uv run scripts/train.py pi05_so100 \
       --exp-name=my_experiment \
       --overwrite

6. 6
   சேவை செய்தல்

   சேவையகம் போர்ட் 8000 இல் கேட்டு, கண்காணிப்பு வினவல்களுக்குப் பதிலளிக்கிறது; உங்கள் ரோபோ ரன்டைம் கிளையன்ட் ஆகும்.

   bash

   uv run scripts/serve_policy.py policy:checkpoint \
       --policy.config=pi05_so100 \
       --policy.dir=checkpoints/pi05_so100/my_experiment/20000

வழி B: lerobot pi05 உடன் ஃபைன்-ட்யூன் செய்யவும்

LeRobot போர்ட் நீங்கள் ஏற்கனவே பயன்படுத்தும் CLI இல் அதே எடைகளை உள்ளடக்கியது ACT மற்றும் SmolVLA. கீழே உள்ள அனைத்தும் lerobot 0.6.1 (ஆகஸ்ட் 3, 2026 முதல் வெளியான பதிப்பு) மற்றும் ஆகஸ்ட் 23, 2026 அன்று வெளியான pi05 ஆவணங்களுக்கு எதிராக சரிபார்க்கப்பட்டது. பதிப்புகள் இங்கு முக்கியம்: v3.0 தரவுத்தொகுப்புகள் அக்டோபர் 2025 இல் 0.4.0 உடன் வந்தன, மார்ச் 9, 2026 இன் 0.5.0 வலைப்பதிவு pi0-FAST மற்றும் Real-Time Chunking ஐ வழங்குகிறது, மேலும் ஜூலை 6, 2026 இல் 0.6.0 அடிப்படை தொகுப்பை இலகுவாக்கி, வரிசைப்படுத்தலை lerobot-rollout க்கு மாற்றியது.

ஒரு விஷயம் மாறவில்லை: lerobot-train மற்றும் lerobot-record ஏற்கனவே 0.3.2, ஆகஸ்ட் 2025 இல் நுழைவுப் புள்ளிகளாக இருந்தன. python -m lerobot.scripts.train என்று இன்னும் அழைக்கும் ஒரு பயிற்சி, ஒரு வருட மாற்றங்களுக்கு முந்தையது மற்றும் மற்றவற்றிலும் நம்பத்தகாதது.

1. 1
   சரியான கூடுதல் அம்சங்களுடன் நிறுவவும்

   0.6.0 முதல், அடிப்படை நிறுவல் முக்கிய ML சார்புகளை மட்டுமே கொண்டுள்ளது, மேலும் pi கூடுதல் எந்த தரவுத்தொகுப்பு அல்லது பயிற்சி குறியீட்டையும் சேர்க்கவில்லை, எனவே ஒரு ஃபைன்-ட்யூன் பயிற்சி கூடுதல் தேவைப்படுகிறது. பழைய ஒரு-வரி கட்டளைகள் இறக்குமதி நேரத்தில் இங்கே தோல்வியடைகின்றன.

   bash

   # policy dependencies plus the training stack
   pip install 'lerobot[pi,training]'
   
   # from a source checkout
   pip install -e ".[pi,training]"
   
   # driving an SO-100 afterwards needs the robot extras too
   pip install 'lerobot[core_scripts,feetech]'

2. 2
   அங்கீகரிக்கவும்

   ஒரு உலாவியில் paligemma-3b-pt-224 உரிமத்தை ஏற்றுக்கொண்டு, பின்னர் பயிற்சி அளிக்கும் கணினியில் உள்நுழையவும்.

   bash

   hf auth login

3. 3
   குவாண்டில் புள்ளிவிவரங்களைச் சேர்க்கவும்

   Pi0.5 ஆனது STATE மற்றும் ACTION ஐ குவாண்டில்களுடன் இயல்பாக்குகிறது, எனவே meta/stats.json க்கு q01 மற்றும் q99 தேவை. பழைய தரவுத்தொகுப்புகள் min, max, mean, std ஆகியவற்றை மட்டுமே கொண்டுள்ளன.

   bash

   lerobot-edit-dataset \
       --repo_id your_dataset \
       --new_repo_id your_dataset \
       --operation.type recompute_stats \
       --operation.overwrite true

4. 4
   lerobot/pi05_base இலிருந்து ஃபைன்-ட்யூன் செய்யவும்

   உங்கள் கார்டு தாங்கும் அளவுக்கு பேட்ச் அளவை அமைக்கவும்; ஆவணங்கள் LIBERO இல் 80 GB இல் 64 ஐப் பயன்படுத்துகின்றன. bfloat16 ஐ வெளிப்படையாக அனுப்பவும், உள்ளமைவு இயல்புநிலை float32 ஆகும்.

   bash

   lerobot-train \
       --dataset.repo_id=${HF_USER}/my_so100_dataset \
       --policy.type=pi05 \
       --policy.pretrained_path=lerobot/pi05_base \
       --policy.gradient_checkpointing=true \
       --policy.dtype=bfloat16 \
       --policy.device=cuda \
       --policy.push_to_hub=false \
       --output_dir=./outputs/pi05_so100 \
       --job_name=pi05_so100 \
       --batch_size=4 \
       --num_workers=8 \
       --steps=30000 \
       --save_freq=5000 \
       --seed=1000

5. 5
   கையில் இயக்கவும்

   0.6.x இல் இது lerobot-rollout: lerobot-record ஒரு கொள்கையை மறுக்கிறது மற்றும் eval_ தரவுத்தொகுப்பு பெயர்களை நிராகரிக்கிறது. Base ஆனது கையை இயக்குகிறது, sentry ஆனது ரோல்அவுட்டைப் பதிவு செய்கிறது.

   bash

   lerobot-rollout \
       --strategy.type=base \
       --policy.path=${HF_USER}/my_policy \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM1 \
       --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}" \
       --task="Put lego brick into the transparent box" \
       --duration=60
   
   # same run, recorded into an eval_ dataset
   lerobot-rollout \
       --strategy.type=sentry \
       --policy.path=${HF_USER}/my_policy \
       --robot.type=so100_follower \
       --robot.port=/dev/ttyACM1 \
       --dataset.repo_id=${HF_USER}/eval_so100 \
       --dataset.single_task="Put lego brick into the transparent box" \
       --duration=600

மூன்று இயல்புநிலை தொகுப்புகள், மற்றும் பயிற்சியாளரை அடையும் தொகுப்புகள்

openpi's TrainConfig என்பது குறிப்பு, LeRobot's PI05Config என்பது lerobot-train நீங்கள் எதுவும் சொல்லாதபோது பயன்படுத்துவது, மேலும் இங்குள்ள படிவம் ஒரு மூன்றாவது தொகுப்பை அனுப்புகிறது. ஆச்சரியம் என்னவென்றால் கற்றல் விகிதம்: இரண்டு அப்ஸ்ட்ரீம் இயல்புநிலைகளும் 2.5e-5 இல் உச்சத்தை அடைகின்றன, அதேசமயம் openpi இன் pi05_libero உள்ளமைவு மற்றும் இந்த தளம் அதை 5e-5 ஆக உயர்த்துகின்றன.

இந்த போர்ட் நம்பகமானதா? LeRobot குழு LIBERO அடிப்படை மாதிரியை மேலும் 6k படிகளுக்கு ஃபைன்-ட்யூன் செய்து, openpi இன் குறிப்பு எண்களுடன் நான்கு தொகுப்புகளில் ஒப்பிட்டது: 97.5 சதவீதம் சராசரி எதிராக 96.85, Libero 10 இல் முன்னணியில், Spatial இல் பின்தங்கியுள்ளது. இந்த வழி ஒரு கருவி தேர்வு, தரமான தேர்வு அல்ல.

485 மில்லி விநாடி யதார்த்தம், மற்றும் அது எங்கு பயன்படுத்த முடியாததாகிறது

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

அப்ஸ்ட்ரீமில் ஒரு தீர்வு உள்ளது, அதில் பாதி நீங்கள் நிறுவக்கூடிய வெளியீட்டில் ஏற்கனவே உள்ளது. ரியல்-டைம் சங்கிங் (Real-Time Chunking) அடுத்த துண்டினை, கை தற்போதைய துண்டினை செயல்படுத்திக் கொண்டிருக்கும்போதே உருவாக்குகிறது, பின்னர் புதிய துண்டின் ஒன்றுடன் ஒன்று சேரும் படிகளை ஏற்கனவே செயல்படுத்தப்பட்ட பகுதிக்கு அருகில் இருக்குமாறு வழிநடத்துகிறது, இதனால் கை இணைப்பில் நின்றுவிடவோ அல்லது அதிர்ச்சியடையவோ செய்யாது. Pi0, Pi0.5 மற்றும் SmolVLA க்கான 0.4.2 சேஞ்ச்லாக்கில் அனுப்பப்பட்ட இன்ஃபரன்ஸ்-டைம் வடிவம் ஒரு ரோல்அவுட் ஃபிளாக் ஆகும், மீண்டும் பயிற்சி அளிப்பது அல்ல:

lerobot-rollout \
    --strategy.type=base \
    --policy.path=${HF_USER}/my_policy \
    --inference.type=rtc \
    --inference.rtc.execution_horizon=10 \
    --inference.rtc.max_guidance_weight=10.0 \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}}" \
    --task="Put lego brick into the transparent box" \
    --duration=60

இது மாடலை வேகமாக ஆக்காது. இது இடைவெளியை மறைக்கிறது: 485 மில்லி விநாடிகள் இன்னும் செலவிடப்படுகின்றன, ஆனால் முக்கியமான பாதையில் இருந்து விலகி, இதனால் துண்டுகளுக்கு இடையில் வரிசை வறண்டு போகாது. arXiv 2512.05964 இலிருந்து பயிற்சி-நேர மாறுபாடு மேலும் செல்கிறது: மாடல் ஒரு சுத்தமான செயல் முன்னொட்டை (action prefix) நிபந்தனைக்குட்படுத்த கற்றுக்கொள்கிறது, எனவே இன்ஃபரன்ஸில் ஒன்றுடன் ஒன்று சேரும் பகுதி வழிகாட்டப்படுவதற்குப் பதிலாக, ஒரு-செயல்-ஓட்ட நேரப்படிகளுடன் (per-action flow timesteps) கடினமாக வரையப்படுகிறது, மேலும் வழிகாட்டுதல் பின்னோக்கிய பாஸ் மறைந்துவிடுகிறது. பயிற்சியின் போது, இது ஒரு எடுத்துக்காட்டுக்கு ஒரு முன்னொட்டு நீளத்தை மாதிரியாக எடுத்து, மீதமுள்ள பின்னொட்டில் (postfix) ஓட்ட இழப்பை (flow loss) எடுக்கிறது. அந்த ஃபிளாக் மெயினில் மட்டுமே உள்ளது, 0.6.1 இல் இல்லை, மேலும் நீங்கள் பயிற்சி அளிக்கும் தாமதம் chunk_size க்கு கீழே இருக்க வேண்டும்.

Pi0.5 செக்பாயிண்ட்டைப் பெறுவதற்கான இரண்டு வழிகள்

lerobot-train \
    --dataset.repo_id=${HF_USER}/my_so100_dataset \
    --policy.type=pi05 \
    --policy.pretrained_path=lerobot/pi05_base \
    --policy.rtc_training_max_delay=10 \
    --policy.gradient_checkpointing=true \
    --policy.dtype=bfloat16 \
    --batch_size=4 --steps=30000 --seed=1000

அது வேலை செய்யாதபோது

• தரவுத்தொகுப்பு நிராகரிக்கப்பட்டது: v3 தேவை
• பயிற்சியின் போது நினைவகம் பற்றாக்குறை
• இழப்பு குறைகிறது ஆனால் கொள்கை எதுவும் செய்யவில்லை
• கொள்கை நடுப்பாதையில் உறைந்துவிடுகிறது
• கொள்கை ஒரு அமைப்பில் மட்டுமே செயல்படுகிறது
• பயிற்சி பணி வரிசையில் சிக்கியுள்ளது

ஒரு ஓட்டத்தின் செலவு என்ன

Pi0.5 ஆனது விலையுயர்ந்த அடுக்கில் உள்ளது, ஏனெனில் அதற்கு 80 GB கார்டு தேவைப்படுகிறது, மேலும் ஸ்பாட் விலைகள் மாறுபடும், எனவே இந்த எண்ணிக்கை ஒரு விலையை விட ஒரு வரம்பாகும். பல SO-100 பணிகளுக்கு, முதலில் SmolVLA அல்லது ACT ஐ 24 GB அடுக்கில் முதலில் பயிற்சி செய்யுங்கள், பணி கற்றுக்கொள்ளக்கூடியதா என்பதை உறுதிப்படுத்தவும், பின்னர் A100 மணிநேரத்தை அதில் செலவிடவும். உங்கள் முதல் கொள்கையைப் பயிற்றுவிக்கவும் அந்த மலிவான சுழற்சியைக் காட்டுகிறது, மேலும் விலை நிர்ணயம் தற்போதைய அடுக்குகளைக் கொண்டுள்ளது.

ஒரு மாலை நேரத்தை அர்ப்பணிக்கும் முன்: GR00T N1.7 மற்றும் Pi0.5 மற்றும் Pi0.5 மற்றும் SmolVLA ஆகியவை ஒரே எண்களை நேருக்கு நேர் ஒப்பிடுகின்றன. Arena ஆனது 85 VLA மாதிரிகள் மற்றும் 332 பெஞ்ச்மார்க் முடிவுகளைக் கொண்டுள்ளது, ஒவ்வொன்றும் அதன் மூலத்துடன் இணைக்கப்பட்டுள்ளது, மேலும் இந்த குடும்பத்தைப் பற்றிய பின்னணி தகவல்கள் எங்கள் VLA கண்ணோட்டத்தில்.