💻 computer science

CAB: Accelerating Flow and Diffusion Sampling via Rectification and Corrected Adams-Bashforth

The paper introduces CAB (Corrected Adams-Bashforth), a training-free sampler that accelerates flow and diffusion models by transforming sampling dynamics into a rectified coordinate system and applying a multistep predictor with a correction term, thereby significantly improving the quality-efficiency trade-off in low-step regimes without requiring additional function evaluations.

Original authors: Anuska Roy, Pravin Nair

Published 2026-05-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Anuska Roy, Pravin Nair

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to draw a perfect picture of a cat, but you are blindfolded. You have a magical guide (the AI model) that whispers directions to you: "Move your hand a little left," "Go up a bit," "Stop."

In the world of AI image generation, this "whispering" is called sampling. The AI starts with a canvas full of static noise (like TV snow) and slowly transforms it into a clear image by following a mathematical path.

The Problem: The Slow Walk

Usually, to get a perfect picture, the AI has to take many tiny steps (often 50 or more) to get from the noise to the final image. Each step requires the AI to "think" (run a complex calculation). If you only let it take a few steps (say, 6 to 10), the picture often comes out blurry, distorted, or full of weird artifacts, like a cat with three ears or a face that melts.

Existing methods to speed this up are like two different types of shortcuts:

The "Training" Shortcut: You teach the AI a new, faster way to walk. This works well but takes a long time to learn and doesn't work on every AI.
The "Smart Walker" Shortcut: You give the AI a smarter map so it can take bigger steps without falling. But if the map is too complex, the AI gets confused and the picture looks bad if it doesn't take enough steps.

The Solution: CAB (The "Corrected Adams-Bashforth" Method)

The authors of this paper propose a new method called CAB. Think of CAB as a GPS with a "Correction" feature that works on any existing AI without needing to retrain it.

Here is how CAB works, using a simple analogy:

1. Straightening the Road (Rectification)

Imagine the path the AI needs to take is a winding, curvy mountain road. Taking big steps on a curvy road is dangerous; you might overshoot the turn and fall off.

What CAB does: It magically straightens the road. It transforms the winding path into a straight highway.
Why it helps: On a straight road, you can take big, confident strides without worrying about missing a turn. This makes the math much easier for the AI to handle.

2. The "Look Back" Step (Adams-Bashforth)

Now that the road is straight, CAB uses a technique called Adams-Bashforth.

The Analogy: Imagine you are walking down a straight path. Instead of just looking at where you are right now, you look at where you were 2 or 3 steps ago. You use that history to guess where you should go next.
The Benefit: This allows the AI to predict the future path very accurately using only a few steps.

3. The "Safety Net" (The Correction)

Here is the secret sauce. Sometimes, even on a straight road, the terrain changes unexpectedly (maybe the wind blows, or the ground shifts). A simple "look back" guess might still be slightly wrong.

What CAB does: It adds a tiny correction term. It checks: "Did my guess match the reality of the last step?" If the AI's prediction was slightly off, CAB applies a small, instant fix based on the difference between the guess and the actual movement.
The Magic: It does this without asking the AI to do any extra work. It uses information the AI already calculated in the previous steps. It's like a co-pilot whispering a tiny adjustment to the driver without the driver having to stop the car.

The Results: Sharper Pictures, Faster

The paper tested this new method on various AI models (both for images and videos) and found:

Low Step Count (6–20 steps): This is where CAB shines. While other methods produce blurry or noisy images when forced to move fast, CAB produces sharper, clearer, and more detailed images.
- Example: In the paper's tests, when asked to draw a bus or a tennis player in just 6 steps, other methods made the bus look like a blob or the player's face distorted. CAB kept the details sharp and the structure correct.
High Step Count: When given many steps, CAB performs just as well as the best existing methods, proving it doesn't break anything.
No Extra Cost: It doesn't require the AI to be retrained, and it doesn't slow down the process. It actually makes the process more efficient because you get better results with fewer steps.

In Summary

CAB is like giving an existing AI a straighter road and a smart co-pilot that makes tiny, free adjustments to the steering wheel. This allows the AI to generate high-quality images and videos in a fraction of the time it usually takes, without needing to learn anything new. It solves the problem of "blurry pictures when you're in a hurry" by making the journey smarter, not just faster.

Technical Summary: CAB (Corrected Adams-Bashforth)

Problem Statement

Flow and diffusion models have established themselves as the dominant paradigm for high-fidelity image and video synthesis. However, their practical deployment is often hindered by high computational costs during the sampling phase, which requires numerically integrating a learned reverse-time ordinary differential equation (ODE) over many neural network evaluations (NFEs). While training-free acceleration methods exist, they face a critical trade-off in the low-NFE regime (typically 6–20 steps). First-order methods like DDIM are robust but require many steps for quality, while existing high-order solvers (e.g., DPM-Solver++, UniPC, STORK) often suffer from instability, oversmoothing, or structural distortions when the step budget is severely limited. Furthermore, many high-order solvers rely on specific model parameterizations (e.g., log-SNR for diffusion) or require additional model-dependent statistics, limiting their generality across both flow and diffusion architectures.

Methodology

The authors propose CAB (Corrected Adams-Bashforth), a training-free sampler designed to accelerate both flow and diffusion models without additional training or model-specific statistics. The methodology consists of two primary components:

1. Rectification of the Reverse-Time ODE

The core theoretical insight is that the reverse-time dynamics of both flow and diffusion models can be transformed into a common coordinate system. By rescaling the state $x_t$ to $y_t = x_t / s_t$ and reparameterizing time using the noise-to-signal ratio $\rho_t = \sigma_t / s_t$ , the authors derive a "rectified" ODE. In this $\rho$ -coordinate system, the linear drift induced by the specific noise schedules ( $s_t, \sigma_t$ ) is removed, and the dynamics reduce to a simple form driven directly by the learned noise field $\epsilon_\theta$ :
$\frac{d\hat{y}_\rho}{d\rho} = \epsilon_\theta(s_t(\rho)\hat{y}_\rho, t(\rho))$
This transformation unifies the sampling dynamics for diverse model families (including VP, VE, and rectified flow paths) under a single explicit ODE formulation.

2. Corrected Adams-Bashforth Integration

On the induced non-uniform $\rho$ -grid, CAB applies a multistep Adams-Bashforth (AB) predictor. To address the inaccuracy of standard AB methods at large step sizes (low NFE), CAB introduces a lightweight correction term.

Prediction: An explicit AB predictor (order 2 or 3) estimates the next state based on past velocity evaluations.
Correction: The method calculates an "extrapolation defect," defined as the discrepancy between the current learned velocity and a linear Lagrange extrapolation of the velocity from the two previous steps.
Update: The final update adds a weighted correction term proportional to this defect:
$y_{t_{i+1}} = y^{pred}_{t_{i+1}} + \gamma_i h_i (\epsilon_i - \epsilon^{ext}_i)$
where $\epsilon^{ext}_i$ is the extrapolated velocity and $\gamma_i$ is a model-specific weight. Crucially, this correction utilizes velocity evaluations already computed in previous steps, incurring zero additional NFEs.

Theoretical analysis proves that despite the added correction, the method retains the formal convergence order of the underlying Adams-Bashforth solvers (second-order global error for CAB-2; third-order for CAB-3 when $\gamma_i = O(h_i)$ ).

Key Contributions

Unified Framework: CAB provides a single, training-free sampler applicable to both flow matching and diffusion models by rectifying their dynamics into a common noise-to-signal coordinate system.
Zero-Overhead Correction: The method introduces a correction mechanism that improves low-NFE stability and accuracy without requiring extra network evaluations, distinguishing it from methods that rely on virtual steps or complex multi-evaluation corrections.
Theoretical Guarantees: The authors provide proofs demonstrating that the corrected schemes preserve the local truncation error and global convergence order of the base Adams-Bashforth methods.
Empirical Performance: Extensive experiments show CAB improves the quality-NFE trade-off in the challenging 6–20 step regime across various benchmarks.

Experimental Results

The authors evaluated CAB on unconditional image generation (CIFAR-10, ImageNet), class-conditional generation (DiT on ImageNet), high-resolution text-to-image synthesis (QWEN-Image), and text-to-video generation (HunyuanVideo).

Low-NFE Regime (6–20 steps): CAB consistently outperforms strong training-free baselines (DDIM, DPM-Solver++, UniPC, STORK) in terms of FID (Fréchet Inception Distance) and perceptual quality. For instance, on DiT/ImageNet at 6 NFEs, CAB-3 achieves an FID of 14.81 compared to 26.64 for DPM++ and 51.52 for STORK.
Qualitative Improvements: Visual comparisons indicate that CAB produces sharper details, better preserves structural integrity (e.g., facial features, object boundaries), and reduces noise artifacts and oversmoothing compared to competitors in low-step settings.
High-Resolution and Video: On QWEN-Image (1024x1024), CAB-3 achieves the highest ImageReward scores at 4–10 NFEs. In video generation (HunyuanVideo), CAB-2 demonstrates superior text-video alignment and temporal consistency at low step counts.
Efficiency: Runtime and memory overhead are negligible, comparable to standard AB solvers, as the correction relies on stored past evaluations.

Significance and Claims

The paper claims that CAB offers a simple yet effective solution to the "low-NFE dilemma" in generative modeling. By rectifying the ODE dynamics and applying a defect-correction strategy, CAB achieves a favorable balance between accuracy, stability, and generality. The authors emphasize that their method does not require additional training or model-specific hyperparameter tuning beyond a single weight $\gamma$ , making it a practical drop-in replacement for existing samplers.

The work suggests that the rectification of the ODE into noise-to-signal coordinates significantly smooths the learned vector field, facilitating more accurate multistep integration. While the method improves robustness, the authors modestly acknowledge limitations: in extremely challenging regimes with very few steps (e.g., $N=6$ ) and highly curved dynamics, geometric mis-tracking can still occur, indicating that the correction does not fully eliminate failure modes associated with stiff or rapidly varying systems. Nevertheless, CAB represents a significant step toward making high-fidelity generative models more accessible in resource-constrained, latency-sensitive applications.