మీ స్వంత రోబోట్ డేటాపై Pi0.5ని ఎలా శిక్షణ ఇవ్వాలి

Pi0.5 అనేది ఒక పాలసీ ఇంతకు ముందు చూడని గదిలో పని చేయాల్సి వచ్చినప్పుడు మీరు ఎంచుకునే మోడల్. ఇది ఇక్కడ ఉన్న ఐదు శిక్షణ ఇవ్వగల పాలసీలు లో అత్యంత కష్టమైనది, చేతితో ఫైన్-ట్యూన్ చేయడానికి: అప్‌స్ట్రీమ్ రిపోజిటరీ మొదట JAX, LeRobot పోర్ట్ 0.6.0లో lerobot-record నుండి డిప్లాయ్‌మెంట్‌ను తరలించింది మరియు బేస్ ఇన్‌స్టాల్‌ను శిక్షణ ఇవ్వడానికి చాలా చిన్నదిగా చేసింది, మరియు పూర్తి ఫైన్-ట్యూన్ 4090లో సరిపోదు. కింద: ఇన్ఫరెన్స్ వద్ద ఫ్లో మ్యాచింగ్ ఎంత ఖర్చవుతుంది, రెండు కమాండ్ మార్గాలు, మరియు ఫలితం ఉపయోగపడగలదా అని నిర్ణయించే 485 ms సంఖ్య.

Pi0.5 అంటే ఏమిటి

ఫిజికల్ ఇంటెలిజెన్స్ అక్టోబర్ 2024లో pi0ను ప్రచురించింది: ఒక ప్రీట్రైన్డ్ VLMపై ఫ్లో మ్యాచింగ్ విజన్-లాంగ్వేజ్-యాక్షన్ మోడల్: 3 బిలియన్ పారామీటర్లతో పాలిగెమ్మా మరియు మొదటి నుండి ప్రారంభించబడిన 300M యాక్షన్ ఎక్స్‌పర్ట్, మొత్తం 3.3 బిలియన్. ఈ పత్రం 7 రోబోట్ కాన్ఫిగరేషన్‌లు మరియు 68 టాస్క్‌లలో 10,000 గంటలకు పైగా రోబోట్ డేటాపై ప్రీ-ట్రైనింగ్‌ను నివేదిస్తుంది. మరింత సమాచారం pi0 వ్యాసంలో.

Pi0.5 (arXiv 2504.16054, 22 ఏప్రిల్ 2025) ఆ స్కెలిటన్‌ను అలాగే ఉంచి, శిక్షణ ఆహారాన్ని మార్చింది: వెబ్ డేటా, ఆబ్జెక్ట్ డిటెక్షన్, రోబోట్‌కు శిక్షణ ఇచ్చే మానవుల నుండి మౌఖిక సూచనలు, సబ్‌టాస్క్ లేబుల్‌లు, అనేక ఇళ్లలోని రోబోట్‌ల నుండి క్రాస్-ఎంబోడిమెంట్ డేటా. శిక్షణ సెట్‌లో లేని ఇళ్లలో వంటగదులను శుభ్రం చేసే రోబోట్ ఫలితం. ఓపెన్‌పి 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 (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 రిపోజిటరీతో ఫైన్-ట్యూన్ చేయండి

రిఫరెన్స్ ఇంప్లిమెంటేషన్: మొదట JAX, Ubuntu 22.04లో మాత్రమే పరీక్షించబడింది, ఫ్లాగ్‌ల కంటే కాన్ఫిగ్ ఆబ్జెక్ట్‌ల ద్వారా నడపబడుతుంది. 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 కోసం కన్వర్టర్‌లను అందిస్తుంది మరియు మీరు ఒకదాన్ని స్వీకరించాలని ఆశిస్తుంది. పని కీ మ్యాపింగ్.

   bash

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

3. 3
   శిక్షణ కాన్ఫిగ్‌ను జోడించండి

   కాన్ఫిగ్‌లు src/openpi/training/config.pyలో TrainConfig ఎంట్రీలు. ఇది pi05_droid_finetuneని స్వీకరిస్తుంది, వెయిట్ లోడర్ 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 డిపెండెన్సీలను మాత్రమే కలిగి ఉంటుంది, మరియు పై ఎక్స్‌ట్రా ఎటువంటి డేటాసెట్ లేదా శిక్షణ కోడ్‌ను జోడించదు, కాబట్టి ఫైన్-ట్యూన్ చేయడానికి శిక్షణ ఎక్స్‌ట్రా కూడా అవసరం. పాత వన్-లైనర్‌లు ఇక్కడ ఇంపోర్ట్ సమయంలో విఫలమవుతాయి.

   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 నుండి ఫైన్-ట్యూన్ చేయండి

   మీ కార్డ్ తట్టుకునే బ్యాచ్ పరిమాణాన్ని సెట్ చేయండి; డాక్యుమెంట్లు 80 GB వద్ద LIBERO లో 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_ డేటాసెట్ పేర్లను అంగీకరించదు. బేస్ ఆర్మ్‌ను నడుపుతుంది, సెంటినల్ రోల్‌అవుట్‌ను రికార్డ్ చేస్తుంది.

   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 యొక్క TrainConfig అనేది రిఫరెన్స్, మీరు ఏమీ చెప్పనప్పుడు lerobot-train ఉపయోగించేది LeRobot యొక్క PI05Config, మరియు ఇక్కడ ఉన్న ఫారం మూడవ సెట్‌ను పంపుతుంది. ఆశ్చర్యకరమైన విషయం ఏమిటంటే లెర్నింగ్ రేట్: రెండు అప్‌స్ట్రీమ్ డిఫాల్ట్‌లు 2.5e-5 వద్ద గరిష్ట స్థాయికి చేరుకుంటాయి, అయితే openpi యొక్క సొంత pi05_libero కాన్ఫిగ్ మరియు ఈ ప్లాట్‌ఫారమ్ దానిని 5e-5కి పెంచుతాయి.

పోర్ట్ నమ్మదగినదా? LeRobot బృందం LIBERO బేస్ మోడల్‌ను అదనంగా 6k స్టెప్స్ కోసం ఫైన్-ట్యూన్ చేసింది మరియు నాలుగు సూట్‌లలో openpi యొక్క రిఫరెన్స్ నంబర్‌లతో పోల్చింది: 96.85కి వ్యతిరేకంగా 97.5 శాతం సగటు, Libero 10లో ముందుంది, Spatialలో వెనుకబడింది. ఈ మార్గం టూలింగ్ ఎంపిక, నాణ్యత ఎంపిక కాదు.

485 ms వాస్తవం, మరియు అది ఎక్కడ ఉపయోగపడకుండా పోతుంది

ఇది మీ ప్రాజెక్ట్‌ను నిర్ణయిస్తుంది, కాబట్టి ఇది ఖర్చు పట్టికకు ముందు వస్తుంది. Pi0.5 కోసం ఇక్కడ కొలవబడిన ప్రతి చర్య దశకు 485 ms. మిగిలిన నాలుగు వాటితో పోలిస్తే:

అప్‌స్ట్రీమ్ వద్ద ఒక పరిష్కారం ఉంది, మరియు అందులో సగం మీరు ఇన్‌స్టాల్ చేయగల విడుదలలోనే ఉంది. రియల్-టైమ్ చంకింగ్, చేయి ప్రస్తుత ఖండాన్ని అమలు చేస్తున్నప్పుడు తదుపరి ఖండాన్ని ఉత్పత్తి చేస్తుంది, ఆపై కొత్త ఖండం యొక్క అతివ్యాప్తి చెందుతున్న దశలను ఇప్పటికే అమలు చేసిన భాగానికి దగ్గరగా ఉండేలా మార్గనిర్దేశం చేస్తుంది, తద్వారా చేయి అతుకు వద్ద ఆగిపోదు లేదా కుదుపుకు గురికాదు. 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 ms ఇప్పటికీ ఖర్చు అవుతుంది, కానీ కీలక మార్గం నుండి దూరంగా, కాబట్టి ఖండాల మధ్య క్యూ ఎండిపోదు. arXiv 2512.05964 నుండి వచ్చిన శిక్షణ-సమయ వేరియంట్ మరింత ముందుకు వెళుతుంది: మోడల్ ఒక క్లీన్ యాక్షన్ ప్రిఫిక్స్‌పై షరతు విధించడం నేర్చుకుంటుంది, కాబట్టి ఇన్ఫరెన్స్ వద్ద అతివ్యాప్తి మార్గనిర్దేశం చేయబడకుండా, ప్రతి-చర్య ప్రవాహ టైమ్‌స్టెప్‌లతో గట్టిగా ఇన్-పెయింట్ చేయబడుతుంది, మరియు మార్గనిర్దేశక బ్యాక్‌వర్డ్ పాస్ అదృశ్యమవుతుంది. శిక్షణ సమయంలో ఇది ప్రతి ఉదాహరణకు ఒక ప్రిఫిక్స్ పొడవును నమూనా చేస్తుంది మరియు మిగిలిన పోస్ట్‌ఫిక్స్‌పై ప్రవాహ నష్టాన్ని తీసుకుంటుంది. ఆ ఫ్లాగ్ మెయిన్‌లో మాత్రమే ఉంటుంది, 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 అదే సంఖ్యలను తలపైన తలపెట్టి చూపిస్తాయి. అరేనా 332 బెంచ్‌మార్క్ ఫలితాలతో 85 VLA మోడళ్లను కలిగి ఉంది, ప్రతి ఒక్కటి దాని మూలానికి లింక్ చేయబడింది, మరియు ఈ కుటుంబం గురించిన నేపథ్యం మా VLA అవలోకనం.