วิธีฝึก SmolVLA บน GPU ขนาด 24 GB (lerobot 0.6.1)

คนส่วนใหญ่ที่ต้องการ โมเดลภาษาการมองเห็นและการกระทำ บนแขนหุ่นยนต์จริงมักจะติดขัดที่ข้อจำกัดด้านฮาร์ดแวร์ GR00T N1.7 และ Pi0.5 มีพารามิเตอร์ประมาณสามพันล้านตัวแต่ละตัวและต้องการ A100 80 GB หรือ H100 หากคุณมีเพียงพีซีสำหรับเล่นเกมที่มี RTX 4090 นั่นคือจุดสิ้นสุดของเส้นทาง SmolVLA เป็นข้อยกเว้น: พารามิเตอร์ 450 M ภายใน LeRobot สร้างขึ้นเพื่อปรับแต่งบนการ์ดผู้บริโภคเพียงใบเดียวและให้บริการจาก CPU

เส้นทางแบบแมนนวลก่อน: ติดตั้ง lerobot, ดึง lerobot/smolvla_base เช็คพอยต์, รันคำสั่งจริง, อ่านผลลัพธ์ขณะที่มันทำงาน จากนั้นเป็นเส้นทางแพลตฟอร์ม และจุดที่มันไม่ช่วยอะไร

SmolVLA คืออะไร ในตัวเลขที่คุณสามารถตรวจสอบได้

SmolVLA เป็น การจับคู่โฟลว์ นโยบายที่ถูกนำมาใช้กับโมเดลภาษาภาพขนาดเล็ก แกนหลักคือ SmolVLM2-500M-Video-Instruct; เอกสารวิจัยนี้ใช้เพียง 16 เลเยอร์แรกของโมเดลภาษาของมัน จำกัดแต่ละเฟรมกล้องไว้ที่ 64 โทเค็นภาพด้วยการสลับพิกเซลแทนการเรียงภาพ และสลับการใส่ cross attention กับ self attention layer ทุกๆ บล็อกที่สอง ต้นทุนการอนุมานเป็นข้อจำกัดในการออกแบบ ไม่ใช่สิ่งที่คิดขึ้นมาทีหลัง

ผลการทดสอบเป็นเหตุผลที่ผู้คนสนใจโมเดลขนาด 450 M บน LIBERO มีค่าเฉลี่ย 87.3 เปอร์เซ็นต์ เทียบกับ 76.5 สำหรับ OpenVLA ที่ 7 B และ 86.0 สำหรับ Pi0 ที่ได้รับการฝึกอบรมด้านหุ่นยนต์ล่วงหน้า ที่ 3.3 B; บน Meta-World, 57.3 เทียบกับ 47.9 บนฮาร์ดแวร์ SO-100 จริง การฝึกอบรมแบบหลายงานให้ผล 75 เปอร์เซ็นต์ในการหยิบและวาง, 90 ในการซ้อน, 70 ในการจัดเรียง, โดยเฉลี่ย 78.3, ในขณะที่ ACT ที่ได้รับการฝึกอบรมต่อภารกิจมีค่าเฉลี่ย 48.3 แถวเดียวกันนี้ปรากฏอยู่ข้าง VLA ที่เผยแพร่ทั้งหมดใน รายการ SmolVLA ในอารีน่า และ การเปรียบเทียบ ACT กับ SmolVLA.

ทำไมการ์ด 24 GB จึงเป็นการเริ่มต้นที่เหมาะสม

LeRobot มีคู่มือการกำหนดขนาดการประมวลผล ซึ่งเป็นหน้าที่มีประโยชน์ที่สุดใน repo สำหรับเรื่องนี้ โดยจะจัดกลุ่มนโยบายตามขนาดแบ็คโบน และให้ซอง VRAM หนึ่งซองต่อกลุ่ม ซึ่งวัดที่ขนาดแบตช์ 8 ด้วย AdamW ซึ่งเป็นค่าเริ่มต้นของ lerobot สถานะของ Optimizer เพียงอย่างเดียวเพิ่มขึ้น 30 ถึง 100 เปอร์เซ็นต์เมื่อเทียบกับการส่งผ่านไปข้างหน้าและย้อนกลับเปล่าๆ ดังนั้นตัวเลขเหล่านี้จึงไม่ใช่แค่ตัวเลขน้ำหนักเท่านั้น

สิบถึงสิบหกกิกะไบต์ที่แบตช์ 8 คือข้อโต้แย้ง: การ์ด 24 GB สามารถรองรับได้พร้อมกับ dataloader AY-Robots วาง SmolVLA บน RTX 4090 หรือการ์ด 24 GB ใดๆ โดยมีขั้นต่ำ 30 ตอน, LeRobot v3.0 ข้อมูล, 245 มิลลิวินาทีต่อขั้นตอนการกระทำ หากเช่า จะอยู่ที่ 2 ถึง 5 ชั่วโมงในราคา 0.30 ถึง 0.60 USD ต่อชั่วโมง ประมาณ 1 ถึง 3 USD ต่อการ ปรับแต่ง รัน เทียบกับ 4 ถึง 12 USD บน GR00T และ Pi0.5 ระดับ 80 GB ที่ต้องการ (ราคา) การรัน SmolVLA ที่ล้มเหลวคือค่ากาแฟ; การรัน GR00T ที่ล้มเหลวคือค่าอาหารกลางวัน

ขั้นตอนที่ 0: ชุดข้อมูลเป็นตัวกำหนดการทำงาน ไม่ใช่แฟล็ก

ไม่มีอะไรด้านล่างนี้สำคัญเลยหากการบันทึกไม่ดี หน้า LeRobot SmolVLA ระบุไว้อย่างชัดเจนว่า: ชุดข้อมูลอ้างอิงมี 50 ตอนใน 5 ตำแหน่งลูกบาศก์, 10 ตอนต่อตำแหน่ง, และงานเดียวกันที่ 25 ตอนทำงานได้ไม่ดี การทำซ้ำต่อความหลากหลายช่วยให้เกิดการสรุปผลได้ แต่จำนวนตอนดิบไม่ช่วย คุณไม่เคยบันทึกเลยใช่ไหม? เริ่มต้นที่ บันทึกชุดข้อมูลแรกของคุณ ด้วย ไคลเอนต์เดสก์ท็อป, ซึ่งเขียนรูปแบบ LeRobot จากเซสชัน การควบคุมระยะไกล หรือยืมจาก ไดเรกทอรีชุดข้อมูล.

• อย่างน้อย 30 ตอนสำหรับ AY-Robots, ประมาณ 50 ตอนสำหรับสูตรอ้างอิงของ LeRobot
• ความหลากหลายทุกรูปแบบที่คุณคาดว่าจะพบในการใช้งานจริง ทำซ้ำหลายครั้ง
• สตริงงานเดียว สะกดเหมือนกันทั้งตอนบันทึกและตอนใช้งานจริง โมเดลจะถูกปรับเงื่อนไขตามข้อความนั้น
• กล้องที่ติดตั้งอยู่กับที่ การเคลื่อนย้ายกล้องระหว่างการบันทึกและการใช้งานจริงเป็นสาเหตุที่พบบ่อยที่สุดที่ทำให้กราฟการสูญเสียที่สะอาดส่งผลให้แขนหุ่นยนต์ไม่เคลื่อนไหว
• ความหลากหลายที่กันไว้ซึ่งคุณไม่เคยฝึกฝน เพื่อให้คุณมีสิ่งที่จะใช้ทดสอบได้อย่างเที่ยงตรง

# 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 พื้นฐานนั้นมีขนาดเล็กและจำกัดการพึ่งพาที่หนักหน่วงไว้เบื้องหลังส่วนเสริม (extras): smolvla เพิ่ม transformers, num2words และ accelerate, training เพิ่มชุดข้อมูลและ wandb, core_scripts เพิ่มการพึ่งพาด้านฮาร์ดแวร์และการแสดงผล บน Linux เส้นทางการติดตั้งยังเป็นตัวกำหนด CUDA wheel ของคุณ: ค่าเริ่มต้นของ PyPI คือ cu130 wheel ที่มี driver floor 580.65 ดังนั้นหากใช้ไดรเวอร์ที่เก่ากว่า ให้ติดตั้ง torch จาก cu128 index ก่อน จากนั้นจึงติดตั้ง lerobot.

การรันเทรนนิ่ง ทีละคำสั่ง

1. 1
   ยืนยันตัวตนกับ Hub

   Base checkpoint มาจาก Hub และชุดข้อมูลของคุณก็น่าจะมาจากที่นั่นด้วย

   bash

   hf auth login

2. 2
   อ่านตัวเลือกต่างๆ หนึ่งครั้ง

   ทุกฟิลด์ของการกำหนดค่า pipeline และ policy เป็น flag ลองอ่านคร่าวๆ ก่อนที่จะลงลึกในโค้ดต้นฉบับ

   bash

   lerobot-train --help

3. 3
   เริ่มการ fine-tune

   ตัวอย่างในเอกสารรัน batch 64 บน A100 ตัวเดียว; คำแนะนำการคำนวณสำหรับ A100 40 GB ใช้ batch 16 และ 8 คือค่าเทียบเท่าสำหรับ 24 GB ไม่มี flag scheduler ที่นี่โดยตั้งใจ ดูด้านล่าง

   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 ไม่ใช่แค่ค่า loss

   ทุกๆ --log_freq steps lerobot จะพิมพ์ loss, grdn, lr, updt_s, data_s, smp/s และบน CUDA จะพิมพ์ mem_gb. mem_gb บอกว่า batch พอดีหรือไม่, lr บอกว่า schedule กำลังลดลงหรือไม่, และ data_s ที่เข้าใกล้ updt_s หมายความว่า dataloader เป็นคอขวด ไม่ใช่ GPU

   bash

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

5. 5
   รวบรวม checkpoint ที่สามารถเปรียบเทียบได้

   save_freq มีค่าเริ่มต้นเป็น 20000 ดังนั้นการรัน 20000 steps จะเหลือ checkpoint เพียงอันเดียวและไม่มีอะไรให้เปรียบเทียบ ตั้งค่าเป็น 2000 การ push ไปยัง Hub ต้องใช้ --policy.repo_id

   bash

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

6. 6
   ดำเนินการต่อหากเครื่องหยุดทำงาน

   ชี้ --config_path ไปที่ train_config.json ที่อยู่ถัดจาก checkpoint lerobot จะปฏิเสธที่จะเริ่มใน output_dir ที่มีอยู่แล้ว เว้นแต่คุณจะทำการ resume ดังนั้นคุณจึงไม่สามารถเขียนทับการรันโดยไม่ตั้งใจได้

   bash

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

Flag ที่ส่งผลต่อผลลัพธ์จริงๆ

ค่าเริ่มต้นที่คุณได้รับหากคุณไม่เปลี่ยนแปลงอะไรเลย

การกำหนดค่า นโยบาย ใน lerobot มีค่าที่ตั้งไว้ล่วงหน้าสำหรับ optimizer และ scheduler ของตัวเอง และเว้นแต่คุณจะตั้งค่า use_policy_training_preset=false ค่าที่ตั้งไว้ล่วงหน้าเหล่านั้นจะมีผล คำถามครึ่งหนึ่งที่ผู้คนถามเกี่ยวกับการฝึก SmolVLA ได้รับคำตอบจากค่าเริ่มต้นที่พวกเขาไม่รู้ว่ามีอยู่

สองบรรทัดที่ทำให้คนประหลาดใจคือ freeze_vision_encoder และ train_expert_only ซึ่งทั้งคู่เป็นจริง โดยค่าเริ่มต้น คุณจะฝึกพารามิเตอร์ประมาณ 100 M ไม่ใช่ 450 M ซึ่งเป็นเหตุผลว่าทำไมจึงสามารถทำงานได้บน 24 GB การรันอ้างอิงของ LeRobot เองบนคลัสเตอร์ H100 สี่ GPU จะเปลี่ยนทั้งสองค่าเป็น false; บนการ์ด 24 GB หนึ่งใบ สิ่งนี้จะเปลี่ยนการรันที่ทำงานได้ให้กลายเป็น .

การรันใช้เวลานานเท่าใด และจำนวนขั้นตอนที่เพียงพอ

LeRobot เผยแพร่จุดอ้างอิงเวลาจริง (wall-clock anchors) สำหรับห้าอีพ็อก (epochs) บนชุดข้อมูลประมาณ 50 ตอน (episode dataset) ซึ่งมีประมาณ 45000 เฟรมที่ 30 fps เอกสารระบุว่าเป็นตัวเลขประมาณการ แต่ตัวเลขเหล่านี้คือความแตกต่างระหว่างการคาดหวังหนึ่งชั่วโมงกับหนึ่งวัน

เรียกใช้นโยบายที่ปรับแต่งแล้วบนแขนกล

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 จะเปลี่ยนการทำงานไปสู่การแบ่งกลุ่มแบบเรียลไทม์ ซึ่งบล็อกการใช้งานของสคริปต์เองแนะนำสำหรับ VLA ที่ทำงานช้า เช่น 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. `lr` ถึงค่าต่ำสุด 2.5e-6 แล้วหรือยัง? หากต่ำกว่า 30000 สเต็ป lerobot จะปรับขนาดการลดลงและแจ้งให้ทราบเมื่อเริ่มต้น; หากสูงกว่านั้น ให้ตั้งค่า `--policy.scheduler_decay_steps` ด้วยตนเอง
2. มีจุดตรวจสอบมากกว่าหนึ่งจุด และมีตอนที่ถูกแยกไว้ด้วย `--dataset.eval_split` เพื่อให้ค่าความสูญเสียในการประเมินผลมีความหมาย
3. นโยบายมีการเคลื่อนไหวเลยหรือไม่? การที่ค่าความสูญเสียลดลงแต่แขนไม่เคลื่อนไหวมีสาเหตุเฉพาะ: ค่าความสูญเสียลดลง แต่นโยบายไม่ทำงาน
4. มันรอดจากการเปลี่ยนฉากหรือไม่? ถ้าไม่: นโยบายทำงานได้ในสถานการณ์เดียวเท่านั้น
5. คุณได้จดค่า seed ไว้หรือไม่? lerobot มีค่าเริ่มต้นเป็น 1000 เพื่อให้การรันสองครั้งที่ไม่ได้แก้ไขยังคงเปรียบเทียบกันได้
6. หลังจากนั้นเท่านั้น: เพิ่มตอน, เพิ่มความหลากหลาย, หรือใช้โมเดลที่ใหญ่ขึ้น ตามลำดับนี้

สำหรับเหตุผลที่โมเดลเหล่านี้มีอยู่และสิ่งที่พวกมันทำกับข้อมูลภาษา, คือข้อมูลพื้นฐาน; จะดำเนินการประกอบผ่าน ไปจนถึงการรัน ครั้งแรก สำหรับจุดตรวจสอบที่เสร็จสมบูรณ์, ; หากแขนไม่ปรากฏขึ้น, .