Technical Summary: Muninn: Your Trajectory Diffusion Model But Faster

Problem Statement

Diffusion-based trajectory planners have become state-of-the-art for generating rich, multimodal robot motions in complex environments. However, their reliance on iterative denoising processes makes them computationally expensive, often rendering them too slow for real-time online planning and control, particularly on embedded platforms or high-rate control loops.

Existing acceleration strategies generally fall into two categories, both of which have significant drawbacks:

1. Model Modification: Distilling the diffusion process into shallower networks or training early-exit policies. These approaches require retraining for each architecture or task, often sacrificing trajectory quality and multimodal coverage.
2. Heuristic Inference Acceleration: Methods that skip steps or reuse cached outputs based on simple metrics (e.g., pixel-space similarity). These often lack guarantees on how approximation errors propagate through the sampler to affect the final trajectory, potentially leading to unsafe or brittle failures in closed-loop control.

The core challenge is to accelerate diffusion-based planners by reusing internal computations without retraining the model, without sacrificing trajectory quality, and with rigorous guarantees on how much the accelerated trajectory deviates from the full-compute counterpart.

Methodology: The Muninn Framework

The authors propose Muninn, a training-free caching wrapper that operates at inference time. Muninn does not modify the underlying diffusion model weights or the sampler architecture. Instead, it exploits two inherent signals in trajectory diffusion planners to make adaptive decisions on when to reuse cached denoiser outputs and when to recompute them.

1. Theoretical Foundation: Error Propagation and Sensitivity

Muninn is grounded in a theoretical analysis of how local errors in the denoiser output propagate through the reverse diffusion process.

• Paired Process Analysis: The authors analyze a "paired run" where a full-compute chain and a cached chain share the same initial noise and sampler noise but differ in denoiser outputs.
• Lipschitz Sensitivity: They establish that the sampler update $\Phi_t$ satisfies a local Lipschitz property. This allows them to derive a closed-form bound on the final trajectory deviation $\|\Delta_0\|$ as a weighted sum of per-step denoiser errors $\|e_t\|$:
  $$\|\Delta_0\| \le \sum_{t=1}^T L_t \|e_t\|$$
  Here, $L_t$ represents the pathwise sensitivity coefficient, quantifying how much an error at step $t$ is amplified by subsequent sampler updates. Early steps often have higher sensitivity ($L_t$) than later steps.

2. The Two Signals

To operationalize this bound without knowing the true error $\|e_t\|$ (which requires a full recomputation), Muninn utilizes two signals:

• Signal A: Cheap Probe of Representation Change. Modern denoisers decompose into a cheap "stem" (input processing) and an expensive "core." Muninn computes a lightweight probe feature $F_t$ from the stem at every step. The score $s_t$, defined as the relative change in probe features between consecutive steps ($s_t \propto \|F_t - F_{t+1}\|_1$), serves as a low-cost indicator of trajectory stability. Small changes suggest the denoiser output would not change significantly if recomputed.
• Signal B: Analytic Sensitivity Coefficients. The coefficients $L_t$ are derived analytically from the sampler's update equations (e.g., DDPM or DDIM coefficients), independent of the specific model weights.

3. Conformal Calibration and Budgeting

Muninn bridges the gap between the cheap probe score $s_t$ and the unknown error magnitude $\|e_t\|$ using split-conformal prediction:

• Offline Calibration: Using a small set of offline episodes, the system runs a "ghost" chain that simulates a fixed reuse pattern. It records pairs of $(s_t, \epsilon_t)$, where $\epsilon_t$ is the actual error magnitude incurred by reusing a cached output.
• Conformal Envelope: A regressor maps scores to error magnitudes, and conformal prediction constructs a high-probability upper bound $U(s_t)$ such that $P(\epsilon_t \le U(s_t)) \ge 1 - \alpha_{step}$.
• Online Budgeting: At runtime, Muninn maintains a trajectory-level deviation budget $\eta_{traj}$. At each step, it calculates an upper-bounded cost $\hat{c}_t(s_t) = \Gamma L_t U(s_t)$.
  • If $\hat{c}_t(s_t)$ fits within the remaining budget, Muninn reuses the cached denoiser output.
  • Otherwise, it recomputes the denoiser.
  • This ensures that the sum of upper-bounded costs for all reused steps stays within $\eta_{traj}$, providing a rigorous guarantee that the final trajectory deviation will not exceed $\eta_{traj}$ with probability $1-\alpha$.

Key Contributions

1. Muninn Algorithm: A training-free, architecture-agnostic caching policy that adaptively reuses denoiser outputs based on a calibrated uncertainty budget.
2. Theoretical Guarantees: A derivation of trajectory-level risk bounds that account for the non-uniform sensitivity of diffusion steps, ensuring that the accelerated trajectory remains within a user-specified distance of the full-compute trajectory with a guaranteed confidence level.
3. Runtime Certificates: The method provides an online, interpretable "deviation certificate" ($\hat{D}$) that tracks how much of the deviation budget has been spent, enabling runtime escalation strategies (e.g., switching to full compute or damping actions) when the risk becomes too high.
4. Comprehensive Evaluation: Validation across diverse domains including offline RL (D4RL), configuration-space motion planning, and visuomotor policies, as well as real-world hardware deployments on marine, aerial, and manipulator robots.

Experimental Results

The paper reports significant speedups while preserving task performance and safety:

• Speedup: Muninn achieves up to 4.6$\times$ wall-clock speedup and reduces denoiser evaluations by up to 7.7$\times$ across various benchmarks.
• Performance Preservation: In offline RL (D4RL) and motion planning tasks, Muninn maintains task success rates and normalized scores comparable to the full-compute models (often >99% relative performance).
• Safety: The method strictly adheres to the user-defined risk level $\alpha$. Empirical violation rates ($\hat{p}_{viol}$) closely match the target risk, significantly outperforming heuristic baselines like fixed step-skipping or simple thresholding, which often fail to control risk in high-sensitivity regimes.
• Hardware Validation: Real-time closed-loop experiments on a SeaRobotics ASV (marine), Crazyflie quadrotor (aerial), and SO-ARM100 (manipulation) demonstrate that Muninn reduces latency sufficiently for high-rate control loops without increasing collision or failure rates.
• Adaptive Compute: Muninn naturally allocates more compute to difficult, high-risk situations (e.g., tight corridors, contact-rich manipulation) and reuses outputs aggressively in stable, low-risk phases, unlike fixed-acceleration methods.

Significance and Claims

The paper positions Muninn as a critical step toward making diffusion-based trajectory planners viable for real-time robotic control. Its primary significance lies in offering a training-free acceleration mechanism that does not require retraining or architectural changes, yet provides formal, distribution-free guarantees on trajectory fidelity.

Unlike prior work that treats acceleration as a black-box trade-off between speed and quality, Muninn explicitly models the relationship between internal representation changes and final trajectory deviation. By treating acceleration as a budgeting problem constrained by conformal risk bounds, it allows practitioners to tune the trade-off between planning speed and safety rigorously. The authors claim that this approach enables the deployment of complex, multimodal diffusion policies on resource-constrained hardware while maintaining the safety and performance characteristics of the original, slower models.