24 GB GPU එකක SmolVLA පුහුණු කරන්නේ කෙසේද (lerobot 0.6.1)

සැබෑ අතක් මත දෘශ්‍ය භාෂා ක්‍රියාකාරී ආකෘතියක් අවශ්‍ය බොහෝ දෙනෙක් දෘඪාංග සීමාවේදී නතර වෙති. GR00T N1.7 සහ Pi0.5 එක් එක් පරාමිති බිලියන තුනක් පමණ වන අතර A100 80 GB හෝ H100 එකක් අවශ්‍ය වේ. ඔබට RTX 4090 සහිත gaming PC එකක් තිබේ නම්, එය මාර්ගයේ අවසානයයි. SmolVLA යනු ව්‍යතිරේකයයි: 450 M පරාමිති, LeRobot තුළ, එක් පාරිභෝගික කාඩ්පතක් මත fine-tune කිරීමට සහ CPU එකකින් සේවය කිරීමට සාදා ඇත.

පළමුව අතින් මාර්ගය: lerobot ස්ථාපනය කරන්න, lerobot/smolvla_base checkpoint එක ලබා ගන්න, සැබෑ විධානය ක්‍රියාත්මක කරන්න, එය සිදුවන අතරතුර ධාවනය කියවන්න. ඉන්පසු platform මාර්ගය, සහ එය උදව් නොකරන තැන.

SmolVLA යනු කුමක්ද, ඔබට පරීක්ෂා කළ හැකි සංඛ්‍යා වලින්

SmolVLA යනු ප්‍රවාහ ගැලපීම ප්‍රතිපත්තියක් කුඩා දෘශ්‍ය භාෂා ආකෘතියකට සම්බන්ධ කර ඇත. ප්‍රධාන පදනම වන්නේ SmolVLM2-500M-Video-Instruct ය; පත්‍රිකාව එහි භාෂා ආකෘතියේ පළමු ස්ථර 16 පමණක් තබා ගනී, එක් එක් කැමරා රාමුව රූප ටයිල් කිරීම වෙනුවට පික්සල් ෂෆල් එකක් සමඟ දෘශ්‍ය ටෝකන 64 කට සීමා කරයි, සහ සෑම දෙවන බ්ලොක් එකකම ස්වයං අවධානය යොමු කරන ස්ථරයක් සමඟ හරස් අවධානය අන්තර් සම්බන්ධ කරයි. අනුමාන පිරිවැය සැලසුම් සීමාවක් මිස පසු සිතුවිල්ලක් නොවේ.

මිලියන 450 ක ආකෘතියක් සමඟ මිනිසුන් වෙහෙසෙන්නේ මිණුම් සලකුණු නිසාය. LIBERO හි එය 7 B හි OpenVLA සඳහා 76.5 ට එරෙහිව 87.3% ක් සහ 3.3 B හි රොබෝ විද්‍යාව සඳහා පූර්ව පුහුණු කරන ලද Pi0 සඳහා 86.0% ක් සාමාන්‍යය කරයි; Meta-World හි, 47.9 ට එරෙහිව 57.3% ක්. සැබෑ SO-100 දෘඪාංග මත, බහු-කාර්ය පුහුණුව තෝරා ගැනීම සහ තැබීම සඳහා 75% ක්, ගොඩගැසීම සඳහා 90% ක්, වර්ග කිරීම සඳහා 70% ක් ලබා දෙයි, සාමාන්‍යය 78.3% ක් වන අතර, ACT එක් කාර්යයක් සඳහා පුහුණු කරන ලද සාමාන්‍යය 48.3% කි. එම පේළි සෑම ප්‍රකාශිත VLA එකක් අසලම SmolVLA පිටියේ ඇතුළත් කිරීම සහ ACT එදිරිව SmolVLA සංසන්දනය අසල ඇත.

24 GB කාඩ්පතක් පළමු ධාවනයට සුදුසු වන්නේ ඇයි

LeRobot මේ සඳහා ගබඩාවේ ඇති වඩාත්ම ප්‍රයෝජනවත් පිටුව වන ගණනය කිරීමේ ප්‍රමාණකරණ මාර්ගෝපදේශයක් සපයයි. එය ප්‍රතිපත්ති (policies) ප්‍රධාන ව්‍යුහයේ ප්‍රමාණය අනුව කාණ්ඩ කරන අතර, lerobot පෙරනිමි අගය වන AdamW සමඟ, batch size 8 දී මනිනු ලබන එක් එක් කාණ්ඩයට VRAM සීමාවක් ලබා දෙයි. Optimizer තත්ත්වය පමණක්, සාමාන්‍ය forward සහ backward pass එකකට වඩා සියයට 30 සිට 100 දක්වා වැඩි කරයි, එබැවින් මේවා බර (weights) පමණක් වන සංඛ්‍යා නොවේ.

batch 8 දී ගිගාබයිට් දහයේ සිට දහසය දක්වා ප්‍රමාණය තර්කයයි: 24 GB කාඩ්පතකට එයට අමතරව dataloader එකද ඇතුළත් වේ. AY-Robots SmolVLA, RTX 4090 හෝ ඕනෑම 24 GB කාඩ්පතක ස්ථාපනය කරයි, අවම වශයෙන් 30 කථාංග, LeRobot v3.0 දත්ත, එක් ක්‍රියාකාරී පියවරකට 245 ms. කුලියට ගත් විට, එය පැයකට 0.30 සිට 0.60 USD බැගින් පැය 2 සිට 5 දක්වා වේ, ආසන්න වශයෙන් 1 සිට 3 USD fine-tuning ධාවනයකට, GR00T සහ Pi0.5 සඳහා අවශ්‍ය 80 GB ස්ථරයේ 4 සිට 12 USD ට සාපේක්ෂව (මිලකරණය). අසාර්ථක SmolVLA ධාවනයක් යනු කෝපි එකක් වැනිය; අසාර්ථක GR00T ධාවනයක්, දිවා ආහාරයකි.

පියවර 0: ධාවනය තීරණය කරන්නේ දත්ත කට්ටලය මිස flags නොවේ

පටිගත කිරීම නරක නම් පහත කිසිවක් වැදගත් නොවේ. 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 ට්‍රාන්ස්ෆෝමර්, num2words සහ accelerate එකතු කරයි, training දත්ත කට්ටල ස්ටැක් එක සහ wandb, core_scripts දෘඪාංග සහ දෘශ්‍යකරණ යැපීම්. ලිනක්ස් මත ස්ථාපන මාර්ගය ඔබේ CUDA wheel එක ද තීරණය කරයි: PyPI පෙරනිමිය 580.65 ක ධාවක අවමයක් සහිත cu130 wheel එකකි, එබැවින් පැරණි ධාවකයක් මත cu128 index එකෙන් මුලින්ම torch ස්ථාපනය කර, පසුව 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 මගින් loss, 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 මත ගැලපේ. LeRobot හිම හතර-GPU H100 පොකුරක් මත සිදු කරන ලද යොමු ධාවනය දෙකම අසත්‍ය බවට පත් කරයි; එක් 24 GB කාඩ්පතක් මත එය ක්‍රියාකාරී ධාවනයක් බවට පත් කරයි .

ධාවනයට ගතවන කාලය සහ ප්‍රමාණවත් පියවර ගණන

LeRobot දළ වශයෙන් 50 කථාංග දත්ත කට්ටලයක් මත epoch පහක් සඳහා wall-clock anchors ප්‍රකාශයට පත් කරයි, එය 30 fps හි රාමු 45000 ක් පමණ වේ. ලේඛනවලට අනුව, මේවා විශාලත්වයේ අනුපිළිවෙලෙහි සංඛ්‍යා වේ, නමුත් ඒවා පැයක් සහ දවසක් අපේක්ෂා කිරීම අතර වෙනසයි.

සියුම්ව සකස් කරන ලද ප්‍රතිපත්තිය නැවත රොබෝ අත මත ක්‍රියාත්මක කිරීම

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 Hz අතක් ධාවනය කළ හැක්කේ එබැවිනි. ඉතිරිව ඇත්තේ අනුමාන ප්‍රමාදය ඛණ්ඩයේ අවසානයේ ය.

එම තුන්වන පේළිය බොහෝ ලිපි මඟ හරින දෙයකි. අසමමුහුර්ත අනුමානය 30% කින් පමණ වේගවත් වන අතර නියමිත කවුළුවක් තුළ ඵලදායිතාව දළ වශයෙන් දෙගුණ කරයි, තවද පත්‍රිකාව සාර්ථකත්ව අනුපාත සැසඳිය හැකි බව පවසයි, සාමාන්‍යයෙන් ඒවා එසේ වේ. ඊට යටින්, වර්ග කිරීම 70 සිට 50 දක්වා අඩු වූ අතර තෝරා තැබීම 5 කින් වැඩි විය. lerobot 0.6.1 එකම ද්විමය තුළ අනෙක් ලීවරය දරයි: --inference.type=rtc එය rollout එක real time chunking වෙත මාරු කරයි, එය script එකේම භාවිත කොටස මන්දගාමී 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 මාර්ගය සඳහා, දෙකම ධාවනයකට 4 සිට 12 USD දක්වා 80 GB ස්ථරයකින් යුක්ත වේ. අනෙක් අතට, ACT යනු ලාභදායී මූලික රේඛාවයි: 80 M පරාමිති, ක්‍රියාකාරී පියවරකට 20 ms, භාෂා තත්ත්වකරණයකින් තොරව. පහම පිහිටා ඇත්තේ ප්‍රතිපත්ති පිටුවෙහි; අරීනාවෙහි ආකෘති 85ක් සහ මිණුම් සලකුණු ප්‍රතිඵල 332ක් ඇත.

ඔබ යමක් පරිමාණය කිරීමට පෙර පරීක්ෂා කළ යුතු දේ

1. `lr` එහි 2.5e-6 අවම අගයට ළඟා වූවාද? පියවර 30000 ට අඩු විට lerobot ක්ෂය වීම නැවත පරිමාණය කර ආරම්භයේදී එය පවසයි; ඊට ඉහළින්, --policy.scheduler_decay_steps ඔබම සකසන්න.
2. එක් පරීක්ෂණ ලක්ෂ්‍යයකට වඩා, සහ --dataset.eval_split සමඟින් වෙන් කර ඇති කථාංග, එවිට ඇගයීම් අලාභයට යම් තේරුමක් ඇත.
3. ප්‍රතිපත්තිය කිසිසේත් චලනය වේද? චලනය නොවන අතක් සමඟ අලාභය අඩුවීම සඳහා නිශ්චිත හේතු ඇත: අලාභය අඩු වේ, ප්‍රතිපත්තිය කිසිවක් නොකරයි.
4. එය දර්ශනයක් වෙනස් කිරීමෙන් පසුවත් ක්‍රියාත්මක වේද? එසේ නොවේ නම්: ප්‍රතිපත්තිය ක්‍රියා කරන්නේ එක් සැකසුමක පමණි.
5. ඔබ seed එක සටහන් කර ගත්තාද? lerobot පෙරනිමියෙන් 1000 ට සකසා ඇත, එබැවින් ස්පර්ශ නොකළ ධාවන දෙකක් සැසඳිය හැකිව පවතී.
6. එවිට පමණි: තවත් කථාංග, තවත් විචලනයන්, හෝ විශාල ආකෘතියක්. එම අනුපිළිවෙලින්.

මෙම ආකෘති පවතින හේතුව සහ භාෂා ආදානය සමඟ ඒවා කරන්නේ කුමක්ද යන්න සඳහා, පසුබිම වේ; එකලස් කිරීම සිදු කරයි සිට පළමු ධාවනය දක්වා. නිම කළ පරීක්ෂණ ලක්ෂ්‍යය සඳහා, ; අත කිසි විටෙකත් නොපෙන්වන්නේ නම්, .