🤖 AI

Bi-Anchor Interpolation Solver for Accelerating Generative Modeling

This paper proposes the Bi-Anchor Interpolation Solver (BA-solver), a lightweight, training-efficient method that accelerates Flow Matching generation by combining a frozen backbone with a small SideNet to achieve high-fidelity synthesis in just 5–10 Neural Function Evaluations without sacrificing versatility or incurring prohibitive training costs.

Original authors: Hongxu Chen, Hongxiang Li, Zhen Wang, Long Chen

Published 2026-06-19

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Hongxu Chen, Hongxiang Li, Zhen Wang, Long Chen

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, smooth curve from a messy scribble (noise) to a clear picture (an image). In the world of AI art, this is how "Flow Matching" models work. They don't just jump to the answer; they have to take many tiny, careful steps along a path to get there.

The problem? Taking those steps is slow. If you want a high-quality picture, the AI usually has to take 100 steps (called "Neural Function Evaluations" or NFEs). That's like walking a marathon just to get a glass of water.

This paper introduces a new method called the BA-solver (Bi-Anchor Interpolation Solver) that acts like a "super-sneaker" for this AI, letting it take huge, confident strides while still landing perfectly on the target. It can generate high-quality images in just 5 to 10 steps.

Here is how it works, using simple analogies:

1. The Old Ways: The "Guess" vs. The "Double-Check"

The paper explains that previous methods had two bad options:

The "Extrapolation" Solver (The Blind Hiker): Imagine you are hiking and you only know the direction you are facing right now. To get to the next camp, you guess where you'll be based on that single direction. If the path curves, you might overshoot or get lost. To fix this, you have to take tiny, tiny steps to stay on track. This is accurate but incredibly slow.
The "Interpolation" Solver (The Over-Prepared Hiker): This hiker knows the start and the end of the path. To get the next step right, they stop, look at the start, look at the end, and calculate the middle. This is very accurate, but because they have to stop and calculate twice for every single step, they are still slow.

2. The New Solution: The "Bi-Anchor" Solver

The BA-solver is a clever mix of both. It uses a Main Brain (the heavy, powerful AI model) and a Lightweight Sidekick (a tiny, fast helper called a "SideNet").

Here is the magic trick, broken down into three parts:

A. The "Sidekick" (Lightweight SideNet)

The main AI model is huge and slow to run. The authors added a tiny, cheap "SideNet" (about 1-2% the size of the main model).

Analogy: Think of the Main Brain as a heavy, slow professor. The SideNet is a quick, agile student assistant.
What it does: The SideNet learns to predict not just where the path is going forward, but also where it came from backward. It gives the system "bidirectional vision."

B. The "Two Anchors" (Bi-Anchor)

Instead of guessing the whole path from just the start (like the Blind Hiker), the BA-solver uses two "anchors" to hold the path steady:

Anchor 1: The current position (calculated by the heavy Main Brain).
Anchor 2: The predicted end position of the step (also calculated by the Main Brain, but only once per step).

The tiny Sidekick then fills in the gaps between these two anchors. Because the Sidekick only has to guess the middle of a short distance (between the two anchors) rather than the whole path, it makes very few mistakes.

C. The "State Reuse" (The Efficiency Hack)

Usually, if you want to check the end of a step, you have to run the heavy Main Brain again. That's expensive.

The Trick: The BA-solver calculates the "end anchor" for Step 1. Then, for Step 2, it reuses that same "end anchor" as the "start anchor."
Result: The heavy Main Brain only has to run once per step. The tiny Sidekick does all the heavy lifting for the middle calculations. This keeps the process fast.

3. The Results: Fast and Accurate

The paper tested this on ImageNet (a standard dataset for AI image generation).

Speed: They achieved results in 5 to 10 steps that usually take 100+ steps with standard methods.
Quality: The images were just as sharp and detailed as the slow methods.
Cost: They didn't have to retrain the massive main AI model. They only trained the tiny "Sidekick," which took a fraction of the time and computing power.

Summary

Think of the BA-solver as a GPS navigation system that doesn't just look at the road ahead. It looks at where you are, predicts where you'll be in a few seconds, and then uses a tiny, fast computer to fill in the details of the road between those two points.

This allows the AI to drive fast (fewer steps) without crashing (maintaining high quality), and it does it without needing a new engine (retraining the whole model). The paper claims this makes generating high-quality images significantly faster and cheaper, while also being flexible enough to work with existing AI tools.

Technical Summary: Bi-Anchor Interpolation Solver for Accelerating Generative Modeling

1. Problem Statement

Flow Matching (FM) models, such as Flux and SD3, have established state-of-the-art performance in high-fidelity image synthesis by regressing a velocity field that transports a noise distribution to a data distribution. However, the generation process requires solving an Ordinary Differential Equation (ODE) via iterative numerical integration, creating a significant latency bottleneck.

Existing solutions face a dichotomy:

Training-free Solvers: Methods like Euler, Heun, and DPM-Solvers are plug-and-play but suffer from large extrapolation errors when using large time intervals. To maintain quality, they require a high number of Neural Function Evaluations (NFEs), often exceeding 100 steps for high-fidelity sampling.
Training-based One/Few-Step Methods: Approaches like Consistency Models and Flow Map Matching accelerate generation to 1–2 steps by directly predicting trajectories. However, they lack versatility (cannot be applied to off-the-shelf models without retraining) and incur prohibitive training costs, often requiring hundreds of thousands of iterations and fine-tuning massive backbone parameters.

The core challenge is to bridge this gap: achieving the acceleration of training-based methods while retaining the plug-and-play versatility of training-free solvers, without incurring massive training costs.

2. Methodology: Bi-Anchor Interpolation Solver (BA-solver)

The authors propose the Bi-Anchor Interpolation Solver (BA-solver), a novel sampling framework that retains a frozen backbone while introducing a lightweight SideNet to enable high-order interpolation with minimal NFEs.

Core Components

1. Lightweight SideNet with Bidirectional Temporal Perception
Instead of retraining the heavy backbone ( $v_\theta$ ), BA-solver introduces a lightweight SideNet ( $S_\phi$ ), comprising approximately 1–2% of the backbone's parameter size.

Function: The SideNet learns to predict velocity deviations conditioned on the current state ( $x_t$ ) and velocity ( $v_t$ ).
Bidirectional Perception: It approximates both future and historical velocities without backpropagating gradients through the frozen backbone. This grants the system "lookahead" and "lookback" capabilities.
Training Efficiency: Training is computationally and memory-efficient, requiring only a fraction of the iterations needed by full fine-tuning methods.

2. Bi-Anchor Velocity Integration
The solver addresses the limitation of single-anchor interpolation, where prediction fidelity degrades as the time offset increases. BA-solver utilizes two anchor velocities to minimize this error:

Forward Probe: Using the current anchor velocity $v_t$ (from the backbone), the SideNet predicts intermediate velocities for a set of quadrature nodes. A provisional next state $\hat{x}_{t-h}$ is computed.
Backward Refinement: The backbone evaluates the velocity at the provisional state, $v_{t-h} = v_\theta(\hat{x}_{t-h}, t-h)$ , establishing a second anchor. The SideNet then performs a "backward lookback" from $v_{t-h}$ to refine predictions for nodes closer to the interval's end.
Integration & State Reuse: The final state update integrates velocities from both directions (forward predictions for the first half, backward refinements for the second) using high-order quadrature rules (e.g., Gauss-Lobatto). Crucially, the computed anchor $v_{t-h}$ is cached and reused as the starting anchor for the next interval, ensuring the total NFE count remains exactly equal to the number of intervals.

3. Chain-Based Training
To ensure robustness, the SideNet is trained using a K-interval chain strategy that mimics the sequential generation process. The training objective minimizes the discrepancy between the SideNet's velocity prediction and the ground truth velocity derived from the backbone at the next state, utilizing a stop-gradient operator to prevent modifying the backbone's targets.

3. Key Contributions

Algorithm: The proposal of BA-solver, a sampling method enabling high-fidelity generation in as few as 5–10 steps. It effectively bridges the gap between expensive training-free solvers and resource-intensive training-based acceleration.
Architecture: The introduction of a lightweight, training-efficient SideNet that endows frozen flow matching backbones with bidirectional temporal perception, avoiding the need for full model retraining.
Performance: Validation on ImageNet-256 and ImageNet-512 demonstrating that BA-solver achieves generation quality comparable to 100+ NFE Euler solvers using only 10 NFEs, and maintains high fidelity at 5 NFEs. It significantly outperforms existing training-based one-step methods in training efficiency (converging in ~250 iterations vs. hundreds of thousands) and parameter efficiency (optimizing only ~6M parameters vs. fine-tuning 675M+).

4. Experimental Results

Quality vs. NFE: On ImageNet-256, BA-solver achieves a Fréchet Inception Distance (FID) of 1.96 at 7 NFEs, substantially outperforming Flow-DPM (4.03) and Euler (7.56). At 10 NFEs, it reaches an FID of 1.72, matching the quality of standard Euler solvers requiring 100+ steps.
Scalability: The method scales effectively to 512 resolutions, maintaining global coherence and texture details with only 7 NFEs.
Training Efficiency: BA-solver converges in 250 training iterations with only 6 million trainable parameters. In contrast, competing one-step methods like MeanFlow or iCT require 313,000 to 800,000 iterations and fine-tune the entire backbone (675M+ parameters).
Image Editing: Leveraging the reversibility of FM ODEs, BA-solver facilitates high-quality image editing (e.g., class-to-class translation) within 10 NFEs, a capability often lacking in rigid one-step generation methods.

5. Significance and Claims

The paper claims that BA-solver represents a "sweet spot" in generative modeling acceleration. By decoupling the heavy backbone from the acceleration mechanism, it offers a plug-and-play solution that does not require the prohibitive costs of retraining large foundation models.

The authors emphasize that their method achieves a superior balance between efficiency and fidelity. Theoretical analysis suggests that the bi-anchor mechanism reduces the error bound coefficient by a factor of 2 compared to single-anchor interpolation, effectively mitigating extrapolation drift. Empirically, the method enables "Green AI" by drastically reducing the computational cost and energy consumption required for high-quality synthesis, lowering the hardware barrier for deploying advanced generative models.

The work asserts that while it accelerates sampling, it does so without compromising the versatility of existing pipelines, facilitating downstream tasks like image editing that rely on the mathematical structure of the ODE, which is often disrupted by other acceleration techniques.