Ω-QVLA Squeezes Robot Policies to 4 Bits, Action Head Included
A training-free method quantizes both the language backbone and the diffusion action head of two robot models to 4 bits, and they keep their task success in simulation.
TL;DR
- Ω-QVLA compresses the Pi 0.5 and GR00T N1.5 robot models, including their diffusion action heads, to 4-bit weights and activations without retraining [^1].
- On the LIBERO simulator the quantized models reached 98.0 and 87.8 percent task success, against 97.1 and 87.0 percent at full precision [^1].
Background
Vision-language-action (VLA) models turn camera images and a text instruction into robot motions within a single policy, using backbones inherited from language models [^1]. They are large: OpenVLA, an open model from 2024, has 7 billion parameters and needs 15 GB of GPU memory at bfloat16 precision [^2]. Quantization shrinks a model by storing its numbers in fewer bits. Newer VLAs add a diffusion transformer (DiT) action head, which refines its output over several denoising steps [^1].
What happened
Researchers from McGill University, Université de Montréal, Mila and other institutions present Ω-QVLA, a post-training quantization method that needs no retraining [^1]. According to the authors, earlier VLA quantization work either left the DiT action head at full precision or quantized only parts of it, because those authors considered it too sensitive to compress [^1]. Ω-QVLA instead converts every linear layer in the language backbone and the action head to W4A4, meaning 4-bit weights and 4-bit activations. The paper notes that GPUs only gain speed when weights and activations share one bit width; otherwise the lower-precision values have to be upcast [^1].
The method has two parts [^1]. A composite rotation, built from a singular value decomposition (SVD) of each weight matrix and a Hadamard matrix, mixes the channels before rounding. The SVD part evens out how much energy each weight channel carries, and the Hadamard part spreads out activation outliers, the few channels with very large values that would otherwise dominate the rounding error [^1]. Second, because the activation ranges in the action head drift across denoising steps, Ω-QVLA stores a separate scale for each step, layer and channel, computed offline from 10 unlabeled calibration trajectories [^1].
The team tested Pi 0.5 and GR00T N1.5 on the four task suites of the LIBERO simulator [^1]. At W4A4, Ω-QVLA averaged 98.0 percent success on Pi 0.5 and 87.8 percent on GR00T N1.5, against 97.1 and 87.0 percent for the 16-bit (FP16) originals [^1]. Quantizing the whole Pi 0.5 model with the weight-only methods GPTQ, AWQ and OmniQuant dropped it to 16.0, 11.5 and 10.3 percent. QuantVLA, a method built for VLAs, reached 82.0 percent at W4A4, and 56.0 percent on the long-horizon suite, where Ω-QVLA reached 96.0 [^1]. On a dual-arm ARX R5 robot doing five real tasks, from placing a cup on a plate to folding a towel, the quantized Pi 0.5 averaged a progress score of 51.0, against 49.6 for the original and 25.0 for QuantVLA, whose motions were jerky [^1].
Why it matters
The result challenges the belief, in the prior work the authors surveyed, that a robot's action head cannot survive uniform low-bit quantization [^1]. The action head sends continuous control signals to physical motors in a closed loop, so errors that would not show in a language benchmark get amplified by contact forces [^1]. The authors trace QuantVLA's failures on long tasks to exactly that: jerky trajectories whose errors accumulate [^1]. The memory savings are also close to the ceiling. Ω-QVLA cut the static footprint of Pi 0.5, 4.27 GB at FP16, by 72.0 percent and that of GR00T N1.5 by 71.3 percent, near the roughly 74 percent of weight-only GPTQ. QuantVLA, which keeps attention at FP16, saved 61.3 percent on GR00T N1.5 [^1].
The paper leaves the most practical question open. It reports memory and task success but not wall-clock latency, because the speed benefits of W4A4 need kernel support that depends on hardware and toolchain [^1]. All experiments ran on NVIDIA A100 GPUs, the vision encoder stays at FP16, and the evaluation covers two models, one simulator and one real robot setup, with 10 rollouts per real task [^1]. The study shows that these models can be compressed without losing task success; whether they then run faster on a robot's own hardware is not yet measured.
Practical example
Say Lena leads software at a small company that builds a two-armed robot for folding laundry. The team has fine-tuned Pi 0.5, which the paper puts at 4.27 GB at FP16 [^1], and the robot's onboard computer has little memory to spare.
Lena first tries the usual route from language models: GPTQ, 4-bit weights, whole model. In simulation the policy falls apart, just as full weight-only quantization dropped Pi 0.5 to 16.0 percent success on LIBERO in the paper [^1]. Leaving the DiT attention layers at full precision rescues the score, to between 81 and 83 percent in the paper, but leaves part of the model uncompressed [^1].
Next Lena follows the Ω-QVLA recipe. It needs only a small calibration set, 10 unlabeled trajectories in the paper, from which it computes the rotations and a scale table for each of the 8 denoising steps, with no retraining [^1]. Every linear layer in the backbone and the action head ends up at 4 bits, while the vision encoder stays at FP16 [^1]. On the paper's dual-arm robot, which also folded towels, this version scored on par with the original, while QuantVLA fell to 25.0 with jerky motions [^1].
One check remains before Lena ships it: speed. The paper did not measure latency, and 4-bit activations only pay off if the robot's chip has suitable kernels [^1]. So Lena benchmarks the quantized model on the real hardware before it replaces the original.
Related gear
We recommend this book because it shows hands-on how neural networks are made small enough for low-power devices, including by quantizing them, the same problem Ω-QVLA tackles for robot models.