מודלי VLA קטנים: TinyVLA, SmolVLA ומקרה התת-1B

כמעט כל מודל ראייה-שפה-פעולה שנכתב עליו מניח כרטיס דאטה סנטר. OpenVLA הוא בעל 7 מיליארד פרמטרים. GR00T N1.7 ו-Pi0.5 הם בסביבות 3 מיליארד ודורשים A100 80 GB לכוונון עדין. אם הכרטיס על שולחנך הוא 4090, סוג מודל זה אינו בהישג יד.

שני מאמרים טוענים שאינך זקוק לכך. TinyVLA (arXiv 2409.12514, התקבל על ידי IEEE Robotics and Automation Letters בפברואר 2025) בונה VLA מליבה של 400 מיליון עד 1.3 מיליארד בתוספת ראש פעולה מבוסס דיפוזיה. SmolVLA (arXiv 2506.01844, הוגש ב-2 ביוני 2025) מגיע עם 450 מיליון פרמטרים עם משקלים פתוחים, נתונים פתוחים וסקריפט שרץ על כרטיס צרכני אחד. הנה מה ששניהם מדדו, והיכן שהטיעון של פחות מ-1 מיליארד מפסיק להיות תקף.

מה באמת נחשב ל-VLA קטן

מספר הפרמטרים בכרטיס מודל אינו מספר יחיד. הוא יכול להתייחס למשקלים הכוללים, למשקלים שנטענים בזמן הסקה, או למשקלים שמקבלים גרדיאנטים במהלך . TinyVLA מדווח על שניהם, והפער גדול: TinyVLA-H הוא 1.3 B סה"כ אך 143 M ניתנים לאימון, מכיוון שמגדל הראייה ורוב מודל השפה נשארים קפואים בזמן שמתאמי LoRA וראש הפעולה נעים. המאמר מציין את החלק הניתן לאימון בכ-5 אחוזים.

שתי שורות ראויות לדיון. בערך 80 M קטן מכל השאר כאן אך אין לו מודל שפה, ולכן הוא אינו VLA: הוא לומד משימה אחת ולא ניתן לומר לו לבצע אחרת. ב-27 M מותנה באמצעות מקודד טקסט T5-Base, לא שלד LLM. בסיסי השוואה טובים, אך אף אחד מהם לא מספק את ביצוע ההוראות שהתווית מרמזת עליו.

TinyVLA: המהירות מגיעה מהראש, לא מה-backbone

הקריאה המתבקשת היא שהם הקטינו את מודל השפה, ולכן הוא הפך מהיר יותר. ניתוח האבלציה של המאמר אומר אחרת. החלפת ה-backbone של OpenVLA בגודל 7 B באחד בגודל של כ-1 B קיצצה את חיזוי הפעולה מ-292 אלפיות השנייה ל-140 אלפיות השנייה, שיפור של פי 2. TinyVLA-H, עם מספר פרמטרים דומה, פועל ב-14 אלפיות השנייה על אותו כרטיס. הפי 10 הנוספים הם בזכות ראש הפעולה (action head).

OpenVLA פולט פעולות כאסימונים בדידים דרך ראש מודל השפה, אחד לכל מימד פעולה, באופן אוטורגרסיבי. TinyVLA מצרף מפענח דיפוזיה שמייצר את כל הנתח בפעם אחת. טבלה V מציגה את הארכיטקטורה ב-TinyVLA-H ומחליפה רק את הראש, באותן חמש משימות רובוט אמיתיות. זוהי העדות הברורה ביותר בשני המאמרים לטיעון שהתאמת זרימה מדיניות יוצרת, והסיבה שPi0 התרחק מפענוח אסימונים.

מה TinyVLA השיג

לשורה הדו-ידית יש הסבר משעמם שהמאמר עצמו מספק: OpenVLA אומן מראש על Open X-Embodiment, המורכב כולו מנתונים של זרוע אחת, ולכן מרחב פעולה דו-ידי חורג מההתפלגות והוא מקבל ציון אפס. בסיס המדיניות של דיפוזיה מנצח את 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, וקבוצת תצפיות עם תמונות מרובות תצוגה, joint_positions, qpos ו-qvel. הריפו מספק את data_utils/rlds_to_h5py.py עבור קלט RLDS, וכל משימה נרשמת ידנית ב-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 מופעל.
• ה-backbone הוא הורדה נפרדת: lesjie/Llava-Pythia-400M, -700M or -1.3B. אין נקודת בדיקה בסיסית יחידה שאליה אתה מכוון מדיניות באותה צורה שבה אתה מכוון ל-lerobot/smolvla_base.

SmolVLA: מודל תת-1B שתוכל להריץ אחר הצהריים

SmolVLA מציג את אותה טענה בתוך ספרייה מתוחזקת. הוא בעל 450 מיליון פרמטרים על גבי backbone מסוג SmolVLM2-500M-Video-Instruct, והיעילות נובעת מהגדרות שניתן לקרוא מתוך configuration_smolvla.py ולא מטענה על היותו קטן.

אימון מוקדם השתמש ב-481 מערכי נתונים קהילתיים של LeRobot, ב-22.9 אלף פרקים וב-10.6 מיליון פריימים על 4 כרטיסי GPU, ב-200,000 צעדים עם גודל אצווה גלובלי של 256; המאמר מעריך את הפרויקט כולו בכ-30 אלף שעות GPU. נתון אחד שכדאי לשים לב אליו: בלוג ההשקה של Hugging Face מציין 487 מערכי נתונים מאוצרים בעוד שהטבלה במאמר מציינת 481. אנו משתמשים בנתון מהמאמר ומציינים את אי ההתאמה.

מקרה אחד מסייע: הטבלה של Meta-World במאמר של SmolVLA מציגה את המספרים שפורסמו על ידי TinyVLA כבסיס השוואה, כך שלפעם אחת שני המודלים נמצאים בטבלה אחת, SmolVLA-0.45B עם 57.3 לעומת TinyVLA-H עם 31.6. הוא גם מדווח על אימון SmolVLA מהיר בכ-40 אחוז מ-Pi0 תוך שימוש בפי 6 פחות זיכרון. כל זה מגיע מהמחברים של SmolVLA; ה-ערך בזירה מקשר כל ערך למקור שלו.

היכן SmolVLA מבלה את זמנו

AY-Robots מפרטת את SmolVLA ב-245 אלפיות שנייה לכל שלב פעולה ואת ACT ב-20 אלפיות שנייה בקטלוג מדיניות. TinyVLA מדווח על 14 אלפיות שנייה לחיזוי פעולה. מספרים אלה אינם ניתנים להשוואה, והתייחסות אליהם כאילו הם כן היא הטעות הנפוצה ביותר בנושא זה: חלק מודדים זמן של מעבר קדימה אחד, חלק מחלקים את המעבר הזה על פני מקטע ברגע שחלוקת פעולות למקטעים מפזרת אותו.

• SmolVLA פולט 50 פעולות בכל מעבר קדימה ומבצע את כל ה-50. בקצב של 30 פריימים לשנייה שהמאמר משתמש בו על רובוטים אמיתיים, הסקה אחת מכסה כ-1.7 שניות של תנועה.
• הסקה אסינכרונית מחשבת את המקטע הבא בזמן שהנוכחי עדיין מתבצע: 9.7 שניות השלמת משימה ממוצעת לעומת 13.75 שניות סינכרונית, מהיר בכ-30 אחוז, ו-19 מחזורי הרמה והנחה בחלון קבוע של 60 שניות לעומת 9.
• שיעורי ההצלחה היו דומים ולא טובים יותר, 78.3 סינכרוני לעומת 73.3 אסינכרוני. אסינכרוני קונה תפוקה, לא דיוק.
• חלוקה למקטעים מסתירה את השהיית החישוב, לא את השהיית הרשת, והיא הופכת את המדיניות לפחות תגובתית מכיוון שהיא מחויבת ל-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 הוא אימון מוקדם קהילתי בתוספת אימון מרובה משימות, לא הארכיטקטורה לבדה. במשימת הלגו SO-101, שניהם למשימה בודדת, 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) הופך כל משקל של עמוד שדרה BitNet b1.58 2B4T חד-ביטי לטרנרי, ומדווח על 11.0x פחות זיכרון ו-4.4x פחות זמן אחזור מקצה לקצה תוך התאמה ל-OpenVLA-OFT בדיוק מלא. X-VLA-0.9B (arXiv 2510.10274) נמצא על קו ה-1 מיליארד פרמטרים עם התאמת זרימה.

החוט המקשר: מפענח הפעולות, לא מודל השפה, הוא המקום שבו נמצא זמן האחזור. שאלו כיצד מדיניות פולטת פעולות לפני שאתם שואלים כמה פרמטרים יש לה. ה-זירה מכילה 85 מודלים ו-332 תוצאות, כל אחת מקושרת למקור שלה; יש סקירה רחבה יותר ב-הקדמת ה-VLA שלנו.