ChunkFlow: Towards Continuity-Consistent Chunked Policy Learning
Abstract: Vision-language action (VLA) models increasingly adopt chunked action heads to satisfy real-time constraints; however, this introduces boundary jitter: overlapping regions between consecutive chunks often yield inconsistent predictions, degrading temporal coherence and the task success rate. Existing methods, such as inference-time blending, merely reweight mismatched proposals without correcting underlying errors, leading to residual accumulation under biased or noisy histories. We propose ChunkFlow, a seam-aware training-and-execution framework for chunked policies that aligns chunk structure with boundary execution. It partitions each chunk into frozen, editable, and future zones, applies deterministic overlap blending at execution, and trains raw predictions with seam and first- and second-order continuity losses. History corruption and scheduled sampling improve robustness to executed-history errors, while an AWAC fine-tuning stage adapts the policy without removing these structural regularizers. Under mild smoothness assumptions, pre-blending seam discrepancies provably decay with increasing overlap. Experiments on CALVIN, LIBERO, and real robots show an improved success-stability trade-off with low-latency inference. Project page: https://cytoderm-ai.github.io/chunkflow.
Paper Prompts
Sign up for free to create and run prompts on this paper.
Top Community Prompts
Explain it Like I'm 14
A simple explanation of “ChunkFlow: Towards Continuity-Consistent Chunked Policy Learning”
What is this paper about?
Robots that follow human instructions often use “vision–language–action” (VLA) models: they look at a camera, read a short instruction (like “pick up the blue block”), and output a sequence of moves. To run fast in the real world, many of these models plan in small batches of actions called “chunks.” But there’s a problem: when one chunk ends and the next begins, the actions can disagree at the join, causing a little shake or jump in motion—like a video with a bad cut. This paper introduces ChunkFlow, a way to make those joins smooth and consistent so the robot moves more steadily and succeeds more often.
What questions are the researchers trying to answer?
- How can we keep robot motions smooth when plans are made in chunks?
- Can we fix the “seams” between chunks so actions agree instead of fighting each other?
- Can we train the robot to handle messy histories (past actions that weren’t perfect) and still stay smooth?
- Can we let the robot learn from rewards (do more of what works) without losing that smoothness?
How does ChunkFlow work? (In everyday terms)
Think of a robot’s plan as a playlist of moves. Instead of playing one long song, it’s lots of short tracks (chunks) that overlap a bit. If two tracks don’t match at the overlap, you hear a glitch.
ChunkFlow tries to make that overlap sound like a clean crossfade:
- It splits each chunk into three parts:
- Frozen zone: already committed; don’t touch it.
- Editable seam: the overlap where we carefully blend with the previous chunk.
- Future zone: the next steps that will become the next chunk’s overlap later.
- At the seam, it blends the old and new actions in a simple, predictable way (like a crossfade in audio). No extra heavy computation is needed—just mix at the overlap.
- It trains the robot to naturally produce chunks that match at the seams:
- “Seam loss” teaches the model to make the overlapping parts agree.
- “Continuity losses” gently push the motion to avoid sudden changes in speed or direction, making movements smooth.
- It practices with imperfect histories:
- Sometimes the robot’s past actions aren’t perfect. During training, ChunkFlow adds noise or swaps in executed actions so the model learns to handle real-world messiness.
- It fine-tunes with rewards (AWAC):
- After learning from demonstrations, the robot also learns which actions lead to success, but it keeps the smoothness and seam rules so it doesn’t become jerky again.
A helpful analogy:
- Seam-aware blending = crossfading two songs so the transition is smooth.
- Continuity losses = telling a driver to keep speed and steering changes gentle.
- History corruption = practicing on a bumpy road so you can handle bumps later.
- AWAC fine-tuning = learning which routes get you to your destination faster without driving erratically.
What did they find, and why does it matter?
The team tested ChunkFlow in three places:
- CALVIN: a standard robotics benchmark with multiple-step tasks.
- LIBERO: very long, multi-part tasks that test how well models handle long sequences.
- Real robots: tasks like picking a cloth strip from a stack and inserting a block into a tight slot.
Main takeaways:
- Smoother motion: ChunkFlow reduced jitter and high-frequency “twitchiness” in the robot’s movements, including smoother velocity, acceleration, and jerk (how quickly acceleration changes).
- Fewer seam glitches: The overlaps between chunks agreed more, so the robot didn’t “fight with itself” at boundaries.
- Stronger success rates: It matched or beat strong baselines, including on long, tricky tasks (e.g., over 93% success on LIBERO; 9/10 successes on real robots).
- Low delay: It kept inference (decision-making) fast—only around 4–5 milliseconds per action on average—so it works in real time.
- Better than quick fixes: Simply smoothing at test time (without training the model to respect seams) wasn’t enough. ChunkFlow’s training-time seam awareness led to better stability and success.
Why this matters:
- Smooth, consistent movement is essential for safe, reliable robots—especially when they make many decisions quickly.
- The method works “under the hood,” so it can pair with many different robot brains (VLA backbones) without slowing them down.
What could this change in the future?
- More reliable robots: Smoother execution means fewer dropped objects, slips, or misalignments—helpful in homes, warehouses, and factories.
- Safer interactions: Less jitter means more predictable motion around people and delicate objects.
- Better long tasks: Because the seams are handled well, robots can do long, multi-step chores without accumulating errors.
- Easy to adopt: The idea sits between planning and doing, so it can improve many existing systems without redesigning everything.
In short, ChunkFlow teaches robots to “stitch” short plans together smoothly, resulting in steadier, safer, and more successful actions—without sacrificing speed.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a concise list of unresolved issues and open directions that future work could address.
- Lack of adaptive seam design: no mechanism to learn or adapt the overlap length , chunk length , or frozen-zone length online based on task dynamics, error signals, or latency constraints.
- Fixed linear blending: blending uses a fixed linear schedule in Euclidean action space; no study of learned, state-dependent, or dynamics-aware blending policies (e.g., ease-in/out, jerk-minimizing, model-based weights).
- Manifold-consistent interpolation: action blending for orientations or poses is done in Euclidean coordinates; no evaluation or method for SE(3)/SO(3)-aware interpolation (e.g., quaternion slerp, Riemannian metrics) or per-dimension anisotropic weighting.
- Hybrid/discrete actions: the framework targets continuous actions; it does not address discrete or mixed action spaces (e.g., gripper open/close, skill switches) where smoothing may be inappropriate or cause delays.
- Constraint-aware execution: there is no incorporation of joint/velocity/torque limits, collision constraints, or contact-safe blending that prevents intermediate infeasible or unsafe commands.
- Safety during RL fine-tuning: beyond gradient clipping and BC anchoring, there is no formal safety mechanism (e.g., control barrier functions, safe sets, Lyapunov constraints) to guarantee constraint satisfaction during exploration/adaptation.
- Theory gaps and assumptions: the seam error scaling result and long-horizon bound rely on “mild” Lipschitz/contractive assumptions; conditions for ensuring (contraction), impacts of observation noise, nonstationarity, and contact dynamics are not analyzed or proven.
- End-to-end gradient flow across chunks: the use of stop-gradient for boundary alignment avoids cyclic dependencies but also blocks cross-chunk credit assignment; it remains open how to train end-to-end across boundaries without instability.
- Credit assignment with blending in RL: critics are trained on post-blended actions while the actor is regularized on raw predictions, potentially introducing off-policy bias; the effect on value estimation, credit assignment, and stability is unexamined.
- Limited ablations on training knobs: scheduled sampling ratio , history dropout rate , and frozen-zone length are introduced but not systematically ablated; no guidance on robust defaults or automatic tuning.
- Unspecified regularizer details: a “sparsity prior” is varied in ablations but not defined in the method, leaving ambiguity about its form, purpose, and implementation.
- Robustness beyond action-history noise: history corruption covers past actions, but robustness to observation noise, occlusions, camera latency/asynchrony, calibration drift, or multi-sensor fusion is not evaluated.
- Domain shift and real-world breadth: real-robot evaluation covers two tasks with limited trials; robustness under broader domains (lighting, materials, surfaces), longer deployments, and statistical significance is not established.
- High-speed and non-smooth tasks: continuity regularization may hinder tasks requiring deliberate discontinuities or fast impulses; the method is not evaluated on dynamic/impact-rich or time-critical maneuvers.
- Control-layer interaction: the interaction of ChunkFlow’s blended commands with low-level controllers (e.g., PID, impedance) and potential side-effects (e.g., integrator wind-up, delay amplification) is not characterized.
- Frequency/time scaling: smoothness is assessed at a fixed control rate; how results transfer across different control frequencies, variable-rate controllers, or time-scaling policies is unexplored.
- Dimension-wise weighting: all action dimensions are regularized uniformly; optimal per-dimension or task-adaptive weighting (e.g., rotations vs translations vs gripper) is not investigated.
- Terminal/episode edges: handling of chunk boundaries near episode termination (e.g., incomplete overlaps, stop conditions) is not specified, and the impact on final-step stability is not measured.
- Data/backbone dependence: although claimed backbone-agnostic, the approach is not validated across multiple VLA backbones within the same framework to confirm plug-and-play generality and data efficiency.
- Computational resource profile: while inference latency is reported, memory footprint (e.g., storing multiple chunks), embedded/edge deployment feasibility, and training-time compute/memory costs are not quantified.
- Automatic hyperparameter selection: there is no meta-optimization or principled criterion for choosing , , , , , , , balancing smoothness and task success across tasks.
- Observation windowing: the effect of overlapping observation windows () on seam consistency, perception lag, and error accumulation is not dissected.
- Compatibility with world models/hierarchy: integration with world-model planning or hierarchical skills (where seams could occur at skill boundaries) is not evaluated; cross-skill seam consistency remains open.
- Evaluation metrics vs physical outcomes: smoothness metrics are based on action differences and spectra; there is no measurement of physical consequences (e.g., contact forces, energy, wear) or user/task-level utility of the reduced jitter.
Practical Applications
Practical Applications of ChunkFlow
Below, we translate the paper’s findings into concrete, real-world applications, organized by deployment horizon. Each item notes sector(s), potential tools/products/workflows, and key assumptions/dependencies that affect feasibility.
Immediate Applications
These can be prototyped or deployed now with modest engineering, assuming access to a chunked policy (e.g., VLA or diffusion/flow policy) and basic training infrastructure.
- Smoother, safer arm motion in industrial manipulation
- Sectors: manufacturing, electronics assembly, automotive
- What: Drop-in “seam-aware chunk executor” to reduce boundary jitter in pick-and-place, insertion, and assembly tasks; lowers jerk, rework, and contact-induced defects.
- Tools/products/workflows: ROS 2 controller plugin implementing deterministic overlap blending; training recipe that adds seam loss + first-/second-order continuity losses; optional AWAC fine-tuning on on-site data; deployment at low ARL (~5–10 ms/action on edge GPUs).
- Assumptions/dependencies: Existing policy produces chunked actions with overlap (O>0); access to small amounts of demonstration logs for behavior cloning and optional sparse success signals for AWAC; real-time control loop supports linear blending without violating safety interlocks.
- Robust warehouse picking and packing under layout shifts
- Sectors: logistics, e-commerce fulfillment
- What: Replace or augment heuristic smoothing with seam-aware training to stabilize grasping and bin-picking with changing bin states.
- Tools/products/workflows: Fine-tuning existing VLA (e.g., OpenVLA/Seer/PI0.x) with seam and continuity regularization; monitoring with Bjump/Bratio/HF_ratio to gate rollouts and trigger re-plans.
- Assumptions/dependencies: RGB-D or stereo vision with instruction/context input; chunked action head; continuous control of gripper/arm.
- Contact-sensitive insertion and alignment
- Sectors: manufacturing, consumer electronics, precision assembly
- What: Reduce micro-jitter when aligning pegs, connectors, or press-fit parts; lower damage risk and cycle variability.
- Tools/products/workflows: Offline BC with continuity losses; online AWAC fine-tuning on sparse success; use of “frozen/editable/future” zones to commit stable sub-chunks while adapting the seam.
- Assumptions/dependencies: Calibrated controllers with torque/force limits; low-latency sensor feedback; small overlap (e.g., O=4–8) validated for task dynamics.
- Assistive and service robotics with gentler motion
- Sectors: healthcare, eldercare, hospitality, domestic robotics
- What: Smoother motion in tasks like fetching, surface wiping, folding, and unloading; reduced risk from abrupt maneuvers in proximity to humans.
- Tools/products/workflows: Edge-deployed VLA with seam-aware executor; real-time safety layer that halts on Bjump spikes; continuity-regularized training with history corruption to handle noisy teleop or user-issued corrections.
- Assumptions/dependencies: Human-robot interaction safeguards, compliance control; local reward proxies (task completion) for AWAC; regulatory expectations for near-human operation.
- Teleoperation stabilization layer
- Sectors: field robotics, maintenance, nuclear/energy, offshore
- What: Smooths operator command streams by chunking-and-blending action proposals; mitigates latency and operator-induced jitter.
- Tools/products/workflows: EMA + overlap blending of operator-conditioned policy chunks; post-blending history fed back to the policy for stability; alarms when seam discrepancy exceeds thresholds.
- Assumptions/dependencies: Operator-in-the-loop latency budget; calibrated chunk length (L) and overlap (O) per task.
- Energy and wear reduction via jerk control
- Sectors: manufacturing, mobile manipulation
- What: Lower high-frequency actuation (jerk) to reduce energy consumption and actuator wear while preserving throughput.
- Tools/products/workflows: Integrate MSD-Δa/Δ²a/Δ³a and TV-L1 as plant KPIs; continuity losses during training; watchdog that throttles aggressive control if HF_ratio rises.
- Assumptions/dependencies: Access to power/torque telemetry; willingness to trade minor speed for longevity.
- Safety monitors and acceptance testing
- Sectors: cross-industry robotics QA, certification labs
- What: Use Bjump, Bratio, HF_ratio, and TV-L1 as acceptance criteria for control smoothness and boundary integrity.
- Tools/products/workflows: “SeamMonitor” tool to score trials; CI pipelines that fail deployments when seam metrics regress; dashboard for temporal spectrum monitoring.
- Assumptions/dependencies: Access to action logs; agreed metric thresholds per task; baseline comparisons.
- Academic benchmarking and reproducible evaluation
- Sectors: academia, open-source robotics
- What: Standardize seam consistency metrics and ablations across CALVIN/LIBERO-like tasks; isolate effects of overlap and chunk length.
- Tools/products/workflows: Open-source training code for seam/continuity losses; scripts for Bjump/Bratio/HF_ratio; baselines with O∈{0,2,4,8}, L∈{8,10,12}.
- Assumptions/dependencies: Dataset availability; compute for BC + AWAC; open licensing for baselines.
- Sim-to-real stabilization
- Sectors: robotics R&D
- What: Use history corruption and continuity regularization to reduce sim-to-real action aliasing at deployment.
- Tools/products/workflows: Domain randomization plus seam-aware training; staged fine-tuning on small real datasets with sparse rewards.
- Assumptions/dependencies: Reasonably matched action spaces; minimal dynamics gap or robust low-level controllers.
- Software SDK for seam-aware policies
- Sectors: software, robotics platforms
- What: “ChunkFlow SDK” that wraps existing chunked policies with: zone partitioning (frozen/editable/future), deterministic overlap blending, seam and continuity losses, and AWAC fine-tuning utilities.
- Tools/products/workflows: Python/PyTorch package; ROS 2 nodes; metrics visualizer; converters for OpenVLA/GR2/PI0.x/Octo/TraceVLA.
- Assumptions/dependencies: Access to model internals (action head outputs and histories); training pipeline to incorporate new losses.
Long-Term Applications
These require additional research, scaling, certification, or broader ecosystem adoption.
- Standardized “continuity compliance” in robotics safety and procurement
- Sectors: policy, certification, public-sector procurement
- What: Formalize motion-continuity metrics (Bjump/Bratio/HF_ratio) in tender specs and safety audits; require seam-aware training for controllers operating near humans.
- Tools/products/workflows: ISO/IEC-like technical reports; reference test suites; compliance badges.
- Assumptions/dependencies: Consensus on metric thresholds; cross-vendor test harnesses; longitudinal incident data linking jitter to risk.
- Surgical and clinical robotics with continuity guarantees
- Sectors: healthcare
- What: Apply seam-aware chunked control to minimize micro-jitter in delicate maneuvers (suturing, end-effector alignment).
- Tools/products/workflows: Rigorous verification of blending under kinematic and force constraints; formal jerk/acceleration bounds; clinical trials.
- Assumptions/dependencies: Regulatory approval; fault tolerance in case of sensor/vision dropouts; clinically validated datasets.
- Human-interactive prosthetics and exoskeletons
- Sectors: healthcare, rehabilitation
- What: Continuity-consistent controllers that provide smooth assistive torques and reduce oscillations at transition boundaries.
- Tools/products/workflows: On-body inference with low-latency blending; user-in-the-loop rewards (comfort/fatigue proxies) for AWAC.
- Assumptions/dependencies: High-rate biosignals; strict safety envelopes; extensive user testing.
- Multi-robot coordination with cross-agent seam alignment
- Sectors: manufacturing cells, construction, agriculture
- What: Align chunk boundaries not only over time, but also across robots, to avoid collisions and deadlocks at shared seams of joint tasks.
- Tools/products/workflows: Multi-agent “global seam” blending policies; shared post-blending histories; joint AWAC training with expectile critics per agent.
- Assumptions/dependencies: Time-synchronized clocks; reliable inter-robot comms; shared reward design.
- Autonomous driving and aerial robotics planners with chunk-aware smoothing
- Sectors: transportation, UAVs
- What: Integrate seam-aware chunking in trajectory planners to reduce jerk and oscillation at plan-update boundaries (replanning seams).
- Tools/products/workflows: Adapter layer between MPC/RL planners and actuators; boundary continuity losses in policy/planner training.
- Assumptions/dependencies: Real-time guarantees under tight latency; integration with vehicle dynamics and safety constraints; extensive validation.
- Hardware–software co-design for “seam-aware” motor control
- Sectors: robotics hardware, servo/control vendors
- What: Servo controllers exposing overlap-aware blending and continuity constraints natively (e.g., jerk-limited blending windows).
- Tools/products/workflows: Firmware support for blending weights; APIs for passing chunk zones; joint identification of optimal O/L under plant dynamics.
- Assumptions/dependencies: Vendor support; standardization across drives; compatibility with existing safety PLCs.
- Foundation robotic models trained with structural continuity priors at scale
- Sectors: generalist robotics, platforms
- What: Make seam and derivative regularization first-class in pretraining (analogous to language modeling’s next-token losses), improving long-horizon reliability across tasks/devices.
- Tools/products/workflows: Large-scale VLA training with overlap-exposed datasets; curriculum over O/L; distributed AWAC fine-tuning with expectile critics.
- Assumptions/dependencies: Massive, diverse datasets with action histories; compute budgets; unified logging formats.
- Cross-domain time-series “chunk compilers”
- Sectors: finance (execution algos), energy (grid control), animation/CGI
- What: Generalize seam-aware chunking to any continuous control or signal synthesis where overlapping windows create boundary artifacts.
- Tools/products/workflows: Domain-specific seam losses (e.g., risk-aware in finance, ramp limits in energy); validators for spectral artifacts and boundary mismatches.
- Assumptions/dependencies: Availability of chunked predictors; domain-appropriate reward signals and safety limits; careful evaluation to avoid over-smoothing critical responses.
- Continual learning with seam-aware stability constraints
- Sectors: field robotics, maintenance/inspection
- What: On-device policy updates that preserve boundary smoothness over time despite distribution drift, using KL anchoring + continuity regularization.
- Tools/products/workflows: Scheduled sampling and history corruption adapted to new environments; seam metrics as regularizers during continual updates.
- Assumptions/dependencies: Safe on-robot learning frameworks; drift detection; rollback mechanisms.
Notes on Assumptions and Dependencies
- Architectural: Requires a chunked action head with overlap (O>0) and the ability to expose per-step raw predictions for loss computation and blending.
- Training data: Behavior cloning needs demonstration trajectories; AWAC fine-tuning benefits from sparse/terminal rewards or success events.
- Real-time constraints: Deterministic overlap blending is near-zero overhead, but perception and policy inference must meet control-rate deadlines; edge GPUs are often necessary.
- Safety: While continuity reduces jitter, it does not replace collision avoidance, force/torque limits, or formal safety certification.
- Generalization: Validated on CALVIN, LIBERO, and two real tasks; broader domains (e.g., surgery, AVs) need domain-specific validation and constraints.
- Tuning: Overlap (O) and chunk length (L) must be calibrated per task to avoid aliasing or over-extrapolation; regularization weights (TV, D2, boundary) require moderate settings to prevent phase lag or drift.
Glossary
- 6-DoF: Six degrees of freedom; in robotics, the number of independent motions (3 translational, 3 rotational) of an arm or end-effector. "a 6-DoF collaborative arm"
- Advantage: In actor–critic RL, the relative value of an action compared to the baseline value, guiding policy updates. "The resulting advantage informs a clipped exponential update weight:"
- Advantage-Weighted Actor-Critic (AWAC): An RL algorithm that performs behavior-cloning-like updates weighted by estimated advantages. "AWAC~\cite{nair2020awac} with expectile critics~\cite{kostrikov2021iql} adapts the policy"
- Aliasing: Undesired high-frequency artifacts due to insufficient temporal resolution or improper stitching of segments. "increasing overlap improves pre-blending agreement and suppresses aliasing:"
- Amortized Reasoning Latency (ARL): The average inference time per executed action when actions are produced in chunks. "we report the Average Reasoning Latency (ARL), the amortized cost per executed action:"
- Autoregressive: A modeling approach that predicts the next output conditioned on previously generated outputs. "including classic BC/RL, diffusion-based, and autoregressive VLA models."
- Behavior Cloning (BC): Imitation learning by supervised fitting of policy actions to expert demonstrations. "Classic BC / RL Baselines"
- Bjump: A seam-consistency metric measuring mean discrepancy in overlapping regions between chunks. "Seam consistency is evaluated via Bjump, the mean discrepancy in the overlap region"
- Boundary jitter: Rapid, inconsistent action changes at chunk boundaries that degrade smoothness. "this introduces boundary jitter: overlapping regions between consecutive chunks often yield inconsistent predictions"
- Boundary loss: A training penalty encouraging agreement of actions in the overlap between consecutive chunks. "we introduce a boundary loss:"
- Bratio: A normalized seam-consistency metric dividing boundary discrepancy by overall action magnitude. "and Bratio, its normalization by"
- Butterworth (low-pass) filter: A signal-processing filter with maximally flat frequency response in the passband, used to smooth signals. "Butterworth (low-pass)"
- Chunk (action chunking): Producing short sequences of actions per decision step to reduce latency and enforce temporal structure. "modern VLA architectures typically employ action-chunking heads"
- Cubic spline: A smooth piecewise-polynomial curve used for post-hoc trajectory smoothing or interpolation. "Cubic spline"
- Deterministic overlap blending: A parameter-free interpolation of actions across chunk overlaps to ensure smooth transitions. "aligning BC and RL updates with deterministic overlap blending"
- End-effector (EE): The tool or gripper at the end of a robotic arm that interacts with the environment. "EE roll-angle traces over the first 200 steps"
- Entropy bonus: A regularizer in RL that encourages policy exploration by maximizing action entropy. "the KL regularizer and entropy bonus stabilize fine-tuning."
- Exponential moving average (EMA): A recursive smoothing of signals giving more weight to recent values. "EMA filtering"
- Expectile: A risk-sensitive statistic (asymmetric analog of quantiles) used for value fitting or weighting in RL. "defines the asymmetric expectile weight."
- Exposure bias: A mismatch between training on ground-truth histories and testing on model-generated histories. "reduce exposure bias."
- Fourier transform: A decomposition of a signal into its frequency components, used to analyze spectral energy. "with the Fourier transform."
- Gradient clipping: A stabilization technique limiting gradient norms to prevent exploding updates. "with gradient clipping and imitation anchoring."
- High-frequency energy ratio (HF_ratio): The fraction of spectral power in a predefined high-frequency band, indicating jitter. "Spectral artifacts are measured by high-frequency energy ratio HF_ratio"
- History corruption: Injecting noise or dropout into the action history during training to improve robustness. "we apply stochastic corruption to the history during training:"
- Imitation anchoring: Regularizing RL fine-tuning toward demonstration-like behavior to maintain stability. "with gradient clipping and imitation anchoring."
- Jerk: The third derivative of position (rate of change of acceleration), penalized to reduce abrupt motion changes. "jerk penalties"
- Kullback–Leibler (KL) divergence: A measure of discrepancy between probability distributions, used as a regularizer. "the KL regularizer"
- Lipschitz continuity: A bounded-sensitivity property of functions; small input changes cause proportionally small output changes. "Under local Lipschitz continuity of "
- Mean squared differences (MSD): Discrete-time squared finite-difference metrics for velocity, acceleration, and jerk smoothness. "mean squared differences: MSD-$\Delta a ="</li> <li><strong>Overlap region (O)</strong>: Shared time steps between consecutive chunks used to blend actions for smooth seams. "Overlapping chunk boundaries ($O{>}0$) allow for smoother transitions"</li> <li><strong>Pareto frontier</strong>: The set of solutions that are not dominated in multi-objective trade-offs (e.g., success vs. smoothness). "ChunkFlow lies on the Pareto frontier"</li> <li><strong>Power spectral density (PSD)</strong>: The distribution of signal power over frequency, used to quantify spectral smoothness. "power spectral density (PSD)"</li> <li><strong>Scheduled sampling</strong>: Gradually replacing ground-truth inputs with model predictions during training to mitigate exposure bias. "History corruption and scheduled sampling improve robustness"</li> <li><strong>Seam-aware</strong>: Explicitly modeling and training with chunk boundaries to ensure cross-chunk consistency. "a seam-aware training-and-execution framework"</li> <li><strong>Seam discrepancy</strong>: The difference between overlapping actions predicted by consecutive chunks. "We define the seam discrepancy in the overlapping region as"</li> <li><strong>Stop-gradient</strong>: An operation preventing gradients from flowing through a variable during backpropagation. "where sg denotes stop-gradient"</li> <li><strong>Temporal-difference regression</strong>: A value-learning method that regresses toward bootstrap targets from subsequent states. "trained via temporal-difference regression"</li> <li><strong>Total variation (TV-L1)</strong>: An L1 penalty on first-order differences to encourage piecewise-smooth trajectories. "Total variation TV-L1 = $\tfrac{1}{T} \sum_t \|a_t - a_{t-1}\|_1$"
- Warm start: Initializing a model or latent state using previous-step solutions to improve stability or convergence. "warm-started chunk latents."








