Add files using upload-large-folder tool

README.md

@@ -20,7 +20,7 @@ Parser-derived artifacts for the `efficient-vla-wiki` project.
 
 This dataset is the data layer companion to the main repository:
 
-- GitHub: `efficient-vla-wiki`
+- GitHub: [guanweifan/efficient-vla-wiki](https://github.com/guanweifan/efficient-vla-wiki)
 - Dataset repo: `efficient-vla-extracts`
 
 ## What is inside

extracts/parses/2605_13778_Realtime-VLA-FLASH/docling/2605_13778_Realtime-VLA-FLASH.md

@@ -0,0 +1,448 @@
+<!-- image -->
+
+## Realtime-VLA FLASH: Speculative Inference Framework for Diffusion-based VLAs
+
+Jiahui Niu 1 , 2 ∗ Kefan Gu 3 , 4 Yucheng Zhao 4 † Shengwen Liang 1 ‡ Tiancai Wang 4 ‡ Xing Hu 1 Ying Wang 1 Huawei Li 1
+
+1 State Key Lab of Processors, Institute of Computing Technology, CAS 2 University of Chinese Academy of Sciences 3 Nanjing University 4 Dexmal
+
+Page: https://dexmal.github.io/realtime-vla-flash
+
+## Abstract
+
+Diffusion-based vision-language-action models (dVLAs) are promising for embodied intelligence but are fundamentally limited in real-time deployment by the high latency of full inference. We propose Realtime-VLA FLASH , a speculative inference framework that eliminates most full inference calls during replanning by introducing a lightweight draft model with parallel verification via the main model's Action Expert and a phase-aware fallback mechanism that reverts to the full inference pipeline when needed. This design enables low-latency, highfrequency replanning without sacrificing reliability. Experiments show that on LIBERO, FLASH largely preserves task performance by replacing many 58.0 ms full-inference rounds with speculative rounds as fast as 7.8 ms , lowering task-level average inference latency to 19.1 ms ( 3.04 × speedup). We additionally demonstrate effectiveness on real-world conveyor-belt sorting, highlighting its practical impact for latency-critical embodied tasks.
+
+Figure 1: Overview of Realtime-VLA FLASH. (a) Standard synchronous dVLA inference runs the full pipeline at each replanning round, causing stale action updates and failure in latency-critical manipulation. (b) Realtime-VLA FLASH accelerates replanning, allowing the robot to react in time and complete the grasp. (c) FLASH introduces speculative inference for dVLAs: a lightweight draft model proposes a continuous action chunk, and the main model's Action Expert reconstructs action endpoints from selected flow-matching timesteps in parallel to check consistency with the draft. The robot executes the longest consistent prefix and falls back to the full path when verification fails.
+
+<!-- image -->
+
+∗ This work was done during the internship at Dexmal.
+
+† Project lead.
+
+‡ Corresponding author.
+
+## 1 Introduction
+
+Diffusion-based vision-language-action models (dVLAs) [1, 10, 20, 21] have recently emerged as an important paradigm for embodied intelligence. Their diffusion-based continuous action generation captures multimodal action distributions, making them well suited to complex manipulation tasks.
+
+However, deploying dVLAs on real robotic systems remains challenging. In practice, robot control typically runs at a much higher frequency than model inference, as shown in Figure 1, and existing systems therefore rely on open-loop action chunking [33] to bridge this mismatch. For example, π 0 [1] predicts a chunk of future actions and replans only after several control steps have already been executed. While this design reduces the frequency of replanning, each replanning round still requires the same expensive full inference pipeline. As a result, end-to-end inference latency remains the main bottleneck, limiting the applicability of dVLAs to reactive, latency-sensitive tasks.
+
+Speculative Inference aims to reduce repeated inference cost and has proven effective in large language models [12-14] and autoregressive VLAs [26, 34, 35]. Its core idea is to have a lightweight draft model propose candidates that are verified in parallel by the main model, thereby reducing expensive full generations. However, extending this paradigm to dVLAs is non-trivial. Speculative inference requires (1) a draft proposal, (2) parallel verification, and (3) an acceptance criterion, which are all well-defined for autoregressive models through token-level probabilities. dVLAs instead produce actions through iterative denoising in continuous space [5, 16], which challenges each ingredient: it is unclear what constitutes a meaningful draft through multi-step denoising, the sequential nature of denoising resists parallel verification, and the absence of explicit likelihoods leaves no natural acceptance criterion. The central bottleneck is therefore verification: without a way to cheaply check a drafted continuous-action chunk, speculative inference collapses back to full sequential denoising.
+
+A key observation is that flow matching provides exactly such a structure. During flow-matching training, interpolation timesteps are sampled along linear paths between Gaussian noise and target actions, learning local flow constraints at intermediate states. Given a drafted action chunk, we can interpolate it with Gaussian noise, evaluate a few intermediate states in parallel using the Action Expert, and check whether the reconstructed endpoints agree with the draft, providing a cheap consistency check without full sequential denoising. In addition, consistency verification does not make speculative inference uniformly safe throughout the trajectory. For much of task execution, the robot performs smooth motions, where observations change slowly and small draft errors can often be tolerated. In fine-adjustment phases such as gripper switching, these errors can quickly accumulate and be amplified, leading to task failure. This motivates falling back to the full inference pipeline when verification or the task phase indicates that higher-fidelity actions are required.
+
+In this paper, we introduce Realtime-VLA FLASH , a speculative inference framework for dVLAs. FLASH introduces a fast speculative path that uses a lightweight draft model to quickly propose a candidate action chunk, and then verifies its consistency with the main model's Action Expert in parallel at a few selected timesteps, producing a dynamically sized executable action prefix. If no action prefix is accepted, FLASH falls back to the full path to correct the trajectory. FLASH also uses gripper switches as heuristic signals of upcoming fine-adjustment phases, where higher-quality full-path actions help prevent draft errors from accumulating into task failures. Thus, FLASH reduces average inference latency and improves action throughput while largely preserving task success.
+
+We evaluate Realtime-VLA FLASH in simulation and real-world tasks. On LIBERO, with Triton optimization, FLASH runs speculative rounds as fast as 7.8 ms , compared with 58.0 ms for fullinference rounds, lowering the task-level average latency to 19.1 ms ( 3.04 × speedup) and improving action throughput by 2.63 × , while largely preserving task performance. On real conveyor-belt sorting, FLASH enables successful grasping at belt speeds up to 15 m/min, where other methods fail, demonstrating that speculative inference reduces effective inference latency and enables higher-speed, latency-sensitive manipulation tasks.
+
+In summary, we make three contributions. First, we formulate speculative inference for flowmatching dVLAs and address its key challenge, continuous-action verification, using flow-matching interpolation paths. Second, we introduce Realtime-VLA FLASH, a dual-path inference runtime that combines a lightweight draft model, flow-consistency-based parallel verification, and phaseaware fallback to reduce expensive full-path inference during replanning. Third, we demonstrate on LIBERO and real-world tasks that FLASH replaces many expensive full-path rounds with low-cost speculative rounds, substantially reducing latency while largely preserving task success.
+
+## 2 Related Work
+
+## 2.1 Efficient Diffusion-based VLAs
+
+Existing work has explored several ways to improve the efficiency of dVLAs [1, 10, 20, 21], among which the following two directions are most closely related to our setting.
+
+Inference Pipeline Acceleration. Existing work on efficient dVLAs primarily reduces the cost of the original full inference pipeline through smaller models [28, 22, 15], layer compression [31], token pruning [25], quantization [28, 29, 32], and kernel/system-level optimization [19, 30]. These approaches improve the efficiency of the original inference pipeline, either by reducing the cost of particular components or by improving end-to-end execution efficiency. Our work is complementary to this line of research, but it addresses a different question at the control-loop level: whether every replanning round needs to invoke the full path.
+
+Diffusion and Flow-Matching Acceleration. Another line of work accelerates diffusion- or flowbased policies [5, 16] by shortening the generation process itself, for example through distillation into few-step models [18, 27, 7] or direct one-step model training [8, 4]. These approaches reduce the cost of sequential denoising more directly, but they typically require additional training or modified policy formulations. In contrast, we keep the original flow-matching formulation intact and improve efficiency by exploiting otherwise idle compute during the Action Denoise stage.
+
+## 2.2 Speculative Inference
+
+Speculative Inference accelerates autoregressive generation by letting a lightweight draft model propose candidate outputs and a larger model verify them in parallel, thereby reducing expensive decoding steps. It has been widely studied in large language models [12-14] and extended to autoregressive VLAs [26, 34, 35], where discrete action tokens admit token-level probabilities that naturally support verification and acceptance.
+
+Related acceleration has also been explored for stochastic diffusion models, where drafted denoising states can be checked using the transition structure of the stochastic reverse process [6, 9]. However, π 0 [1]-style dVLAs differ from both settings: they generate continuous action chunks under flow matching by integrating an ODE-defined velocity field, not discrete tokens or samples from a stochastic reverse kernel. Consequently, neither token-level verification nor transition-based diffusion verification applies directly, and the absence of explicit likelihoods leaves no natural acceptance criterion for drafted continuous-action chunks.
+
+## 3 Methods
+
+In this section, we present the architecture of Realtime-VLA FLASH. Section 3.1 revisits the dVLA inference pipeline and the latency bottlenecks revealed by profiling; Section 3.2 then summarizes the overall two-path design, and Sections 3.3-3.5 present the three core components of the flash path, namely draft action generation, multi-step parallel verification, and phase-aware fallback.
+
+## 3.1 dVLA Preliminaries and Latency Analysis
+
+dVLAs, such as π 0 [1], typically combine a pre-trained vision-language model (VLM) backbone [23, 24] with an Action Expert (AE). Perceptual context is passed from the VLM to the AE through the KV Cache. Formally, the model takes a multimodal observation
+
+<!-- formula-not-decoded -->
+
+where I i t denotes the images, ℓ t the language prompt, and q t the robot state, and predicts a future action chunk
+
+<!-- formula-not-decoded -->
+
+Each per-step action a t contains semantically distinct channels corresponding to end-effector position ∆ p t , rotation ∆ θ t , and binary gripper control g t . Under chunked execution, only a prefix of A t is executed before the next action chunk is regenerated from the updated observation; we refer to each such refresh as a replanning round.
+
+At inference time, the input images are first encoded into visual features, then concatenated with the language features, and the resulting multimodal prefix is processed by the VLM to construct a prefix KV Cache. This cache is then passed to the Action Expert, which predicts the action chunk by solving an observation-conditioned ODE from Gaussian noise:
+
+<!-- formula-not-decoded -->
+
+where A τ t denotes the intermediate noisy action state at denoising time τ . At each denoising step, the Action Expert predicts the instantaneous denoising velocity field v θ ( A τ t , τ, o t ) , and the final action chunk is obtained by numerically integrating this learned field over multiple timesteps, typically 10 denoising steps in the default setting, until τ = 1 . Consequently, a full inference round in π 0 -style dVLAs consists of three stages: Image Encoder, VLM prefill to construct the visual KV Cache, and a multi-step Action Denoise stage under the learned flow field.
+
+We further profile these three stages on an NVIDIA RTX 4090D [11] and summarize the results with a roofline analysis in Figure 2. The measured latencies of Image Encoder, VLM prefill, and Action Denoise are 11.3 ms, 26.7 ms, and 20.0 ms, respectively. The roofline places Image Encoder and VLM prefill primarily in the compute-bound regime, suggesting that their latency should be reduced by eliminating redundant computation. For VLM prefill, this naturally motivates reusing the previously computed prefix KV Cache. In contrast, Action Denoise is memory-bound, since each denoising step repeatedly reads the cache while remaining unable to parallelize across steps. This leaves available compute resources underutilized and motivates parallel verification instead of repeatedly invoking the full path.
+
+## 3.2 Realtime-VLA FLASH Overview
+
+Motivated by Section 3.1, Realtime-VLA FLASH adopts the dual-path architecture shown in Figure 3(a). In a flash-path round, FLASH still encodes the current images and feeds the features to a lightweight draft model, which proposes a candidate action chunk. The main model's Action Expert then reuses the visual KV Cache produced by the most recent full-path round to reconstruct action endpoints at selected denoising timesteps and check their consistency. If no drafted action prefix
+
+<!-- image -->
+
+Figure 3: Realtime-VLA FLASH Framework. (a) Realtime-VLA FLASH uses two inference paths: the original full path (Full Path) and a lightweight speculative path (Flash Path). The Full Path performs Image Encoder, VLM prefill, and Action Denoise, while the flash path still encodes the current images but skips VLM prefill to draft a candidate action chunk for verification. (b) Draft model architecture. The draft model uses a single Gemma block with the same structure as the VLM, augments the input with learned action queries, and predicts the full action chunk in parallel through a linear action head.
+
+<!-- image -->
+
+Encoder
+
+Ac*on Denoise
+
+VLM Prefill
+
+Figure 2: Roofline analysis of π 0 [1] inference on NVIDIA RTX 4090D. 145.79 is the balanced arithmetic intensity point.
+
+is accepted, the cached context may no longer provide a reliable basis for speculative execution; FLASH therefore returns to the full path to refresh the context and correct the trajectory. In addition, FLASH uses gripper switches as phase-transition signals and proactively falls back to the full path during fine-adjustment phases, where higher-fidelity actions help mitigate error amplification.
+
+## 3.3 Draft Action Generation
+
+For flash-path rounds, candidate generation must be cheaper than invoking the full path. We therefore design a lightweight draft model that proposes a candidate action chunk for subsequent verification.
+
+The draft model architecture in Figure 3(b) consists of a single Gemma block followed by a linear action head. At inference time, the flash path still runs the image encoder of the main model on the current images and combines the resulting visual features with the language instruction, while the robot state is projected into the same hidden space through a linear layer. We then append H learned action queries to the input sequence, one for each future timestep in the chunk. The attention mask follows the blockwise structure of the base model: visual and language tokens form the conditional prefix block, the state token forms a separate block, and the action queries form the action block. The action block attends to the full conditional prefix, allowing the model to predict the entire candidate chunk in parallel. The draft model is trained by supervised regression to the target action chunk,
+
+<!-- formula-not-decoded -->
+
+where w h is a step-dependent weight and ℓ ( · , · ) is the per-step action regression loss.
+
+This design has several advantages. The draft model is lightweight, containing about 110M parameters in our implementation, compared with roughly 2.7B parameters in the VLM, which makes candidate generation substantially cheaper than invoking the full path. It also remains architecturally close to the main VLM and preserves the same action-chunk representation, making it easy to integrate and allowing the verification stage to reuse the Action Expert. Additional architectural and training details are provided in Appendix A.
+
+## 3.4 Multi-step Parallel Verification
+
+The remaining challenge is to verify a draft action chunk without rerunning the full sequential denoising process in Figure 4(a). In flow matching, this becomes possible because the policy learns the velocity field along the linear path between Gaussian noise and the endpoint at training time.
+
+For a draft endpoint ˆ A ( d ) t and Gaussian noise ϵ , we construct an intermediate denoising state as
+
+<!-- formula-not-decoded -->
+
+where τ denotes denoising progress from Gaussian noise to the action endpoint. Under this convention, the Action Expert predicts the local velocity from the intermediate state toward the endpoint. Since the remaining denoising interval is 1 -τ , we reconstruct the endpoint by
+
+<!-- formula-not-decoded -->
+
+Figure 4: Parallel verification. (a) π 0 [1] generates an action chunk with flow matching through 10step sequential denoising. (b) Realtime-VLA FLASH reconstructs endpoints from selected denoising timesteps in parallel and checks an action-by-action distance threshold within the chunk, yielding the accepted prefix. (c) If reconstructed endpoints deviate beyond the threshold, no prefix is accepted and the flash path falls back to the full path.
+
+<!-- image -->
+
+## Algorithm 1 Multi-Step Parallel Verification
+
+Require: Draft action chunk ˆ A ( d ) t , reused visual KV Cache c t , latest robot state s t , verification timesteps T = { τ 1 , . . . , τ K } , threshold δ
+
+Ensure:
+
+Executable prefix length L
+
+- 1: Sample a shared Gaussian noise ϵ for all verification timesteps
+- 2: for all τ k ∈ T in parallel do
+- 3: Construct intermediate state: ˜ A ( k ) τ k = τ k ˆ A ( d ) t +(1 -τ k ) ϵ
+- 4: Predict local denoising velocity with the Action Expert: v ( k ) = v θ ( ˜ A ( k ) τ k , τ k ∣ ∣ ∣ c t , s t ) ,
+- 5: Reconstruct endpoint estimate: ˆ A ( k ) t = ˜ A ( k ) τ k +(1 -τ k ) v ( k )
+- 6: for h = 1 , . . . , H do
+- 7: Compute step distance: d ( k ) h = Dist cont ( ˆ a ( d ) t + h -1 , ˆ a ( k ) t + h -1 )
+- 8: end for
+- 9: Compute prefix length: L ( k ) = ∑ H h =1 ∏ h j =1 1 [ d ( k ) j ≤ δ ]
+- 10: end for
+- 11: Return the conservative prefix length: L = min k =1 ,...,K L ( k )
+
+If the draft is consistent with the main policy under the reused KV Cache c t and the latest robot state s t , these reconstructed endpoints should remain close to the draft across verification timesteps.
+
+We therefore evaluate a small set of verification timesteps T = { τ 1 , . . . , τ K } in parallel and define the executable prefix as the longest leading segment whose included actions all satisfy the distance threshold at every verification timestep, as summarized in Algorithm 1 and Figure 4(b). We apply this distance-based rule to the continuous position and rotation channels through Dist cont , while the gripper channel is treated separately because it encodes discrete semantic states rather than incremental motion. If L = 0 , no executable prefix survives all verification checks, so the draft is rejected and control immediately returns to the full path, corresponding to the rejection case in Figure 4(c). Compared with binary acceptance, this rule returns an executable prefix, enabling more fine-grained execution and a smoother handoff to fallback. See Appendix B for further discussion.
+
+## 3.5 Phase-aware Fallback
+
+Verification in Section 3.4 is local: it checks the current draft under the reused context but does not anticipate transitions into fine-adjustment phases. Figure 5 compares the LIBERO-Spatial bowl-
+
+Figure 5: Phase-aware fallback on a LIBERO-Spatial task trajectory. 3D trajectories for a bowl-to-plate task. (a) Without phase-aware fallback, the flash path drifts during final placement and fails near the plate edge. (b) With fallback, final placement returns to the full path and succeeds.
+
+<!-- image -->
+
+Figure 6: Key-frame visualization of Figure 5. Orange borders indicate flash-path execution and blue borders indicate full-path execution after fallback. The failure rollout keeps final placement on the flash path, leaving the bowl misaligned with the plate.
+
+<!-- image -->
+
+to-plate trajectory without and with phase-aware fallback. Without fallback, flash-path execution continues into the final fine-adjustment phase, where the trajectory drifts toward the plate edge and leaves the bowl misaligned with the plate. Figure 6 provides key frames.
+
+We therefore augment verification-triggered fallback with a phase-aware fallback rule based on the gripper channel, as shown in Figure 5(b). Unlike the continuous position and rotation channels, the gripper channel represents discrete open and closed modes, encoded as -1 and 1 in LIBERO. After applying the same standardization used by the policy, the two modes remain separated around zero, so we detect gripper switches by thresholding the standardized gripper value at zero. Such switches correspond to grasp or release events, which often mark precision-critical fine-adjustment phases.
+
+If a gripper switch appears in any verification branch within the candidate chunk, we treat it as evidence that the rollout has entered a fine-adjustment phase. The system then falls back immediately to the full path to regenerate higher-quality actions, avoiding error accumulation in precision-sensitive phases where small deviations can cause task failure.
+
+## 4 Experiments
+
+## 4.1 Setup
+
+We evaluate Realtime-VLA FLASH on π 0 [1] in both simulation and real-world reactive manipulation tasks. All online inference experiments are run on a single NVIDIA RTX 4090D. We use an action chunk size of H = 50 and replan after every 12 executed actions.
+
+Simulation. We follow the standard LIBERO setup [17] and report results on four suites: LIBEROSpatial, LIBERO-Object, LIBERO-Goal, and LIBERO-10. Each suite contains 10 tasks, and each task is evaluated over 50 trials. We train a separate draft model for each LIBERO suite.
+
+Real-world. For real-world experiments, we use a single-arm UR5 platform equipped with two Intel RealSense D435i cameras, which provide multi-view observations of the workspace. We evaluate conveyor-belt sorting with two object categories: toy dog and hairbrush. For each object category, we collect 200 demonstrations and fine-tune the policy with LoRA for 20k steps. Each real-world condition is evaluated over 10 trials.
+
+## 4.2 Simulation Evaluation
+
+Setup. We evaluate Realtime-VLA FLASH on LIBERO by comparing four methods: Torchπ 0 [1], Tritonπ 0 [19], FLASHπ 0 , and FLASH+Tritonπ 0 . We adapt Tritonπ 0 to LIBERO and build FLASH+Tritonπ 0 by combining our FLASH with the Triton implementation. The structurally aligned draft and verify modules allow partial reuse of existing Tritonπ 0 kernels. We report suitelevel success rates, average task-level inference latency ( Lat. ), and per-action latency ( /Act ).
+
+Table 1: Simulation results on four LIBERO suites. We report suite-level success rates, average success rate ( SR ), average task-level latency ( Lat. (ms) ), average per-action latency ( /Act (ms) ), and relative improvement over the original π 0 [1].
+
+| Methods           | Success Rate (%)   | Success Rate (%)   | Success Rate (%)   |   Success Rate (%) | Average   | Average   | Average   | Improvement   | Improvement   |
+|-------------------|--------------------|--------------------|--------------------|--------------------|-----------|-----------|-----------|---------------|---------------|
+|                   | Spatial            | Object             | Goal               |               10   | SR        | Lat.      | /Act      | ∆ SR          | Speedup       |
+| Torch- π 0 [1]    | 96.8               | 98.8               | 95.8               |               85.2 | 94.1      | 58.0      | 5.0       | -             | 1.00 ×        |
+| Triton- π 0 [19]  | 96.4               | 98.8               | 95.0               |               86.6 | 94.2      | 39.7      | 3.5       | +0.1          | 1.46 ×        |
+| FLASH- π 0        | 96.4               | 99.2               | 94.6               |               83.4 | 93.4      | 34.9      | 3.0       | -0.7          | 1.66 ×        |
+| FLASH+Triton- π 0 | 96.8               | 99.2               | 94.4               |               84.6 | 93.8      | 19.1      | 1.9       | -0.3          | 3.04 ×        |
+
+Table 2: Suite-level flash-path statistics on LIBERO. Acc. is the average accepted draft prefix length in flash-path rounds, normalized by the replan size (12). Flash Path Rate (FR.) is the fraction of flash-path rounds among all replanning rounds across task trajectories.
+
+| LIBERO Suites   | Acc. (%)   | Acc. (%)   | FR. (%)   | FR. (%)   | Lat. (ms)   | Lat. (ms)   | /Act (ms)   | /Act (ms)   |
+|-----------------|------------|------------|-----------|-----------|-------------|-------------|-------------|-------------|
+| LIBERO Suites   | FLASH      | +Tri.      | FLASH     | +Tri.     | FLASH       | +Tri.       | FLASH       | +Tri.       |
+| Spatial         | 75.8       | 60.2       | 71.6      | 68.9      | 34.3        | 19.2        | 3.0         | 2.1         |
+| Object          | 78.1       | 89.3       | 72.4      | 86.4      | 34.6        | 12.6        | 3.0         | 1.2         |
+| Goal            | 81.4       | 66.9       | 63.7      | 62.4      | 37.5        | 20.5        | 3.3         | 2.1         |
+| 10              | 82.4       | 62.5       | 57.5      | 49.6      | 33.2        | 24.1        | 2.8         | 2.3         |
+| Avg.            | 79.4       | 69.7       | 66.3      | 66.8      | 34.9        | 19.1        | 3.0         | 1.9         |
+
+Results. Table 1 summarizes the main simulation results. Compared with the 58.0 ms original fullpath round, a flash-path round costs only 17.9 ms for FLASHπ 0 and 7.8 ms for FLASH+Tritonπ 0 (Appendix A, Table 6). With phase-aware fallback, FLASHπ 0 reduces the task-level average latency to 34.9 ms, achieving a 1.66 × speedup over Torchπ 0 ; with Triton optimization, FLASH+Tritonπ 0 further reduces it to 19.1 ms , achieving a 3.04 × speedup. This also corresponds to a 2.63 × reduction in per-action latency, with only a 0.3-point drop in average success rate.
+
+Table 2 attributes the FLASH speedup to high flashpath usage: FLASH+Tritonπ 0 handles 66.8% of replanning rounds via the flash path, with accepted prefixes covering 69.7% of the replan window, thereby reducing full-path calls and amortizing speculative execution. Table 3 evaluates runtime components on LIBERO-10, the most hyperparameter-sensitive suite, where small speculative errors can accumulate and cause task failure. We fix the verification threshold to δ = 0 . 15 and use two verifier timesteps ( |T | = 2 ), then ablate periodic full-path refresh ( PF ) and phaseaware fallback ( FB ). PF periodically invokes higherfidelity full-path actions to correct long-horizon drift, while FB performs targeted correction near precisioncritical phases indicated by gripper switches. We finally select +FB &amp; PF=2 as the best success-latency
+
+Table 3: Ablation of key components on LIBERO-10. PF = n denotes forcing one full-path refresh every n fl ash-path rounds.
+
+| Configuration                       |   SR (%) |   Lat. (ms) |
+|-------------------------------------|----------|-------------|
+| Baseline (Flash-path only)          |     58.4 |        13.3 |
+| Periodic full-path refresh + PF = 2 |     80.6 |        21   |
+| + PF = 3                            |     82   |        18.6 |
+| + PF = 4                            |     75.4 |        17.2 |
+| Phase-aware fallback + FB           |     66.8 |        17.7 |
+| +FB&PF=2                            |     84.6 |        24.1 |
+| + FB &PF = 3                        |     81.6 |        21.9 |
+| + FB &PF = 4                        |     78.4 |        20.2 |
+
+trade-off for the LIBERO-10 result in Table 1, with detailed ablations provided in Appendix C.1.
+
+## 4.3 Real-world Evaluation
+
+Setup. We evaluate real-world conveyor-belt sorting, where the robot must grasp a moving object and finish sorting before it leaves the reachable region, as shown in Figure 7. To isolate policy inference latency, all methods use the same synchronous inference loop without asynchronous inference, real-time chunking [2, 3], or other latency-hiding optimizations. We compare JAXπ 0 [1], Tritonπ 0 [19], and FLASH+Tritonπ 0 under the same hardware and protocol across medium, high, and extra high speeds. Appendix C.2 provides the platform and training hyperparameters.
+
+FLASH + Triton: Success
+
+Figure 7: Conveyor-belt sorting demo.
+
+<!-- image -->
+
+Table 4: Conveyor-belt sorting results under synchronous inference. We report success rate (%) over 10 trials for each object and speed; demonstrations are collected at 6 m/min.
+
+| Methods           | Medium (10m/min)   | Medium (10m/min)   | High (13m/min)   | High (13m/min)   | Extra High (15m/min)   | Extra High (15m/min)   |
+|-------------------|--------------------|--------------------|------------------|------------------|------------------------|------------------------|
+|                   | Toy dog            | Hairbrush          | Toy dog          | Hairbrush        | Toy dog                | Hairbrush              |
+| JAX- π 0 [1]      | 20.0               | 50.0               | 0.0              | 0.0              | 0.0                    | 0.0                    |
+| Triton- π 0 [19]  | 80.0               | 40.0               | 30.0             | 10.0             | 0.0                    | 0.0                    |
+| FLASH+Triton- π 0 | 80.0               | 90.0               | 50.0             | 30.0             | 20.0                   | 10.0                   |
+
+Results. Table 4 shows that conveyor speed amplifies the effect of policy inference latency. As a reference point below the reported speed range, JAXπ 0 achieves 80% success on toy dog at 8 m/min, but drops sharply at the reported speeds. At medium speed, all methods achieve nonzero success, but FLASH+Tritonπ 0 already improves the more timing-sensitive hairbrush task. As speed increases, the synchronous baselines degrade rapidly: JAXπ 0 [1] fails at high speed, Tritonπ 0 [19] retains only limited success, and both fail at extra high speed. In contrast, FLASH+Tritonπ 0 remains successful at extra high speed and is the only method with nonzero success at 15 m/min.
+
+Failures of the slower baselines mostly come from stale action chunks: the robot approaches an outdated belt position, so the gripper arrives behind the object or closes too late. This effect is stronger at higher speeds and on hairbrushes, whose thin geometry leaves less tolerance to timing and pose errors. These failures support the main real-world takeaway: under synchronous control, reducing policy latency directly expands the speed range in which dVLAs can complete reactive manipulation.
+
+## 5 Conclusion
+
+We presented Realtime-VLA FLASH, a speculative inference framework that serves most replanning rounds through the flash path and reverts to the full path when verification or fine-adjustment phases require higher fidelity. Experiments on LIBERO and conveyor-belt sorting show substantial latency reductions while largely preserving task performance, suggesting a practical path toward latencysensitive embodied control. FLASH still relies on heuristic thresholds, leaving trajectory-adaptive verification thresholds as an important direction for future work.
+
+## Acknowledgements
+
+We thank Haoqiang Fan and collaborators for insightful discussions and for the Realtime-VLA line of work [19, 30] which helped shape our focus on latency-aware VLA deployment.
+
+## References
+
+- [1] Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Lachy Groom, Karol Hausman, Brian Ichter, et al. π 0 : A vision-language-action flow model for general robot control. ArXiv , abs/2410.24164, 2024.
+- [2] Kevin Black, Manuel Y Galliker, and Sergey Levine. Real-time execution of action chunking flow policies. arXiv preprint arXiv:2506.07339 , 2025.
+- [3] Kevin Black, Allen Z Ren, Michael Equi, and Sergey Levine. Training-time action conditioning for efficient real-time chunking. arXiv preprint arXiv:2512.05964 , 2025.
+- [4] Yang Chen, Xiaoguang Ma, and Bin Zhao. Mean-flow based one-step vision-language-action. arXiv preprint arXiv:2603.01469 , 2026.
+- [5] Cheng Chi, Zhenjia Xu, Siyuan Feng, Eric Cousineau, Yilun Du, Benjamin Burchfiel, Russ Tedrake, and Shuran Song. Diffusion policy: Visuomotor policy learning via action diffusion. The International Journal of Robotics Research , page 02783649241273668, 2023.
+- [6] Valentin De Bortoli, Alexandre Galashov, Arthur Gretton, and Arnaud Doucet. Accelerated diffusion models via speculative sampling. arXiv preprint arXiv:2501.05370 , 2025.
+- [7] Kevin Frans, Danijar Hafner, Sergey Levine, and Pieter Abbeel. One step diffusion via shortcut models. arXiv preprint arXiv:2410.12557 , 2024.
+- [8] Zhengyang Geng, Mingyang Deng, Xingjian Bai, J Zico Kolter, and Kaiming He. Mean flows for one-step generative modeling. arXiv preprint arXiv:2505.13447 , 2025.
+- [9] Hengyuan Hu, Aniket Das, Dorsa Sadigh, and Nima Anari. Diffusion models are secretly exchangeable: Parallelizing ddpms via autospeculation. arXiv preprint arXiv:2505.03983 , 2025.
+- [10] Physical Intelligence, Kevin Black, Noah Brown, James Darpinian, Karan Dhabalia, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Manuel Y. Galliker, Dibya Ghosh, Lachy Groom, Karol Hausman, Brian Ichter, Szymon Jakubczak, Tim Jones, Liyiming Ke, Devin LeBlanc, Sergey Levine, Adrian Li-Bell, Mohith Mothukuri, Suraj Nair, Karl Pertsch, Allen Z. Ren, Lucy Xiaoyang Shi, Laura Smith, Jost Tobias Springenberg, Kyle Stachowicz, James Tanner, Quan Vuong, Homer Walke, Anna Walling, Haohuan Wang, Lili Yu, and Ury Zhilinsky. π 0 . 5 : a vision-language-action model with open-world generalization, 2025. URL https://arxiv.org/abs/2504.16054 .
+- [11] Wenqi Jiang, Jason Clemons, Karu Sankaralingam, and Christos Kozyrakis. How fast can i run my vla? demystifying vla inference performance with vla-perf. arXiv preprint arXiv:2602.18397 , 2026.
+- [12] Yuhui Li, Fangyun Wei, Chao Zhang, and Hongyang Zhang. Eagle: Speculative sampling requires rethinking feature uncertainty. arXiv preprint arXiv:2401.15077 , 2024.
+- [13] Yuhui Li, Fangyun Wei, Chao Zhang, and Hongyang Zhang. Eagle-2: Faster inference of language models with dynamic draft trees. In Proceedings of the 2024 conference on empirical methods in natural language processing , pages 7421-7432, 2024.
+- [14] Yuhui Li, Fangyun Wei, Chao Zhang, and Hongyang Zhang. Eagle-3: Scaling up inference acceleration of large language models via training-time test. arXiv preprint arXiv:2503.01840 , 2025.
+- [15] Tao Lin, Yilei Zhong, Yuxin Du, Jingjing Zhang, Jiting Liu, Yinxinyu Chen, Encheng Gu, Ziyan Liu, Hongyi Cai, Yanwen Zou, et al. Evo-1: Lightweight vision-language-action model with preserved semantic alignment. arXiv preprint arXiv:2511.04555 , 2025.
+
+- [16] Yaron Lipman, Ricky TQ Chen, Heli Ben-Hamu, Maximilian Nickel, and Matt Le. Flow matching for generative modeling. arXiv preprint arXiv:2210.02747 , 2022.
+- [17] Bo Liu, Yifeng Zhu, Chongkai Gao, Yihao Feng, Qiang Liu, Yuke Zhu, and Peter Stone. Libero: Benchmarking knowledge transfer for lifelong robot learning. Advances in Neural Information Processing Systems , 36:44776-44791, 2023.
+- [18] Songming Liu, Bangguo Li, Kai Ma, Lingxuan Wu, Hengkai Tan, Xiao Ouyang, Hang Su, and Jun Zhu. Rdt2: Exploring the scaling limit of umi data towards zero-shot cross-embodiment generalization. arXiv preprint arXiv:2602.03310 , 2026.
+- [19] Yunchao Ma, Yizhuang Zhou, Yunhuan Yang, Tiancai Wang, and Haoqiang Fan. Running vlas at real-time speed. arXiv preprint arXiv:2510.26742 , 2025.
+- [20] NVIDIA, Johan Bjorck, Nikita Cherniadev Fernando Castañeda, Xingye Da, Runyu Ding, Linxi "Jim" Fan, Yu Fang, Dieter Fox, Fengyuan Hu, Spencer Huang, Joel Jang, Zhenyu Jiang, Jan Kautz, Kaushil Kundalia, Lawrence Lao, Zhiqi Li, Zongyu Lin, Kevin Lin, Guilin Liu, Edith Llontop, Loic Magne, Ajay Mandlekar, Avnish Narayan, Soroush Nasiriany, Scott Reed, You Liang Tan, Guanzhi Wang, Zu Wang, Jing Wang, Qi Wang, Jiannan Xiang, Yuqi Xie, Yinzhen Xu, Zhenjia Xu, Seonghyeon Ye, Zhiding Yu, Ao Zhang, Hao Zhang, Yizhou Zhao, Ruijie Zheng, and Yuke Zhu. GR00T N1: An open foundation model for generalist humanoid robots. In ArXiv Preprint , March 2025.
+- [21] NVIDIA GEAR Team, Allison Azzolini, Johan Bjorck, Valts Blukis, et al. Gr00t n1.6: An improved open foundation model for generalist humanoid robots. https://research.nvidia. com/labs/gear/gr00t-n1\_6/ , December 2025.
+- [22] Mustafa Shukor, Dana Aubakirova, Francesco Capuano, Pepijn Kooijmans, Steven Palma, Adil Zouitine, Michel Aractingi, Caroline Pascal, Martino Russi, Andres Marafioti, et al. Smolvla: A vision-language-action model for affordable and efficient robotics. arXiv preprint arXiv:2506.01844 , 2025.
+- [23] Gemma Team, Thomas Mesnard, Cassidy Hardin, Robert Dadashi, Surya Bhupatiraju, Shreya Pathak, Laurent Sifre, Morgane Rivière, Mihir Sanjay Kale, Juliette Love, et al. Gemma: Open models based on gemini research and technology. arXiv preprint arXiv:2403.08295 , 2024.
+- [24] Gemma Team, Morgane Riviere, Shreya Pathak, Pier Giuseppe Sessa, Cassidy Hardin, Surya Bhupatiraju, Léonard Hussenot, Thomas Mesnard, Bobak Shahriari, Alexandre Ramé, et al. Gemma 2: Improving open language models at a practical size. arXiv preprint arXiv:2408.00118 , 2024.
+- [25] Hanzhen Wang, Jiaming Xu, Yushun Xiang, Jiayi Pan, Yongkang Zhou, Yong-Lu Li, and Guohao Dai. Specprune-vla: Accelerating vision-language-action models via action-aware self-speculative pruning. arXiv preprint arXiv:2509.05614 , 2025.
+- [26] Songsheng Wang, Rucheng Yu, Zhihang Yuan, Chao Yu, Feng Gao, Yu Wang, and Derek F Wong. Spec-vla: speculative decoding for vision-language-action models with relaxed acceptance. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing , pages 26916-26928, 2025.
+- [27] Zhendong Wang, Zhaoshuo Li, Ajay Mandlekar, Zhenjia Xu, Jiaojiao Fan, Yashraj Narang, Linxi Fan, Yuke Zhu, Yogesh Balaji, Mingyuan Zhou, et al. One-step diffusion policy: Fast visuomotor policies via diffusion distillation. arXiv preprint arXiv:2410.21257 , 2024.
+- [28] Junjie Wen, Yichen Zhu, Jinming Li, Minjie Zhu, Zhibin Tang, Kun Wu, Zhiyuan Xu, Ning Liu, Ran Cheng, Chaomin Shen, et al. Tinyvla: Towards fast, data-efficient vision-language-action models for robotic manipulation. IEEE Robotics and Automation Letters , 2025.
+- [29] Justin Williams, Kishor Datta Gupta, Roy George, and Mrinmoy Sarkar. Lite vla: Efficient vision-language-action control on cpu-bound edge robots. arXiv preprint arXiv:2511.05642 , 2025.
+
+- [30] Chen Yang, Yucheng Hu, Yunchao Ma, Yunhuan Yang, Jing Tan, and Haoqiang Fan. Realtimevla v2: Learning to run vlas fast, smooth, and accurate. arXiv preprint arXiv:2603.26360 , 2026.
+- [31] Yantai Yang, Yuhao Wang, Zichen Wen, Luo Zhongwei, Chang Zou, Zhipeng Zhang, Chuan Wen, and Linfeng Zhang. Efficientvla: Training-free acceleration and compression for visionlanguage-action models. arXiv preprint arXiv:2506.10100 , 2025.
+- [32] Jingxuan Zhang, Yunta Hsieh, Zhongwei Wang, Haokun Lin, Xin Wang, Ziqi Wang, Yingtie Lei, and Mi Zhang. Quantvla: Scale-calibrated post-training quantization for vision-language-action models. arXiv preprint arXiv:2602.20309 , 2026.
+- [33] Tony Z Zhao, Vikash Kumar, Sergey Levine, and Chelsea Finn. Learning fine-grained bimanual manipulation with low-cost hardware. arXiv preprint arXiv:2304.13705 , 2023.
+- [34] Zihao Zheng, Zhihao Mao, Maoliang Li, Jiayu Chen, Xinhao Sun, Zhaobo Zhang, Donggang Cao, Hong Mei, and Xiang Chen. Kerv: Kinematic-rectified speculative decoding for embodied vla models. arXiv preprint arXiv:2603.01581 , 2026.
+- [35] Zihao Zheng, Zhihao Mao, Sicheng Tian, Maoliang Li, Jiayu Chen, Xinhao Sun, Zhaobo Zhang, Xuanzhe Liu, Donggang Cao, Hong Mei, et al. Heisd: Hybrid speculative decoding for embodied vision-language-action models with kinematic awareness. arXiv preprint arXiv:2603.17573 , 2026.
+
+## A Draft Model Details
+
+## A.1 Architecture
+
+This section expands the draft architecture introduced in Section 3.3. Because the draft model reuses a VLM block, the observations provide visual context but do not define where a fixed-length action chunk should be written. We therefore append H learned action slots as explicit output positions:
+
+<!-- formula-not-decoded -->
+
+where q h corresponds to the h -th future action. These slots are trainable parameters, and they serve as persistent output queries that decode structured future actions from the shared context.
+
+We use a blockwise attention mask to make these slots compatible with the reused VLM architecture. Each action slot attends to the visual-language prefix and state token, and the slots can also interact within the action block, allowing the predicted actions to be coordinated across the chunk. Because all H slots are processed in the same forward pass, the transformer produces hidden states for the entire action chunk in parallel.
+
+After the transformer block, only the hidden states associated with the action slots are decoded. A shared linear action head maps each slot representation to its corresponding continuous action:
+
+<!-- formula-not-decoded -->
+
+where z h is the final hidden representation of slot q h .
+
+Thus, the learned action slots convert a VLM block into a parallel action-chunk predictor.
+
+## A.2 Training Hyperparameters and Inference Cost Breakdown
+
+Table 5 summarizes the draft-model training setup. The draft model regresses to frozen full-path policy outputs with a prefix-weighted objective, so early executable actions receive higher weight while verification and fallback still decide the final executed prefix.
+
+Table 6 reports the component-level latency behind the task-level results in Table 1. We include both per-round component costs and trajectory-level averages because flash-path rounds may execute variable-length prefixes.
+
+Table 5: Training hyperparameters for the draft model.
+
+| Item                    | Value                                                               |
+|-------------------------|---------------------------------------------------------------------|
+| Optimizer Learning rate | AdamW 2 × 10 - 3                                                    |
+| Weight decay            | 0 . 01                                                              |
+| Batch size              | 64                                                                  |
+| Epochs                  | 100                                                                 |
+| Precision               | FP32                                                                |
+| Loss                    | Weighted Smooth L1 / Huber loss, β = 1 . 0                          |
+| Prefix weighting        | Sampled prefix up to 16 steps, γ prefix = 0 . 9 , tail weight 0 . 1 |
+| Checkpoint              | Best validation RMS over the first 12 executable steps              |
+| Compute cost            | 4 NVIDIA RTX 4090D GPUs, approximately 6 hours per draft model      |
+
+Table 6: Inference cost breakdown.
+
+| Component                | Torch- π 0   | Triton- π 0   | FLASH- π 0   | FLASH+Triton- π 0   |
+|--------------------------|--------------|---------------|--------------|---------------------|
+| Full-path round (ms)     |              |               |              |                     |
+| Image encoder            | 11.3         | 4.7           | 11.3         | 4.7                 |
+| VLM prefill              | 26.7         | 22.4          | 26.7         | 22.4                |
+| Action denoise           | 20.0         | 12.6          | 20.0         | 12.6                |
+| Full-path total          | 58.0         | 39.7          | 58.0         | 39.7                |
+| Flash-path round (ms)    |              |               |              |                     |
+| Image encoder            | -            | -             | 11.0         | 4.7                 |
+| Draft model              | -            | -             | 3.5          | 0.9                 |
+| Parallel verifier        | -            | -             | 3.4          | 2.2                 |
+| Flash-path total         | -            | -             | 17.9         | 7.8                 |
+| Trajectory-level average |              |               |              |                     |
+| Replanning latency       | 58.0         | 39.7          | 34.9         | 19.1                |
+| Per-action latency       | 5.0          | 3.5           | 3.0          | 1.9                 |
+| Speedup                  | 1.00 ×       | 1.46 ×        | 1.66 ×       | 3.04 ×              |
+
+## B Verification Consistency Interpretation
+
+The endpoint check in Algorithm 1 should be interpreted as a heuristic local consistency test, rather than as a formal guarantee that the accepted draft and the full-path rollout induce identical trajectories or task-level behavior. The key distinction is that the Action Expert is trained by flow matching on interpolation paths toward target action endpoints, whereas verification probes the learned flow field on states induced by a drafted endpoint. Thus, passing verification indicates that the draft is locally compatible with the learned velocity field under the reused conditioning context, but it does not establish full-path equivalence.
+
+Let A ⋆ t denote the endpoint produced by a full-path rollout under the current conditioning context, and let ˆ A ( d ) t denote the accepted draft endpoint. Informally, the endpoint discrepancy can be viewed as controlled by the acceptance threshold, the local reconstruction error of the Action Expert, the residual conditioning mismatch, and the mismatch between target-induced and draft-induced interpolation paths:
+
+<!-- formula-not-decoded -->
+
+Here, ϵ AE accounts for approximation errors in the local velocity field and the single-step endpoint reconstruction performed by the Action Expert. The term ϵ cond captures residual mismatch introduced by reusing the cached visual-language prefix. The term ϵ path captures the fact that verification evaluates the flow field on draft-induced interpolation states, rather than on the target-endpoint paths used during training or the states visited by a full sequential rollout.
+
+Importantly, as shown in Algorithm 1, the robot state s t is refreshed at every verification call and therefore does not constitute a stale cached variable. Overall, the acceptance rule should be understood as a conservative local agreement criterion, not as a formal correctness guarantee for the accepted prefix. This interpretation motivates conservative thresholds, multi-timestep verification, phase-aware fallback, and full-path fallback when local consistency fails.
+
+## C Experimental Details
+
+## C.1 Simulation Details: Verification Hyperparameter Ablation
+
+We isolate the verifier before adding phase-aware fallback and periodic full-path refresh, so this subsection should be interpreted as a verifier trade-off study. Table 7 uses LIBERO-10 as a stress test and varies the number of verification timesteps K = |T | and distance threshold δ . Loose thresholds keep more rounds on the flash path and reduce latency, but they also allow inaccurate drafts to pass verification. Stricter thresholds and larger K reject more speculative actions, improving reliability in sensitive settings while pushing latency toward the full-path regime.
+
+We use K = 2 , δ = 0 . 15 as the base verifier setting for the full runtime rather than as a standalone verifier-only optimum. This point preserves high flash-path coverage and low latency, while the complete runtime recovers reliability through phase-aware fallback and periodic full-path refresh (Table 3). Table 8 further fixes K = 2 and sweeps δ across all LIBERO suites. The same acceptancelatency pattern appears across suites, while LIBERO-10 shows the largest success-rate variation; we therefore use it as the primary verifier stress test in Table 7.
+
+Table 7: Verifier-only ablation on LIBERO-10.
+
+| Verifier Setting   | Verifier Setting   | Verifier Setting   | LIBERO-10 Result   | LIBERO-10 Result   | LIBERO-10 Result   | LIBERO-10 Result   | LIBERO-10 Result   |
+|--------------------|--------------------|--------------------|--------------------|--------------------|--------------------|--------------------|--------------------|
+| K                  | Lat. (ms)          | δ                  | SR (%)             | Lat. (ms)          | /Act (ms)          | Acc. (%)           | FR. (%)            |
+|                    |                    | 0.20               | 82.6               | 35.7               | 4.2                | 13.9               | 18.8               |
+|                    |                    | 0.15               | 86.2               | 39.9               | 4.4                | 6.8                | 9.2                |
+| 4                  | 4.3                | 0.10               | 85.0               | 47.5               | 4.5                | 1.8                | 2.1                |
+|                    |                    | 0.05               | 84.4               | 52.4               | 4.5                | 0.0                | 0.0                |
+|                    |                    | 0.00               | 86.4               | 52.3               | 4.5                | 0.0                | 0.0                |
+|                    |                    | 0.20               | 54.3               | 10.3               | 0.9                | 91.8               | 94.3               |
+|                    |                    | 0.15               | 58.4               | 13.3               | 1.5                | 65.6               | 83.0               |
+| 2                  | 2.2                | 0.10               | 79.4               | 21.1               | 3.3                | 23.3               | 40.9               |
+|                    |                    | 0.05               | 93.5               | 44.9               | 4.5                | 2.0                | 2.5                |
+|                    |                    | 0.00               | 85.6               | 47.9               | 4.1                | 0.0                | 0.0                |
+|                    |                    | 0.20               | 54.9               | 13.5               | 1.2                | 99.7               | 95.4               |
+|                    |                    | 0.15               | 53.8               | 12.5               | 1.1                | 99.4               | 95.4               |
+| 1                  | 1.4                | 0.10               | 51.0               | 12.9               | 1.2                | 84.8               | 92.4               |
+|                    |                    | 0.05               | 84.2               | 28.5               | 4.0                | 11.4               | 19.6               |
+|                    |                    | 0.00               | 86.8               | 49.8               | 4.2                | 0.0                | 0.0                |
+
+Table 8: Cross-suite threshold sensitivity with K = 2 .
+
+|    δ | Success Rate (%)   | Success Rate (%)   | Success Rate (%)   |   Success Rate (%) | Latency (ms)   | Latency (ms)   | Latency (ms)   |   Latency (ms) | Average   | Average   | Average   | Average   | Average   |
+|------|--------------------|--------------------|--------------------|--------------------|----------------|----------------|----------------|----------------|-----------|-----------|-----------|-----------|-----------|
+|      | Spatial            | Object             | Goal               |               10   | Spatial        | Object         | Goal           |           10   | SR        | Lat.      | /Act      | Acc.      | FR.       |
+| 0.3  | 95.8               | 99.2               | 86.6               |               53.8 | 12.0           | 11.1           | 11.8           |            9.9 | 83.9      | 11.1      | 1.0       | 99.7      | 91.3      |
+| 0.25 | 93.6               | 98.4               | 87.6               |               53.8 | 11.9           | 11.3           | 11.8           |           10   | 83.4      | 11.1      | 1.0       | 98.8      | 91.4      |
+| 0.2  | 94.8               | 98.6               | 86.4               |               54.3 | 11.8           | 11.3           | 11.9           |           10.3 | 83.5      | 11.2      | 1.0       | 95.1      | 90.9      |
+| 0.15 | 96.0               | 99.2               | 90.8               |               58.4 | 12.3           | 12.6           | 12.5           |           13.3 | 86.1      | 12.7      | 1.4       | 77.5      | 84.9      |
+| 0.1  | 97.2               | 98.8               | 92.6               |               79.4 | 19.5           | 20.7           | 19.5           |           21.1 | 92.0      | 20.4      | 3.0       | 30.5      | 46.6      |
+| 0.05 | 93.8               | 98.8               | 94.4               |               87.2 | 41.0           | 40.2           | 40.9           |           41.6 | 93.5      | 41.0      | 4.1       | 2.0       | 2.5       |
+| 0    | 97.0               | 97.6               | 96.2               |               85.6 | 47.4           | 47.2           | 47.2           |           47.9 | 94.1      | 47.5      | 4.1       | 0.0       | 0.0       |
+
+## C.2 Real-world Details
+
+Figure 8 illustrates the real-world evaluation platform used for conveyor-belt sorting. In the real-world deployment, accepted actions are still executed through the robot controller with joint limits and command constraints, so a false acceptance remains subject to these low-level safety constraints.
+
+Table 9 reports the training configuration. We first fine-tune the main policy from the pre-trained π 0 checkpoint using LoRA on the collected demonstrations, and then train the draft model for the same real-world domain. For draft training, the observations come from the real demonstrations, while the regression targets are teacher action chunks generated by the fine-tuned main model rather than directly by behavior cloning from raw demonstration actions.
+
+Figure 8: Real-world robot platform used for conveyor-belt sorting.
+
+<!-- image -->
+
+Table 9: Training hyperparameters for real-world demonstration adaptation.
+
+| Item                   | Value                                                                                          |
+|------------------------|------------------------------------------------------------------------------------------------|
+| Main Model fine-tuning | Main Model fine-tuning                                                                         |
+| Batch size             | 128                                                                                            |
+| Training steps         | 20k                                                                                            |
+| LR schedule            | Cosine decay with 500 warmup steps                                                             |
+| Peak / final LR        | 1 × 10 - 4 / 1 × 10 - 5                                                                        |
+| Draft model training   | Draft model training                                                                           |
+| Optimizer              | AdamW                                                                                          |
+| Learning rate          | 2 × 10 - 3                                                                                     |
+| LR schedule            | Cosine schedule with 1 warmup epoch and 1 × 10 - 5 minimum LR                                  |
+| Batch size             | 64 per GPU                                                                                     |
+| Epochs                 | 100                                                                                            |
+| Gradient clipping      | Global norm 1.0                                                                                |
+| Loss                   | Weighted Smooth L1 / Huber loss, β = 1 . 0                                                     |
+| Prefix weighting       | Sampled prefix up to 20 steps, γ prefix = 0 . 9 , tail weight 0 . 1                            |
+| Checkpoint             | Best validation RMS over the first 12 executable steps                                         |
+| Compute cost           | 8 NVIDIA H20 GPUs, approximately 12 hours for fine-tuning and 2 hours for draft model training |
+
+## D Future Work
+
+Realtime-VLA FLASH suggests several directions for future work.
+
+First, the current verifier uses heuristic hyperparameters, including fixed acceptance thresholds and hand-picked verification timesteps. A more adaptive verifier could adjust both the threshold and the timestep locations over the course of a trajectory, tightening verification during fine-adjustment phases, rapid observation changes, or high-curvature motions, while relaxing it during smooth freespace motion. This generalizes the intuition behind our phase-aware fallback mechanism from a gripper-switch heuristic to a broader context-dependent verification rule.
+
+Second, FLASH could be combined with real-time chunking (RTC) methods. Current RTC methods often assume a fixed inference latency, whereas FLASH introduces dynamic accepted prefix lengths and variable effective latency across replanning rounds. Adapting RTC to this setting would require trajectory optimization algorithms that account for variable-latency policy updates, potentially yielding trajectories that are both fast and smooth.
+
+Third, FLASH may further benefit edge deployments. VLA-Perf [11] reports that VLA inference stages become memory-bound on edge devices, where memory bandwidth, power, and thermal budgets are substantially tighter than on desktop GPUs. By reducing repeated full-path inference calls, FLASH can lower average memory traffic and power consumption during replanning. Extending this design to resource-constrained edge devices could make low-latency dVLA deployment more practical for robots with limited compute, power, or thermal budgets.

extracts/parses/2605_16154_PCM/docling/2605_16154_PCM.md

@@ -0,0 +1,511 @@
+## Learn Where Outcomes Diverge: Efficient VLA RL via Probabilistic Chunk Masking
+
+Vaidehi Bagaria ∗ , Nikshep Grampurohit ∗ , Pulkit Verma †
+
+Indian Institute of Technology Madras
+
+## Abstract
+
+Reinforcement learning (RL) allows vision-language-action (VLA) policies to generalize beyond their training distribution by optimizing directly for task success, but this post-training stage is computationally expensive. A natural response has been to speed up rollout data collection through faster simulators and world models. In GRPO-based VLA RL, however, we find that the dominant cost lies elsewhere: gradient computation accounts for ∼ 78% of wall-clock time per step in our runs, while rollout collection accounts for only ∼ 21%. Gradient cost dominates because much of this computation is spent on phases that contribute little to learning. GRPO's learning signal is driven by advantage variance: only phases where successful and failed rollouts diverge produce useful learning signal. However, GRPO assigns the same advantage to every chunk in a rollout. As a result, actor-update compute is spent uniformly across the trajectory, including phases the policy already handles after pre-training and supervised fine-tuning. This paper presents Probabilistic Chunk Masking (PCM), a drop-in modification to GRPO that allocates gradient computation to a small, probabilistically selected subset of chunks per trajectory. PCM scores semantic phases using success-failure action variance, a rollout-derived proxy for per-phase gradient variance, and samples a fixed chunk budget with online-updated phase-level keep probabilities. We formalize per-phase gradient variance as the quantity that determines where gradient computation is useful and show that success-failure action variance provides a measurable proxy for it. PCM requires no reward model or learned critic. On three LIBERO benchmarks, PCM matches the final success rate of standard GRPO while achieving 2 . 38 × wall-clock speedup, 4 . 8 × faster gradient updates, and 60 % lower peak activation memory, while backpropagating through fewer than 20 % of trajectory chunks.
+
+## 1 Introduction
+
+Reinforcement learning (RL) has become essential for vision-language-action (VLA) models, enabling generalization to new environments and behaviors [Black et al., 2024, Kim et al., 2024]. The field has increasingly converged on Group Relative Policy Optimization (GRPO) [Shao et al., 2024] whose critic-free formulation removes the cost and complexity of training a separate value model [Li et al., 2025a, Lu et al., 2025]. As these systems scale, speeding up post-training has become critical. Efforts to speed up GRPO-based VLA RL have implicitly assumed that rollout collection is the bottleneck. We measure where time actually goes and find the reverse: in our runs gradient computation accounts for ∼ 78% of wall-clock time per training step, while rollout collection accounts for only ∼ 21% (Fig. 1, right).
+
+* Equal contribution.
+
+† Correspondence to pulkitv@cse.iitm.ac.in .
+
+| Benchmark      |   Grad (%) |   Rollout (%) |
+|----------------|------------|---------------|
+| LIBERO-Object  |      77.91 |         21.27 |
+| LIBERO-Goal    |      77.86 |         21.29 |
+| LIBERO-Spatial |      77.85 |         21.29 |
+
+Figure 1: Left: per-phase success-failure action variance ( C c ) concentrates on decision-critical phases. Right: gradient computation dominates wall-clock training cost in simulator-based GRPO with 10 rollouts per prompt. Remaining ∼ 1% is logging, evaluation, and inter-step overhead.
+
+<!-- image -->
+
+This inefficiency arises from a deeper structural feature shared by most RL algorithms. Backpropagation runs over every chunk in the trajectory, and trajectory-level credit assigns the same advantage to each chunk regardless of which determined the outcome. Both inefficiencies share a common cause: the trajectory has been treated as the unit of gradient computation. Even methods that differentiate per-step credit, such as PPO [Schulman et al., 2017] with a learned critic, still apply forward/backward-pass compute to all sampled timesteps. They modify the signal, not the compute allocation.
+
+This observation suggests a missing axis in VLA RL optimization: within a trajectory, which chunks should receive gradient computation at all?
+
+The answer is not all of them. GRPO's learning signal is driven by differences in advantage across rollouts: when rollout rewards are uniform, gradients vanish [Wang et al., 2026, Xu and Ding, 2026]. We argue that variance non-uniformity persists even within a single non-collapsed group. Supervised fine-tuning is effective in densely covered, unimodal regions, but weak under sparse demonstrations or multimodal optimal behavior [Chu et al., 2025]; these are precisely the regimes that RL fine-tuning is intended to refine. This suggests that (a) gradient computation should be treated as an allocatable resource and (b) recomputing gradients on phases the base policy already handles wastes compute and memory. From this perspective, RL training becomes a problem of allocating limited gradient budget to the parts of trajectories that carry useful learning signal.
+
+We present Probabilistic Chunk Masking (PCM), a drop-in modification to GRPO that updates only a fixed budget of chunks per trajectory. PCM assigns phase-level keep probabilities using the success-failure action variance C c , which is concentrated in a small number of outcome-critical semantic phases c (Fig. 1, left). It then physically removes the unselected chunks from the backward pass, significantly reducing actor-update compute and activation memory. We further prove that C c serves as a measurable lower-bound proxy for the true per-phase gradient variance V c , giving a principled basis for this allocation. The main contributions of this paper are as follows:
+
+- We show that V c is the right signal for gradient allocation and derive a Neyman allocation proportional to N c √ V c ( N c is the number of chunks in phase c ), which concentrates gradient compute on outcome-divergent phases.
+- We establish that the per-phase success-failure action variance C c is a sufficient proxy for V c , computable directly from rollouts GRPO already produces with no reward model or learned critic.
+- Empirically, these enable substantial efficiency gains in gradient-bound VLA-RL. On LIBERO [Liu et al., 2023], PCM achieves 2 . 38 × wall-clock speedup to 98% convergence, 4 . 8 × faster gradient steps, 60% lower peak activation memory, using less than 20% of chunks per trajectory.
+
+## 2 Related works
+
+Reinforcement Learning Fine-Tuning of VLA Models. Reinforcement learning has become an effective post-training stage for vision-language-action (VLA) models [Chu et al., 2025, Liu et al., 2025]. Early approaches relied on learned critics [Hu et al., 2024, Guo et al., 2025, Chen et al., 2025a, Tan et al., 2025], but the field has converged on critic-free GRPO-style optimization as these systems have scaled [Li et al., 2025a, Lu et al., 2025, Chen et al., 2025b, Ye et al., 2025].
+
+To support this shift, advances in world models and simulation have significantly reduced rollout cost [Zhu et al., 2025, Liu et al., 2026, Zang et al., 2026] under the implicit assumption that data collection
+
+is the bottleneck. However, this progress has left gradient computation, which we observe accounts for ∼ 78% of training time, largely unoptimized. Other work improves the source or structure of the reward signal [Li et al., 2025b, Zhai et al., 2025, Tan et al., 2025] by altering the reward, critic, rollout source, or advantage/credit-assignment rule. We show that this additional machinery can be avoided: C c (success-failure action variance within a phase), an internal signal already present in GRPO rollouts, directly captures where learning signal concentrates and is sufficient to guide gradient allocation.
+
+Efficiency Methods for GRPO. GRPO's learning signal is driven by advantage variance [Nan et al., 2025], and prior large language model (LLM) RL work has exploited this at two granularities. At the prompt level, methods filter or reweight zero-variance rollout groups [Yu et al., 2025, Zheng et al., 2025, Hu et al., 2025]. At the token level, work selects which sequence positions receive gradient using policy-internal signals such as token entropy or probability shifts [Wang et al., 2025, Khandoga et al., 2026, Hu et al., 2026]. PCM operates at a third granularity: phase-level allocation within a trajectory. Entropy and probability shifts are indirect proxies that measure where the model is uncertain, not where successful and failed rollouts actually diverge. In settings with verifiable outcomes (like VLA RL), this raises a more fundamental question, why estimate outcome-criticality indirectly when the outcome signal is already available? We use C c , computed directly from rollout outcomes, to allocate gradient compute according to observed success-failure divergence. Unlike prior work that relies on proxy signals such as entropy or probability shifts, PCM exploits outcome-grounded divergence.
+
+Parameter-efficient methods like LoRA and its extensions are standard in LLM and VLA fine-tuning, reducing trainable parameters but not the activation cost of backpropagating through long trajectories [Hu et al., 2021, Aghajanyan et al., 2021, Dettmers et al., 2023, Zhang et al., 2025, 2023]. Activationfocused methods reduce this memory cost through checkpointing and streaming backpropagation [Chen et al., 2016, Korthikanti et al., 2023, Luo et al., 2025]. Crucially, prior methods do not address the inefficiency of computing gradients on outcome-invariant phases within a trajectory, which still incur computation cost despite contributing little to learning.
+
+## 3 Preliminaries
+
+We briefly describe the setup for chunk-level GRPO, which our method builds on.
+
+VLA Policies and Action Chunks. Let π θ denote a VLA policy that produces actions in chunks of length L conditioned on observation s i,k , where i indexes the trajectory and k the chunk within that trajectory. A rollout of trajectory i decomposes into N i = ⌈ T i /L ⌉ chunks, where T i is the total number of timesteps.
+
+Group Relative Policy Optimization. GRPO [Shao et al., 2024] samples a group of G rollouts from the current policy, scores each with a binary reward r i ∈ { 0 , 1 } , and forms the group-relative advantage
+
+<!-- formula-not-decoded -->
+
+Writing a i,k for the action tokens of chunk k in trajectory i , the chunk-level GRPO objective is
+
+<!-- formula-not-decoded -->
+
+with PPO-style clipping omitted for clarity.
+
+## 4 Methodology: Probabilistic Chunk Masking
+
+## 4.1 Phase-Conditioned Gradient Variance
+
+Following the VLA-RL setup formalized in Appendix A, we partition every trajectory into K semantic phases using a deterministic labeling rule (described in Sec. 5.1). Let P = { c 1 , . . . , c K } denote this phase set, and let φ ( i, k ) ∈ P denote the phase of chunk ( i, k ) .
+
+Figure 2: Probabilistic Chunk Masking (PCM). We compute per-phase success-failure action variance ( C c ) from GRPO rollouts, use it to prioritize decision-critical phases, and sample a fixed budget of chunks per trajectory. Gradients are computed only on selected chunks.
+
+<!-- image -->
+
+Phase decomposition of the GRPO gradient. The gradient of L GRPO decomposes by phase:
+
+<!-- formula-not-decoded -->
+
+The learning signal available in phase c is characterized by the per-phase gradient variance
+
+<!-- formula-not-decoded -->
+
+Intuitively, V c is large for phases where the policy behaves differently across successful and failed rollouts. Throughout, V c refers to the within-trajectory chunk variance ( A i fixed); under advantage normalization (Eq. 1), this matches the unconditional variance in Eq. (4) up to an O (1) constant. We formalize this observation as follows. Note that formal proofs appear in Appendix B.
+
+Lemma 1 (Phase gradient variance) . Let c ∈ P be a phase in which π θ has converged, i.e., the action distributions of successful and failed rollouts are identical in phase c . Then ∥ g c ( θ ) ∥ ≈ 0 and V c ≈ 0 , so gradient samples from phase c contribute negligible signal. Conversely, for a phase c in which the base policy is underspecified, V c is large and gradient samples from phase c are informative.
+
+Empirical proxy for V c . Computing V c exactly requires access to the gradient distribution, which is expensive. We instead use the success-failure action variance
+
+<!-- formula-not-decoded -->
+
+computable directly from the rollout group that GRPO already produces, with no auxiliary model or annotation. We compute C c only for rollout groups with non-zero reward variance.
+
+Lemma 2 ( C c as a proxy for V c ) . For a policy π θ that is locally Gaussian with per-dimension variance σ 2 π , the per-phase gradient variance satisfies V c ≥ C 2 c / 4 σ 2 π .
+
+Note that the bound in Lemma 2 is a lower bound that absorbs ∥∇ θ µ θ ( s ) ∥ 2 into the constant. It justifies using C c to recover the ordering of V c across phases, rather than exact correspondence. We treat C c as a practical proxy supported by empirical evidence: the realized allocation (Fig. 6) closely matches the √ V c -weighted prediction, and variance-aware ablations (Fig. 5b) show that C c -weighted selection outperforms both random masking and highest-variance-only selection.
+
+## 4.2 Optimal Budget Allocation
+
+We now state the core theoretical result. Given a fixed chunk budget B per trajectory and phase variance estimates { V c } c ∈P , we ask: how should B be distributed across phases to minimize the variance of the GRPO gradient estimator (the sampling noise around the true gradient, distinct from the per-phase signal V c )? Lower estimator variance means a more accurate estimate of the true gradient per step, which translates directly to faster stochastic gradient descent (SGD) convergence [Bottou et al., 2018]. This follows Neyman-allocation intuition: under a fixed sampling budget, phases should be sampled in proportion to their contribution to estimator variance.
+
+Theorem 1 (Optimal phase allocation) . Let b c denote the number of chunks sampled from phase c , with ∑ c ∈P b c = B , and let N c denote the expected number of chunks in phase c per trajectory. The
+
+allocation minimizing the variance of the unbiased GRPO gradient estimator (Eq. (2) subject to the budget constraint is √
+
+<!-- formula-not-decoded -->
+
+The speedup over uniform allocation depends on how sharply V c concentrates across phases. When V c is uniform across all K phases, Eq. (6) reduces to uniform allocation b c = B/K . When V c concentrates on a small subset of phases, the Neyman allocation assigns disproportionately more budget to those outcome divergent phases, reducing estimator variance relative to uniform at the same total budget B . The concentration of C c on contact-rich phases observed in Fig. 1, combined with Lemma 2, implies that V c is similarly concentrated, making this regime directly applicable here. Section 5 quantifies the resulting wall-clock speedup empirically. A formal convergence-rate derivation and speedup formula are provided in Appendix B.1.
+
+## 4.3 Online Phase Score Estimation
+
+Theorem 1 requires knowledge of { V c } , which is not directly observable. By Lemma 2, the relative ordering of { V c } is captured by the rollout-computable proxy { C c } . We therefore use C c to set per-phase weights; since phase c contains N c candidate chunks, weighted sampling consistent with Eq. (6) gives E [ b c ] ∝ N c √ V c , concentrating gradient computation on outcome-divergent phases. Phases with larger estimated V c receive higher keep probability, while larger N c contributes more candidate chunks. Both factors increase sampling frequency within the fixed budget B .
+
+During training, we compute a batch-level phase score C ( t ) c from the rollout group at step t . We maintain a short buffer B c for each phase and append the current score to the short refresh buffer. With G = 10 rollouts and binary rewards, individual C c estimates may be noisy, especially under imbalanced success-failure splits. Therefore, scores are averaged over T rc = 5 batches before refreshing the keep probabilities.
+
+<!-- formula-not-decoded -->
+
+Every T rc steps (we use T rc = 5 ), we collapse the buffered scores into a share-normalized phase score:
+
+<!-- formula-not-decoded -->
+
+Share normalization is scale-invariant: it preserves the relative phase ordering even though the absolute magnitude of C c can vary across tasks and training stages. The resulting ˜ ρ c is used as the phase-level score for probabilistic chunk selection. For the first update, the keep probabilities are computed from the phase scores of the first rollout group itself; after that, scores are updated every T rc steps using the buffered window. This online update lets PCM track the realized learning signal: if a phase learns faster, its success-failure divergence decreases and keep probability naturally falls.
+
+## 4.4 Probabilistic Mask Selection
+
+Given phase scores { ˜ ρ c } as proxies for { √ V c } , we map them to per-phase keep-probabilities that implement the allocation of Theorem 1 in expectation:
+
+<!-- formula-not-decoded -->
+
+with p min = 0 . 1 . The floor p min prevents any phase from being structurally excluded between buffer recomputes. This is important because ˜ ρ c may be transiently zero for a phase with nonzero true variance V c if that phase is underrepresented or temporarily underestimated in the current buffer window. Excluding such phases entirely would violate the exploration requirement of the allocation and could cause the estimated { ρ c } to diverge from the true { V c } ordering over time. Each chunk inherits its phase's probability weight: w i,k = p φ ( i,k ) . The set { p c } is held fixed across the next T rc steps.
+
+## 4.5 Fixed-Budget Sampling and Physical Shrinking
+
+Given the allocation rule derived in Theorem 1, we sample a fixed budget of B chunks per trajectory using weighted sampling without replacement [Plackett, 1975, Luce, 1959], with weights { w i,k } :
+
+<!-- formula-not-decoded -->
+
+The selected set is K i = { k 1 , . . . , k m i } . Non-selected chunks are physically removed from the batch tensor before the forward pass.
+
+The actor update uses the masked objective:
+
+<!-- formula-not-decoded -->
+
+The masked objective in Eq. (11) omits the 1 /p c importance weights, making it a biased estimator of the full-trajectory GRPO gradient. The bias is ∑ c ∈P (1 -p c ) g c : chunks that are not selected contribute zero to Eq. (11) but g c to the full gradient. Under our allocation p c ∝ √ V c , the factor (1 -p c ) is large precisely when V c is small, and by Lemma 1, small V c implies small ∥ g c ∥ . Each term in the bias is therefore suppressed by at least one small factor, so Theorem 1's allocation remains approximately optimal under the biased estimator. The trade-off is favorable: at the same chunk budget B , the masked estimator has substantially lower variance than the importance-weighted unbiased alternative, translating to faster SGD convergence (Appendix B.1). A formal bound is given in Appendix B.2.
+
+## Algorithm 1 Probabilistic Chunk Masking for GRPO
+
+| Require: Policy π θ ; group size G ; chunk budget B ; floor p min ; refresh window T rc   | Require: Policy π θ ; group size G ; chunk budget B ; floor p min ; refresh window T rc   | Require: Policy π θ ; group size G ; chunk budget B ; floor p min ; refresh window T rc   |
+|-------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------|
+| 1:                                                                                        | Initialize phase-score buffers B c ← [ ] for all phases c                                 |                                                                                           |
+| 2:                                                                                        | while not converged do                                                                    |                                                                                           |
+| 3:                                                                                        | Sample G rollouts and compute binary rewards { r i }                                      | ▷ Eq. (1)                                                                                 |
+| 4:                                                                                        | Compute GRPO advantages { A i } from the group rewards                                    | ▷ Eq. (1)                                                                                 |
+| 5:                                                                                        | Label each chunk with a phase φ ( i,k ) from the gripper trajectory                       | ▷ Sec. 5.1                                                                                |
+| 6:                                                                                        | Compute per-phase success-failure action variance { C ( t ) c } c ∈P from rollouts        | ▷ Eq. (5)                                                                                 |
+| 7:                                                                                        | Append C ( t ) c to buffer B c for all c ∈ P                                              | ▷ Eq. (7)                                                                                 |
+| 8:                                                                                        | if first batch or &#124;B c &#124; = T rc then                                            |                                                                                           |
+| 9:                                                                                        | Collapse buffers, share-normalize and max-normalize                                       | ▷ Eq. (8)                                                                                 |
+| 10:                                                                                       | Apply floor: p c ← max( p min , ˜ ρ c ) for all c                                         | ▷ Eq. (9)                                                                                 |
+| 11:                                                                                       | Reset phase buffers: B c ← [ ] for all c ∈ P                                              |                                                                                           |
+| 12:                                                                                       | end if                                                                                    |                                                                                           |
+| 13:                                                                                       | for each trajectory i with N i chunks do                                                  |                                                                                           |
+| 14:                                                                                       | Set chunk weights w i,k ← p φ ( i,k ) for k = 1 ,...,N i                                  | ▷ Sec. (4.4)                                                                              |
+| 15:                                                                                       | Sample K i with &#124;K i &#124; = min( B,N i ) via weighted sampling w/o replacement     | ▷ Eq. (10)                                                                                |
+| 16:                                                                                       | Physically remove non-selected chunks from batch; keep only K i for actor update ▷        | Sec. 4.5                                                                                  |
+| 17:                                                                                       | end for                                                                                   |                                                                                           |
+| 18:                                                                                       | Update π θ using the masked GRPO loss                                                     | ▷ Eq. (11)                                                                                |
+| 19:                                                                                       | end while                                                                                 |                                                                                           |
+
+## 5 Empirical Evaluation
+
+## 5.1 Experimental Setup
+
+Models and Benchmarks. We run our experiments on OpenVLA-OFT [Kim et al., 2025], a 7B vision-language-action model that predicts 7-DoF action chunks with chunk length L =8 . We evaluate on three benchmarks: LIBERO-Object, LIBERO-Spatial, and LIBERO-Goal [Liu et al., 2023].
+
+Phase Labeling. We assign each chunk to one of K =5 semantic phases using a deterministic, multi-grasp-aware rule over the per-chunk gripper-close fraction g f [ j ] ∈ [0 , 1] . Activegrip chunks ( g f [ j ] ≥ 0 . 5 ) capture sustained grasp and transport; pre-grasp labels the up-tothree chunks immediately before sustained closure ( 0 . 1 ≤ g f [ j ] &lt; 0 . 5 ); release-ramp labels the up-to-three chunks after; approach covers the remaining pre-contact chunks; and tail covers post-release open-gripper chunks; Overlapping windows are resolved by the priority ordering active-grip &gt; pre-grasp &gt; release-ramp &gt; approach &gt; tail . This rule is applied identically to successful and failed trajectories, enabling C c to compare outcomes under a shared phase partition. Full details are in Appendix E.2.
+
+Training and Evaluation. Weimplement PCM on the SimpleVLA-RL [Li et al., 2025a] verl [Sheng et al., 2025] pipeline with GRPO groups of 10 rollouts per prompt, comparing against the fulltrajectory chunk-level GRPO baseline. We fine-tune OpenVLA-OFT with LoRA using 2 NVIDIA H100 GPUs. We evaluate every training step using 50 held-out validation rollouts. Results are averaged across three seeds, and we report per-step update time and peak GPU memory. Detailed experimental settings are in Appendix E.
+
+Research Questions. Our experiments are designed to answer the following:
+
+- RQ1 Does variance-aware chunk selection preserve the learning dynamics of full-trajectory GRPO, measured by step-wise accuracy curves?
+- RQ2 Does selective gradient allocation reduce wall-clock time to reach a target success rate without affecting sample efficiency?
+- RQ3 How sensitive is performance to the chunk budget B , and is there a stable operating point that balances gradient signal with per-step speedup?
+- RQ4 Is variance-aware probabilistic selection necessary, or do simpler masking strategies achieve comparable performance under the same chunk budget?
+
+## 5.2 Results and Discussion
+
+Figure 3: Success rate as a function of wall-clock time (a) and training step (b) on LIBERO-Object, averaged over three seeds. PCM ( B =12 ) closely matches full-trajectory GRPO across training steps while converging significantly faster.
+
+<!-- image -->
+
+RQ1: Learning Dynamics. We compare PCM with chunk budget B =12 against full-trajectory GRPO on LIBERO-Object using the same SFT-initialized OpenVLA-OFT checkpoint, identical rollout groups, rewards, advantages, and optimizer settings. The methods differ only in whether the actor update is computed over all chunks or the subset selected by PCM. Both are trained for a fixed budget of 200 steps.
+
+As a function of training step (Fig. 3b), PCM and GRPO exhibit nearly identical learning curves and reach matched final accuracy. This shows that PCM preserves per-step learning dynamics while improving efficiency, confirming that the selective gradient allocation does not degrade step-wise convergence behavior .
+
+RQ2: Wall-Clock Efficiency. As shown in Fig. 3a, PCM reaches nearsaturation significantly earlier in wallclock time. Fig. 4a shows that PCM reaches the target success rate of 98% ± 0 . 02 up to 2 . 38 × faster than vanilla GRPO, with the gap widening sharply at higher accuracy thresholds. Table 1 shows that this trend holds across all LIBERO benchmarks, reducing the av-
+
+Table 1: Wall-clock time in hours to reach 98% ± 0 . 02 success rate. Lower is better.
+
+|                | Vanilla GRPO     | PCM (Ours)       |
+|----------------|------------------|------------------|
+| LIBERO-Object  | 45 . 78 ± 0 . 95 | 19 . 23 ± 0 . 57 |
+| LIBERO-Goal    | 51 . 25 ± 1 . 05 | 21 . 18 ± 0 . 59 |
+| LIBERO-Spatial | 49 . 89 ± 0 . 98 | 21 . 23 ± 0 . 63 |
+| Overall        | 48 . 97 ± 0 . 99 | 20 . 55 ± 0 . 60 |
+
+erage time to 98% ± 0 . 02 success from 48 . 97 ± 0 . 99 to 20 . 55 ± 0 . 60 hours. To understand how this speedup decomposes, Fig. 4b-c separate per-step compute from overall convergence. PCM reduces
+
+Figure 4: Efficiency on LIBERO-Object at B =12 . (a) Wall-clock time to first reach each SR threshold; the PCM/GRPO gap widens at higher thresholds. (b) Activation memory is reduced by 60%. (c) Cumulative actor-update time over 200 steps is 4 . 8 × faster.
+
+<!-- image -->
+
+activation memory by 60% ( 10 . 1 → 4 . 1 GB) and peak GPU memory by 15% ( 39 . 7 → 33 . 6 GB) per step.
+
+Cumulative gradient-update time over 200 training steps is 4 . 8 × faster. Because the per-step learning curves are matched (Fig. 3b), the wall-clock gain is entirely attributable to per-step compute savings rather than improved sample efficiency. Together these results show that the selective gradient allocation substantially reduces per-step cost while leaving sample efficiency intact .
+
+Figure 5: Ablations on LIBERO-Object. (a) Chunk budget sweep shows that B =12 preserves final success while retaining most of the wall-clock speedup. (b) At fixed B =12 , PCM outperforms random masking and highest-variance-phase selection.
+
+<!-- image -->
+
+RQ3: Sensitivity to Chunk Budget B . PCM samples a fixed budget of B chunks per trajectory. Smaller budgets improve per-step efficiency but reduce gradient coverage, while larger budgets better approximate full GRPO at higher cost. We sweep B ∈ {8, 12, 16} on LIBERO-Object using the same training configuration. We select this range for B to bracket the inflection of the cumulative C c curve in Fig. 8b, plotted against the fraction of trajectory chunks retained, which marks the smallest budget capturing most of the available learning signal. Details in Appendix D.
+
+Fig. 5a shows that all budgets reach comparable final accuracy, but differ in efficiency. B =8 is fastest per step but has degraded sample efficiency and plateaus at a slightly lower accuracy, indicating insufficient gradient signal. B =16 provides no accuracy gain over B =12 while increasing convergence time, showing diminishing returns beyond highC c phases. B =12 lies at the inflection point, matching final accuracy while preserving the wall-clock advantage. We use B =12 as our default for all other experiments. B =12 is large enough to consistently sample from highC c phases under the probabilistic selection rule while remaining small enough to deliver substantial per-step compute and memory savings.
+
+RQ4: Variance Concentration and the Role of Variance-Aware Selection. To test whether variance-aware probabilistic selection is necessary, we compare PCM at B =12 against two ablations that occupy opposite extremes of the allocation spectrum: random masking , which samples B chunks uniformly at random from each trajectory (no concentration on highC c phases), and full masking , which restricts updates to the single highestC c phase and discards all other chunks (maximum concentration, no exploration). Together, these bracket PCM, which lies between these extremes via probabilistic C c -weighted sampling.
+
+Fig. 5b shows that both ablations underperform PCM. Random masking plateaus at ∼ 78% success rate, 22 points below PCM at the same chunk budget. Full masking fails more sharply, plateauing at a low accuracy of ∼ 43% . Since all methods use the same B =12 budget, these gaps isolate the contribution of variance-aware selection from compute reduction.
+
+Fig. 6 shows PCM's realized gradient allocation across training, revealing three mechanisms that together explain its performance.
+
+- Concentration: Active-grip ( ∼ 7-8 chunks per trajectory) and pre-grasp ( ∼ 3-5 chunks per trajectory) dominate throughout, matching the highC c phases (Fig. 1) and the √ V c -weighted allocation predicted by Theorem 1. The agreement between predicted and realized allocation is the empirical confirmation that C c tracks V c in practice, validating Lemma 2's proxy assumption.
+- Exploration: Probabilistic C c -weighted sampling (Eq. 10) ensures that every phase has nonzero selection probability whenever its weight is above zero, providing the primary exploration mechanism. The p min = 0 . 1 fl oor (Eq. 9) acts as a safety net for low-
+
+Figure 6: Phase-wise gradient allocation under PCM over training steps.
+
+<!-- image -->
+
+scoring phases (e.g., tail ): it prevents transient zero estimates from collapsing a phase's weight to zero between buffer recomputes, which would otherwise cause online phase scores to fail to recover when the true V c ordering shifts during training.
+
+- Adaptation: Approach and release-ramp allocations decline from ∼ 2 to ∼ 1 chunks and from ∼ 2.5 to ∼ 1.5 chunks, respectively, as the policy masters those phases, with budget shifting toward phases where learning signal concentrates. This online dynamic that adapts with evolving success-failure gap of the policy cannot be reproduced by static weighting.
+
+The ablations occupy degenerate corners of this design space. Random masking explores but lacks concentration, matching the suboptimal uniform-allocation regime in Theorem 1, where b c = B/K (equal budget across phases) is inefficient when V c is non-uniform across phases. Full masking concentrates updates on the highestC c phase but discards weaker adjacent-phase signals and prevents exploration and adaptation.
+
+Only PCM has all three properties: C c -weighted keep probabilities with a p min fl oor to concentrate updates on contact-rich phases while retaining lower-scoring phases. The ablations show that varianceaware probabilistic selection substantially outperforms uninformed masking strategies in exploiting the concentrated structure of C c .
+
+## 6 Limitations and Future Work
+
+Our evaluation spans the three LIBERO suites (Object, Spatial, Goal), which test transfer of object, spatial, and task knowledge respectively (Table 1). We do not test longer horizons or bimanual coordination; however, the underlying allocation principle applies whenever V c is non-uniform, a structural feature of any GRPO setting where the policy has not converged uniformly. Experiments use a gripper-based phase partition rule. Extension to other settings is straightforward in principle (any consistent decomposition suffices), though we do not validate alternative phase abstractions empirically. We do not directly benchmark against methods targeting sample efficiency through different objectives (e.g., entropy-based token selection or prompt filtering). These methods differ from PCM in both granularity (token vs. phase) and signal (policy-internal uncertainty vs. outcomegrounded divergence); adapting them to the VLA chunk-level setting is beyond the scope of this work.
+
+Future work includes extending PCM to longer-horizon and bimanual tasks, validating learned temporal phase segmenters or LLM-derived phase labelers, and applying the variance-allocation principle to LLM reasoning where C c can be computed against verified outcomes. Combining PCM with orthogonal sample-efficiency methods remains an open direction.
+
+## References
+
+- Armen Aghajanyan, Luke Zettlemoyer, and Sonal Gupta. Intrinsic Dimensionality Explains the Effectiveness of Language Model Fine-Tuning. In Annual Meeting of the Association for Computational Linguistics , 2021. doi: 10.18653/v1/2021.acl-long.568. URL https://arxiv.org/abs/2012.13255v1 .
+- Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Lachy Groom, Karol Hausman, Brian Ichter, Szymon Jakubczak, Tim Jones, Liyiming Ke, Sergey Levine, Adrian Li-Bell, Mohith Mothukuri, Suraj Nair, Karl Pertsch, Lucy Xiaoyang Shi, James Tanner, Quan Vuong, Anna Walling, Haohuan Wang, and Ury Zhilinsky. π 0 : A Vision-Language-Action Flow Model for General Robot Control, 2024. URL https://arxiv.org/abs/2410.24164v4 .
+- Léon Bottou, Frank E. Curtis, and Jorge Nocedal. Optimization methods for large-scale machine learning. SIAM Review , 60(2):223-311, 2018. doi: 10.1137/16M1080173.
+- Tianqi Chen, Bing Xu, Chiyuan Zhang, and Carlos Guestrin. Training deep nets with sublinear memory cost. abs/1604.06174, 2016. URL http://arxiv.org/abs/1604.06174 .
+- Yuhui Chen, Shuai Tian, Shugao Liu, Yingting Zhou, Haoran Li, and Dongbin Zhao. ConRFT: A Reinforced Fine-tuning Method for VLA Models via Consistency Policy, 2025a. URL https://arxiv.org/abs/ 2502.05450v2 .
+- Zengjue Chen, Runliang Niu, He Kong, Qi Wang, Qianli Xing, and Zipei Fan. TGRPO :Fine-tuning VisionLanguage-Action Model via Trajectory-wise Group Relative Policy Optimization, 2025b. URL https: //arxiv.org/abs/2506.08440 .
+- Tianzhe Chu, Yuexiang Zhai, Jihan Yang, Shengbang Tong, Saining Xie, Dale Schuurmans, Quoc V. Le, Sergey Levine, and Yi Ma. SFT Memorizes, RL Generalizes: A Comparative Study of Foundation Model Posttraining. In International Conference on Machine Learning , 2025. doi: 10.48550/arxiv.2501.17161. URL https://arxiv.org/abs/2501.17161v2 .
+- Tim Dettmers, Artidoro Pagnoni, Ari Holtzman, and Luke Zettlemoyer. QLoRA: Efficient Finetuning of Quantized LLMs. In Advances in Neural Information Processing Systems , 2023. doi: 10.48550/arxiv.2305. 14314. URL https://arxiv.org/abs/2305.14314v1 .
+- Yanjiang Guo, Jianke Zhang, Xiaoyu Chen, Xiang Ji, Yen-Jen Wang, Yucheng Hu, and Jianyu Chen. Improving Vision-Language-Action Model with Online Reinforcement Learning. In IEEE International Conference on Robotics and Automation , 2025. URL https://arxiv.org/abs/2501.16664v1 .
+- Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. LoRA: Low-Rank Adaptation of Large Language Models. In International Conference on Learning Representations , 2021. URL https://arxiv.org/abs/2106.09685v2 .
+- Jiaheng Hu, Rose Hendrix, Ali Farhadi, Aniruddha Kembhavi, Roberto Martin-Martin, Peter Stone, Kuo-Hao Zeng, and Kiana Ehsani. FLaRe: Achieving Masterful and Adaptive Robot Policies with Large-Scale Reinforcement Learning Fine-Tuning. In IEEE International Conference on Robotics and Automation , 2024. doi: 10.1109/icra55743.2025.11127934. URL https://arxiv.org/abs/2409.16578v2 .
+- Yuelin Hu, Zhengxue Cheng, Wei Liu, and Li Song. Entropy-Gated Selective Policy Optimization:Token-Level Gradient Allocation for Hybrid Training of Large Language Models, 2026. URL https://arxiv.org/ abs/2602.03309 .
+- Zengjie Hu, Jiantao Qiu, Tianyi Bai, Haojin Yang, Binhang Yuan, Qi Jing, Conghui He, and Wentao Zhang. VADE: Variance-Aware Dynamic Sampling via Online Sample-Level Difficulty Estimation for Multimodal RL, 2025. URL https://arxiv.org/abs/2511.18902 .
+- Mykola Khandoga, Rui Yuan, and Vinay Kumar Sankarapu. Beyond Uniform Credit: Causal Credit Assignment for Policy Optimization, 2026. URL https://arxiv.org/abs/2602.09331 .
+- Moo Jin Kim, Karl Pertsch, Siddharth Karamcheti, Ted Xiao, Ashwin Balakrishna, Suraj Nair, Rafael Rafailov, Ethan Foster, Grace Lam, Pannag Sanketi, Quan Vuong, Thomas Kollar, Benjamin Burchfiel, Russ Tedrake, Dorsa Sadigh, Sergey Levine, Percy Liang, and Chelsea Finn. OpenVLA: An Open-Source Vision-LanguageAction Model. In Conference on Robot Learning , 2024. doi: 10.48550/arxiv.2406.09246. URL https: //arxiv.org/abs/2406.09246v3 .
+- Moo Jin Kim, Chelsea Finn, and Percy Liang. Fine-Tuning Vision-Language-Action Models: Optimizing Speed and Success. In Robotics: Science and Systems , 2025. URL https://arxiv.org/abs/2502.19645 .
+
+- Vijay Anand Korthikanti, Jared Casper, Sangkug Lym, Lawrence McAfee, Michael Andersch, Mohammad Shoeybi, and Bryan Catanzaro. Reducing Activation Recomputation in Large Transformer Models. In Proceedings of the Machine Learning and Systems Conference (MLSys) , 2023. URL https://openreview. net/forum?id=nvRncppDoD .
+- Haozhan Li, Yuxin Zuo, Jiale Yu, Yuhao Zhang, Zhaohui Yang, Kaiyan Zhang, Xuekai Zhu, Yuchen Zhang, Tianxing Chen, Ganqu Cui, Dehui Wang, Dingxiang Luo, Yuchen Fan, Youbang Sun, Jia Zeng, Jiangmiao Pang, Shanghang Zhang, Yu Wang, Yao Mu, Bowen Zhou, and Ning Ding. SimpleVLA-RL: Scaling VLA Training via Reinforcement Learning, 2025a. URL https://arxiv.org/abs/2509.09674v1 .
+- Hengtao Li, Pengxiang Ding, Runze Suo, Yihao Wang, Zirui Ge, Dongyuan Zang, Kexian Yu, Mingyang Sun, Hongyin Zhang, Donglin Wang, and Weihua Su. VLA-RFT: Vision-Language-Action Reinforcement Finetuning with Verified Rewards in World Simulators, 2025b. URL https://arxiv.org/abs/2510.00406 .
+- Bo Liu, Yifeng Zhu, Chongkai Gao, Yihao Feng, Qiang Liu, Yuke Zhu, and Peter Stone. LIBERO: Benchmarking Knowledge Transfer for Lifelong Robot Learning. In Advances in Neural Information Processing Systems , 2023. URL https://arxiv.org/abs/2306.03310 .
+- Jijia Liu, Feng Gao, Bingwen Wei, Xinlei Chen, Qingmin Liao, Yi Wu, Chao Yu, and Yu Wang. What Can RL Bring to VLA Generalization? An Empirical Study, 2025. URL https://arxiv.org/abs/2505.19789v4 .
+- Xiaokang Liu, Zechen Bai, Hai Ci, Kevin Yuchen Ma, and Mike Zheng Shou. World-VLA-Loop: Closed-Loop Learning of Video World Model and VLA Policy, 2026. URL https://arxiv.org/abs/2602.06508 .
+- Guanxing Lu, Wenkai Guo, Chubin Zhang, Yuheng Zhou, Haonan Jiang, Zifeng Gao, Yansong Tang, and Ziwei Wang. VLA-RL: Towards Masterful and General Robotic Manipulation with Scalable Reinforcement Learning, 2025. URL https://arxiv.org/abs/2505.18719v1 .
+- R. Duncan Luce. Individual Choice Behavior: A Theoretical Analysis . Wiley, New York, 1959.
+- Qijun Luo, Mengqi Li, Lei Zhao, and Xiao Li. StreamBP: Memory-Efficient Exact Backpropagation for Long Sequence Training of LLMs. In Advances in Neural Information Processing Systems , 2025. URL https://arxiv.org/abs/2506.03077v1 .
+- Gongrui Nan, Siye Chen, Jing Huang, Mengyu Lu, Dexun Wang, Chunmei Xie, Weiqi Xiong, Xianzhou Zeng, Qixuan Zhou, Yadong Li, and Xingzhong Xu. NGRPO: Negative-enhanced Group Relative Policy Optimization, 2025. URL https://arxiv.org/abs/2509.18851 .
+- R. L. Plackett. The analysis of permutations. 24(2):193-202, 1975. doi: 10.2307/2346567.
+- John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal Policy Optimization Algorithms, 2017. URL https://arxiv.org/abs/1707.06347 .
+- Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, Y. K. Li, Y. Wu, and Daya Guo. DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models, 2024. URL https://arxiv.org/abs/2402.03300v3 .
+- Guangming Sheng, Chi Zhang, Zilingfeng Ye, Xibin Wu, Wang Zhang, Ru Zhang, Yanghua Peng, Haibin Lin, and Chuan Wu. HybridFlow: A Flexible and Efficient RLHF Framework. In Proceedings of the Twentieth European Conference on Computer Systems , EuroSys '25, page 1279-1297, New York, NY, USA, 2025. Association for Computing Machinery. ISBN 9798400711961. doi: 10.1145/3689031.3696075. URL https://doi.org/10.1145/3689031.3696075 .
+- Shuhan Tan, Kairan Dou, Yue Zhao, and Philipp Krähenbühl. Interactive Post-Training for Vision-LanguageAction Models, 2025. URL https://arxiv.org/abs/2505.17016v1 .
+- Hongcheng Wang, Yinuo Huang, Sukai Wang, Guanghui Ren, and Hao Dong. Why Tree-Style Branching Matters for Thought Advantage Estimation in GRPO, 2026. URL https://arxiv.org/abs/2509.24494 .
+- Shenzhi Wang, Le Yu, Chang Gao, Chujie Zheng, Shixuan Liu, Rui Lu, Kai Dang, Xionghui Chen, Jianxin Yang, Zhenru Zhang, Yuqiong Liu, An Yang, Andrew Zhao, Yang Yue, Shiji Song, Bowen Yu, Gao Huang, and Junyang Lin. Beyond the 80/20 Rule: High-Entropy Minority Tokens Drive Effective Reinforcement Learning for LLM Reasoning. In Advances in Neural Information Processing Systems , 2025. URL https: //arxiv.org/abs/2506.01939 .
+- Zhongwen Xu and Zihan Ding. Single-stream Policy Optimization. In International Conference on Learning Representations , 2026. URL https://openreview.net/forum?id=b61UW62K7W .
+
+- Angen Ye, Zeyu Zhang, Boyuan Wang, Xiaofeng Wang, Dapeng Zhang, and Zheng Zhu. VLA-R1: Enhancing Reasoning in Vision-Language-Action Models, 2025. URL https://arxiv.org/abs/2510.01623 .
+- Qiying Yu, Zheng Zhang, Ruofei Zhu, Yufeng Yuan, Xiaochen Zuo, Yu Yue, Weinan Dai, Tiantian Fan, Gaohong Liu, Lingjun Liu, Xin Liu, Haibin Lin, Zhiqi Lin, Bole Ma, Guangming Sheng, Yuxuan Tong, Chi Zhang, Mofan Zhang, Wang Zhang, Hang Zhu, Jinhua Zhu, Jiaze Chen, Jiangjie Chen, Chengyi Wang, Hongli Yu, Yuxuan Song, Xiangpeng Wei, Hao Zhou, Jingjing Liu, Wei-Ying Ma, Ya-Qin Zhang, Lin Yan, Mu Qiao, Yonghui Wu, and Mingxuan Wang. DAPO: An Open-Source LLM Reinforcement Learning System at Scale. In Advances in Neural Information Processing Systems , 2025. URL https: //arxiv.org/abs/2503.14476v2 .
+- Hongzhi Zang, Mingjie Wei, Si Xu, Yongji Wu, Zhen Guo, Yuanqing Wang, Hao Lin, Peihong Wang, Liangzhi Shi, Yuqing Xie, Zhexuan Xu, Zhihao Liu, Kang Chen, Wenhao Tang, Quanlu Zhang, Weinan Zhang, Chao Yu, and Yu Wang. RLinf-VLA: A Unified and Efficient Framework for Reinforcement Learning of Vision-Language-Action Models, 2026. URL https://arxiv.org/abs/2510.06710 .
+- Shaopeng Zhai, Qi Zhang, Tianyi Zhang, Fuxian Huang, Haoran Zhang, Ming Zhou, Shengzhe Zhang, Litao Liu, Sixu Lin, and Jiangmiao Pang. A Vision-Language-Action-Critic Model for Robotic Real-World Reinforcement Learning, 2025. URL https://arxiv.org/abs/2509.15937 .
+- Jun Zhang, Jue Wang, Huan Li, Lidan Shou, Ke Chen, Yang You, Guiming Xie, Xuejian Gong, and Kunlong Zhou. Train Small, Infer Large: Memory-Efficient LoRA Training for Large Language Models. In International Conference on Learning Representations , 2025. URL https://arxiv.org/abs/2502.13533v2 .
+- Qingru Zhang, Minshuo Chen, Alexander Bukharin, Nikos Karampatziakis, Pengcheng He, Yu Cheng, Weizhu Chen, and Tuo Zhao. AdaLoRA: Adaptive Budget Allocation for Parameter-Efficient Fine-Tuning. In International Conference on Learning Representations , 2023. URL https://arxiv.org/abs/2303.10512 .
+- Haizhong Zheng, Yang Zhou, Brian R. Bartoldson, Bhavya Kailkhura, Fan Lai, Jiawei Zhao, and Beidi Chen. Act Only When It Pays: Efficient Reinforcement Learning for LLM Reasoning via Selective Rollouts. In Advances in Neural Information Processing Systems , 2025. URL https://openreview.net/forum?id= x5lITYXmW2 .
+- Fangqi Zhu, Zhengyang Yan, Zicong Hong, Quanxin Shou, Xiao Ma, and Song Guo. WMPO: World Modelbased Policy Optimization for Vision-Language-Action Models, 2025. URL https://arxiv.org/abs/ 2511.09515v1 .
+
+## Appendix
+
+## A Problem Formulation and Assumptions
+
+For clarity, we explicitly restate the problem formulation and assumptions underlying PCM. While these are implicit in the main text, we formalize them here to precisely define the input setting, the chunk-selection objective, and the structural conditions required for the analysis.
+
+Input. A VLA policy π 0 θ initialized from a supervised fine-tuning checkpoint, a simulated environment E , a distribution over tasks T with binary reward r : τ → { 0 , 1 } , and a group of G rollouts { τ i } G i =1 where each trajectory decomposes into N i = ⌈ T i /L ⌉ chunks of length L , and a fixed gradient compute budget B ≪ ∑ i N i .
+
+Output. A chunk selection policy M : { τ i , r i } G i =1 →{ K i ⊆ { 1 , . . . , N i }} G i =1 that minimizes
+
+<!-- formula-not-decoded -->
+
+subject to | K i | = B for all i (fixed compute budget), and M using only { τ i , r i } G i =1 without access to auxiliary reward models or learned critics.
+
+Assumptions. We assume the following:
+
+- Binary reward: r : τ → { 0 , 1 } is trajectory-level, with each group containing both successes and failures ( 0 &lt; µ r &lt; 1 ); when all rollouts succeed or fail, advantages collapse and the variance signal is uninformative.
+- Fixed chunk length: The policy produces actions in chunks of fixed length L , so the phase decomposition ϕ ( i, k ) is well-defined and consistent across trajectories.
+- Deterministic phase labeling: ϕ ( i, k ) ∈ P is computable from the gripper command trajectory alone, requiring no learned model.
+- Shared phase structure: Successful and failed rollouts share the same phase partition P , so per-phase action variance compares like with like across outcome groups.
+- SFT initialization: π 0 θ is initialized from a supervised fine-tuning checkpoint, ensuring gradient variance concentrates on a small subset of outcome-critical phases.
+
+## B Theoretical Results
+
+In this section we provide proofs for the formal results in the main paper.
+
+Lemma 1 (Phase gradient variance) . Let c ∈ P be a phase in which π θ has converged, i.e., the action distributions of successful and failed rollouts are identical in phase c . Then ∥ g c ( θ ) ∥ ≈ 0 and V c ≈ 0 , so gradient samples from phase c contribute negligible signal. Conversely, for a phase c in which the base policy is underspecified, V c is large and gradient samples from phase c are informative.
+
+Proof. Since A i is zero-mean by construction (Eq. (1)), we have V c = 0 if and only if π θ ( a i,k | s i,k ) is identical across successful and failed rollouts for every chunk ( i, k ) with φ ( i, k ) = c . This holds exactly when outcomes are independent of the actions taken in phase c . When these conditional action distributions match, positive- and negative-advantage score-function terms are drawn from the same distribution and cancel in expectation, leaving ∥ g c ( θ ) ∥ ≈ 0 . When they diverge, phase c carries useful learning signal.
+
+Lemma 2 ( C c as a proxy for V c ) . For a policy π θ that is locally Gaussian with per-dimension variance σ 2 π , the per-phase gradient variance satisfies V c ≥ C 2 c / 4 σ 2 π .
+
+Proof. Let µ + c = E [ a i,k | r i = 1 , φ ( i, k ) = c ] and µ -c = E [ a i,k | r i = 0 , φ ( i, k ) = c ] . For a Gaussian policy π θ ( · | s ) = N ( µ θ ( s ) , σ 2 π I ) , the score function is ∇ θ log π θ ( a | s ) = ( a -
+
+µ θ ( s )) /σ 2 π · ∇ θ µ θ ( s ) . Conditioning on the outcome group, the variance of the score is lower-bounded by the variance of the mean action across groups. Specifically, for any random variable X and a binary conditioning event E , Var( X ) ≥ Var( E [ X | E ]) by the law of total variance. Applying this with X = A i · ∇ θ log π θ ( a i,k | s i,k ) and E = { r i = 1 } versus { r i = 0 } , and using | A i | ≤ 1 /ε as a finite bound, yields the equation in the lemma after absorbing the gradient norm ∥∇ θ µ θ ∥ 2 and balanced-group constants into σ 2 π . The bound preserves the relative ordering of { V c } across phases.
+
+Theorem 1 (Optimal phase allocation) . Let b c denote the number of chunks sampled from phase c , with ∑ c ∈P b c = B , and let N c denote the expected number of chunks in phase c per trajectory. The allocation minimizing the variance of the unbiased ratio estimator of the GRPO gradient (Eq. (2)) subject to the budget constraint is
+
+<!-- formula-not-decoded -->
+
+Proof. We analyze the idealized stratified ratio estimator with deterministic per-phase budget bc; the masked loss in Eq. (11) implements this allocation in expectation under the sampling rule of Eq. (10), at the cost of a finite-sample bias bounded by the contribution of low-Vc phases (Sec. 4.5). The GRPO gradient decomposes by phase as in Eq. (3). PCM estimates the full phase gradient g c ( θ ) , which sums over all N c chunks in phase c , via the ratio estimator
+
+<!-- formula-not-decoded -->
+
+where K c ⊆ { k : φ ( i, k ) = c } with | K c | = b c chunks drawn uniformly without replacement from the N c available chunks in phase c . The N c /b c factor scales up the sampled sum to account for the full phase size, making ˆ g c unbiased for g c ( θ ) :
+
+<!-- formula-not-decoded -->
+
+<!-- formula-not-decoded -->
+
+where V c is the per-chunk variance within phase c (Eq. (4)), and the b c in the numerator is the variance of a single-chunk sample, reduced by b c draws.
+
+The total estimator variance across all phases is
+
+<!-- formula-not-decoded -->
+
+We minimize σ 2 ( { b c } ) subject to ∑ c ∈P b c = B , b c ≥ 0 . By the Cauchy-Schwarz inequality,
+
+<!-- formula-not-decoded -->
+
+with equality if and only if N c √ V c / √ b c ∝ √ b c , i.e., b c ∝ N c √ V c . Combining with ∑ c b c = B yields Eq. (13).
+
+Substituting b ∗ c = B · N c √ V c / ∑ c ′ N c ′ √ V c ′ into Eq. (16), the minimum total variance achieved is
+
+<!-- formula-not-decoded -->
+
+The variance of ˆ g c is
+
+## B.1 Convergence Derivation for Phase Allocation
+
+We derive the convergence-rate comparison between the optimal allocation of Theorem 1 and uniform allocation. Under standard SGD assumptions (L-smooth objective, bounded per-phase gradient variance V c ), the number of steps to reach an ε -stationary point satisfies [Bottou et al., 2018]
+
+<!-- formula-not-decoded -->
+
+where σ 2 is the variance of the gradient estimator at sample budget B ; the 1 /B variance reduction from B -sample averaging is incorporated into σ 2 via the per-phase variance formulas.
+
+Optimal allocation. From Theorem 1 and Eq. (17), the minimum achievable estimator variance under budget B is
+
+<!-- formula-not-decoded -->
+
+<!-- formula-not-decoded -->
+
+Substituting into Eq. (18):
+
+Uniform allocation. Under b c = B/K for all K phases, the total estimator variance is
+
+<!-- formula-not-decoded -->
+
+<!-- formula-not-decoded -->
+
+Speedup ratio. Dividing Eq. (22) by Eq. (20):
+
+<!-- formula-not-decoded -->
+
+By the Cauchy-Schwarz inequality,
+
+<!-- formula-not-decoded -->
+
+so ∆ ≥ 1 , with equality if and only if all N 2 c V c are equal across phases. When variance concentrates on few phases such that max c N 2 c V c ≫ 1 K ∑ c N 2 c V c , then ∆ ≫ 1 : the optimal allocation yields substantially fewer convergence steps than uniform allocation at the same chunk budget B .
+
+## B.2 Bias Analysis of the Masked Estimator
+
+The masked objective in Eq. (11) omits the N c /b c rescaling of the unbiased estimator (Eq. 14), trading a small bias for lower variance. We bound this bias.
+
+Lemma 3 (Bias of the masked estimator). Let p c denote the keep probability for phase c . The bias of the masked estimator relative to the unbiased estimator satisfies
+
+<!-- formula-not-decoded -->
+
+Substituting into Eq. (18):
+
+Proof. Under weighted sampling without replacement with inclusion probability p c , the expected contribution of phase c to the masked estimator is p c · g c , while the unbiased estimator yields g c . Summing across phases and applying the triangle inequality gives the bound.
+
+Under the allocation p c ∝ √ V c , (1 -p c ) is large only when V c is small, and by Lemma 1, small V c implies ∥ g c ∥ → 0 . Each term in the bound is therefore suppressed by at least one small factor, so Theorem 1's allocation remains approximately optimal under the biased estimator.
+
+## C Methods We Tried That Did Not Work
+
+The motivating observation behind this paper was that VLA rollouts on a given task are remarkably similar across trajectories. Most timesteps execute nearly identical motion patterns regardless of whether the trajectory eventually succeeds. A reaching phase looks like a reaching phase across all rollouts; the divergence concentrates on a small number of decision points. This led us to hypothesize that gradient compute was being misallocated: the same per-step budget was being spent on phases that contributed little to the policy update as on phases that determined the outcome. Before arriving at PCM, we explored two alternative directions for exploiting this observation. Both failed, and the failures shaped the eventual design.
+
+## C.1 Branching at Decision Critical Timesteps
+
+Our initial approach attempted to increase the rollout signal at high-uncertainty points by branching: at each candidate decision point, fork the rollout into K alternative continuations to give GRPO more contrastive signal in the regions that mattered. Two problems made this infeasible. First, each branch required actually executing a downstream rollout in the simulator to be useful for GRPO, which meant returning to the branch point and continuing the simulation; this added significant rollout-side overhead and partially undid the efficiency motivation. Second, naive branching is exponential in depth, refining beyond the first branch point requires nested branching, and the rollout count grows as K d where d is the number of branches per trajectory. We found no principled way to bound depth without re-introducing the same uniform-allocation problem we were trying to escape.
+
+Figure 7: (a) Success vs. training steps for vanilla GRPO vs branching GRPO. (b) Action entropy over trajectory progress at different stages of training, showing weak alignment with outcome-critical phases. The training and evaluation follow the same procedures as Sec. 5.2
+
+<!-- image -->
+
+.
+
+The lesson from this attempt was that any practical method had to operate within the existing rollout structure rather than expanding it. PCM instead reduces gradient computation over rollouts that have already been generated.
+
+## C.2 Entropy as a Signal to Concentrate Learning
+
+Our second attempt used per-chunk policy entropy as a proxy for "where the model has room to learn." The hypothesis was the standard one: high-entropy chunks indicate uncertainty, uncertainty indicates a learning opportunity, and concentrating gradient on these chunks should yield faster convergence. We expected that as training progressed, entropy would decrease in initially-uncertain chunks and the gradient allocation would naturally shift toward the remaining noisy regions.
+
+Two empirical findings led us to abandon this approach. First, entropy was poorly structured across trajectories: we did not observe consistent concentration on decision-critical phases the way we
+
+Figure 8: Cumulative C c captured as a function of the fraction of trajectory chunks retained, with chunks sorted in descending order by phase-level C c . The solid curve shows the empirical cumulative C c , while the dashed diagonal shows the uniform baseline under which C c would scale linearly with chunk count. The gap between the two reflects the uneven distribution of learning signal across the trajectory: a small fraction of chunks captures a disproportionate share of the total C c .
+
+<!-- image -->
+
+eventually observed for C c (Figure 1). Per-chunk entropy varied substantially across rollouts even within the same task and phase, and the high-entropy chunks did not align with the points where successful and failed rollouts actually diverged. We attribute this to the fact that VLA action distributions are typically already low-entropy after SFT. The supervised pretraining drives the policy toward confident, low-entropy actions, and the residual entropy reflects modeling noise rather than genuine multimodal uncertainty over correct behavior. Second, and more decisively, entropy did not meaningfully decrease over training. Across multiple runs on LIBERO, we measured per-chunk entropy at the start and end of GRPO fine-tuning and found negligible reduction. This is consistent with the known property that GRPO is a relatively weak signal for changing the underlying action distribution: the group-relative advantage primarily reweights existing modes rather than collapsing the policy onto a sharper one. Entropy under SFT-initialized policies is therefore close to a fixed property of the model rather than a quantity RL can drive down. Selecting on entropy would mean repeatedly allocating gradient to the same chunks throughout training regardless of whether they had become well-learned, and would not adapt to the shifting locus of the success-failure gap as training progressed.
+
+## D Analysis of Chunk Budget
+
+The compute-signal trade-off. Choosing B reflects a trade-off between two opposing pressures. Lowering B reduces per-step gradient computation linearly: fewer chunks in the backward pass reduce activation memory and accelerate actor updates, which is the source of PCM's wall-clock advantage. Increasing B captures more of the available learning signal: a larger budget includes more chunks from outcome-divergent phases and approaches the gradient quality of full-trajectory GRPO.
+
+The cumulative C c curve in Fig. 8 is sharply concave: early chunks, corresponding to highC c phases, deliver disproportionate signal, while additional chunks beyond the knee contribute progressively less. The knee of this curve, the point at which marginal C c capture per chunk drops sharply, occurs at approximately 20% of trajectory chunks. This concavity makes the trade-off non-trivial. Below the knee, each additional chunk yields substantial signal at fixed compute cost, so excluding it sacrifices accuracy for marginal speedup. Above the knee, each additional chunk yields diminishing signal at the same cost, so including it sacrifices speedup for marginal accuracy. The knee marks the point where these pressures balance: the smallest B for which captured C c has largely saturated and further increases primarily incur additional compute cost.
+
+Budget range selection. The cumulative C c curve in Fig. 8 is sharply concave, with a knee at approximately 20% of trajectory chunks. We compute captured C c by ranking chunks according
+
+to their phase score and measuring the fraction of total chunk-level score mass retained by the top B chunks. Beyond the knee, each additional chunk yields progressively smaller marginal gains in captured C c . We select B ∈ { 8 , 12 , 16 } to bracket this knee, corresponding to 12% , 19% , and 25% of trajectory chunks, respectively.
+
+- B = 8 ( 12% of chunks, 50% of C c captured): Below the knee. Tests whether aggressive truncation that falls short of the inflection leads to signal under-coverage and degraded final accuracy.
+- B = 12 ( 19% of chunks, 59% of C c captured): At the knee. Tests the predicted operating point where C c capture is high and marginal returns begin to flatten.
+- B = 16 ( 25% of chunks, 64% of C c captured): Beyond the knee. Tests whether additional budget yields meaningful gains. The extra 5 percentage points of C c capture over B = 12 come at substantially higher per-step compute.
+
+The empirical sweep in Sec. 5.2 (RQ3) confirms this curvature: B = 8 underperforms in final accuracy, B = 16 matches B = 12 but at higher cost, and B = 12 emerges as the operating point consistent with the knee of the cumulative C c curve.
+
+Choosing B for other domains. The knee of the cumulative C c curve provides a principled approximation for B in any RL setting with a defined phase partition. The reasoning generalizes directly from the compute-signal trade-off: C c is computed from rollouts that GRPO already produces, so the curve can be measured in any domain where outcomes are verifiable and rollouts decompose into phases. The structural assumptions of the method are therefore not specific to manipulation. The knee identifies the operating point at which the two pressures balance, independent of the absolute magnitude of C c or the number of phases, because it is determined by the curvature of the signal.
+
+The procedure is the same across domains. For a target domain, compute C c per phase from a single rollout group, plot the cumulative C c curve as in Fig. 8, and select B at the knee, the smallest fraction of chunks at which captured C c has largely saturated. The phase partition itself is domain-specific, such as gripper-state heuristics for manipulation, semantic decomposition for LLM reasoning, or episode segmentation for dialogue. Once defined, the curve and its knee are computed identically. Domains with sharper curvature, where signal concentrates in a few phases, admit smaller B and larger speedups. Flatter curves indicate more uniform signal and require larger B to capture comparable C c , yielding smaller speedups. Only the resulting value of B varies; the selection rule remains unchanged.
+
+## E Implementation Details
+
+This appendix provides additional experimental details omitted from the main text, including benchmark construction, training hyperparameters, PCM-specific settings, and evaluation protocol. Unless stated otherwise, PCM and the full-trajectory GRPO baseline use the same rollout, reward, advantage, optimizer, and evaluation configuration.
+
+## E.1 Benchmarks
+
+Models and Benchmarks. We evaluate on three LIBERO suites to cover diverse manipulation regimes and test generalization. LIBERO-Object tests object-centric pick-and-place, LIBEROSpatial tests spatial-relation following, and LIBERO-Goal tests goal-conditioned manipulation. The manipulation tasks are specified by natural-language instructions. The following examples illustrate the types of prompts used across the benchmarks:
+
+- Object-centric manipulation: 'pick up the mug and place it in the bowl.'
+- Spatial manipulation: 'place the object on the left side of the tray.'
+- Goal-conditioned manipulation: 'move the object to the target location.'
+
+The policy receives the language instruction and RGB observation and predicts a sequence of 7-DoF end-effector actions. These suites vary in object identity, spatial layout, goal specification, and task structure, bringing diversity in manipulation regimes and causing phase-level failure patterns to
+
+appear with different frequencies across benchmarks. Each benchmark contains 10 tasks with 50 trials per task under different initial object configurations, yielding 500 evaluation trials per benchmark. Trajectories contain a total of 64 chunks. During RL fine-tuning, we use visual augmentations such as brightness changes and image jitter to improve robustness.
+
+Training. Our method is implemented based on the SimpleVLA-RL verl pipeline [Sheng et al., 2025]. We initialize from the SimpleVLA-RL 1-trajectory SFT checkpoint, where OpenVLA-OFT is supervised-fine-tuned with one demonstration per task. We then perform RL fine-tuning with LoRA rank r =32 and α =32 on 2 NVIDIA H100 GPUs. We use a prompt batch size of 8 and sample 10 rollouts per prompt, giving 80 trajectories per training step. The trajectory mini-batch size is 4, and the PPO mini-batch size is 2 with micro-batch size 1. We optimize the actor with AdamW using a constant learning rate of 1 × 10 -5 , ( β 1 , β 2 ) = (0 . 9 , 0 . 999) , weight decay 0 , and gradient clipping at 2 . 0 . Following SimpleVLA-RL, we use one PPO epoch per update, asymmetric clipping ( ϵ low , ϵ high ) = (0 . 2 , 0 . 4) , entropy coefficient 10 -3 , and disable the KL penalty. Rollouts are sampled with temperature 1 . 6 , topp = 1 . 0 , and topk = -1 without truncation.
+
+For PCM, we use a fixed chunk budget of B =12 chunks per trajectory. Phase keep probabilities are initialized from the success-failure phase scores C c computed from the rollout group, and then recomputed every T rc =5 training steps from the recent phase-score buffer. We clip keep probabilities below by p min =0 . 1 , ensuring that low-variance phases are not completely discarded and preserving a small amount of exploration throughout training. Non-selected chunks are physically removed before the actor forward and backward pass. PCM is simple to integrate into existing GRPO pipelines: it only adds phase-score computation from rollout statistics and a chunk-shrinking step before the actor update. We use the same PCM hyperparameters across all benchmarks without task-specific tuning.
+
+## E.2 Phase Allotment Rules
+
+We assign trajectory chunks to semantic phases using a deterministic gripper-based heuristic. For each chunk j , we compute g f [ j ] ∈ [0 , 1] , the fraction of timesteps in the chunk where the gripper-close command is active. We use a sustained-close threshold τ = 0 . 75 to locate grasp intervals, and then assign phase labels around those intervals.
+
+- Active-grip. Chunks with substantial gripper closure are labeled active-grip . We use a softer threshold g f [ j ] ≥ 0 . 5 for labeling, so this phase includes both sustained grasp chunks and nearby partial-close chunks. In successful rollouts, this covers grasp and transport while the object is held, or recovery after drop; in failed rollouts, it can also capture drops, re-grasp attempts, or repeated failed closure near the object.
+- Pre-grasp. Up to three chunks immediately before a sustained-close interval are labeled pre-grasp when the gripper has begun closing but has not yet reached sustained closure ( 0 . 1 ≤ g f [ j ] &lt; 0 . 5 ). This phase often captures final alignment and orientation adjustment before contact.
+- Release-ramp. Up to three chunks immediately after a sustained-close interval are labeled release-ramp ( g f [ j ] &lt; 0 . 5 ), capturing the transition from holding the object to releasing it. This phase is important when failures occur because the object is released at the wrong location or does not fall into the target bin.
+- Approach. Chunks before the pre-grasp/active-grip region of a grasp cycle are labeled approach ( g f [ j ] &lt; 0 . 5 ), corresponding to navigation toward the object.
+- Tail Chunks after the final release with an open gripper are labeled tail ( g f [ j ] &lt; 0 . 1 ). These often capture post-release behavior, including cases where the object was not successfully placed and the policy continues hovering or moving after release or attempts.
+
+The unified phase set is resolved by priority:
+
+<!-- formula-not-decoded -->
+
+When multiple phase rules apply due to overlapping windows, we assign the highest-priority label. Phases are distinguished first by their position relative to sustained-close intervals and then by the gripper thresholds above: open-gripper chunks before a future grasp attempt are approach , whereas open-gripper chunks after the final release-ramp window (after a sustained grasp interval) are tail .
+
+Figure 9: Successful and failed manipulation rollouts look similar for most of the trajectory, diverging mainly around outcome-critical grasp phases.
+
+<!-- image -->
+
+Since labels are assigned at the chunk level, averaging the gripper command over the chunk reduces sensitivity to single-timestep noise and makes the thresholding rule more stable.
+
+The same rule is applied to successful and failed trajectories. The terminal success label is never used by the phase classifier, so C c compares success and failure trajectories under a shared phase partition. The labeling rule is lightweight, requires no learned phase model, and adds no inference overhead. Other phase allocators, such as task-specific heuristics, temporal semantic phase segmenters, or LLM-based labelers, could be used when gripper state is insufficient.
+
+Phase-based failure localization: Figure 9 illustrates how common failures fall naturally into this phase partition. In a missed-grasp failure, the robot may approach the object similarly to successful rollouts but close with poor alignment. The closing chunks are labeled active-grip , while the immediately preceding orientation-adjustment chunks are labeled pre-grasp . This explains why both pre-grasp and active-grip can receive high C c : the failure may be caused not only by the closure itself, but also by the pose and alignment right before contact. After such failures, however, many remaining chunks are downstream consequence states (hovering, searching, colliding, or moving without the object) which are typically labeled tail . These chunks can occupy a large fraction of failed rollouts, but they are less causally informative than the contact error that produced them. PCM therefore keeps them with low nonzero probability while concentrating budget on the grasp phases that prevent the policy from entering these failed states.
+
+Other failures are captured by the same heuristic without additional case rules. If the object is grasped but later dropped or repeatedly re-grasped during transport, the corresponding close/hold chunks remain active-grip , making this phase sensitive to transport instability. These chunks provide useful RL signal by penalizing slips, failed recovery and unstable holds while rewarding successful recovery. If the grasp succeeds but placement fails, the error appears around release-ramp : the robot releases at the wrong location or the object misses the bin, making its C c moderately high. Subsequent tail chunks mostly capture open-gripper hovering after release, and are therefore less outcome-discriminative and provide little learning signal. When computing C c , we compare only phases that contain both successful and failed samples in the rollout group; phases absent from one outcome group in a batch are skipped for that update. In the observed rollout groups, failures often diverge during active-grip, making it the most outcome-discriminative phase and causing C c to become largest there. This concentration emerges automatically from the gripper-based phase labels and rollout outcomes, without hand-designed phase weights or task-specific tuning.

extracts/parses/2605_16154_PCM/manifest.json

@@ -0,0 +1,95 @@
+{
+  "paper_id": "2605_16154_PCM",
+  "raw_path": "raw/2605_16154_PCM.pdf",
+  "generated_at": "2026-05-25T16:33:44+08:00",
+  "page_count": 20,
+  "kind": "extract_build_artifacts",
+  "notes": [
+    "These files are reference parse artifacts, not raw sources and not wiki facts.",
+    "They exist to maximize later retrieval, anchoring, figure/table lookup, and cross-checking during wiki construction."
+  ],
+  "stages": {
+    "pdfinfo": {
+      "status": "ok",
+      "command": [
+        "/usr/bin/pdfinfo",
+        "/home/guanweifan/Workspace/efficient-vla-wiki/raw/2605_16154_PCM.pdf"
+      ]
+    },
+    "pdftotext": {
+      "status": "ok",
+      "command": [
+        "/usr/bin/pdftotext",
+        "/home/guanweifan/Workspace/efficient-vla-wiki/raw/2605_16154_PCM.pdf",
+        "/home/guanweifan/Workspace/efficient-vla-wiki/extracts/parses/2605_16154_PCM/pdftotext.txt"
+      ],
+      "output": "extracts/parses/2605_16154_PCM/pdftotext.txt"
+    },
+    "pdftotext_bbox": {
+      "status": "ok",
+      "command": [
+        "/usr/bin/pdftotext",
+        "-bbox-layout",
+        "/home/guanweifan/Workspace/efficient-vla-wiki/raw/2605_16154_PCM.pdf",
+        "/home/guanweifan/Workspace/efficient-vla-wiki/extracts/parses/2605_16154_PCM/pdftotext.bbox.html"
+      ],
+      "output": "extracts/parses/2605_16154_PCM/pdftotext.bbox.html"
+    },
+    "docling": {
+      "status": "ok",
+      "command": [
+        "/home/guanweifan/Workspace/efficient-vla-wiki/.venv/bin/python3",
+        "-m",
+        "docling.cli.main",
+        "/home/guanweifan/Workspace/efficient-vla-wiki/raw/2605_16154_PCM.pdf",
+        "--to",
+        "md",
+        "--to",
+        "json",
+        "--show-layout",
+        "--image-export-mode",
+        "placeholder",
+        "--tables",
+        "--table-mode",
+        "accurate",
+        "--no-ocr",
+        "--output",
+        "/home/guanweifan/Workspace/efficient-vla-wiki/extracts/parses/2605_16154_PCM/docling"
+      ]
+    },
+    "marker_markdown": {
+      "status": "ok",
+      "command": [
+        "/home/guanweifan/Workspace/efficient-vla-wiki/.venv/bin/python3",
+        "-m",
+        "marker.scripts.convert_single",
+        "/home/guanweifan/Workspace/efficient-vla-wiki/raw/2605_16154_PCM.pdf",
+        "--output_dir",
+        "/home/guanweifan/Workspace/efficient-vla-wiki/extracts/parses/2605_16154_PCM/marker/markdown",
+        "--output_format",
+        "markdown",
+        "--disable_multiprocessing",
+        "--disable_tqdm",
+        "--disable_ocr"
+      ]
+    }
+  },
+  "files": [
+    {
+      "path": "extracts/parses/2605_16154_PCM/docling/2605_16154_PCM.json",
+      "size_bytes": 435764
+    },
+    {
+      "path": "extracts/parses/2605_16154_PCM/docling/2605_16154_PCM.md",
+      "size_bytes": 74267
+    },
+    {
+      "path": "extracts/parses/2605_16154_PCM/pdftotext.bbox.html",
+      "size_bytes": 1293453
+    },
+    {
+      "path": "extracts/parses/2605_16154_PCM/pdftotext.txt",
+      "size_bytes": 69287
+    }
+  ]
+}

extracts/parses/2605_16154_PCM/pdftotext.txt

@@ -0,0 +1,1337 @@
+Learn Where Outcomes Diverge: Efficient VLA RL
+via Probabilistic Chunk Masking
+
+arXiv:2605.16154v1 [cs.LG] 15 May 2026
+
+Vaidehi Bagaria∗ , Nikshep Grampurohit∗ , Pulkit Verma†
+Indian Institute of Technology Madras
+
+Abstract
+Reinforcement learning (RL) allows vision-language-action (VLA) policies to
+generalize beyond their training distribution by optimizing directly for task success, but this post-training stage is computationally expensive. A natural response
+has been to speed up rollout data collection through faster simulators and world
+models. In GRPO-based VLA RL, however, we find that the dominant cost lies
+elsewhere: gradient computation accounts for ∼78% of wall-clock time per step
+in our runs, while rollout collection accounts for only ∼21%. Gradient cost dominates because much of this computation is spent on phases that contribute little
+to learning. GRPO’s learning signal is driven by advantage variance: only phases
+where successful and failed rollouts diverge produce useful learning signal. However, GRPO assigns the same advantage to every chunk in a rollout. As a result,
+actor-update compute is spent uniformly across the trajectory, including phases the
+policy already handles after pre-training and supervised fine-tuning. This paper
+presents Probabilistic Chunk Masking (PCM), a drop-in modification to GRPO
+that allocates gradient computation to a small, probabilistically selected subset of
+chunks per trajectory. PCM scores semantic phases using success-failure action
+variance, a rollout-derived proxy for per-phase gradient variance, and samples a
+fixed chunk budget with online-updated phase-level keep probabilities. We formalize per-phase gradient variance as the quantity that determines where gradient
+computation is useful and show that success-failure action variance provides a
+measurable proxy for it. PCM requires no reward model or learned critic. On
+three LIBERO benchmarks, PCM matches the final success rate of standard GRPO
+while achieving 2.38× wall-clock speedup, 4.8× faster gradient updates, and 60%
+lower peak activation memory, while backpropagating through fewer than 20% of
+trajectory chunks.
+
+1
+
+Introduction
+
+Reinforcement learning (RL) has become essential for vision-language-action (VLA) models, enabling generalization to new environments and behaviors [Black et al., 2024, Kim et al., 2024].
+The field has increasingly converged on Group Relative Policy Optimization (GRPO) [Shao et al.,
+2024] whose critic-free formulation removes the cost and complexity of training a separate value
+model [Li et al., 2025a, Lu et al., 2025]. As these systems scale, speeding up post-training has
+become critical. Efforts to speed up GRPO-based VLA RL have implicitly assumed that rollout
+collection is the bottleneck. We measure where time actually goes and find the reverse: in our runs
+gradient computation accounts for ∼78% of wall-clock time per training step, while rollout collection
+accounts for only ∼21% (Fig. 1, right).
+* Equal contribution.
+† Correspondence to pulkitv@cse.iitm.ac.in.
+
+Preprint.
+
+Benchmark
+LIBERO-Object
+LIBERO-Goal
+LIBERO-Spatial
+
+Grad (%) Rollout (%)
+77.91
+77.86
+77.85
+
+21.27
+21.29
+21.29
+
+Figure 1: Left: per-phase success–failure action variance (Cc ) concentrates on decision-critical
+phases. Right: gradient computation dominates wall-clock training cost in simulator-based GRPO
+with 10 rollouts per prompt. Remaining ∼1% is logging, evaluation, and inter-step overhead.
+This inefficiency arises from a deeper structural feature shared by most RL algorithms. Backpropagation runs over every chunk in the trajectory, and trajectory-level credit assigns the same advantage
+to each chunk regardless of which determined the outcome. Both inefficiencies share a common
+cause: the trajectory has been treated as the unit of gradient computation. Even methods that
+differentiate per-step credit, such as PPO [Schulman et al., 2017] with a learned critic, still apply
+forward/backward-pass compute to all sampled timesteps. They modify the signal, not the compute
+allocation.
+This observation suggests a missing axis in VLA RL optimization: within a trajectory, which chunks
+should receive gradient computation at all?
+The answer is not all of them. GRPO’s learning signal is driven by differences in advantage across
+rollouts: when rollout rewards are uniform, gradients vanish [Wang et al., 2026, Xu and Ding, 2026].
+We argue that variance non-uniformity persists even within a single non-collapsed group. Supervised
+fine-tuning is effective in densely covered, unimodal regions, but weak under sparse demonstrations
+or multimodal optimal behavior [Chu et al., 2025]; these are precisely the regimes that RL fine-tuning
+is intended to refine. This suggests that (a) gradient computation should be treated as an allocatable
+resource and (b) recomputing gradients on phases the base policy already handles wastes compute
+and memory. From this perspective, RL training becomes a problem of allocating limited gradient
+budget to the parts of trajectories that carry useful learning signal.
+We present Probabilistic Chunk Masking (PCM), a drop-in modification to GRPO that updates
+only a fixed budget of chunks per trajectory. PCM assigns phase-level keep probabilities using the
+success-failure action variance Cc , which is concentrated in a small number of outcome-critical
+semantic phases c (Fig. 1, left). It then physically removes the unselected chunks from the backward
+pass, significantly reducing actor-update compute and activation memory. We further prove that
+Cc serves as a measurable lower-bound proxy for the true per-phase gradient variance Vc , giving a
+principled basis for this allocation. The main contributions of this paper are as follows:
+• We show that √
+Vc is the right signal for gradient allocation and derive a Neyman allocation
+proportional to Nc Vc (Nc is the number of chunks in phase c), which concentrates gradient compute
+on outcome-divergent phases.
+• We establish that the per-phase success–failure action variance Cc is a sufficient proxy for Vc ,
+computable directly from rollouts GRPO already produces with no reward model or learned critic.
+• Empirically, these enable substantial efficiency gains in gradient-bound VLA-RL. On
+LIBERO [Liu et al., 2023], PCM achieves 2.38× wall-clock speedup to 98% convergence, 4.8×
+faster gradient steps, 60% lower peak activation memory, using less than 20% of chunks per trajectory.
+
+2
+
+Related works
+
+Reinforcement Learning Fine-Tuning of VLA Models. Reinforcement learning has become an
+effective post-training stage for vision-language-action (VLA) models [Chu et al., 2025, Liu et al.,
+2025]. Early approaches relied on learned critics [Hu et al., 2024, Guo et al., 2025, Chen et al., 2025a,
+Tan et al., 2025], but the field has converged on critic-free GRPO-style optimization as these systems
+have scaled [Li et al., 2025a, Lu et al., 2025, Chen et al., 2025b, Ye et al., 2025].
+To support this shift, advances in world models and simulation have significantly reduced rollout cost
+[Zhu et al., 2025, Liu et al., 2026, Zang et al., 2026] under the implicit assumption that data collection
+2
+
+is the bottleneck. However, this progress has left gradient computation, which we observe accounts
+for ∼78% of training time, largely unoptimized. Other work improves the source or structure of
+the reward signal [Li et al., 2025b, Zhai et al., 2025, Tan et al., 2025] by altering the reward, critic,
+rollout source, or advantage/credit-assignment rule. We show that this additional machinery can be
+avoided: Cc (success-failure action variance within a phase), an internal signal already present in
+GRPO rollouts, directly captures where learning signal concentrates and is sufficient to guide gradient
+allocation.
+Efficiency Methods for GRPO. GRPO’s learning signal is driven by advantage variance [Nan
+et al., 2025], and prior large language model (LLM) RL work has exploited this at two granularities.
+At the prompt level, methods filter or reweight zero-variance rollout groups [Yu et al., 2025, Zheng
+et al., 2025, Hu et al., 2025]. At the token level, work selects which sequence positions receive
+gradient using policy-internal signals such as token entropy or probability shifts [Wang et al., 2025,
+Khandoga et al., 2026, Hu et al., 2026]. PCM operates at a third granularity: phase-level allocation
+within a trajectory. Entropy and probability shifts are indirect proxies that measure where the model
+is uncertain, not where successful and failed rollouts actually diverge. In settings with verifiable
+outcomes (like VLA RL), this raises a more fundamental question, why estimate outcome-criticality
+indirectly when the outcome signal is already available? We use Cc , computed directly from
+rollout outcomes, to allocate gradient compute according to observed success–failure divergence.
+Unlike prior work that relies on proxy signals such as entropy or probability shifts, PCM exploits
+outcome-grounded divergence.
+Parameter-efficient methods like LoRA and its extensions are standard in LLM and VLA fine-tuning,
+reducing trainable parameters but not the activation cost of backpropagating through long trajectories
+[Hu et al., 2021, Aghajanyan et al., 2021, Dettmers et al., 2023, Zhang et al., 2025, 2023]. Activationfocused methods reduce this memory cost through checkpointing and streaming backpropagation
+[Chen et al., 2016, Korthikanti et al., 2023, Luo et al., 2025]. Crucially, prior methods do not address
+the inefficiency of computing gradients on outcome-invariant phases within a trajectory, which still
+incur computation cost despite contributing little to learning.
+
+3
+
+Preliminaries
+
+We briefly describe the setup for chunk-level GRPO, which our method builds on.
+VLA Policies and Action Chunks. Let πθ denote a VLA policy that produces actions in chunks
+of length L conditioned on observation si,k , where i indexes the trajectory and k the chunk within
+that trajectory. A rollout of trajectory i decomposes into Ni = ⌈Ti /L⌉ chunks, where Ti is the total
+number of timesteps.
+Group Relative Policy Optimization. GRPO [Shao et al., 2024] samples a group of G rollouts
+from the current policy, scores each with a binary reward ri ∈ {0, 1}, and forms the group-relative
+advantage
+1 X
+1 X
+ri − µr
+Ai =
+,
+µr =
+rj , σr2 =
+(rj − µr )2 .
+(1)
+σr + ε
+G j
+G j
+Writing ai,k for the action tokens of chunk k in trajectory i, the chunk-level GRPO objective is
+"N
+#
+i
+X
+LGRPO (θ) = −Ei
+Ai · log πθ (ai,k | si,k ) ,
+(2)
+k=1
+
+with PPO-style clipping omitted for clarity.
+
+4
+
+Methodology: Probabilistic Chunk Masking
+
+4.1
+
+Phase-Conditioned Gradient Variance
+
+Following the VLA-RL setup formalized in Appendix A, we partition every trajectory into K semantic
+phases using a deterministic labeling rule (described in Sec. 5.1). Let P = {c1 , . . . , cK } denote this
+phase set, and let φ(i, k) ∈ P denote the phase of chunk (i, k).
+3
+
+Figure 2: Probabilistic Chunk Masking (PCM). We compute per-phase success–failure action variance
+(Cc ) from GRPO rollouts, use it to prioritize decision-critical phases, and sample a fixed budget of
+chunks per trajectory. Gradients are computed only on selected chunks.
+The gradient of LGRPO decomposes by phase:
+
+
+X
+gc (θ) = −Ei Ai
+∇θ log πθ (ai,k | si,k ) .
+(3)
+
+Phase decomposition of the GRPO gradient.
+∇θ LGRPO =
+
+X
+
+gc (θ),
+
+c∈P
+
+k : φ(i,k)=c
+
+The learning signal available in phase c is characterized by the per-phase gradient variance
+Vc = Var(Ai · ∇θ log πθ (ai,k | si,k ) | φ(i, k) = c) .
+
+(4)
+
+Intuitively, Vc is large for phases where the policy behaves differently across successful and failed
+rollouts. Throughout, Vc refers to the within-trajectory chunk variance (Ai fixed); under advantage
+normalization (Eq. 1), this matches the unconditional variance in Eq. (4) up to an O(1) constant. We
+formalize this observation as follows. Note that formal proofs appear in Appendix B.
+Lemma 1 (Phase gradient variance). Let c ∈ P be a phase in which πθ has converged, i.e., the action
+distributions of successful and failed rollouts are identical in phase c. Then ∥gc (θ)∥ ≈ 0 and Vc ≈ 0,
+so gradient samples from phase c contribute negligible signal. Conversely, for a phase c in which the
+base policy is underspecified, Vc is large and gradient samples from phase c are informative.
+Empirical proxy for Vc . Computing Vc exactly requires access to the gradient distribution, which
+is expensive. We instead use the success-failure action variance
+Cc = E[ai,k | ri = 1, φ(i, k) = c] − E[ai,k | ri = 0, φ(i, k) = c] ,
+
+(5)
+
+computable directly from the rollout group that GRPO already produces, with no auxiliary model or
+annotation. We compute Cc only for rollout groups with non-zero reward variance.
+Lemma 2 (Cc as a proxy for Vc ). For a policy πθ that is locally Gaussian with per-dimension
+variance σπ2 , the per-phase gradient variance satisfies Vc ≥ Cc2 /4σπ2 .
+Note that the bound in Lemma 2 is a lower bound that absorbs ∥∇θ µθ (s)∥2 into the constant. It
+justifies using Cc to recover the ordering of Vc across phases, rather than exact correspondence. We
+treat Cc as a√
+practical proxy supported by empirical evidence: the realized allocation (Fig. 6) closely
+matches the Vc -weighted prediction, and variance-aware ablations (Fig. 5b) show that Cc -weighted
+selection outperforms both random masking and highest-variance-only selection.
+4.2
+
+Optimal Budget Allocation
+
+We now state the core theoretical result. Given a fixed chunk budget B per trajectory and phase
+variance estimates {Vc }c∈P , we ask: how should B be distributed across phases to minimize the
+variance of the GRPO gradient estimator (the sampling noise around the true gradient, distinct from the
+per-phase signal Vc )? Lower estimator variance means a more accurate estimate of the true gradient
+per step, which translates directly to faster stochastic gradient descent (SGD) convergence [Bottou
+et al., 2018]. This follows Neyman-allocation intuition: under a fixed sampling budget, phases should
+be sampled in proportion to their contribution to estimator variance.
+Theorem
+P 1 (Optimal phase allocation). Let bc denote the number of chunks sampled from phase c,
+with c∈P bc = B, and let Nc denote the expected number of chunks in phase c per trajectory. The
+4
+
+allocation minimizing the variance of the unbiased GRPO gradient estimator (Eq. (2) subject to the
+budget constraint is
+√
+Nc V c
+√ .
+b∗c = B · P
+(6)
+′
+Vc′
+c′ ∈P Nc
+The speedup over uniform allocation depends on how sharply Vc concentrates across phases. When
+Vc is uniform across all K phases, Eq. (6) reduces to uniform allocation bc = B/K. When Vc
+concentrates on a small subset of phases, the Neyman allocation assigns disproportionately more
+budget to those outcome divergent phases, reducing estimator variance relative to uniform at the
+same total budget B. The concentration of Cc on contact-rich phases observed in Fig. 1, combined
+with Lemma 2, implies that Vc is similarly concentrated, making this regime directly applicable
+here. Section 5 quantifies the resulting wall-clock speedup empirically. A formal convergence-rate
+derivation and speedup formula are provided in Appendix B.1.
+4.3
+
+Online Phase Score Estimation
+
+Theorem 1 requires knowledge of {Vc }, which is not directly observable. By Lemma 2, the relative
+ordering of {Vc } is captured by the rollout-computable proxy {Cc }. We therefore use Cc to set
+per-phase weights; since phase
+√ c contains Nc candidate chunks, weighted sampling consistent with
+Eq. (6) gives E[bc ] ∝ Nc Vc , concentrating gradient computation on outcome-divergent phases.
+Phases with larger estimated Vc receive higher keep probability, while larger Nc contributes more
+candidate chunks. Both factors increase sampling frequency within the fixed budget B.
+(t)
+
+During training, we compute a batch-level phase score Cc from the rollout group at step t. We
+maintain a short buffer Bc for each phase and append the current score to the short refresh buffer.
+With G = 10 rollouts and binary rewards, individual Cc estimates may be noisy, especially under
+imbalanced success-failure splits. Therefore, scores are averaged over Trc = 5 batches before
+refreshing the keep probabilities.
+Bc ← Bc ∪ {Cc(t) }.
+(7)
+Every Trc steps (we use Trc = 5), we collapse the buffered scores into a share-normalized phase
+score:
+X
+Sc
+ρc
+Sc =
+Cc(t) ,
+ρc = P
+,
+ρ̃c =
+∈ [0, 1].
+(8)
+′
+S
+max
+c′ ρc′
+c′ c
+(t)
+Cc ∈Bc
+
+Share normalization is scale-invariant: it preserves the relative phase ordering even though the
+absolute magnitude of Cc can vary across tasks and training stages. The resulting ρ̃c is used as the
+phase-level score for probabilistic chunk selection. For the first update, the keep probabilities are
+computed from the phase scores of the first rollout group itself; after that, scores are updated every
+Trc steps using the buffered window. This online update lets PCM track the realized learning signal:
+if a phase learns faster, its success–failure divergence decreases and keep probability naturally falls.
+4.4
+
+Probabilistic Mask Selection
+
+√
+Given phase scores {ρ̃c } as proxies for { Vc }, we map them to per-phase keep-probabilities that
+implement the allocation of Theorem 1 in expectation:
+pc = max(pmin , ρ̃c ) ∈ [pmin , 1],
+(9)
+with pmin = 0.1. The floor pmin prevents any phase from being structurally excluded between buffer
+recomputes. This is important because ρ̃c may be transiently zero for a phase with nonzero true
+variance Vc if that phase is underrepresented or temporarily underestimated in the current buffer
+window. Excluding such phases entirely would violate the exploration requirement of the allocation
+and could cause the estimated {ρc } to diverge from the true {Vc } ordering over time. Each chunk
+inherits its phase’s probability weight: wi,k = pφ(i,k) . The set {pc } is held fixed across the next Trc
+steps.
+4.5
+
+Fixed-Budget Sampling and Physical Shrinking
+
+Given the allocation rule derived in Theorem 1, we sample a fixed budget of B chunks per trajectory
+using weighted sampling without replacement [Plackett, 1975, Luce, 1959], with weights {wi,k }:
+Ki ∼ WeightedSample(wi,1 , . . . , wi,Ni ; min(B, Ni ), w/o replacement) .
+(10)
+5
+
+The selected set is Ki = {k1 , . . . , kmi }. Non-selected chunks are physically removed from the batch
+tensor before the forward pass.
+The actor update uses the masked objective:
+"
+LPCM (θ) = −Ei
+
+#
+X
+
+Ai · log πθ (ai,k | si,k )
+
+(11)
+
+k∈Ki
+
+The masked objective in Eq. (11) omits the 1/pc importance
+weights, making it a biased estimator
+P
+of the full-trajectory GRPO gradient. The bias is c∈P (1 − pc ) gc : chunks that are not selected
+√
+contribute zero to Eq. (11) but gc to the full gradient. Under our allocation pc ∝ Vc , the factor
+(1 − pc ) is large precisely when Vc is small, and by Lemma 1, small Vc implies small ∥gc ∥. Each term
+in the bias is therefore suppressed by at least one small factor, so Theorem 1’s allocation remains
+approximately optimal under the biased estimator. The trade-off is favorable: at the same chunk
+budget B, the masked estimator has substantially lower variance than the importance-weighted
+unbiased alternative, translating to faster SGD convergence (Appendix B.1). A formal bound is given
+in Appendix B.2.
+Algorithm 1 Probabilistic Chunk Masking for GRPO
+Require: Policy πθ ; group size G; chunk budget B; floor pmin ; refresh window Trc
+1: Initialize phase-score buffers Bc ← [ ] for all phases c
+2: while not converged do
+3:
+Sample G rollouts and compute binary rewards {ri }
+▷ Eq. (1)
+4:
+Compute GRPO advantages {Ai } from the group rewards
+▷ Eq. (1)
+5:
+Label each chunk with a phase φ(i, k) from the gripper trajectory
+▷ Sec. 5.1
+(t)
+▷ Eq. (5)
+6:
+Compute per-phase success-failure action variance {Cc }c∈P from rollouts
+(t)
+▷ Eq. (7)
+7:
+Append Cc to buffer Bc for all c ∈ P
+8:
+if first batch or |Bc | = Trc then
+9:
+Collapse buffers, share-normalize and max-normalize
+▷ Eq. (8)
+10:
+Apply floor: pc ← max(pmin , ρ̃c ) for all c
+▷ Eq. (9)
+11:
+Reset phase buffers: Bc ← [ ] for all c ∈ P
+12:
+end if
+13:
+for each trajectory i with Ni chunks do
+14:
+Set chunk weights wi,k ← pφ(i,k) for k = 1, . . . , Ni
+▷ Sec. (4.4)
+15:
+Sample Ki with |Ki | = min(B, Ni ) via weighted sampling w/o replacement ▷ Eq. (10)
+16:
+Physically remove non-selected chunks from batch; keep only Ki for actor update ▷ Sec. 4.5
+17:
+end for
+18:
+Update πθ using the masked GRPO loss
+▷ Eq. (11)
+19: end while
+
+5
+
+Empirical Evaluation
+
+5.1
+
+Experimental Setup
+
+Models and Benchmarks. We run our experiments on OpenVLA-OFT [Kim et al., 2025], a 7B
+vision-language-action model that predicts 7-DoF action chunks with chunk length L=8. We evaluate
+on three benchmarks: LIBERO-Object, LIBERO-Spatial, and LIBERO-Goal [Liu et al., 2023].
+Phase Labeling. We assign each chunk to one of K=5 semantic phases using a deterministic, multi-grasp-aware rule over the per-chunk gripper-close fraction gf [j] ∈ [0, 1]. Activegrip chunks (gf [j] ≥ 0.5) capture sustained grasp and transport; pre-grasp labels the up-tothree chunks immediately before sustained closure (0.1 ≤ gf [j] < 0.5); release-ramp labels
+the up-to-three chunks after; approach covers the remaining pre-contact chunks; and tail covers
+post-release open-gripper chunks; Overlapping windows are resolved by the priority ordering
+active-grip > pre-grasp > release-ramp > approach > tail. This rule is applied
+identically to successful and failed trajectories, enabling Cc to compare outcomes under a shared
+phase partition. Full details are in Appendix E.2.
+6
+
+Training and Evaluation. We implement PCM on the SimpleVLA-RL [Li et al., 2025a] verl [Sheng
+et al., 2025] pipeline with GRPO groups of 10 rollouts per prompt, comparing against the fulltrajectory chunk-level GRPO baseline. We fine-tune OpenVLA-OFT with LoRA using 2 NVIDIA
+H100 GPUs. We evaluate every training step using 50 held-out validation rollouts. Results are
+averaged across three seeds, and we report per-step update time and peak GPU memory. Detailed
+experimental settings are in Appendix E.
+Research Questions.
+
+Our experiments are designed to answer the following:
+
+RQ1 Does variance-aware chunk selection preserve the learning dynamics of full-trajectory
+GRPO, measured by step-wise accuracy curves?
+RQ2 Does selective gradient allocation reduce wall-clock time to reach a target success rate
+without affecting sample efficiency?
+RQ3 How sensitive is performance to the chunk budget B, and is there a stable operating point
+that balances gradient signal with per-step speedup?
+RQ4 Is variance-aware probabilistic selection necessary, or do simpler masking strategies achieve
+comparable performance under the same chunk budget?
+5.2
+
+Results and Discussion
+
+Figure 3: Success rate as a function of wall-clock time (a) and training step (b) on LIBERO-Object,
+averaged over three seeds. PCM (B=12) closely matches full-trajectory GRPO across training steps
+while converging significantly faster.
+RQ1: Learning Dynamics. We compare PCM with chunk budget B=12 against full-trajectory
+GRPO on LIBERO-Object using the same SFT-initialized OpenVLA-OFT checkpoint, identical
+rollout groups, rewards, advantages, and optimizer settings. The methods differ only in whether the
+actor update is computed over all chunks or the subset selected by PCM. Both are trained for a fixed
+budget of 200 steps.
+As a function of training step (Fig. 3b), PCM and GRPO exhibit nearly identical learning curves
+and reach matched final accuracy. This shows that PCM preserves per-step learning dynamics while
+improving efficiency, confirming that the selective gradient allocation does not degrade step-wise
+convergence behavior.
+RQ2: Wall-Clock Efficiency. As
+Vanilla GRPO PCM (Ours)
+shown in Fig. 3a, PCM reaches nearsaturation significantly earlier in wallLIBERO-Object 45.78 ± 0.95 19.23 ± 0.57
+clock time. Fig. 4a shows that PCM
+LIBERO-Goal
+51.25 ± 1.05 21.18 ± 0.59
+LIBERO-Spatial 49.89 ± 0.98 21.23 ± 0.63
+reaches the target success rate of 98% ±
+0.02 up to 2.38× faster than vanilla
+Overall
+48.97 ± 0.99 20.55 ± 0.60
+GRPO, with the gap widening sharply
+at higher accuracy thresholds. Table 1
+Table 1: Wall-clock time in hours to reach 98% ± 0.02
+shows that this trend holds across all
+success rate. Lower is better.
+LIBERO benchmarks, reducing the average time to 98% ± 0.02 success from 48.97 ± 0.99 to 20.55 ± 0.60 hours. To understand how this
+speedup decomposes, Fig. 4b-c separate per-step compute from overall convergence. PCM reduces
+7
+
+Figure 4: Efficiency on LIBERO-Object at B=12. (a) Wall-clock time to first reach each SR
+threshold; the PCM/GRPO gap widens at higher thresholds. (b) Activation memory is reduced by
+60%. (c) Cumulative actor-update time over 200 steps is 4.8× faster.
+activation memory by 60% (10.1 → 4.1 GB) and peak GPU memory by 15% (39.7 → 33.6 GB) per
+step.
+Cumulative gradient-update time over 200 training steps is 4.8× faster. Because the per-step learning
+curves are matched (Fig. 3b), the wall-clock gain is entirely attributable to per-step compute savings
+rather than improved sample efficiency. Together these results show that the selective gradient
+allocation substantially reduces per-step cost while leaving sample efficiency intact.
+
+Figure 5: Ablations on LIBERO-Object. (a) Chunk budget sweep shows that B=12 preserves final
+success while retaining most of the wall-clock speedup. (b) At fixed B=12, PCM outperforms
+random masking and highest-variance-phase selection.
+RQ3: Sensitivity to Chunk Budget B. PCM samples a fixed budget of B chunks per trajectory.
+Smaller budgets improve per-step efficiency but reduce gradient coverage, while larger budgets better
+approximate full GRPO at higher cost. We sweep B ∈ {8, 12, 16} on LIBERO-Object using the same
+training configuration. We select this range for B to bracket the inflection of the cumulative Cc curve
+in Fig. 8b, plotted against the fraction of trajectory chunks retained, which marks the smallest budget
+capturing most of the available learning signal. Details in Appendix D.
+Fig. 5a shows that all budgets reach comparable final accuracy, but differ in efficiency. B=8
+is fastest per step but has degraded sample efficiency and plateaus at a slightly lower accuracy,
+indicating insufficient gradient signal. B=16 provides no accuracy gain over B=12 while increasing
+convergence time, showing diminishing returns beyond high-Cc phases. B=12 lies at the inflection
+point, matching final accuracy while preserving the wall-clock advantage. We use B=12 as our
+default for all other experiments. B=12 is large enough to consistently sample from high-Cc phases
+under the probabilistic selection rule while remaining small enough to deliver substantial per-step
+compute and memory savings.
+RQ4: Variance Concentration and the Role of Variance-Aware Selection. To test whether
+variance-aware probabilistic selection is necessary, we compare PCM at B=12 against two ablations
+that occupy opposite extremes of the allocation spectrum: random masking, which samples B chunks
+uniformly at random from each trajectory (no concentration on high-Cc phases), and full masking,
+which restricts updates to the single highest-Cc phase and discards all other chunks (maximum
+concentration, no exploration). Together, these bracket PCM, which lies between these extremes via
+probabilistic Cc -weighted sampling.
+8
+
+Fig. 5b shows that both ablations underperform PCM. Random masking plateaus at ∼78% success
+rate, 22 points below PCM at the same chunk budget. Full masking fails more sharply, plateauing
+at a low accuracy of ∼43%. Since all methods use the same B=12 budget, these gaps isolate the
+contribution of variance-aware selection from compute reduction.
+Fig. 6 shows PCM’s realized gradient allocation across training, revealing three mechanisms that
+together explain its performance.
+• Concentration: Active-grip (∼7–8 chunks per trajectory) and pre-grasp (∼3–5 chunks per trajectory)
+dominate throughout,
+matching the high-Cc phases
+√
+(Fig. 1) and the Vc -weighted allocation predicted
+by Theorem 1. The agreement between predicted and
+realized allocation is the empirical confirmation that
+Cc tracks Vc in practice, validating Lemma 2’s proxy
+assumption.
+• Exploration: Probabilistic Cc -weighted sampling
+(Eq. 10) ensures that every phase has nonzero selection probability whenever its weight is above zero,
+providing the primary exploration mechanism. The Figure 6: Phase-wise gradient allocation unpmin = 0.1 floor (Eq. 9) acts as a safety net for low- der PCM over training steps.
+scoring phases (e.g., tail): it prevents transient zero estimates from collapsing a phase’s weight to
+zero between buffer recomputes, which would otherwise cause online phase scores to fail to recover
+when the true Vc ordering shifts during training.
+• Adaptation: Approach and release-ramp allocations decline from ∼2 to ∼1 chunks and from ∼2.5
+to ∼1.5 chunks, respectively, as the policy masters those phases, with budget shifting toward phases
+where learning signal concentrates. This online dynamic that adapts with evolving success-failure
+gap of the policy cannot be reproduced by static weighting.
+The ablations occupy degenerate corners of this design space. Random masking explores but lacks
+concentration, matching the suboptimal uniform-allocation regime in Theorem 1, where bc = B/K
+(equal budget across phases) is inefficient when Vc is non-uniform across phases. Full masking
+concentrates updates on the highest-Cc phase but discards weaker adjacent-phase signals and prevents
+exploration and adaptation.
+Only PCM has all three properties: Cc -weighted keep probabilities with a pmin floor to concentrate
+updates on contact-rich phases while retaining lower-scoring phases. The ablations show that varianceaware probabilistic selection substantially outperforms uninformed masking strategies in exploiting
+the concentrated structure of Cc .
+
+6
+
+Limitations and Future Work
+
+Our evaluation spans the three LIBERO suites (Object, Spatial, Goal), which test transfer of object,
+spatial, and task knowledge respectively (Table 1). We do not test longer horizons or bimanual
+coordination; however, the underlying allocation principle applies whenever Vc is non-uniform, a
+structural feature of any GRPO setting where the policy has not converged uniformly. Experiments
+use a gripper-based phase partition rule. Extension to other settings is straightforward in principle
+(any consistent decomposition suffices), though we do not validate alternative phase abstractions
+empirically. We do not directly benchmark against methods targeting sample efficiency through
+different objectives (e.g., entropy-based token selection or prompt filtering). These methods differ
+from PCM in both granularity (token vs. phase) and signal (policy-internal uncertainty vs. outcomegrounded divergence); adapting them to the VLA chunk-level setting is beyond the scope of this
+work.
+Future work includes extending PCM to longer-horizon and bimanual tasks, validating learned
+temporal phase segmenters or LLM-derived phase labelers, and applying the variance-allocation
+principle to LLM reasoning where Cc can be computed against verified outcomes. Combining PCM
+with orthogonal sample-efficiency methods remains an open direction.
+
+9
+
+References
+Armen Aghajanyan, Luke Zettlemoyer, and Sonal Gupta. Intrinsic Dimensionality Explains the Effectiveness of
+Language Model Fine-Tuning. In Annual Meeting of the Association for Computational Linguistics, 2021.
+doi: 10.18653/v1/2021.acl-long.568. URL https://arxiv.org/abs/2012.13255v1.
+Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Lachy
+Groom, Karol Hausman, Brian Ichter, Szymon Jakubczak, Tim Jones, Liyiming Ke, Sergey Levine, Adrian
+Li-Bell, Mohith Mothukuri, Suraj Nair, Karl Pertsch, Lucy Xiaoyang Shi, James Tanner, Quan Vuong, Anna
+Walling, Haohuan Wang, and Ury Zhilinsky. π0 : A Vision-Language-Action Flow Model for General Robot
+Control, 2024. URL https://arxiv.org/abs/2410.24164v4.
+Léon Bottou, Frank E. Curtis, and Jorge Nocedal. Optimization methods for large-scale machine learning. SIAM
+Review, 60(2):223–311, 2018. doi: 10.1137/16M1080173.
+Tianqi Chen, Bing Xu, Chiyuan Zhang, and Carlos Guestrin. Training deep nets with sublinear memory cost.
+abs/1604.06174, 2016. URL http://arxiv.org/abs/1604.06174.
+Yuhui Chen, Shuai Tian, Shugao Liu, Yingting Zhou, Haoran Li, and Dongbin Zhao. ConRFT: A Reinforced
+Fine-tuning Method for VLA Models via Consistency Policy, 2025a. URL https://arxiv.org/abs/
+2502.05450v2.
+Zengjue Chen, Runliang Niu, He Kong, Qi Wang, Qianli Xing, and Zipei Fan. TGRPO :Fine-tuning VisionLanguage-Action Model via Trajectory-wise Group Relative Policy Optimization, 2025b. URL https:
+//arxiv.org/abs/2506.08440.
+Tianzhe Chu, Yuexiang Zhai, Jihan Yang, Shengbang Tong, Saining Xie, Dale Schuurmans, Quoc V. Le, Sergey
+Levine, and Yi Ma. SFT Memorizes, RL Generalizes: A Comparative Study of Foundation Model Posttraining. In International Conference on Machine Learning, 2025. doi: 10.48550/arxiv.2501.17161. URL
+https://arxiv.org/abs/2501.17161v2.
+Tim Dettmers, Artidoro Pagnoni, Ari Holtzman, and Luke Zettlemoyer. QLoRA: Efficient Finetuning of
+Quantized LLMs. In Advances in Neural Information Processing Systems, 2023. doi: 10.48550/arxiv.2305.
+14314. URL https://arxiv.org/abs/2305.14314v1.
+Yanjiang Guo, Jianke Zhang, Xiaoyu Chen, Xiang Ji, Yen-Jen Wang, Yucheng Hu, and Jianyu Chen. Improving
+Vision-Language-Action Model with Online Reinforcement Learning. In IEEE International Conference on
+Robotics and Automation, 2025. URL https://arxiv.org/abs/2501.16664v1.
+Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu
+Chen. LoRA: Low-Rank Adaptation of Large Language Models. In International Conference on Learning
+Representations, 2021. URL https://arxiv.org/abs/2106.09685v2.
+Jiaheng Hu, Rose Hendrix, Ali Farhadi, Aniruddha Kembhavi, Roberto Martin-Martin, Peter Stone, Kuo-Hao
+Zeng, and Kiana Ehsani. FLaRe: Achieving Masterful and Adaptive Robot Policies with Large-Scale
+Reinforcement Learning Fine-Tuning. In IEEE International Conference on Robotics and Automation, 2024.
+doi: 10.1109/icra55743.2025.11127934. URL https://arxiv.org/abs/2409.16578v2.
+Yuelin Hu, Zhengxue Cheng, Wei Liu, and Li Song. Entropy-Gated Selective Policy Optimization:Token-Level
+Gradient Allocation for Hybrid Training of Large Language Models, 2026. URL https://arxiv.org/
+abs/2602.03309.
+Zengjie Hu, Jiantao Qiu, Tianyi Bai, Haojin Yang, Binhang Yuan, Qi Jing, Conghui He, and Wentao Zhang.
+VADE: Variance-Aware Dynamic Sampling via Online Sample-Level Difficulty Estimation for Multimodal
+RL, 2025. URL https://arxiv.org/abs/2511.18902.
+Mykola Khandoga, Rui Yuan, and Vinay Kumar Sankarapu. Beyond Uniform Credit: Causal Credit Assignment
+for Policy Optimization, 2026. URL https://arxiv.org/abs/2602.09331.
+Moo Jin Kim, Karl Pertsch, Siddharth Karamcheti, Ted Xiao, Ashwin Balakrishna, Suraj Nair, Rafael Rafailov,
+Ethan Foster, Grace Lam, Pannag Sanketi, Quan Vuong, Thomas Kollar, Benjamin Burchfiel, Russ Tedrake,
+Dorsa Sadigh, Sergey Levine, Percy Liang, and Chelsea Finn. OpenVLA: An Open-Source Vision-LanguageAction Model. In Conference on Robot Learning, 2024. doi: 10.48550/arxiv.2406.09246. URL https:
+//arxiv.org/abs/2406.09246v3.
+Moo Jin Kim, Chelsea Finn, and Percy Liang. Fine-Tuning Vision-Language-Action Models: Optimizing Speed
+and Success. In Robotics: Science and Systems, 2025. URL https://arxiv.org/abs/2502.19645.
+
+10
+
+Vijay Anand Korthikanti, Jared Casper, Sangkug Lym, Lawrence McAfee, Michael Andersch, Mohammad
+Shoeybi, and Bryan Catanzaro. Reducing Activation Recomputation in Large Transformer Models. In
+Proceedings of the Machine Learning and Systems Conference (MLSys), 2023. URL https://openreview.
+net/forum?id=nvRncppDoD.
+Haozhan Li, Yuxin Zuo, Jiale Yu, Yuhao Zhang, Zhaohui Yang, Kaiyan Zhang, Xuekai Zhu, Yuchen Zhang,
+Tianxing Chen, Ganqu Cui, Dehui Wang, Dingxiang Luo, Yuchen Fan, Youbang Sun, Jia Zeng, Jiangmiao
+Pang, Shanghang Zhang, Yu Wang, Yao Mu, Bowen Zhou, and Ning Ding. SimpleVLA-RL: Scaling VLA
+Training via Reinforcement Learning, 2025a. URL https://arxiv.org/abs/2509.09674v1.
+Hengtao Li, Pengxiang Ding, Runze Suo, Yihao Wang, Zirui Ge, Dongyuan Zang, Kexian Yu, Mingyang Sun,
+Hongyin Zhang, Donglin Wang, and Weihua Su. VLA-RFT: Vision-Language-Action Reinforcement Finetuning with Verified Rewards in World Simulators, 2025b. URL https://arxiv.org/abs/2510.00406.
+Bo Liu, Yifeng Zhu, Chongkai Gao, Yihao Feng, Qiang Liu, Yuke Zhu, and Peter Stone. LIBERO: Benchmarking
+Knowledge Transfer for Lifelong Robot Learning. In Advances in Neural Information Processing Systems,
+2023. URL https://arxiv.org/abs/2306.03310.
+Jijia Liu, Feng Gao, Bingwen Wei, Xinlei Chen, Qingmin Liao, Yi Wu, Chao Yu, and Yu Wang. What Can RL
+Bring to VLA Generalization? An Empirical Study, 2025. URL https://arxiv.org/abs/2505.19789v4.
+Xiaokang Liu, Zechen Bai, Hai Ci, Kevin Yuchen Ma, and Mike Zheng Shou. World-VLA-Loop: Closed-Loop
+Learning of Video World Model and VLA Policy, 2026. URL https://arxiv.org/abs/2602.06508.
+Guanxing Lu, Wenkai Guo, Chubin Zhang, Yuheng Zhou, Haonan Jiang, Zifeng Gao, Yansong Tang, and
+Ziwei Wang. VLA-RL: Towards Masterful and General Robotic Manipulation with Scalable Reinforcement
+Learning, 2025. URL https://arxiv.org/abs/2505.18719v1.
+R. Duncan Luce. Individual Choice Behavior: A Theoretical Analysis. Wiley, New York, 1959.
+Qijun Luo, Mengqi Li, Lei Zhao, and Xiao Li. StreamBP: Memory-Efficient Exact Backpropagation for
+Long Sequence Training of LLMs. In Advances in Neural Information Processing Systems, 2025. URL
+https://arxiv.org/abs/2506.03077v1.
+Gongrui Nan, Siye Chen, Jing Huang, Mengyu Lu, Dexun Wang, Chunmei Xie, Weiqi Xiong, Xianzhou
+Zeng, Qixuan Zhou, Yadong Li, and Xingzhong Xu. NGRPO: Negative-enhanced Group Relative Policy
+Optimization, 2025. URL https://arxiv.org/abs/2509.18851.
+R. L. Plackett. The analysis of permutations. 24(2):193–202, 1975. doi: 10.2307/2346567.
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal Policy Optimization
+Algorithms, 2017. URL https://arxiv.org/abs/1707.06347.
+Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang,
+Y. K. Li, Y. Wu, and Daya Guo. DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open
+Language Models, 2024. URL https://arxiv.org/abs/2402.03300v3.
+Guangming Sheng, Chi Zhang, Zilingfeng Ye, Xibin Wu, Wang Zhang, Ru Zhang, Yanghua Peng, Haibin Lin,
+and Chuan Wu. HybridFlow: A Flexible and Efficient RLHF Framework. In Proceedings of the Twentieth
+European Conference on Computer Systems, EuroSys ’25, page 1279–1297, New York, NY, USA, 2025.
+Association for Computing Machinery. ISBN 9798400711961. doi: 10.1145/3689031.3696075. URL
+https://doi.org/10.1145/3689031.3696075.
+Shuhan Tan, Kairan Dou, Yue Zhao, and Philipp Krähenbühl. Interactive Post-Training for Vision-LanguageAction Models, 2025. URL https://arxiv.org/abs/2505.17016v1.
+Hongcheng Wang, Yinuo Huang, Sukai Wang, Guanghui Ren, and Hao Dong. Why Tree-Style Branching
+Matters for Thought Advantage Estimation in GRPO, 2026. URL https://arxiv.org/abs/2509.24494.
+Shenzhi Wang, Le Yu, Chang Gao, Chujie Zheng, Shixuan Liu, Rui Lu, Kai Dang, Xionghui Chen, Jianxin
+Yang, Zhenru Zhang, Yuqiong Liu, An Yang, Andrew Zhao, Yang Yue, Shiji Song, Bowen Yu, Gao Huang,
+and Junyang Lin. Beyond the 80/20 Rule: High-Entropy Minority Tokens Drive Effective Reinforcement
+Learning for LLM Reasoning. In Advances in Neural Information Processing Systems, 2025. URL https:
+//arxiv.org/abs/2506.01939.
+Zhongwen Xu and Zihan Ding. Single-stream Policy Optimization. In International Conference on Learning
+Representations, 2026. URL https://openreview.net/forum?id=b61UW62K7W.
+
+11
+
+Angen Ye, Zeyu Zhang, Boyuan Wang, Xiaofeng Wang, Dapeng Zhang, and Zheng Zhu. VLA-R1: Enhancing
+Reasoning in Vision-Language-Action Models, 2025. URL https://arxiv.org/abs/2510.01623.
+Qiying Yu, Zheng Zhang, Ruofei Zhu, Yufeng Yuan, Xiaochen Zuo, Yu Yue, Weinan Dai, Tiantian Fan,
+Gaohong Liu, Lingjun Liu, Xin Liu, Haibin Lin, Zhiqi Lin, Bole Ma, Guangming Sheng, Yuxuan Tong,
+Chi Zhang, Mofan Zhang, Wang Zhang, Hang Zhu, Jinhua Zhu, Jiaze Chen, Jiangjie Chen, Chengyi
+Wang, Hongli Yu, Yuxuan Song, Xiangpeng Wei, Hao Zhou, Jingjing Liu, Wei-Ying Ma, Ya-Qin Zhang,
+Lin Yan, Mu Qiao, Yonghui Wu, and Mingxuan Wang. DAPO: An Open-Source LLM Reinforcement
+Learning System at Scale. In Advances in Neural Information Processing Systems, 2025. URL https:
+//arxiv.org/abs/2503.14476v2.
+Hongzhi Zang, Mingjie Wei, Si Xu, Yongji Wu, Zhen Guo, Yuanqing Wang, Hao Lin, Peihong Wang, Liangzhi
+Shi, Yuqing Xie, Zhexuan Xu, Zhihao Liu, Kang Chen, Wenhao Tang, Quanlu Zhang, Weinan Zhang,
+Chao Yu, and Yu Wang. RLinf-VLA: A Unified and Efficient Framework for Reinforcement Learning of
+Vision-Language-Action Models, 2026. URL https://arxiv.org/abs/2510.06710.
+Shaopeng Zhai, Qi Zhang, Tianyi Zhang, Fuxian Huang, Haoran Zhang, Ming Zhou, Shengzhe Zhang, Litao
+Liu, Sixu Lin, and Jiangmiao Pang. A Vision-Language-Action-Critic Model for Robotic Real-World
+Reinforcement Learning, 2025. URL https://arxiv.org/abs/2509.15937.
+Jun Zhang, Jue Wang, Huan Li, Lidan Shou, Ke Chen, Yang You, Guiming Xie, Xuejian Gong, and Kunlong Zhou.
+Train Small, Infer Large: Memory-Efficient LoRA Training for Large Language Models. In International
+Conference on Learning Representations, 2025. URL https://arxiv.org/abs/2502.13533v2.
+Qingru Zhang, Minshuo Chen, Alexander Bukharin, Nikos Karampatziakis, Pengcheng He, Yu Cheng, Weizhu
+Chen, and Tuo Zhao. AdaLoRA: Adaptive Budget Allocation for Parameter-Efficient Fine-Tuning. In International Conference on Learning Representations, 2023. URL https://arxiv.org/abs/2303.10512.
+Haizhong Zheng, Yang Zhou, Brian R. Bartoldson, Bhavya Kailkhura, Fan Lai, Jiawei Zhao, and Beidi Chen.
+Act Only When It Pays: Efficient Reinforcement Learning for LLM Reasoning via Selective Rollouts. In
+Advances in Neural Information Processing Systems, 2025. URL https://openreview.net/forum?id=
+x5lITYXmW2.
+Fangqi Zhu, Zhengyang Yan, Zicong Hong, Quanxin Shou, Xiao Ma, and Song Guo. WMPO: World Modelbased Policy Optimization for Vision-Language-Action Models, 2025. URL https://arxiv.org/abs/
+2511.09515v1.
+
+12
+
+Appendix
+A
+
+Problem Formulation and Assumptions
+
+For clarity, we explicitly restate the problem formulation and assumptions underlying PCM. While
+these are implicit in the main text, we formalize them here to precisely define the input setting, the
+chunk-selection objective, and the structural conditions required for the analysis.
+Input. A VLA policy πθ0 initialized from a supervised fine-tuning checkpoint, a simulated environment E, a distribution over tasks T with binary reward r : τ → {0, 1}, and a group of G
+rollouts {τi }G
+i=1 where each trajectory
+P decomposes into Ni = ⌈Ti /L⌉ chunks of length L, and a
+fixed gradient compute budget B ≪ i Ni .
+Output.
+
+G
+A chunk selection policy M : {τi , ri }G
+i=1 → {Ki ⊆ {1, . . . , Ni }}i=1 that minimizes
+!
+G
+X
+X
+Var
+Ai · ∇θ log πθ (ai,k | si,k )
+(12)
+i=1
+
+k∈Ki
+
+subject to |Ki | = B for all i (fixed compute budget), and M using only {τi , ri }G
+i=1 without access to
+auxiliary reward models or learned critics.
+Assumptions.
+
+We assume the following:
+
+• Binary reward: r : τ → {0, 1} is trajectory-level, with each group containing both successes
+and failures (0 < µr < 1); when all rollouts succeed or fail, advantages collapse and the variance
+signal is uninformative.
+• Fixed chunk length: The policy produces actions in chunks of fixed length L, so the phase
+decomposition ϕ(i, k) is well-defined and consistent across trajectories.
+• Deterministic phase labeling: ϕ(i, k) ∈ P is computable from the gripper command trajectory
+alone, requiring no learned model.
+• Shared phase structure: Successful and failed rollouts share the same phase partition P, so
+per-phase action variance compares like with like across outcome groups.
+• SFT initialization: πθ0 is initialized from a supervised fine-tuning checkpoint, ensuring gradient
+variance concentrates on a small subset of outcome-critical phases.
+
+B
+
+Theoretical Results
+
+In this section we provide proofs for the formal results in the main paper.
+Lemma 1 (Phase gradient variance). Let c ∈ P be a phase in which πθ has converged, i.e., the action
+distributions of successful and failed rollouts are identical in phase c. Then ∥gc (θ)∥ ≈ 0 and Vc ≈ 0,
+so gradient samples from phase c contribute negligible signal. Conversely, for a phase c in which the
+base policy is underspecified, Vc is large and gradient samples from phase c are informative.
+Proof. Since Ai is zero-mean by construction (Eq. (1)), we have Vc = 0 if and only if πθ (ai,k | si,k )
+is identical across successful and failed rollouts for every chunk (i, k) with φ(i, k) = c. This holds
+exactly when outcomes are independent of the actions taken in phase c. When these conditional
+action distributions match, positive- and negative-advantage score-function terms are drawn from the
+same distribution and cancel in expectation, leaving ∥gc (θ)∥ ≈ 0. When they diverge, phase c carries
+useful learning signal.
+Lemma 2 (Cc as a proxy for Vc ). For a policy πθ that is locally Gaussian with per-dimension
+variance σπ2 , the per-phase gradient variance satisfies Vc ≥ Cc2 /4σπ2 .
+−
+Proof. Let µ+
+c = E[ai,k | ri = 1, φ(i, k) = c] and µc = E[ai,k | ri = 0, φ(i, k) = c]. For
+2
+a Gaussian policy πθ (· | s) = N (µθ (s), σπ I), the score function is ∇θ log πθ (a | s) = (a −
+
+13
+
+µθ (s))/σπ2 · ∇θ µθ (s). Conditioning on the outcome group, the variance of the score is lower-bounded
+by the variance of the mean action across groups. Specifically, for any random variable X and a
+binary conditioning event E, Var(X) ≥ Var(E[X | E]) by the law of total variance. Applying this
+with X = Ai · ∇θ log πθ (ai,k | si,k ) and E = {ri = 1} versus {ri = 0}, and using |Ai | ≤ 1/ε
+as a finite bound, yields the equation in the lemma after absorbing the gradient norm ∥∇θ µθ ∥2
+and balanced-group constants into σπ2 . The bound preserves the relative ordering of {Vc } across
+phases.
+Theorem
+P 1 (Optimal phase allocation). Let bc denote the number of chunks sampled from phase c,
+with c∈P bc = B, and let Nc denote the expected number of chunks in phase c per trajectory. The
+allocation minimizing the variance of the unbiased ratio estimator of the GRPO gradient (Eq. (2))
+subject to the budget constraint is
+√
+Nc V c
+√ .
+b∗c = B · P
+(13)
+′
+Vc′
+c′ ∈P Nc
+Proof. We analyze the idealized stratified ratio estimator with deterministic per-phase budget bc;
+the masked loss in Eq. (11) implements this allocation in expectation under the sampling rule of
+Eq. (10), at the cost of a finite-sample bias bounded by the contribution of low-Vc phases (Sec. 4.5).
+The GRPO gradient decomposes by phase as in Eq. (3). PCM estimates the full phase gradient gc (θ),
+which sums over all Nc chunks in phase c, via the ratio estimator
+Nc X
+ĝc =
+Ai · ∇θ log πθ (ai,k | si,k ),
+(14)
+bc
+k∈Kc
+
+where Kc ⊆ {k : φ(i, k) = c} with |Kc | = bc chunks drawn uniformly without replacement from
+the Nc available chunks in phase c. The Nc /bc factor scales up the sampled sum to account for the
+full phase size, making ĝc unbiased for gc (θ):
+EKc [ĝc ] =
+
+Nc
+gc (θ)
+· bc ·
+= gc (θ).
+bc
+Nc
+
+The variance of ĝc is
+Var(ĝc ) =
+
+Nc2 Vc
+Nc2
+·
+b
+·
+V
+=
+,
+c
+c
+b2c
+bc
+
+(15)
+
+where Vc is the per-chunk variance within phase c (Eq. (4)), and the bc in the numerator is the variance
+of a single-chunk sample, reduced by bc draws.
+The total estimator variance across all phases is
+σ 2 ({bc }) =
+
+X N 2 Vc
+c
+
+c∈P
+
+bc
+
+.
+
+(16)
+
+P
+We minimize σ 2 ({bc }) subject to c∈P bc = B, bc ≥ 0. By the Cauchy-Schwarz inequality,
+!2
+!2
+!
+!
+X Nc √Vc p
+X N 2 Vc
+X
+X p
+c
+√
+Nc Vc
+=
+· bc
+≤
+·
+bc ,
+bc
+bc
+c∈P
+c∈P
+c∈P
+c∈P
+|
+{z
+} | {z }
+σ 2 ({bc })
+
+√
+
+B
+
+√
+√
+√
+P
+Vc / bc ∝ bc , i.e., bc ∝ Nc Vc . Combining with c bc = B
+
+with equality if and only if Nc
+yields Eq. (13).
+√
+√
+P
+Substituting b∗c = B · Nc Vc / c′ Nc′ Vc′ into Eq. (16), the minimum total variance achieved is
+!2
+1 X p
+2
+σ∗ =
+Nc Vc .
+(17)
+B
+c∈P
+
+14
+
+B.1
+
+Convergence Derivation for Phase Allocation
+
+We derive the convergence-rate comparison between the optimal allocation of Theorem 1 and uniform
+allocation. Under standard SGD assumptions (L-smooth objective, bounded per-phase gradient
+variance Vc ), the number of steps to reach an ε-stationary point satisfies [Bottou et al., 2018]
+ 2
+σ
+T (ε) = O 2 ,
+(18)
+ε
+where σ 2 is the variance of the gradient estimator at sample budget B; the 1/B variance reduction
+from B-sample averaging is incorporated into σ 2 via the per-phase variance formulas.
+Optimal allocation.
+under budget B is
+
+From Theorem 1 and Eq. (17), the minimum achievable estimator variance
+σ∗2 =
+
+!2
+
+1
+B
+
+X
+
+Nc
+
+p
+
+Vc
+
+Substituting into Eq. (18):
+
+(19)
+
+√ 
2 !
+Vc
+
+P
+
+c∈P Nc
+B · ε2
+
+∗
+
+T (ε) = O
+Uniform allocation.
+
+.
+
+c∈P
+
+.
+
+(20)
+
+Under bc = B/K for all K phases, the total estimator variance is
+2
+σuniform
+=
+
+X N 2 Vc
+c
+
+c∈P
+
+B/K
+
+KX 2
+Nc V c .
+B
+
+(21)
+
+
+2
+c∈P Nc Vc
+.
+B · ε2
+
+(22)
+
+=
+
+c∈P
+
+Substituting into Eq. (18):
+
+Tuniform (ε) = O
+Speedup ratio.
+
+K
+
+P
+
+Dividing Eq. (22) by Eq. (20):
+K
+Tuniform (ε)
+=
+T ∗ (ε)
+
+∆=
+
+X
+
+Nc2 Vc
+
+c∈P
+
+X
+
+!2 .
+
+Nc
+
+p
+
+(23)
+
+Vc
+
+c∈P
+
+By the Cauchy-Schwarz inequality,
+!2
+X
+
+p
+Nc Vc
+
+≤K
+
+c∈P
+
+X
+
+Nc2 Vc ,
+
+c∈P
+
+so ∆ ≥ 1, with equality if and only if all Nc2 V
+c are equal across phases. When variance concentrates
+P
+1
+2
+on few phases such that maxc Nc2 Vc ≫ K
+c Nc Vc , then ∆ ≫ 1: the optimal allocation yields
+substantially fewer convergence steps than uniform allocation at the same chunk budget B.
+B.2
+
+Bias Analysis of the Masked Estimator
+
+The masked objective in Eq. (11) omits the Nc /bc rescaling of the unbiased estimator (Eq. 14),
+trading a small bias for lower variance. We bound this bias.
+Lemma 3 (Bias of the masked estimator). Let pc denote the keep probability for phase c. The
+bias of the masked estimator relative to the unbiased estimator satisfies
+X
+X
+∥bias∥ =
+(1 − pc ) gc ≤
+(1 − pc ) ∥gc ∥.
+c∈P
+
+c∈P
+
+15
+
+Proof. Under weighted sampling without replacement with inclusion probability pc , the expected
+contribution of phase c to the masked estimator is pc · gc , while the unbiased estimator yields gc .
+Summing across phases and applying the triangle inequality gives the bound.
+√
+Under the allocation pc ∝ Vc , (1 − pc ) is large only when Vc is small, and by Lemma 1, small Vc
+implies ∥gc ∥ → 0. Each term in the bound is therefore suppressed by at least one small factor, so
+Theorem 1’s allocation remains approximately optimal under the biased estimator.
+
+C
+
+Methods We Tried That Did Not Work
+
+The motivating observation behind this paper was that VLA rollouts on a given task are remarkably
+similar across trajectories. Most timesteps execute nearly identical motion patterns regardless of
+whether the trajectory eventually succeeds. A reaching phase looks like a reaching phase across all
+rollouts; the divergence concentrates on a small number of decision points. This led us to hypothesize
+that gradient compute was being misallocated: the same per-step budget was being spent on phases
+that contributed little to the policy update as on phases that determined the outcome. Before arriving
+at PCM, we explored two alternative directions for exploiting this observation. Both failed, and the
+failures shaped the eventual design.
+C.1
+
+Branching at Decision Critical Timesteps
+
+Our initial approach attempted to increase the rollout signal at high-uncertainty points by branching:
+at each candidate decision point, fork the rollout into K alternative continuations to give GRPO more
+contrastive signal in the regions that mattered. Two problems made this infeasible. First, each branch
+required actually executing a downstream rollout in the simulator to be useful for GRPO, which
+meant returning to the branch point and continuing the simulation; this added significant rollout-side
+overhead and partially undid the efficiency motivation. Second, naive branching is exponential in
+depth, refining beyond the first branch point requires nested branching, and the rollout count grows
+as K d where d is the number of branches per trajectory. We found no principled way to bound depth
+without re-introducing the same uniform-allocation problem we were trying to escape.
+
+Figure 7: (a) Success vs. training steps for vanilla GRPO vs branching GRPO. (b) Action entropy
+over trajectory progress at different stages of training, showing weak alignment with outcome-critical
+phases. The training and evaluation follow the same procedures as Sec. 5.2
+.
+The lesson from this attempt was that any practical method had to operate within the existing rollout
+structure rather than expanding it. PCM instead reduces gradient computation over rollouts that have
+already been generated.
+C.2
+
+Entropy as a Signal to Concentrate Learning
+
+Our second attempt used per-chunk policy entropy as a proxy for "where the model has room to
+learn." The hypothesis was the standard one: high-entropy chunks indicate uncertainty, uncertainty
+indicates a learning opportunity, and concentrating gradient on these chunks should yield faster
+convergence. We expected that as training progressed, entropy would decrease in initially-uncertain
+chunks and the gradient allocation would naturally shift toward the remaining noisy regions.
+Two empirical findings led us to abandon this approach. First, entropy was poorly structured across
+trajectories: we did not observe consistent concentration on decision-critical phases the way we
+16
+
+Figure 8: Cumulative Cc captured as a function of the fraction of trajectory chunks retained, with
+chunks sorted in descending order by phase-level Cc . The solid curve shows the empirical cumulative
+Cc , while the dashed diagonal shows the uniform baseline under which Cc would scale linearly with
+chunk count. The gap between the two reflects the uneven distribution of learning signal across the
+trajectory: a small fraction of chunks captures a disproportionate share of the total Cc .
+eventually observed for Cc (Figure 1). Per-chunk entropy varied substantially across rollouts even
+within the same task and phase, and the high-entropy chunks did not align with the points where
+successful and failed rollouts actually diverged. We attribute this to the fact that VLA action
+distributions are typically already low-entropy after SFT. The supervised pretraining drives the policy
+toward confident, low-entropy actions, and the residual entropy reflects modeling noise rather than
+genuine multimodal uncertainty over correct behavior. Second, and more decisively, entropy did
+not meaningfully decrease over training. Across multiple runs on LIBERO, we measured per-chunk
+entropy at the start and end of GRPO fine-tuning and found negligible reduction. This is consistent
+with the known property that GRPO is a relatively weak signal for changing the underlying action
+distribution: the group-relative advantage primarily reweights existing modes rather than collapsing
+the policy onto a sharper one. Entropy under SFT-initialized policies is therefore close to a fixed
+property of the model rather than a quantity RL can drive down. Selecting on entropy would mean
+repeatedly allocating gradient to the same chunks throughout training regardless of whether they had
+become well-learned, and would not adapt to the shifting locus of the success–failure gap as training
+progressed.
+
+D
+
+Analysis of Chunk Budget
+
+The compute-signal trade-off. Choosing B reflects a trade-off between two opposing pressures.
+Lowering B reduces per-step gradient computation linearly: fewer chunks in the backward pass
+reduce activation memory and accelerate actor updates, which is the source of PCM’s wall-clock
+advantage. Increasing B captures more of the available learning signal: a larger budget includes more
+chunks from outcome-divergent phases and approaches the gradient quality of full-trajectory GRPO.
+The cumulative Cc curve in Fig. 8 is sharply concave: early chunks, corresponding to high-Cc phases,
+deliver disproportionate signal, while additional chunks beyond the knee contribute progressively
+less. The knee of this curve, the point at which marginal Cc capture per chunk drops sharply, occurs
+at approximately 20% of trajectory chunks. This concavity makes the trade-off non-trivial. Below the
+knee, each additional chunk yields substantial signal at fixed compute cost, so excluding it sacrifices
+accuracy for marginal speedup. Above the knee, each additional chunk yields diminishing signal at
+the same cost, so including it sacrifices speedup for marginal accuracy. The knee marks the point
+where these pressures balance: the smallest B for which captured Cc has largely saturated and further
+increases primarily incur additional compute cost.
+Budget range selection. The cumulative Cc curve in Fig. 8 is sharply concave, with a knee at
+approximately 20% of trajectory chunks. We compute captured Cc by ranking chunks according
+17
+
+to their phase score and measuring the fraction of total chunk-level score mass retained by the top
+B chunks. Beyond the knee, each additional chunk yields progressively smaller marginal gains in
+captured Cc . We select B ∈ {8, 12, 16} to bracket this knee, corresponding to 12%, 19%, and 25%
+of trajectory chunks, respectively.
+• B = 8 (12% of chunks, 50% of Cc captured): Below the knee. Tests whether aggressive
+truncation that falls short of the inflection leads to signal under-coverage and degraded final
+accuracy.
+• B = 12 (19% of chunks, 59% of Cc captured): At the knee. Tests the predicted operating
+point where Cc capture is high and marginal returns begin to flatten.
+• B = 16 (25% of chunks, 64% of Cc captured): Beyond the knee. Tests whether additional
+budget yields meaningful gains. The extra 5 percentage points of Cc capture over B = 12
+come at substantially higher per-step compute.
+The empirical sweep in Sec. 5.2 (RQ3) confirms this curvature: B = 8 underperforms in final
+accuracy, B = 16 matches B = 12 but at higher cost, and B = 12 emerges as the operating point
+consistent with the knee of the cumulative Cc curve.
+Choosing B for other domains. The knee of the cumulative Cc curve provides a principled
+approximation for B in any RL setting with a defined phase partition. The reasoning generalizes
+directly from the compute–signal trade-off: Cc is computed from rollouts that GRPO already produces,
+so the curve can be measured in any domain where outcomes are verifiable and rollouts decompose
+into phases. The structural assumptions of the method are therefore not specific to manipulation. The
+knee identifies the operating point at which the two pressures balance, independent of the absolute
+magnitude of Cc or the number of phases, because it is determined by the curvature of the signal.
+The procedure is the same across domains. For a target domain, compute Cc per phase from
+a single rollout group, plot the cumulative Cc curve as in Fig. 8, and select B at the knee, the
+smallest fraction of chunks at which captured Cc has largely saturated. The phase partition itself is
+domain-specific, such as gripper-state heuristics for manipulation, semantic decomposition for LLM
+reasoning, or episode segmentation for dialogue. Once defined, the curve and its knee are computed
+identically. Domains with sharper curvature, where signal concentrates in a few phases, admit smaller
+B and larger speedups. Flatter curves indicate more uniform signal and require larger B to capture
+comparable Cc , yielding smaller speedups. Only the resulting value of B varies; the selection rule
+remains unchanged.
+
+E
+
+Implementation Details
+
+This appendix provides additional experimental details omitted from the main text, including benchmark construction, training hyperparameters, PCM-specific settings, and evaluation protocol. Unless
+stated otherwise, PCM and the full-trajectory GRPO baseline use the same rollout, reward, advantage,
+optimizer, and evaluation configuration.
+E.1
+
+Benchmarks
+
+Models and Benchmarks. We evaluate on three LIBERO suites to cover diverse manipulation
+regimes and test generalization. LIBERO-Object tests object-centric pick-and-place, LIBEROSpatial tests spatial-relation following, and LIBERO-Goal tests goal-conditioned manipulation. The
+manipulation tasks are specified by natural-language instructions. The following examples illustrate
+the types of prompts used across the benchmarks:
+• Object-centric manipulation: “pick up the mug and place it in the bowl.”
+• Spatial manipulation: “place the object on the left side of the tray.”
+• Goal-conditioned manipulation: “move the object to the target location.”
+The policy receives the language instruction and RGB observation and predicts a sequence of 7-DoF
+end-effector actions. These suites vary in object identity, spatial layout, goal specification, and
+task structure, bringing diversity in manipulation regimes and causing phase-level failure patterns to
+18
+
+appear with different frequencies across benchmarks. Each benchmark contains 10 tasks with 50 trials
+per task under different initial object configurations, yielding 500 evaluation trials per benchmark.
+Trajectories contain a total of 64 chunks. During RL fine-tuning, we use visual augmentations such
+as brightness changes and image jitter to improve robustness.
+Training. Our method is implemented based on the SimpleVLA-RL verl pipeline [Sheng et al.,
+2025]. We initialize from the SimpleVLA-RL 1-trajectory SFT checkpoint, where OpenVLA-OFT
+is supervised-fine-tuned with one demonstration per task. We then perform RL fine-tuning with
+LoRA rank r=32 and α=32 on 2 NVIDIA H100 GPUs. We use a prompt batch size of 8 and sample
+10 rollouts per prompt, giving 80 trajectories per training step. The trajectory mini-batch size is
+4, and the PPO mini-batch size is 2 with micro-batch size 1. We optimize the actor with AdamW
+using a constant learning rate of 1 × 10−5 , (β1 , β2 ) = (0.9, 0.999), weight decay 0, and gradient
+clipping at 2.0. Following SimpleVLA-RL, we use one PPO epoch per update, asymmetric clipping
+(ϵlow , ϵhigh ) = (0.2, 0.4), entropy coefficient 10−3 , and disable the KL penalty. Rollouts are sampled
+with temperature 1.6, top-p = 1.0, and top-k = −1 without truncation.
+For PCM, we use a fixed chunk budget of B=12 chunks per trajectory. Phase keep probabilities
+are initialized from the success–failure phase scores Cc computed from the rollout group, and then
+recomputed every Trc =5 training steps from the recent phase-score buffer. We clip keep probabilities
+below by pmin =0.1, ensuring that low-variance phases are not completely discarded and preserving a
+small amount of exploration throughout training. Non-selected chunks are physically removed before
+the actor forward and backward pass. PCM is simple to integrate into existing GRPO pipelines: it
+only adds phase-score computation from rollout statistics and a chunk-shrinking step before the actor
+update. We use the same PCM hyperparameters across all benchmarks without task-specific tuning.
+E.2
+
+Phase Allotment Rules
+
+We assign trajectory chunks to semantic phases using a deterministic gripper-based heuristic. For each
+chunk j, we compute gf [j] ∈ [0, 1], the fraction of timesteps in the chunk where the gripper-close
+command is active. We use a sustained-close threshold τ = 0.75 to locate grasp intervals, and then
+assign phase labels around those intervals.
+• Active-grip. Chunks with substantial gripper closure are labeled active-grip. We use a
+softer threshold gf [j] ≥ 0.5 for labeling, so this phase includes both sustained grasp chunks
+and nearby partial-close chunks. In successful rollouts, this covers grasp and transport while
+the object is held, or recovery after drop; in failed rollouts, it can also capture drops, re-grasp
+attempts, or repeated failed closure near the object.
+• Pre-grasp. Up to three chunks immediately before a sustained-close interval are labeled
+pre-grasp when the gripper has begun closing but has not yet reached sustained closure
+(0.1 ≤ gf [j] < 0.5). This phase often captures final alignment and orientation adjustment
+before contact.
+• Release-ramp. Up to three chunks immediately after a sustained-close interval are labeled
+release-ramp (gf [j] < 0.5), capturing the transition from holding the object to releasing
+it. This phase is important when failures occur because the object is released at the wrong
+location or does not fall into the target bin.
+• Approach. Chunks before the pre-grasp/active-grip region of a grasp cycle are labeled
+approach (gf [j] < 0.5), corresponding to navigation toward the object.
+• Tail Chunks after the final release with an open gripper are labeled tail (gf [j] < 0.1). These
+often capture post-release behavior, including cases where the object was not successfully
+placed and the policy continues hovering or moving after release or attempts.
+The unified phase set is resolved by priority:
+active-grip > pre-grasp > release-ramp > approach > tail
+When multiple phase rules apply due to overlapping windows, we assign the highest-priority label.
+Phases are distinguished first by their position relative to sustained-close intervals and then by the
+gripper thresholds above: open-gripper chunks before a future grasp attempt are approach, whereas
+open-gripper chunks after the final release-ramp window (after a sustained grasp interval) are tail.
+19
+
+Figure 9: Successful and failed manipulation rollouts look similar for most of the trajectory, diverging
+mainly around outcome-critical grasp phases.
+Since labels are assigned at the chunk level, averaging the gripper command over the chunk reduces
+sensitivity to single-timestep noise and makes the thresholding rule more stable.
+The same rule is applied to successful and failed trajectories. The terminal success label is never used
+by the phase classifier, so Cc compares success and failure trajectories under a shared phase partition.
+The labeling rule is lightweight, requires no learned phase model, and adds no inference overhead.
+Other phase allocators, such as task-specific heuristics, temporal semantic phase segmenters, or
+LLM-based labelers, could be used when gripper state is insufficient.
+Phase-based failure localization: Figure 9 illustrates how common failures fall naturally into
+this phase partition. In a missed-grasp failure, the robot may approach the object similarly to
+successful rollouts but close with poor alignment. The closing chunks are labeled active-grip, while
+the immediately preceding orientation-adjustment chunks are labeled pre-grasp. This explains why
+both pre-grasp and active-grip can receive high Cc : the failure may be caused not only by the closure
+itself, but also by the pose and alignment right before contact. After such failures, however, many
+remaining chunks are downstream consequence states (hovering, searching, colliding, or moving
+without the object) which are typically labeled tail. These chunks can occupy a large fraction of
+failed rollouts, but they are less causally informative than the contact error that produced them. PCM
+therefore keeps them with low nonzero probability while concentrating budget on the grasp phases
+that prevent the policy from entering these failed states.
+Other failures are captured by the same heuristic without additional case rules. If the object is
+grasped but later dropped or repeatedly re-grasped during transport, the corresponding close/hold
+chunks remain active-grip, making this phase sensitive to transport instability. These chunks provide
+useful RL signal by penalizing slips, failed recovery and unstable holds while rewarding successful
+recovery. If the grasp succeeds but placement fails, the error appears around release-ramp: the
+robot releases at the wrong location or the object misses the bin, making its Cc moderately high.
+Subsequent tail chunks mostly capture open-gripper hovering after release, and are therefore less
+outcome-discriminative and provide little learning signal. When computing Cc , we compare only
+phases that contain both successful and failed samples in the rollout group; phases absent from
+one outcome group in a batch are skipped for that update. In the observed rollout groups, failures
+often diverge during active-grip, making it the most outcome-discriminative phase and causing Cc to
+become largest there. This concentration emerges automatically from the gripper-based phase labels
+and rollout outcomes, without hand-designed phase weights or task-specific tuning.
+
+20
+
+