Drop-Then-Recovery: How Redundant Are Vision-Language-Action Models?¶

🕒 Published (v1): 2026-06-26 00:00 UTC · Source: HuggingFace · link

Why this paper was selected

Systematic VLA redundancy analysis; actionable pruning for efficient deployment

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

TL;DR¶

VLA models inherit language backbones from pretrained VLMs that are massively over-sized for standard robotic manipulation tasks. The Drop-Then-Recovery (DTR) protocol physically removes transformer blocks then fine-tunes the smaller model, revealing a sharp asymmetry: language blocks are highly redundant (removing half of them improves OpenVLA-OFT from 95.0% to 98.3% on LIBERO), while vision and action pathways are substantially less tolerant. The proposed GateProbe metric — a one-shot virtual-gate gradient sensitivity score — outperforms static and other gradient-based block-selection metrics, especially under aggressive compression.

Problem¶

VLA models (e.g., π0.5, OpenVLA-OFT) inherit large pretrained VLM backbones, but standard manipulation benchmarks use short, templated instructions ("pick up the red cup"). It is unknown how much architectural capacity is actually necessary for closed-loop control. Existing compression methods (pruning, quantization) evaluate drop-only degradation without recovery fine-tuning, which is inadequate because small action errors accumulate over long control horizons, causing task-level collapse. Prior block-removal metrics (cosine similarity, perplexity, magnitude) measure immediate degradation rather than recoverability after fine-tuning.

Method¶

Drop-Then-Recovery (DTR) is a two-stage protocol applied to a VLA model with block set $\mathcal{B} = \{B_i^V\} \cup \{B_i^L\} \cup \{B_i^A\}$ (vision, language, action):

Stage 1 — Drop: Select the $K$ least important blocks $S = \operatorname{argsort}_K I(B_i)$ and physically remove them, short-circuiting their residuals ($h_i = h_{i-1}$). This yields a genuinely smaller dense model with proportionally reduced FLOPs, memory, and latency.
Stage 2 — Recovery: Fine-tune the dropped model on the downstream task: $\theta^* = \arg\min_\theta \mathcal{L}_{\text{action}}(\pi_\theta(a \mid o, p),\, a_{gt})$.

GateProbe is the proposed block-importance metric. A virtual scalar gate $\alpha_i$ is inserted on each block's residual branch: $$\tilde{h}_i = h_{i-1} + \alpha_i \cdot F_i(h_{i-1};\theta_i).$$ The importance score is: $$I_{\text{gate}}(B_i) = \mathbb{E}_{x \sim \mathcal{D}}\!\left[\left|\frac{\partial \mathcal{L}(x)}{\partial \alpha_i}\bigg|_{\alpha_i=1}\right|\right] = \mathbb{E}\!\left[\left\langle \frac{\partial \mathcal{L}}{\partial h_i},\, F_i(h_{i-1})\right\rangle\right],$$ computed in one forward+backward pass using cached hidden states and backpropagated gradients — no architectural modification required.

Key Contributions¶

Demonstrates that language backbones are the dominant source of redundancy in VLA models across four architectures; vision and action pathways are substantially less tolerant to removal.
Introduces DTR, a controlled analysis protocol that separates compression from recovery, measuring whether removed capacity was truly necessary for closed-loop task success.
Proposes GateProbe, a one-shot virtual-gate metric that outperforms static (CosSim, Magnitude, PPL) and gradient-based (Taylor, IGIA, Fisher, Hessian) alternatives, particularly under aggressive compression.
Validates real-world transfer: language-backbone redundancy observed in simulation holds on a physical xArm 850 deployment for warehouse parcel sorting.
Argues that current VLA benchmarks under-test language grounding, motivating benchmarks with compositional instructions, longer horizons, and more OOD perturbations.

Results¶

Component redundancy (LIBERO): Language Drop Half — OpenVLA-OFT 98.3% (vs. 95.0% baseline, −44.5% params); Vision Drop Half — 83.9% (−3.6% params); Action Drop Half — 94.5% (−0.05% params).
Extreme compression (Keep 2): OpenVLA-OFT Language Keep 2 → 95.1% (≈baseline); π0.5 Language Keep 2 → 91.0% (≈baseline); π0.5 Vision Keep 2 → 62.4%; π0.5 Action Keep 2 → 26.2%.
GateProbe vs. baselines (π0.5, Drop-16/18 blocks): GateProbe 92.2% vs. Taylor 85.2%, CosSim 81.9%, Magnitude 81.9%; advantage grows with compression intensity (+4.3 pp at Drop-17).
FLOPs-matched training (π0.5/LIBERO): Drop-12 (47.5% size, 43.8% FLOPs) reaches 93.7% (vs. 91.7% baseline) by scaling batch size and steps within the same compute envelope.
Inference efficiency: DTR-16 achieves 1.56× action speedup and 1.64× task speedup with 42% memory reduction on OpenVLA-OFT; zero-shot block dropping (no recovery) achieves negative task speedup (0.72× at Block Drop 8) due to SR degradation.
Cross-benchmark: Drop-9 matches baseline on LIBERO but degrades by −3.8% on LIBERO-Plus (average) and −6.6% on RoboTwin 2.0 Hard variants.
Real-world (π0.5 on xArm 850): Drop-9 matches full model (65.0% vs. 63.3% Env 1); under green-light OOD, Drop-16 falls to 35% vs. 50% full model.
Cross-architecture (Table 7): All four VLAs (OpenVLA-OFT, π0.5, GigaBrain-0, Lingbot-VLA) match or exceed baseline after Language Drop Half under identical fine-tuning budget.

Limitations¶

Language blocks contribute to physical generalization beyond pure language understanding; dropping them reduces robustness to OOD conditions (lighting, pose, novel objects) even when in-distribution performance is preserved.
Findings are evaluated on benchmarks (LIBERO, LIBERO-Plus, RoboTwin 2.0) that may be saturated or insufficiently language-demanding — the observed redundancy may not generalize to tasks requiring compositional or long-horizon language grounding.
In dual-stream architectures (π0.5), "dropping" a language block retains K/V projections for cross-attention, so reported compression ratios overstate actual parameter reduction for those models.
Real-world experiments cover a single robot platform and one manipulation scenario; generalization to other hardware and task classes is not demonstrated.
GateProbe requires one forward+backward pass over a calibration dataset; this cost, while small, is non-zero and architecture-dependent.

Relevance to Vision-Language Models¶

This paper directly probes the efficiency of VLMs when repurposed as VLA policies, revealing that the language understanding capacity that makes large VLMs powerful is largely superfluous for current robotics benchmarks — a fundamental mismatch between VLM pretraining objectives and embodied control demands. The GateProbe metric is a task-aware, gradient-based importance estimator that generalizes prior VLM compression ideas (layer dropping, Taylor sensitivity) to the fine-tuning-for-recovery regime, which is methodologically novel for the VLM compression literature. The finding that current benchmarks exert "limited pressure on deep language grounding" is a direct call to the VLM-for-robotics community to design harder evaluation protocols. For VLM researchers, the asymmetry results (vision blocks ≫ language blocks in terms of sensitivity) inform where to invest architectural capacity when designing future VLMs intended for downstream action tasks.