24 GB GPU-வில் SmolVLA-வை எப்படிப் பயிற்றுவிப்பது (lerobot 0.6.1)

பெரும்பாலான மக்கள் ஒரு பார்வை மொழி செயல் மாதிரி ஒரு உண்மையான கையில் வன்பொருள் எல்லையில் நின்றுவிடுகிறார்கள். GR00T N1.7 மற்றும் Pi0.5 ஒவ்வொன்றும் சுமார் மூன்று பில்லியன் அளவுருக்களைக் கொண்டுள்ளன மற்றும் ஒரு A100 80 GB அல்லது ஒரு H100 ஐ விரும்புகின்றன. உங்களிடம் RTX 4090 கொண்ட ஒரு கேமிங் PC இருந்தால், அதுதான் முடிவின் வழி. SmolVLA ஒரு விதிவிலக்கு: 450 மில்லியன் அளவுருக்கள், LeRobot க்குள், ஒரு நுகர்வோர் கார்டில் ஃபைன்-ட்யூன் செய்யவும் CPU இலிருந்து சேவை செய்யவும் உருவாக்கப்பட்டது.

முதலில் கையேடு வழி: lerobot ஐ நிறுவவும், lerobot/smolvla_base செக்பாயிண்ட்டை இழுக்கவும், உண்மையான கட்டளையை இயக்கவும், அது நடக்கும்போது இயக்கத்தைப் படிக்கவும். பின்னர் தள வழி, மற்றும் அது எங்கு உதவாது.

SmolVLA என்றால் என்ன, நீங்கள் சரிபார்க்கக்கூடிய எண்களில்

SmolVLA என்பது ஒரு ஃப்ளோ மேட்சிங் கொள்கையாகும், இது ஒரு சிறிய பார்வை மொழி மாதிரியுடன் இணைக்கப்பட்டுள்ளது. இதன் முதுகெலும்பு SmolVLM2-500M-Video-Instruct ஆகும்; இந்த ஆய்வுக் கட்டுரை அதன் மொழி மாதிரியின் முதல் 16 அடுக்குகளை மட்டுமே பயன்படுத்துகிறது, ஒவ்வொரு கேமரா பிரேமையும் இமேஜ் டைலிங்கிற்குப் பதிலாக பிக்சல் ஷஃபிள் மூலம் 64 காட்சி டோக்கன்களாகக் கட்டுப்படுத்துகிறது, மற்றும் ஒவ்வொரு இரண்டாவது பிளாக்கிலும் ஒரு சுய-கவன அடுக்குடன் குறுக்கு-கவனத்தை (cross attention) ஒன்றிணைக்கிறது. இன்ஃபரன்ஸ் செலவு ஒரு வடிவமைப்புத் தடையாக இருந்தது, ஒரு பிந்தைய சிந்தனை அல்ல.

450 M மாதிரியுடன் மக்கள் ஏன் சிரமப்படுகிறார்கள் என்பதற்கு பெஞ்ச்மார்க்குகள் தான் காரணம். LIBERO-வில், இது 7 B OpenVLA-க்கு 76.5 மற்றும் 3.3 B ரோபோடிக்ஸ்-முன் பயிற்சி பெற்ற Pi0-க்கு 86.0 எதிராக சராசரியாக 87.3 சதவீதத்தை அடைகிறது; Meta-World-ல், 47.9-க்கு எதிராக 57.3. உண்மையான SO-100 ஹார்டுவேரில், பல-பணி பயிற்சி, பிக் அண்ட் பிளேஸில் 75 சதவீதம், ஸ்டாக்கிங்கில் 90, வரிசைப்படுத்துதலில் 70 என சராசரியாக 78.3 சதவீதத்தை அளிக்கிறது, அங்கு ACT ஒவ்வொரு பணிக்கும் பயிற்சி அளிக்கப்பட்டு சராசரியாக 48.3 சதவீதத்தை அடைந்தது. அதே வரிசைகள் SmolVLA அரங்கம் உள்ளீடு மற்றும் ACT மற்றும் SmolVLA ஒப்பீடு ஆகியவற்றில் வெளியிடப்பட்ட ஒவ்வொரு VLA-யுடனும் உள்ளன.

24 GB கார்டு ஏன் முதல் ஓட்டத்திற்கு சரியான தேர்வு?

LeRobot ஒரு கணக்கீட்டு அளவிடுதல் வழிகாட்டியை வழங்குகிறது, இது இந்த களஞ்சியத்தில் மிகவும் பயனுள்ள பக்கம். இது கொள்கைகளை பேக்போன் அளவின் அடிப்படையில் தொகுக்கிறது மற்றும் ஒவ்வொரு குழுவிற்கும் ஒரு VRAM அளவை வழங்குகிறது, இது lerobot இயல்புநிலையான AdamW உடன் பேட்ச் அளவு 8 இல் அளவிடப்படுகிறது. ஆப்டிமைசர் நிலை மட்டும் ஒரு சாதாரண முன்னோக்கி மற்றும் பின்னோக்கி செல்லும் பாதையை விட 30 முதல் 100 சதவீதம் வரை சேர்க்கிறது, எனவே இவை எடைகள் மட்டுமே கொண்ட புள்ளிவிவரங்கள் அல்ல.

பேட்ச் 8 இல் பத்து முதல் பதினாறு ஜிகாபைட் என்பது வாதம்: ஒரு 24 GB கார்டு அதையும் டேட்டா லோடரையும் உள்ளடக்கும். AY-Robots ஆனது SmolVLA ஐ RTX 4090 அல்லது எந்த 24 GB கார்டிலும் வைக்கிறது, குறைந்தபட்சம் 30 எபிசோடுகள், LeRobot v3.0 தரவு, ஒரு செயல் படிக்கு 245 ms. வாடகைக்கு, இது ஒரு மணி நேரத்திற்கு 0.30 முதல் 0.60 USD என்ற விகிதத்தில் 2 முதல் 5 மணிநேரம் ஆகும், சுமார் 1 முதல் 3 USD ஒரு ஃபைன்-ட்யூனிங் ஓட்டத்திற்கு, 80 GB அடுக்கு GR00T மற்றும் Pi0.5 தேவைப்படும் 4 முதல் 12 USD உடன் ஒப்பிடுகையில் (விலை நிர்ணயம்). ஒரு தோல்வியுற்ற SmolVLA ஓட்டம் ஒரு காபி; ஒரு தோல்வியுற்ற GR00T ஓட்டம், மதிய உணவு.

படி 0: தரவுத்தொகுப்பு இயக்கத்தை தீர்மானிக்கிறது, கொடிகள் அல்ல

பதிவு மோசமாக இருந்தால் கீழே உள்ள எதுவும் முக்கியமில்லை. LeRobot SmolVLA பக்கம் வெளிப்படையாகக் கூறுகிறது: குறிப்பு தரவுத்தொகுப்பு 5 கன சதுர நிலைகளில் 50 எபிசோடுகள், ஒரு நிலைக்கு 10, மற்றும் அதே பணி 25 எபிசோடுகளில் மோசமாக செயல்பட்டது. மாறுபாட்டிற்கு ஒரு மறுபடியும் பொதுமைப்படுத்துகிறது, மூல எபிசோட் எண்ணிக்கை இல்லை. ஒருபோதும் பதிவு செய்யவில்லையா? இங்கு தொடங்கவும் உங்கள் முதல் தரவுத்தொகுப்பை பதிவு செய்யவும், உடன் டெஸ்க்டாப் கிளையன்ட், இது ஒரு தொலைசெயல்பாடு அமர்விலிருந்து LeRobot வடிவத்தை எழுதுகிறது, அல்லது தரவுத்தொகுப்பு அடைவு இலிருந்து ஒன்றைப் பெறவும்.

• AY-Robots இல் குறைந்தது 30 எபிசோடுகள், LeRobot குறிப்பு செய்முறைக்கு சுமார் 50.
• வெளியீட்டில் நீங்கள் எதிர்பார்க்கும் ஒவ்வொரு மாறுபாடும், பலமுறை மீண்டும் மீண்டும்.
• பதிவு மற்றும் வெளியீட்டு நேரத்தில் ஒரே மாதிரியாக உச்சரிக்கப்படும் ஒரு பணி சரம். மாதிரி அந்த உரையால் நிபந்தனைக்குட்படுத்தப்பட்டுள்ளது.
• நிலையான கேமராக்கள். பதிவு மற்றும் வெளியீட்டிற்கு இடையில் நகர்த்தப்பட்ட ஒரு கேமரா, ஒரு சுத்தமான இழப்பு வளைவு அசைவற்ற கையை வழங்குவதற்கான பொதுவான காரணம்.
• நீங்கள் ஒருபோதும் பயிற்சி செய்யாத ஒரு ஒதுக்கப்பட்ட மாறுபாடு, எனவே நீங்கள் நேர்மையாக சோதிக்க ஒரு விஷயம் உள்ளது.

# v2.1 -> v3.0: aggregates per-episode files into shards and writes the episode offsets
python -m lerobot.scripts.convert_dataset_v21_to_v30 --repo-id=${HF_USER}/so100_pick_place

இது பற்றி மேலும் உயர்தர VLA பயிற்சித் தரவை எவ்வாறு சேகரிப்பது. சுருக்கமாக: வேண்டுமென்றே மாறுபாடுகளுடன் ஒரு பணியின் 30 முதல் 50 சுத்தமான எபிசோடுகள், மூன்று பணிகளின் 200 ஒழுங்கற்ற எபிசோடுகளை விட சிறந்தவை, எந்த ஹைப்பர்பாராமீட்டரும் ஈடுசெய்ய முடியாத ஒரு வித்தியாசத்தில்.

lerobot 0.6.1 ஐ நிறுவவும்

# LeRobot needs Python 3.12 or newer as of 0.6.x
conda create -y -n lerobot python=3.12
conda activate lerobot

# TorchCodec decodes the dataset videos and wants ffmpeg
conda install ffmpeg -c conda-forge

# Base package is deliberately thin; extras pull the rest
pip install 'lerobot[smolvla,training,core_scripts]'

# Sanity check: prints the lerobot version, the GPU torch sees, and the console scripts you got
lerobot-info

அடிப்படை lerobot நிறுவல் மெல்லியதாக உள்ளது மற்றும் கூடுதல் அம்சங்களுக்குப் பின்னால் கனமான சார்புகளைக் கட்டுப்படுத்துகிறது: smolvla ஆனது transformers, num2words மற்றும் accelerate ஐ சேர்க்கிறது, training தரவுத்தொகுப்பு அடுக்கு மற்றும் wandb ஐ சேர்க்கிறது, core_scripts வன்பொருள் மற்றும் காட்சிப்படுத்தல் சார்புகளை சேர்க்கிறது. லினக்ஸில் நிறுவல் பாதை உங்கள் CUDA வீலையும் தீர்மானிக்கிறது: PyPI இயல்புநிலை 580.65 இன் டிரைவர் தளத்துடன் கூடிய cu130 வீல் ஆகும், எனவே பழைய டிரைவரில் முதலில் cu128 குறியீட்டிலிருந்து டார்ச்சை நிறுவி, பின்னர் lerobot ஐ நிறுவவும்.

பயிற்சி ஓட்டம், கட்டளைக்குக் கட்டளை

1. 1
   ஹப்புடன் அங்கீகரி

   அடிப்படை சரிபார்ப்பு புள்ளி ஹப்பிலிருந்து வருகிறது, உங்கள் தரவுத்தொகுப்பும் அப்படித்தான் இருக்கும்.

   bash

   hf auth login

2. 2
   விருப்பங்களை ஒருமுறை படிக்கவும்

   பைப்பலைன் மற்றும் கொள்கை உள்ளமைவின் ஒவ்வொரு புலமும் ஒரு கொடி. மூலத்தை ஆராய்வதற்கு முன் அதை மேலோட்டமாகப் பார்க்கவும்.

   bash

   lerobot-train --help

3. 3
   ஃபைன்-ட்யூனைத் தொடங்கு

   ஆவணங்களின் எடுத்துக்காட்டு ஒரு A100 இல் தொகுதி 64 ஐ இயக்குகிறது; கணக்கீட்டு வழிகாட்டியின் சொந்த A100 40 GB ஆங்கர் தொகுதி 16 ஆகும், மேலும் 8 என்பது 24 GB க்கு சமமானதாகும். இங்கே திட்டமிட்டு எந்த ஷெட்யூலர் கொடியும் இல்லை, கீழே பார்க்கவும்.

   bash

   lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/so100_pick_place \
     --batch_size=8 \
     --steps=20000 \
     --save_freq=2000 \
     --log_freq=200 \
     --seed=1000 \
     --output_dir=outputs/train/smolvla_pick_place \
     --job_name=smolvla_pick_place \
     --policy.device=cuda \
     --wandb.enable=true

4. 4
   இழப்பை மட்டும் பார்க்காமல், பதிவு வரியைப் படிக்கவும்

   ஒவ்வொரு --log_freq படிகளிலும் lerobot இழப்பு, grdn, lr, updt_s, data_s, smp/s மற்றும், CUDA இல், mem_gb ஆகியவற்றை அச்சிடுகிறது. mem_gb தொகுதி பொருந்துகிறதா என்பதையும், lr அட்டவணை சிதைந்து வருகிறதா என்பதையும், data_s ஆனது updt_s ஐ நெருங்குவது டேட்டா லோடர் தான் சிக்கல், GPU அல்ல என்பதையும் குறிக்கிறது.

   bash

   # if data_s creeps toward updt_s
   lerobot-train ... --num_workers=8

5. 5
   ஒப்பிடக்கூடிய சரிபார்ப்பு புள்ளிகளைச் சேகரிக்கவும்

   save_freq இயல்பாக 20000 ஆக உள்ளது, எனவே 20000 படி ஓட்டம் ஒரு சரிபார்ப்பு புள்ளியை மட்டுமே விட்டுச்செல்கிறது, ஒப்பிடுவதற்கு எதுவும் இல்லை. 2000 ஆக அமைக்கவும். ஹப்பிற்கு தள்ளுவதற்கு --policy.repo_id தேவை.

   bash

   --save_freq=2000 \
   --policy.repo_id=${HF_USER}/smolvla_pick_place \
   --save_checkpoint_to_hub=true

6. 6
   இயந்திரம் செயலிழந்தால் மீண்டும் தொடங்கு

   சரிபார்ப்பு புள்ளிக்கு அடுத்த train_config.json ஐ --config_path இல் சுட்டிக்காட்டவும். நீங்கள் மீண்டும் தொடங்காத வரை, ஏற்கனவே உள்ள output_dir இல் lerobot தொடங்க மறுக்கிறது, எனவே நீங்கள் தற்செயலாக ஒரு ஓட்டத்தை மேலெழுத முடியாது.

   bash

   lerobot-train \
     --config_path=<path to the saved train_config.json> \
     --resume=true

முடிவை உண்மையில் மாற்றும் கொடிகள்

நீங்கள் எதையும் தொடாவிட்டால் நீங்கள் பெறும் இயல்புநிலைகள்

ஒரு உள்ளமைவு lerobot இல் அதன் சொந்த ஆப்டிமைசர் மற்றும் ஷெட்யூலர் முன்னமைவை கொண்டுள்ளது, மேலும் நீங்கள் use_policy_training_preset=false என்று அமைக்காதவரை அந்த முன்னமைவுகள் வெற்றி பெறும். SmolVLA பயிற்சி பற்றி மக்கள் கேட்கும் கேள்விகளில் பாதி, அவர்களுக்குத் தெரியாத ஒரு இயல்புநிலையால் பதிலளிக்கப்படுகின்றன.

மக்களை ஆச்சரியப்படுத்தும் இரண்டு வரிகள் freeze_vision_encoder மற்றும் train_expert_only, இரண்டும் உண்மை. இயல்பாகவே நீங்கள் தோராயமாக 100 M அளவுருக்களைப் பயிற்றுவிக்கிறீர்கள், 450 M அல்ல, அதனால்தான் இது 24 GB இல் பொருந்துகிறது. நான்கு GPU H100 கிளஸ்டரில் LeRobot இன் சொந்த குறிப்பு இயக்கம் இரண்டையும் தவறாக மாற்றுகிறது; ஒரு 24 GB கார்டில் அது ஒரு வேலை செய்யும் இயக்கத்தை .

இயக்கம் எவ்வளவு நேரம் எடுக்கும், மற்றும் எத்தனை படிகள் போதுமானது

LeRobot தோராயமாக 50 எபிசோட் தரவுத்தொகுப்பில் ஐந்து எபோக்குகளுக்கான சுவர்-கடிகார ஆங்கர்களை வெளியிடுகிறது, இது 30 fps இல் சுமார் 45000 பிரேம்கள் ஆகும். ஆவணங்கள் கூறுவது போல், இவை தோராயமான புள்ளிவிவரங்கள், ஆனால் அவை ஒரு மணிநேரத்தை எதிர்பார்ப்பதற்கும் ஒரு நாளை எதிர்பார்ப்பதற்கும் உள்ள வேறுபாடு.

fine-tune செய்யப்பட்ட கொள்கையை மீண்டும் கையில் இயக்குதல்

lerobot-rollout \
  --strategy.type=base \
  --robot.type=so100_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.id=my_follower_arm \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \
  --task="Grasp the cube and put it in the box." \
  --policy.path=${HF_USER}/smolvla_pick_place

245 மில்லி விநாடிகள் ஒரு செயல் படிக்கு என்பதை தவறாகப் புரிந்துகொள்வது எளிது: கொள்கை chunk_size = 50 செயல்களை முன்னோக்கி செல்லும் ஒவ்வொரு படிக்கும் வெளியிடுகிறது மற்றும் n_action_steps = 50 அவற்றில் செயல்படுத்துகிறது, எனவே நீங்கள் அந்த செலவை எவ்வளவு அடிக்கடி செலுத்துகிறீர்கள் என்பது அந்த கட்டுப்பாடுகளால் நிர்ணயிக்கப்படுகிறது, சர்வோக்கள் எவ்வளவு அடிக்கடி கட்டளையைப் பெறுகின்றன என்பதன் மூலம் அல்ல. அதுதான் வாங்குகிறது, மேலும் 245 மில்லி விநாடிகள் மாதிரி ஏன் 30 ஹெர்ட்ஸ் கையை இயக்க முடியும். மீதமுள்ளது துண்டின் முடிவில்.

அந்த மூன்றாவது வரிதான் பெரும்பாலான கட்டுரைகள் தவிர்க்கின்றன. ஒத்திசைவற்ற ஊகிப்பு சுமார் 30 சதவீதம் வேகமானது மற்றும் ஒரு குறிப்பிட்ட சாளரத்தில் வெளியீட்டை தோராயமாக இருமடங்காக்குகிறது, மேலும் ஆய்வுக்கட்டுரை வெற்றி விகிதங்களை ஒப்பிடக்கூடியவை என்று கூறுகிறது, சராசரியாக அவை அப்படித்தான். அதன் கீழ், வரிசைப்படுத்துதல் 70 சதவீதத்திலிருந்து 50 சதவீதமாகக் குறைந்தது, அதே நேரத்தில் எடுத்து வைத்தல் 5 சதவீதம் அதிகரித்தது. lerobot 0.6.1 அதே பைனரியில் மற்ற நெம்புகோலை கொண்டுள்ளது: --inference.type=rtc இது வெளியீட்டை நிகழ்நேர துண்டாக்குதலுக்கு மாற்றுகிறது, இது ஸ்கிரிப்ட்டின் சொந்த பயன்பாட்டுப் பகுதி மெதுவான VLAs, Pi0, Pi0.5 மற்றும் SmolVLA-க்கு பரிந்துரைக்கிறது.

ஒரே செக்பாயிண்டிற்கு இரண்டு வழிகள்

pip install 'lerobot[smolvla,training,core_scripts]'
hf auth login

lerobot-train \
  --policy.path=lerobot/smolvla_base \
  --dataset.repo_id=${HF_USER}/so100_pick_place \
  --batch_size=8 --steps=20000 \
  --save_freq=2000 --seed=1000 \
  --output_dir=outputs/train/smolvla_pick_place \
  --job_name=smolvla_pick_place \
  --policy.device=cuda --wandb.enable=true

SmolVLA தவறான தேர்வாக இருக்கும்போது

SmolVLA சரியான முதல் ஓட்டமா என்பதற்கான சோதனை அது வேலை செய்ததா என்பதல்ல, தோல்வி உங்களுக்கு ஏதாவது சொன்னதா என்பதுதான். 60 அல்லது 70 சதவீதத்தை அடைந்தால், ஒரு பெரிய மாதிரி அடுத்ததாக செலவழிக்க நியாயமானது: தரவு சிக்னலைக் கொண்டுள்ளது. 10 சதவீதத்தை அடைந்தால், ஒரு 3 B மாதிரியும் பெரும்பாலும் 10 சதவீதத்தை அடையும், இதை நீங்கள் பன்னிரண்டு டாலர்களுக்குப் பதிலாக மூன்று டாலர்களுக்குக் கற்றுக்கொண்டீர்கள்.

மேலும் செலவழிக்கும் முன் படிக்க வேண்டியவை: Pi0.5 எதிராக SmolVLA அதே யோசனையில் அதிக திறனுக்காக, மற்றும் GR00T N1.7 எதிராக SmolVLA NVIDIA வழித்தடத்திற்காக, இவை இரண்டும் 80 GB அடுக்கில் ஒரு ஓட்டத்திற்கு 4 முதல் 12 USD ஆகும். மற்றொரு வழி, ACT என்பது மலிவான அடிப்படை: 80 M அளவுருக்கள், ஒரு செயல் படிக்கு 20 ms, மொழி நிபந்தனை இல்லை. இந்த ஐந்தும் கொள்கைகள் பக்கத்தில் உள்ளன; அரங்கில் 85 மாதிரிகள் மற்றும் 332 பெஞ்ச்மார்க் முடிவுகள் உள்ளன.

எதையும் அளவிடுவதற்கு முன் சரிபார்ப்புப் பட்டியல்

1. Did the lr reach its 2.5e-6 floor? 30000 படிகளுக்குக் கீழே lerobot சிதைவை மறுசீரமைத்து தொடக்கத்தில் அதைக் குறிப்பிடும்; அதற்கு மேல், `--policy.scheduler_decay_steps` ஐ நீங்களே அமைக்கவும்.
2. ஒன்றுக்கு மேற்பட்ட சரிபார்ப்புப் புள்ளிகள், மற்றும் `--dataset.eval_split` உடன் ஒதுக்கப்பட்ட எபிசோடுகள், இதனால் மதிப்பீட்டு இழப்பு ஒரு அர்த்தத்தைக் கொடுக்கும்.
3. கொள்கை சிறிதளவாவது நகர்கிறதா? அசைவற்ற கையுடன் இழப்பு குறைவது குறிப்பிட்ட காரணங்களைக் கொண்டுள்ளது: இழப்பு குறைகிறது, கொள்கை எதுவும் செய்யவில்லை.
4. இது காட்சி மாற்றத்தைத் தாங்குமா? இல்லையெனில்: கொள்கை ஒரு அமைப்பில் மட்டுமே செயல்படுகிறது.
5. விதையை எழுதி வைத்தீர்களா? lerobot இயல்பாக 1000 ஆக இருக்கும், எனவே இரண்டு தொடப்படாத ஓட்டங்கள் ஒப்பிடக்கூடியதாக இருக்கும்.
6. அதன் பிறகு மட்டுமே: அதிக எபிசோடுகள், அதிக மாறுபாடுகள் அல்லது பெரிய மாதிரி. அந்த வரிசையில்.

இந்த மாதிரிகள் ஏன் உள்ளன மற்றும் மொழி உள்ளீட்டைக் கொண்டு அவை என்ன செய்கின்றன என்பதற்கு, பின்னணியாகும்; அசெம்பிளியை வழியாக முதல் ஓட்டம் வரை நடத்துகிறது. முடிக்கப்பட்ட சரிபார்ப்புப் புள்ளிக்கு, ; கை ஒருபோதும் தோன்றவில்லை என்றால், .