Models that generate several consistent views of an object or scene from one image rely on cross-view attention. In this layer, each view's features look up related features in the other views, so that a chair leg drawn in the front view appears in the matching place in the side view. Today these generators are diffusion models: generators that turn random noise into images by denoising many times in sequence. They run this expensive cross-view lookup at every one of dozens of steps, which is why they take seconds to hours per object. A newer family, average-velocity flow models such as Mean Flows for One-step Generative Modeling, learns to jump from noise to data in a single network call without a teacher. It has not been applied to multi-view images.
The obvious move is to bolt a multi-view backbone onto a one-step objective. We argue that this move hides a real design problem. In a many-step sampler, views can agree gradually, because each step refines a slightly cleaner guess. In a one-step jump, every bit of cross-view agreement has to be settled in one forward pass whose input is nearly pure noise. Attention between the noisy target views then has nothing meaningful to match. We propose a cross-view attention module whose behaviour is conditioned on the size of the jump being taken. For long jumps from noise, it routes correspondence through clean signals: the input view, the camera geometry, and a cheap internal sketch of the jump's endpoint. Direct attention between noisy target views is reserved for short jumps near the data, where it actually carries information. We then test whether this matters, rather than assuming it does.
Core Claim
The claim has three parts, and each can be falsified. First, in a multi-view generator, attention between noisy target views is close to uninformative at high noise levels. The structure of MvDeDiffusion already hints at this: it uses time-conditioned layer normalization so that structural cross-view alignment happens mainly at high signal-to-noise ratios. Second, a one-step average-velocity generator trained with ordinary cross-view attention will therefore fall short on cross-view consistency compared with one whose cross-view pathway is anchored to clean geometric signals at long jumps. Third, once anchoring is done, the expensive dense target-to-target attention can be shrunk or skipped for long jumps. This cuts both inference latency and the memory cost of the Jacobian-vector products that average-velocity training needs.
The training objective is the MeanFlow identity. A network $u_\theta(z_t, r, t)$ predicts the average velocity over the interval from time $r$ to time $t$, and is trained so that
$$u_\theta(z_t, r, t) \approx v(z_t, t) - (t-r)\,\frac{d}{dt}u_\theta(z_t, r, t),$$
where $z_t$ is the stack of all target-view latents at noise level $t$ and $v$ is the instantaneous flow-matching velocity. The total derivative is computed by a Jacobian-vector product. Sampling in one step means evaluating at $r=0, t=1$ and setting $z_0 = z_1 - u_\theta(z_1, 0, 1)$. Our contribution lives inside $u_\theta$. The cross-view block receives the jump length $t-r$ and the noise level $t$ as inputs. It then mixes three attention paths through gates learned as functions of $(r,t)$. The first is epipolar attention from each target view into the clean input-view features, sampled along projected epipolar lines for arbitrary camera poses. The second is attention among target views keyed on an endpoint sketch, which is a per-view estimate $\hat z_r = z_t - (t-r)\,\tilde u$ produced by a light head partway through the network. The third is ordinary dense or near-view attention among the noisy target latents.
Research Program
The first stage is diagnostic and needs no new architecture. We train a standard multi-view flow-matching model in the style of Era3D: six views from one image, rendered from Objaverse. We then measure, as a function of noise level, how well target-to-target attention maps hit the geometrically correct correspondences. We also measure how much consistency drops when each attention path is zeroed at each noise level. If target-to-target attention turns out to be accurate even at high noise, the core claim is wrong and we stop at the simpler design.
The second stage builds the jump-aware model and trains it from scratch with the MeanFlow objective. We use epipolar sampling rather than Era3D's row-wise attention, because row-wise attention requires canonical cameras at zero elevation and cannot serve general rigs. Sampling a fixed number of points per epipolar line keeps cost sub-quadratic without that assumption. The third stage measures the compute trade: at matched wall-clock latency, is it better to spend the budget on one step with richer cross-view attention, or on two or four steps with cheaper attention? We report the consistency, latency and memory frontier across these settings. We treat the diversity loss that 3D MeanFlow reports for its one-step generator as a known risk. We measure it explicitly by sampling many outputs per input on occluded regions.
Baselines
The naive reference is a one-step MeanFlow model that generates each view independently, with camera pose as conditioning and no cross-view attention at all. It shows how much consistency the cross-view pathway buys. It is trained on the same Objaverse renders with the same backbone size and step budget.
The strongest multi-step competitor on quality is Era3D itself. It reports a Chamfer distance of 0.0217 on Google Scanned Objects, compared with 0.0248 for Wonder3D and 0.0261 for SyncDreamer (Era3D). We cite that number and also retrain an Era3D-style flow-matching model on our data, so the backbone and training data match exactly. Our one-step model counts as competitive if it stays within a small, pre-declared margin of that Chamfer distance while running at least an order of magnitude faster. For latency context, EpiDiff, which restricts attention to near views and epipolar lines inside a frozen Zero123, reports 12 seconds for 16 views against 60 seconds for SyncDreamer.
The strongest acceleration competitor is distillation of our own multi-step teacher into a few-step student, following the recipe of FVGen. That recipe uses a GAN-initialized student followed by distribution matching with a softened reverse KL, built on One-Step Diffusion with Distribution Matching Distillation. FVGen reports cutting 16-frame generation from 13.2 seconds to about 1 second on DL3DV-10K. It reports no consistency metric we can transfer, so we run the distillation ourselves. The distillation run gets the same total GPU-hours as our from-scratch training, counting the teacher's training cost. Beating it means equal or better consistency and Chamfer distance at equal step count, with no larger diversity loss.
A training-free baseline runs the multi-step teacher with a fast ODE solver at 1, 2 and 4 steps. No reported result was found on Lacuna for fast-solver sampling of multi-view diffusion models.
The key ablation is MeanFlow with an ordinary fixed cross-view block of identical parameter count and compute. It has epipolar and dense attention but no jump conditioning and no endpoint sketch. This isolates our ingredient. If this ablation matches the full model, the proposal's central claim fails.
Why not just…?
Why not just train MeanFlow on an existing multi-view backbone and stop there? This is the real threat, and it is exactly our key ablation. The 3D MeanFlow work shows that average-velocity training transfers to structured 3D data. It may well be that a plain cross-view block learns to ignore noisy target-to-target attention by itself. The stage-one diagnostic tells us whether there is a problem to solve, and the matched ablation tells us whether our module solves it. If both models tie on consistency, we report that simpler recipe as the finding. We would still keep the compute-saving result if gating lets us drop dense attention at long jumps without loss.
Why not just distill a multi-view diffusion model, as FVGen does? FVGen needed a two-stage GAN-plus-softened-KL pipeline to avoid mode dropping, and it inherits its teacher's structural failures under sparse views (FVGen). Distillation also has to hold teacher and student multi-view activations in memory at the same time. Our distillation baseline, run at matched GPU-hours, settles whether training from scratch is actually better or merely simpler.
Why not just use a feed-forward reconstructor like MVSplat? MVSplat reaches 26.39 PSNR on RealEstate10K at 44 ms. When enough views are given, that is hard to beat, and we do not claim to beat it in that regime. It is deterministic, however, and has no mechanism for producing plausible content in regions no input view sees. Our target setting is single-image generation, where most of each output view is unobserved. In a secondary experiment we hold out wide-baseline target views on RealEstate10K and compare PSNR and LPIPS on regions visible versus unseen in the inputs. If MVSplat wins on unseen regions too, the generative argument weakens.
Why not just run fewer steps with a better ODE solver? Large steps along the curved paths of a standard model accumulate discretization error. CvG-Diff needed dedicated error-propagation training to reach 10 steps even in CT. Since no number exists for multi-view images, we measure it directly with the solver baseline at 1 to 4 steps.
Proposed Experiments
Training uses Objaverse renders, with six target views at 256×256 and then 512×512. Evaluation uses Google Scanned Objects. We report per-view PSNR, SSIM and LPIPS against ground-truth renders. We report Chamfer distance and volume IoU after mesh reconstruction, using the same reconstruction pipeline for every method. Cross-view consistency is measured as the reprojection error of matched keypoints between generated views, using known cameras. We also report wall-clock latency and peak memory for both training and inference, and sample diversity on occluded regions as pairwise LPIPS across seeds. To test general camera poses, which Era3D's canonical setup excludes, we evaluate on views with randomized elevation. A secondary scene-level test on RealEstate10K covers the wide-baseline question raised by MVSplat.
Three checks decide the outcome. First, the stage-one attention-accuracy curve must show target-to-target correspondence degrading at high noise; otherwise the motivation fails. Second, the jump-aware model must beat the matched fixed-block MeanFlow ablation on consistency at one step; otherwise the mechanism is unnecessary. Third, at matched latency, the one-step jump-aware model must match or beat the distilled student and the fast-solver teacher on Chamfer distance without a larger diversity drop. If it does, we will have shown that one-step multi-view generation needs cross-view attention designed for the jump, and does not inherit cleanly from multi-step designs.
References
- Mean Flows for One-step Generative Modeling
- MvDeDiffusion: Multi-view Consistent Generation via Cross-view Deformable Attention for Denoising Diffusion Models
- Era3D: High-Resolution Multiview Diffusion using Efficient Row-wise Attention
- 3D MeanFlow: One-Step Point Cloud Completion and Generation via Average-Velocity Transport
- EpiDiff: Enhancing Multi-View Synthesis via Localized Epipolar-Constrained Diffusion
- FVGen: Accelerating Novel-View Synthesis with Adversarial Video Diffusion Distillation
- One-step Diffusion with Distribution Matching Distillation
- MVSplat: Efficient 3D Gaussian Splatting from Sparse Multi-view Images
- Cross-View Generalized Diffusion Model for Sparse-View CT Reconstruction