acceptodds
Under review as a conference paper at ICLR 2027

ActTune: Action-Aware Precision and GPU Operating-Point Adaptation for Energy-Efficient Vision-Language-Action Inference

Abstract

Vision-language-action (VLA) policies repeatedly invoke inference to control robots, making graphics processing unit (GPU) energy a recurring cost of task execution. Reducing energy per inference call, however, may not reduce energy per successful task if numerical errors increase failures or slower inference prolongs execution. We therefore target GPU energy per successful task while preserving task success and limiting increases in episode duration. Our approach builds on two observations: quantization sensitivity varies across action classes, model layers, and weights versus activations; and numerical precision changes the workload, shifting favorable GPU operating points. We introduce ActTune, an action-aware framework that connects layer-wise precision allocation with workload-dependent GPU frequency selection. A lightweight recognizer selects precision before each policy call. The controller forecasts the next workload and applies GPU settings asynchronously using a lookup table calibrated under a latency budget. A shared resident quantized weight bank enables configuration switching without weight reconstruction or additional policy evaluations. On LIBERO, a benchmark for lifelong robot learning, ActTune with the evaluated selector improves mean task success by up to 2.4% relative to state of the art. Relative to the original BF16 implementations, it delivers up to faster inference and, with dynamic voltage and frequency scaling (DVFS), reduces energy per successful task by up to 76.8%.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Vision-Language-Action Models, Energy-Efficient Inference, Mixed-Precision Quantization。

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_aBmuOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

ActTune combines action-aware mixed-precision selection with GPU operating-point adaptation to reduce GPU energy per successful task for VLA models. A lightweight decision tree selects precision configurations, supported by a shared weight bank, integer kernels, and asynchronous frequency–power control. Experiments cover OpenVLA-OFT and π₀.₅ on four LIBERO suites, reporting up to 2.02× faster inference and 76.8% lower energy than the original BF16 implementations. GPU adaptation increases mean inference latency by less than 10% relative to the same quantized policy at the fixed operating point. Energy measurements include failed episodes, GPU simulation rendering, and intervals between policy calls.

Critical strengths
  1. The evaluation objective reflects task execution costs. Energy per successful task accounts for failed attempts, and experiments cover two models and four suites. At W4A4, the two models outperform the strongest compared baseline in their respective groups by 4.0 and 5.1 percentage points in success rate.
  2. The implementation addresses practical deployment costs. The shared weight bank, native integer kernels, and asynchronous GPU control support an executable system. The full controller achieves an additional 4.15 percentage points of energy savings over the best fixed operating point, suggesting value in context-aware control.
Critical weaknesses
  1. The independent benefit of dynamic precision selection remains insufficiently established. Only two matrices switch between W2 and W4 online, while their activation precision and corresponding arithmetic type remain unchanged . The single-leaf comparison shows success-rate gains, but the paper does not report success–energy–latency comparisons across all four fixed configurations or uncertainty estimates. This makes it difficult to distinguish gains from dynamic selection from those attributable to static mixed precision and backend optimization.

  2. Baseline differences and measurement scope limit attribution of efficiency gains. ActTune incorporates CUDA Graph and other runtime optimizations, whereas the BF16 reference does not receive equivalent optimization. Quantized-layer coverage may also differ across methods. Moreover, energy measurements include GPU rendering and intervals between calls. Comparisons with matched runtime optimizations and an energy breakdown are needed to establish the gains attributable to the inference method itself.

Questions for authors
  1. With identical kernels and a fixed GPU operating point, what are the success rates, energy costs, and latencies of each of the four fixed configurations versus the dynamic selector? Could you provide confidence intervals for paired differences?
  2. How much of ActTune’s speedup and energy savings remains after applying transferable optimizations, such as CUDA Graph, to BF16? Is quantized-layer coverage consistent across methods?
  3. Which model–precision setting does Figure 6a evaluate? Are the additional savings over the best fixed operating point stable, and do they primarily arise from inference, rendering, or intervals between calls?
  4. Are the numbers of successful episodes identical with and without DVFS in Table 1? Please report them separately to substantiate the claim of preserving task success.
Reviewer_ejLjOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper propose ActTune, a framework aims to reduce GPU energy consumption while preserving the task success of vision-language-action robotic tasks.

It combines action sensitive precision with a decision tree and shared weight bank, allowing configurations to change without additional policy evaluations. It also introduces asynchronous GPU DVFS and power capping, supported by optimised integer kernels and inference code.

They evaluated 2 models under 4 LIBERO simulation suites, using the Ampere A6000 GPU. The complete system reports up to 76.8% lower GPU energy per successful task and 2.02× faster inference than the original BF16 implementations

Critical strengths

Concrete, efficient implementation supported by meaningful closed-loop evaluation

  • paper integrates quantized weight storage, optimized inference kernels, inexpensive configuration selection, and GPU operating-point control into a working system that substantially reduces GPU energy while largely preserving task success
  • Evaluation uses 2,000 closed-loop episodes per model–precision setting, and its energy-per-success metric includes failed attempts

Ablations provide evidence that adaptation contributes beyond fixed choices

  • The learned selector improves success by 1.2–1.4 percentage points over a single fixed configuration in the tested settings, while adaptive GPU control achieves 26.40% energy savings compared with 22.25% for the best fixed operating point
  • support the central premise that execution context can inform useful precision and hardware decisions
Critical weaknesses

The methodological advance over closely related work is insufficiently established

  • Action-sensitive quantization and motion-conditioned precision switching already exist, making the paper’s main distinction the learned configuration selector and its integration with GPU operating-point control
  • However, the evaluation omits a quantitative comparison with DyQ-VLA, which the paper explicitly acknowledges as closely related
  • Without a matched comparison against an existing motion-conditioned approach, it remains unclear whether the proposed selection mechanism constitutes a meaningful advance

The headline efficiency gains do not sufficiently establish the significance and generality of the distinguishing contribution

  • The largest reported improvements combine quantization, substantial kernel/runtime optimization, and hardware adaptation against the original BF16 implementation
  • There is uncertainty about how much advantage the proposed adaptation would retain under equally optimized execution

Narrow experimental scope and uncertain portability to newer GPUs

  • The evaluation covers only two VLA models, one benchmark (LIBERO), and one GPU type (RTX A6000), leaving applicability across additional models, environments, and hardware insufficiently established
  • The hardware restriction is particularly consequential because the W4A4 implementation uses Ampere’s native INT4 Tensor Core support, whereas conventional INT4 matrix instructions can execute through INT8-based emulation on newer architectures such as Hopper and Blackwell
  • This changes the computational tradeoffs underlying precision selection and GPU operating-point adaptation, so the reported efficiency gains cannot be assumed to transfer
  • Without broader evaluation or a careful analysis of these architectural dependencies, the paper provides limited evidence that its benefits extend beyond the tested setup
Questions for authors

Advance over the closest prior work:

  • What does the learned action-error selector contribute beyond existing motion-conditioned precision selection, particularly DyQ-VLA?
  • Can you substantiate this advantage through a comparison with matched precision budgets, calibration data, and execution conditions?

Attribution of the efficiency gains:

  • How much of the headline energy reduction remains against a comparably optimized BF16 reference?
  • With the quantized configurations and runtime optimizations held fixed, how much additional energy does the complete adaptive system save over a strong baseline using fixed precision and a tuned, fixed GPU operating point?

Generality and dependence on native INT4:

  • What evidence supports applicability beyond the two models, LIBERO benchmark, and RTX A6000 used in the evaluation?
  • In particular, do the W4A4 efficiency gains persist when conventional native INT4 execution is unavailable, as demonstrated by another GPU architecture or a controlled INT8-fallback experiment?
Reviewer_nJ2xOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Nice paper with a new angle. Basic idea is to quantize the right layers (which can absorb the numerical errors), using a small model (decision tree) to select among precomputed precision configurations: config = qm(current_proprioception, prev_action_chunk_features). Each config specifies layer-wise weight and activation precision, and the decision tree is learned from downstream action error compared to baseline BF16 execution. Based on the predicted next decision region and config, it also selects GPU frequency and power cap asynchronously between inference calls, targeting lower energy per successful task while limiting the mean inference-latency increase to 10% relative to the same quantized policy at a fixed operating point. I have not previously seen this coupling of layer-wise quantization and GPU operating-point selection, with downstream action error guiding precision selection.

Critical strengths
  1. The idea of coupling action-aware quantization with GPU power tradeoffs is interesting. I have not seen this particular combination before: quantization at different layers changes the workload and gives you leeway to reduce power consumption by adjusting GPU frequency and power cap. Generally, quantization is used to reduce latency or memory, but using it together with hardware throttling to reduce energy, while allowing slightly higher mean latency than the same quantized policy, is a nice idea and makes sense. In many robotics applications, if one has already reached the latency target they need, reducing energy consumption is the next “frontier”.

  2. Using a simple decision tree makes the system more interpretable in terms of the precision choices being made, while keeping the overhead low. It could also make it easier to explore the tradeoffs when other axes are considered. I also liked that the quantization tradeoff is based on a simple downstream action error minimization metric.

  3. Measuring energy per successful task is another strength. Reducing energy per inference does not necessarily help if the robot takes longer or fails more often. Including failed attempts and the gaps between inference calls makes the evaluation more meaningful.

Critical weaknesses
  1. Is there a need for the adaptation to be dynamic in time? I would imagine most of the benefit could be captured with a well-chosen static policy. Figure 6a partly supports this: the best fixed GPU setting achieves 22.25% energy savings compared to 26.40% for the dynamic approach, with similar latency overhead. The precision-selection ablation does show a ~1% percentage-point improvement in success over a fixed configuration. However, it is still unclear how much the full dynamic system gains over a well-tuned, fully static combination of precision and GPU settings. A clearer comparison would help establish when adaptation within an episode is worth the added complexity.

  2. How does the policy transfer across hardware and embodiments? The profiling approach seems hardware-specific, and the hardware evaluation is limited to an RTX A6000. It is unclear which parts of the system can transfer unchanged and which need to be recalibrated or retrained for each new hardware or embodiment combination. Is there a way to factorize the problem for easier generalization across platforms? Some evidence on transfer and the cost of recalibration would help clarify how broadly practical the approach is.

Questions for authors

Please answer the questions in weaknesses.

Comments on the paper

1 comment

Dear Reviewers,

The authors have submitted their rebuttal. Please review it and share your comments. If anything is unclear or requires clarification, please let the authors know as soon as possible. The author–reviewer discussion period ends on 18 November.

Best regards,

AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.