โมเดล VLA ขนาดเล็ก: TinyVLA, SmolVLA และกรณีที่ต่ำกว่า 1 พันล้านพารามิเตอร์

โมเดล วิสัยทัศน์-ภาษา-การกระทำ เกือบทุกตัวที่เขียนถึงมักจะสันนิษฐานว่าใช้การ์ดสำหรับศูนย์ข้อมูล OpenVLA มีพารามิเตอร์ 7 พันล้านตัว GR00T N1.7 และ Pi0.5 มีขนาดประมาณ 3 พันล้านตัว และต้องการ A100 80 GB สำหรับการปรับแต่ง (fine-tune) หากการ์ดบนโต๊ะของคุณคือ 4090 โมเดลประเภทนั้นก็เกินกำลังที่จะใช้งานได้

มีงานวิจัยสองฉบับที่โต้แย้งว่าคุณไม่จำเป็นต้องใช้การ์ดเหล่านั้น TinyVLA (arXiv 2409.12514, ได้รับการยอมรับโดย IEEE Robotics and Automation Letters ในเดือนกุมภาพันธ์ 2025) สร้าง VLA จากแกนหลักขนาด 400 ล้านถึง 1.3 พันล้านพารามิเตอร์ พร้อมส่วนหัวการกระทำแบบ diffusion SmolVLA (arXiv 2506.01844, ส่งเมื่อ 2 มิถุนายน 2025) มาพร้อมพารามิเตอร์ 450 ล้านตัว พร้อมน้ำหนักโมเดลแบบเปิด ข้อมูลแบบเปิด และสคริปต์ที่สามารถรันบนการ์ดผู้บริโภคเพียงใบเดียว นี่คือสิ่งที่ทั้งสองโมเดลวัดได้ และจุดที่ข้อโต้แย้งเรื่องโมเดลขนาดต่ำกว่า 1 พันล้านพารามิเตอร์เริ่มไม่เป็นจริง

อะไรคือ VLA ขนาดเล็กที่แท้จริง

จำนวนพารามิเตอร์บนโมเดลการ์ดไม่ใช่ตัวเลขเดียว อาจหมายถึงน้ำหนักรวม, น้ำหนักที่โหลดเมื่ออนุมาน, หรือน้ำหนักที่ได้รับเกรเดียนต์ระหว่าง . TinyVLA รายงานทั้งสองอย่าง และช่องว่างมีขนาดใหญ่: TinyVLA-H มีน้ำหนักรวม 1.3 พันล้าน แต่สามารถฝึกได้ 143 ล้าน เนื่องจากส่วนวิชันและโมเดลภาษาส่วนใหญ่ยังคงถูกตรึงไว้ ในขณะที่อะแดปเตอร์ LoRA และส่วนหัวการกระทำมีการเคลื่อนไหว บทความระบุว่าส่วนที่ฝึกได้อยู่ที่ประมาณ 5 เปอร์เซ็นต์

มีสองแถวที่ควรพิจารณา ที่ประมาณ 80 M มีขนาดเล็กกว่าโมเดลอื่น ๆ ทั้งหมดในที่นี้ แต่ไม่มีโมเดลภาษา ดังนั้นจึงไม่ใช่ VLA: มันเรียนรู้งานเดียวและไม่สามารถสั่งให้ทำงานอื่นได้ ที่ 27 M ถูกปรับสภาพผ่านตัวเข้ารหัสข้อความ T5-Base ไม่ใช่แบ็คโบน LLM เป็นเกณฑ์มาตรฐานที่ดี แต่ทั้งสองอย่างไม่ได้ให้การปฏิบัติตามคำสั่งตามที่ระบุไว้

TinyVLA: ความเร็วมาจากส่วนหัว ไม่ใช่ส่วนแกนหลัก

การตีความที่ชัดเจนคือ พวกเขาทำให้โมเดลภาษาเล็กลง จึงทำงานได้เร็วขึ้น แต่ผลการทดลอง ablation ในงานวิจัยกลับชี้ไปในทางตรงกันข้าม การเปลี่ยนแกนหลักของ OpenVLA ขนาด 7B เป็นขนาดประมาณ 1B ช่วยลดเวลาการทำนายต่อการกระทำจาก 292 ms เหลือ 140 ms ซึ่งเพิ่มขึ้น 2 เท่า TinyVLA-H ซึ่งมีจำนวนพารามิเตอร์ใกล้เคียงกัน ทำงานที่ 14 ms บนการ์ดเดียวกัน ส่วนอีก 10 เท่าที่เหลือมาจากส่วนหัวของการกระทำ

OpenVLA ปล่อยการกระทำออกมาเป็นโทเค็นแบบไม่ต่อเนื่องผ่านส่วนหัวของโมเดลภาษา โดยมีหนึ่งโทเค็นต่อมิติการกระทำ และทำงานแบบ autoregressively TinyVLA ใช้ diffusion decoder ที่สร้างข้อมูลทั้งหมดออกมาในครั้งเดียว ตาราง V แสดงสถาปัตยกรรมของ TinyVLA-H และเปลี่ยนเฉพาะส่วนหัว โดยทดสอบกับงานหุ่นยนต์จริงห้างานเดียวกัน นี่คือหลักฐานที่ชัดเจนที่สุดในงานวิจัยทั้งสองฉบับสำหรับข้อโต้แย้งที่ว่า flow matching policies สร้างขึ้น และเป็นเหตุผลที่ Pi0 เลิกใช้การถอดรหัสโทเค็น.

TinyVLA ทำคะแนนได้เท่าไร

แถวของการทำงานสองมือมีคำอธิบายที่น่าเบื่อที่ระบุไว้ในบทความเอง: OpenVLA ได้รับการฝึกอบรมล่วงหน้าบน Open X-Embodiment ซึ่งประกอบด้วยข้อมูลแขนเดียวทั้งหมด ดังนั้นพื้นที่การกระทำสองแขนจึงอยู่นอกเหนือการกระจายและได้คะแนนเป็นศูนย์ โมเดลพื้นฐาน diffusion policy เอาชนะ TinyVLA-H ในสองในสามงานนั้น ข้อมูลพื้นฐานอยู่ใน บทความเกี่ยวกับ Open X-Embodiment.

ที่เก็บ TinyVLA ณ เดือนสิงหาคม 2026

บทความนี้ดี โค้ดเป็นเพียงผลงานวิจัยที่เผยแพร่ ที่เก็บโค้ดอยู่ที่ github.com/liyaxuanliyaxuan/TinyVLA; ไฟล์ README ระบุวันที่เผยแพร่โค้ดคือ 17 กุมภาพันธ์ 2025 และการคอมมิตครั้งสุดท้ายคือ 11 มีนาคม 2025 เหมาะสำหรับการทำซ้ำผลงานวิจัย แต่จะเป็นปัญหาหากคุณต้องการไลบรารีที่ได้รับการดูแล

git clone https://github.com/liyaxuanliyaxuan/TinyVLA
conda create -n tinyvla python=3.10 -y
conda activate tinyvla
pip install --upgrade pip
pip install -r requirements.txt
cd policy_heads && pip install -e .
cd ../llava-pythia && pip install -e .

TinyVLA ยังไม่อ่าน ชุดข้อมูล LeRobot. รูปแบบของมันคือ HDF5 สไตล์ ACT: action, language_raw และกลุ่ม observations ที่มีภาพหลายมุมมอง, joint_positions, qpos และ qvel. repository มี data_utils/rlds_to_h5py.py สำหรับอินพุต RLDS และแต่ละ task จะถูกลงทะเบียนด้วยตนเองใน aloha_scripts/constants.py พร้อมกับ dataset_dir, episode_len และ camera_names. หาก ตอน มาจาก lerobot หรือ ไคลเอนต์เดสก์ท็อป คุณต้องรับผิดชอบการแปลงข้อมูลเอง

# scripts/train.sh, the real flags from the repository
ACTION_HEAD=droid_diffusion

deepspeed --master_port 29600 --num_gpus=8 --num_nodes=1 ./train_tinyvla.py \
  --deepspeed scripts/zero2.json \
  --lora_enable True \
  --lora_module 'vit llm' \
  --lora_r 64 \
  --lora_alpha 256 \
  --non_lora_lr 2e-5 \
  --task_name "example_task_config" \
  --model_name_or_path /path/to/pretrained_vlm \
  --freeze_vision_tower True \
  --freeze_backbone True \
  --bf16 True \
  --max_steps 10000 \
  --per_device_train_batch_size 32 \
  --gradient_accumulation_steps 1 \
  --learning_rate 2e-4 \
  --lr_scheduler_type "cosine" \
  --warmup_ratio 0.005 \
  --save_steps 1000 \
  --action_head_type $ACTION_HEAD \
  --use_state True \
  --window_size 6

• --num_gpus=8 สมมติว่าใช้โหนดแปดการ์ด ตั้งค่าเป็น 1 และลดขนาดแบทช์ให้ต่ำกว่า 32 มาก ไม่มีรุ่น GPU เดี่ยวที่จัดส่งมาตั้งแต่ต้น ดังนั้นคำสั่งจึงไม่สามารถรันได้ตามตัวอักษรบน 4090
• --deepspeed scripts/zero2.json ชี้ไปยังไฟล์ที่ไม่ได้อยู่ในไดเรกทอรี scripts ระดับบนสุด การกำหนดค่า DeepSpeed อยู่ที่ llava-pythia/scripts/zero2.json แก้ไขพาธก่อนการรันครั้งแรกของคุณ
• README กำหนดให้ชื่อไดเรกทอรีเอาต์พุตต้องมี llava_pythia และ lora หากเปิดใช้งาน LoRA
• แบ็คโบนเป็นการดาวน์โหลดแยกต่างหาก: lesjie/Llava-Pythia-400M, -700M หรือ -1.3B ไม่มีจุดตรวจสอบพื้นฐานเดียวที่คุณจะชี้ นโยบาย ไปยังในลักษณะเดียวกับที่คุณชี้ไปที่ lerobot/smolvla_base

SmolVLA: โมเดลขนาดต่ำกว่า 1 B ที่คุณสามารถรันได้บ่ายนี้

SmolVLA ใช้ข้อโต้แย้งเดียวกันภายในไลบรารีที่ได้รับการดูแลรักษา มีพารามิเตอร์ 450 M บนแบ็คโบน SmolVLM2-500M-Video-Instruct และประสิทธิภาพมาจากค่าการตั้งค่าที่คุณสามารถอ่านได้จาก configuration_smolvla.py แทนที่จะมาจากการอ้างว่ามีขนาดเล็ก

การฝึกอบรมล่วงหน้าใช้ชุดข้อมูล LeRobot ของชุมชน 481 ชุด, 22.9 K ตอน และ 10.6 M เฟรมบน 4 GPUs, 200000 ขั้นตอนที่ global batch ขนาด 256; เอกสารระบุว่าโครงการทั้งหมดใช้เวลาประมาณ 30 K GPU ชั่วโมง ตัวเลขหนึ่งที่น่าจับตา: บล็อกเปิดตัวของ Hugging Face ระบุว่ามีชุดข้อมูลที่คัดสรรแล้ว 487 ชุด ในขณะที่ตารางในเอกสารระบุ 481 ชุด เราใช้ตัวเลขจากเอกสารและแจ้งข้อขัดแย้งนี้

มีเรื่องบังเอิญหนึ่งที่ช่วยได้: ตาราง Meta-World ในเอกสาร SmolVLA มีตัวเลขที่เผยแพร่ของ TinyVLA เองเป็นค่าพื้นฐาน ดังนั้นเป็นครั้งแรกที่ทั้งสองโมเดลอยู่ในตารางเดียวกัน โดย SmolVLA-0.45B อยู่ที่ 57.3 เทียบกับ TinyVLA-H ที่ 31.6 นอกจากนี้ยังรายงานว่าการฝึก SmolVLA เร็วกว่า Pi0 ประมาณ 40 เปอร์เซ็นต์ โดยใช้หน่วยความจำน้อยลง 6 เท่า ทั้งหมดนี้มาจากผู้เขียน SmolVLA; รายการในอารีน่า เชื่อมโยงแต่ละค่าไปยังแหล่งที่มา

SmolVLA ใช้เวลาไปกับอะไร

AY-Robots ระบุ SmolVLA ที่ 245 มิลลิวินาทีต่อขั้นตอนการกระทำ และ ACT ที่ 20 มิลลิวินาทีใน แค็ตตาล็อกนโยบาย. TinyVLA รายงาน 14 มิลลิวินาทีต่อการคาดการณ์การกระทำ ตัวเลขเหล่านี้ไม่สามารถเปรียบเทียบกันได้ และการถือว่าเปรียบเทียบได้เป็นข้อผิดพลาดที่พบบ่อยที่สุดในหัวข้อนี้: บางครั้งใช้เวลาหนึ่ง forward pass บางครั้งแบ่ง pass นั้นออกเป็นส่วนๆ เมื่อ การแบ่งกลุ่มการกระทำ ช่วยลดภาระ

• SmolVLA ปล่อย 50 การกระทำต่อหนึ่ง forward pass และดำเนินการทั้งหมด 50 การกระทำ ที่ 30 fps ที่เอกสารใช้กับหุ่นยนต์จริง การอนุมานหนึ่งครั้งครอบคลุมการเคลื่อนไหวประมาณ 1.7 วินาที
• การอนุมานแบบอะซิงโครนัสจะคำนวณกลุ่มถัดไปในขณะที่กลุ่มปัจจุบันยังคงทำงานอยู่: เวลาเฉลี่ยในการทำงานเสร็จสิ้น 9.7 วินาที เทียบกับ 13.75 วินาทีแบบซิงโครนัส ซึ่งเร็วกว่าประมาณ 30 เปอร์เซ็นต์ และ 19 รอบการหยิบและวางในกรอบเวลา 60 วินาทีที่กำหนด เทียบกับ 9 รอบ
• อัตราความสำเร็จสามารถเปรียบเทียบกันได้มากกว่าที่จะดีกว่า โดย 78.3 แบบซิงโครนัส เทียบกับ 73.3 แบบอะซิงโครนัส Async ช่วยเพิ่มปริมาณงาน ไม่ใช่ความแม่นยำ
• การแบ่งกลุ่มช่วยซ่อนความหน่วงในการประมวลผล ไม่ใช่ความหน่วงของเครือข่าย และทำให้ policy ตอบสนองได้น้อยลงเนื่องจากถูกกำหนดให้ดำเนินการ 50 การกระทำ

การปรับแต่ง SmolVLA บนการ์ดผู้บริโภคหนึ่งใบ

เส้นทางแบบแมนนวล บน lerobot 0.6.1 ซึ่งเป็นรุ่น PyPI ปัจจุบัน ณ วันที่ 23 สิงหาคม 2026 ทุกสิ่งที่อยู่ด้านล่างมาจากเอกสาร Hugging Face lerobot SmolVLA ที่ดึงมาในวันเดียวกัน; เวอร์ชันแนะนำ นั้นง่ายกว่า

1. 1
   ติดตั้ง lerobot พร้อมส่วนเสริม smolvla

   การพึ่งพา SmolVLA เป็นส่วนเสริมที่ไม่บังคับ ไม่ใช่ส่วนหนึ่งของการติดตั้งพื้นฐาน การติดตั้งโดยไม่มีส่วนเสริมนี้แล้วสงสัยว่าทำไมประเภทนโยบายจึงไม่รู้จัก เป็นเรื่องปกติที่ทำให้เสียเวลาไปครึ่งชั่วโมง

   bash

   git clone https://github.com/huggingface/lerobot.git
   cd lerobot
   pip install -e ".[smolvla]"

2. 2
   รับชุดข้อมูลที่มีจำนวนตอนเพียงพอ

   เอกสารแนะนำประมาณ 50 ตอน และระบุว่างานเดียวกันที่มี 25 ตอนไม่เพียงพอ AY-Robots กำหนดขั้นต่ำไว้ที่ 30 ตอน บันทึกข้อมูลของคุณเอง หรือเริ่มต้นจาก ไดเรกทอรีชุดข้อมูล

   bash

   # any LeRobotDataset on the Hub works as --dataset.repo_id
   # lerobot/svla_so100_pickplace is the paper's own 50-episode set:
   # 5 cube positions, 10 episodes each

3. 3
   เริ่มการปรับแต่ง

   คำสั่งจากคู่มือ lerobot โดยไม่มีการแก้ไข เอกสารระบุว่า 20000 ขั้นตอนใช้เวลาประมาณ 4 ชั่วโมงบน A100 หนึ่งตัว บนการ์ด 24 GB คาดว่าจะใช้เวลานานขึ้นและควรวัดเวลา

   bash

   cd lerobot && lerobot-train \
     --policy.path=lerobot/smolvla_base \
     --dataset.repo_id=${HF_USER}/mydataset \
     --batch_size=64 \
     --steps=20000 \
     --output_dir=outputs/train/my_smolvla \
     --job_name=my_smolvla_training \
     --policy.device=cuda \
     --wandb.enable=true

4. 4
   ลดขนาดแบทช์จนกว่าจะพอดี

   batch_size=64 เป็นตัวอย่างที่ระบุไว้ในเอกสาร ไม่ใช่การรับประกันเกี่ยวกับการ์ดของคุณ เอกสารแนะนำให้เริ่มต้นด้วยขนาดเล็กและเพิ่มขึ้นเรื่อยๆ ตราบใดที่เวลาโหลดสั้น

   bash

   lerobot-train --help

5. 5
   นำเช็คพอยต์ไปใช้งานบนแขนกล

   ไลบรารีเดียวกัน คำสั่งเดียว แฟล็กการแบ่งส่วนข้อมูลแบบเรียลไทม์ถูกคอมเมนต์ไว้ในเอกสาร และเป็นสิ่งที่ควรใช้สำหรับฮาร์ดแวร์ที่มีพลังงานต่ำ

   bash

   lerobot-rollout \
     --strategy.type=base \
     --robot.type=so101_follower \
     --robot.port=/dev/ttyACM0 \
     --robot.id=my_blue_follower_arm \
     --robot.cameras="{ front: {type: opencv, index_or_path: 8, width: 640, height: 480, fps: 30}}" \
     --task="Grasp a lego block and put it in the bin." \
     --policy.path=HF_USER/FINETUNE_MODEL_NAME

สองวิธีในการนำ VLA ขนาดเล็กไปใช้กับแขนกล

เมื่อโมเดลขนาดเล็กไม่ใช่ทางเลือกที่ถูกต้อง

ทั้งสองบทความมีความระมัดระวังมากกว่าบทสรุปที่นำเสนอ การวิเคราะห์ความล้มเหลวของ TinyVLA นั้นเฉพาะเจาะจง: โมเดลรุ่น 0.4 B ล้มเหลวสามครั้งจากการอ่านคำสั่งผิด ซึ่งผู้เขียนระบุว่าเป็นผลมาจากความเข้าใจภาษาที่จำกัดใน VLM ขนาดเล็ก และโหมดดังกล่าวหายไปเมื่อใช้โมเดลขนาด 1.3 B. SmolVLA แสดงเส้นโค้งเดียวกันจากอีกด้านหนึ่ง: โมเดลเวอร์ชัน 2.25 B ของสถาปัตยกรรมที่เหมือนกันได้คะแนน 88.75 บน LIBERO และ 68.24 บน Meta-World เทียบกับ 87.3 และ 57.3 สำหรับโมเดล 0.45 B.

การเปรียบเทียบที่ควรทำไม่ใช่ TinyVLA กับ SmolVLA แต่เป็นการเปรียบเทียบ SmolVLA กับ ACT ในงานของคุณเอง และบทความของ SmolVLA คือเหตุผลที่สนับสนุนเรื่องนี้ SmolVLA ที่ได้รับการฝึกแบบภารกิจเดียวโดยไม่มีการฝึกอบรมล่วงหน้าด้านหุ่นยนต์ ได้คะแนนเฉลี่ย 40.0 ในสามภารกิจ SO-100 ในขณะที่ ACT แบบภารกิจเดียวทำได้ 48.3 สิ่งที่ทำให้คะแนนเพิ่มขึ้นเป็น 78.3 คือการฝึกอบรมล่วงหน้าจากชุมชน (community pretraining) บวกกับการฝึกแบบหลายภารกิจ ไม่ใช่แค่สถาปัตยกรรมเพียงอย่างเดียว ในภารกิจ SO-101 lego ซึ่งเป็นแบบภารกิจเดียวทั้งคู่ SmolVLA ชนะ: 90 ต่อ 70 ในการกระจายข้อมูล จากนั้นเป็นการเปรียบเทียบ SmolVLA กับ Pi0.5 หากงบประมาณเอื้ออำนวย

ตารางการตัดสินใจที่คุณสามารถนำไปปฏิบัติได้

สำหรับแถวสุดท้าย แขนหุ่นยนต์แบบสด สตรีม SO-100 จริงที่คุณสามารถควบคุมได้จากเบราว์เซอร์โดยไม่ต้องมีบัญชี และ สามวิธีในการเริ่มต้น ครอบคลุมส่วนที่เหลือ SO-100 เป็นแขนหุ่นยนต์อ้างอิงในที่นี้ มีราคาชิ้นส่วนประมาณ 110 ถึง 150 ยูโร พร้อมด้วย คู่มือการตั้งค่าฉบับสมบูรณ์.

อะไรจะตามมาหลังจากโมเดลขนาดต่ำกว่า 1 พันล้านพารามิเตอร์

การลดจำนวนพารามิเตอร์เป็นวิธีหนึ่งที่จะทำให้ VLA มีราคาถูกและอาจไม่ใช่ทางเลือกที่ดีที่สุดเสมอไป OpenVLA-OFT (arXiv 2502.19645) ยังคงใช้โครงสร้างหลักขนาด 7 พันล้านพารามิเตอร์ และเปลี่ยนเฉพาะวิธีการถอดรหัสการกระทำ โดยรายงานว่าอัตราการสร้างการกระทำเพิ่มขึ้น 26 เท่า และ LIBERO เพิ่มขึ้นจาก 76.5 เป็น 97.1 เปอร์เซ็นต์ BitVLA (arXiv 2506.07530) ทำให้ทุกน้ำหนักของโครงสร้างหลัก 1-bit BitNet b1.58 2B4T เป็นแบบ ternary โดยรายงานว่าใช้หน่วยความจำน้อยลง 11.0 เท่า และมีความหน่วงจากต้นทางถึงปลายทางลดลง 4.4 เท่า ในขณะที่ยังคงประสิทธิภาพเทียบเท่า OpenVLA-OFT แบบความแม่นยำเต็ม X-VLA-0.9B (arXiv 2510.10274) อยู่ในกลุ่มโมเดลขนาด 1 พันล้านพารามิเตอร์ด้วยเทคนิค flow matching.

ประเด็นร่วมกันคือ: ตัวถอดรหัสการกระทำ ไม่ใช่โมเดลภาษา คือส่วนที่ทำให้เกิดความหน่วง ถามว่านโยบายปล่อยการกระทำอย่างไรก่อนที่จะถามว่ามีพารามิเตอร์กี่ตัว อารีน่า มีโมเดล 85 ตัวและผลลัพธ์ 332 รายการ ซึ่งแต่ละรายการเชื่อมโยงไปยังแหล่งที่มาของมัน; มีภาพรวมที่กว้างขึ้นใน บทนำ VLA ของเรา.