MeanFuser: Mean-Based Fusion Across Domains

• MeanFuser is a family of techniques that uses mean statistics as a design primitive for model fusion and optimization across varied tasks including autonomous driving and Bayesian optimization.
• It encompasses diverse strategies such as using Gaussian-process prior means, MOS-guided fusion in fake audio detection, averaged-image representations for deepfake detection, and token-level fusion in semantic segmentation.
• Empirical evaluations demonstrate that leveraging mean-based approaches can enhance convergence, reduce error rates, and improve computational efficiency in real-world applications.

Searching arXiv for the cited papers and related "MeanFuser" terminology. arxiv_search(query="MeanFuser OR MFuser OR \"What do you Mean? The Role of the Mean Function in Bayesian Optimisation\" OR \"MOS-FAD\" OR \"μFlow\" OR MONK", max_results=10, sort_by="relevance") arxiv_search(query="(Ath et al., 2020, Zhou et al., 2024, Pontorno et al., 29 Jun 2026, Zhang et al., 4 Apr 2025, Wang et al., 23 Feb 2026, Lerasle et al., 2018, Hector, 2022, Claici et al., 2020)", max_results=10, sort_by="relevance") MeanFuser is not a single standardized method in the recent literature. The name appears directly in end-to-end autonomous driving as "MeanFuser: Fast One-Step Multi-Modal Trajectory Generation and Adaptive Reconstruction via MeanFlow for End-to-End Autonomous Driving" (Wang et al., 23 Feb 2026), while closely related usages appear as a practical “MeanFuser” strategy for Gaussian-process mean selection in Bayesian optimisation (Ath et al., 2020), as MOS-guided model fusion in fake audio detection (Zhou et al., 2024), as the averaging component of $μ$Flow for one-class deepfake detection (Pontorno et al., 29 Jun 2026), as the Mamba-based semantic-segmentation framework MFuser (Zhang et al., 4 Apr 2025), and in statistical settings involving robust mean embedding estimation, fused mean structure learning, and KL-based posterior fusion (Lerasle et al., 2018, Hector, 2022, Claici et al., 2020). This suggests that, across domains, MeanFuser names a recurring pattern in which a mean statistic, mean function, or mean-based aggregation mechanism is used to guide optimization, fusion, reconstruction, or uncertainty handling.

1. Terminological scope and recurring design pattern

Recent usage of the term spans multiple problem classes. In some cases, the “mean” is a prior function; in others it is a quality score, an averaged image, a latent distributional target, or an object-level fusion rule. The shared thread is not a single architecture but a family of mechanisms that exploit mean structure to regularize or combine models.

Label in the literature	Domain	Core mean-based object
MeanFuser	End-to-end autonomous driving	GMN-sampled proposals and adaptive reconstruction
Practical “MeanFuser” strategy	Bayesian optimisation	Portfolio of GP prior mean functions
MOS-FAD	Fake audio detection	FAD scores gated by predicted MOS
$μ$Flow	Deepfake face detection	Averaged real images and their feature distribution
MFuser	Domain-generalized semantic segmentation	VFM and VLM token fusion plus text enhancement
MONK / fused mean / KL fusion	Statistics and Bayesian inference	Block means, mean parameters, or mean-field posterior components

A common misconception is that these works all implement the same module. The literature does not support that reading. Instead, it presents several distinct formalisms in which “mean fusion” can mean prior centering, confidence gating, pixel-wise averaging, latent-distribution alignment, sequence-level feature fusion, or robust aggregation (Wang et al., 23 Feb 2026, Ath et al., 2020, Zhou et al., 2024, Pontorno et al., 29 Jun 2026, Zhang et al., 4 Apr 2025, Lerasle et al., 2018, Hector, 2022, Claici et al., 2020).

2. Mean functions as fusion variables in Bayesian optimisation

In Bayesian optimisation, the relevant MeanFuser idea concerns the Gaussian-process prior mean function $m(x)$. The optimisation problem is

$\min_{x \in X} f(x),$

with surrogate prior

$f(x) \sim GP(m(x), k(x,x')).$

Given data $D=\{(x_i,y_i)\}_{i=1}^n$, the posterior mean and variance are

$$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$

$$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$

Because $\mu(x)$ reverts to $m(x)$ away from observed data, the mean function directly changes the exploration–exploitation profile of the acquisition function (Ath et al., 2020).

The paper evaluates eight mean functions: constant functions equal to the arithmetic mean, minimum, median and maximum of the observed function evaluations, linear, quadratic polynomials, random forests and RBF networks. It studies 10 synthetic test problems and two real-world problems with Expected Improvement and Upper Confidence Bound. The central empirical result is that, for design dimensions $μ$0, a constant mean function equal to the worst observed quality value is consistently the best choice on the synthetic problems considered when using EI. Illustrative medians at 200 evaluations include Ackley (5D): Max 1.66 vs Arithmetic 4.27; Hartmann6 (6D): Max $μ$1 vs Arithmetic $μ$2; Michalewicz (10D): Max $μ$3 vs Arithmetic $μ$4; Rosenbrock (10D): Max $μ$5 vs Arithmetic $μ$6; and Styblinski–Tang (10D): Max $μ$7 vs Arithmetic $μ$8 (Ath et al., 2020).

The mechanism is explicit in the acquisition formulas. For minimization,

$μ$9

and the paper’s UCB implementation is

$m(x)$0

If $m(x)$1 is large, then $m(x)$2 is large far from data, so EI and UCB both suppress blind exploration unless $m(x)$3 is very large. The paper argues that this worst-observed-quality function promotes exploitation leading to more rapid convergence. By contrast, the minimum observed value strongly promotes exploration and can perform very poorly; on Shekel 4D under EI, the Min constant mean yields median regret 7.02 versus Max 0.0716 (Ath et al., 2020).

The practical “MeanFuser” strategy proposed there is a portfolio method. It maintains

$m(x)$4

fits each candidate at each BO iteration, scores them by model evidence, predictive CV error, or one-step lookahead utility, and then either selects

$m(x)$5

or fuses them with

$m(x)$6

or alternatively

$m(x)$7

On real tasks, especially robot pushing, more complex mean functions can help, but there is no clearly optimum choice. The broader implication is that mean choice is not a nuisance hyperparameter; it is a low-cost lever on BO convergence (Ath et al., 2020).

3. MOS-gated MeanFuser in fake audio detection

In fake audio detection, the MeanFuser mechanism is instantiated through predicted Mean Opinion Score. MOS-FAD uses MOS at two key points: training data selection and model fusion. The architecture contains seven SSL-FAD detector models built by adding mean pooling and a fully-connected head on top of different SSL encoders, several MOS predictors with the same SSL encoders plus mean pooling and FC head, a fused SSL-MOS module, and a final MOS-FAD fusion stage implemented with LightGBM, MLP, or a Gated MLP (Zhou et al., 2024).

The MOS predictor uses VoiceMOS Challenge 2022 main track labels in $m(x)$8, quantized into 33 bins at a step of 0.125. With CrossEntropy training, each sample produces logits $m(x)$9 and probabilities $\min_{x \in X} f(x),$0, and a scalar MOS can be reconstructed by expectation over bin centers,

$\min_{x \in X} f(x),$1

The fused SSL-MOS combines seven per-SSL MOS predictions $\min_{x \in X} f(x),$2 using a 2-layer NN:

$\min_{x \in X} f(x),$3

Training uses SGD, learning rate 0.001, CrossEntropy loss, and early stopping if dev loss does not improve for 20 epochs (Zhou et al., 2024).

The first mean-based intervention is data filtering. Because ASVspoof2019 LA train/dev are heavily imbalanced and MOS is bimodal, MOS-FAD keeps only samples with MOS in $\min_{x \in X} f(x),$4 for training and validation. The reported counts are Train: 25,380 $\min_{x \in X} f(x),$5 5,034; Real: 2,580 $\min_{x \in X} f(x),$6 2,568; Fake: 22,800 $\min_{x \in X} f(x),$7 2,466; and Dev: 22,438 $\min_{x \in X} f(x),$8 5,198; Real: 2,548 $\min_{x \in X} f(x),$9 2,533; Fake: 22,438 $f(x) \sim GP(m(x), k(x,x')).$0 2,665. This balances classes and focuses learning on the overlap region (Zhou et al., 2024).

The second intervention is the fusion gate itself. Weighted probability fusion is

$f(x) \sim GP(m(x), k(x,x')).$1

and weighted logit fusion is

$f(x) \sim GP(m(x), k(x,x')).$2

MOS-FAD also uses a piecewise threshold gate:

• If $f(x) \sim GP(m(x), k(x,x')).$3, force fake.
• If $f(x) \sim GP(m(x), k(x,x')).$4, force real.
• Else, fuse detectors normally.

The reported thresholds are $f(x) \sim GP(m(x), k(x,x')).$5 and $f(x) \sim GP(m(x), k(x,x')).$6. In the Gated MLP, if $f(x) \sim GP(m(x), k(x,x')).$7, the gate is

$f(x) \sim GP(m(x), k(x,x')).$8

the gated inputs are

$f(x) \sim GP(m(x), k(x,x')).$9

and the head is

$D=\{(x_i,y_i)\}_{i=1}^n$0

Empirically, MOS-based filtering strongly reduces EER for all seven detectors; for example, W2V2 Large improves from 0.4794 to 0.1891. In fusion, non-MOS baselines do not beat the best single model, whereas MOS-FAD with Gated MLP plus thresholding achieves EER $D=\{(x_i,y_i)\}_{i=1}^n$1 on ASVspoof2021 DF eval, better than prior SOTA 0.1564 and corresponding to a 13.6% relative EER reduction, significant at $D=\{(x_i,y_i)\}_{i=1}^n$2 (Zhou et al., 2024).

4. Averaged-image MeanFuser in one-class deepfake detection

$D=\{(x_i,y_i)\}_{i=1}^n$3Flow uses mean fusion in a different sense: averaging multiple real face images to build a discriminative target distribution for a one-class detector trained only on real data. The averaging step is

$D=\{(x_i,y_i)\}_{i=1}^n$4

and sets can be formed per identity, per video, or from random mini-batches of real faces. The method uses random grouping on real faces and never averages fake images during training (Pontorno et al., 29 Jun 2026).

Feature extraction is performed by a frozen ResNet-50 pretrained on ImageNet-1K. If $D=\{(x_i,y_i)\}_{i=1}^n$5 denotes the feature extractor, the method constructs averaged real images

$D=\{(x_i,y_i)\}_{i=1}^n$6

fits a target distribution $D=\{(x_i,y_i)\}_{i=1}^n$7 on averaged real features, and trains a FastFlow normalizing flow $D=\{(x_i,y_i)\}_{i=1}^n$8 so that single-image features $D=\{(x_i,y_i)\}_{i=1}^n$9 align with that distribution. In the main derivation and experiments, the target is a single Gaussian

$$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$0

although the figure also shows a GMM variant (Pontorno et al., 29 Jun 2026).

The likelihood is obtained through the change-of-variables formula,

$$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$1

and training minimizes

$$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$2

With a single Gaussian base, the paper rewrites this in terms of Mahalanobis distance. At test time,

$$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$3

or equivalently

$$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$4

with “lower is more real; higher is more fake.” Thresholding uses

$$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$5

with $$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$6 in experiments (Pontorno et al., 29 Jun 2026).

The implementation uses random subsets from real-only training data, $$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$7 images per average chosen via a Silhouette score analysis, AdamW with learning rate $$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$8, weight decay $$\mu(x_*) = m(x_*) + k_*^\top (K + \sigma_n^2 I)^{-1} (y - m(X)),$$9, batch size 32, and 1000 epochs on a single NVIDIA RTX A6000. Training uses only FFHQ reals; evaluation is fully out-of-distribution on unseen real faces from CelebA-HQ and unseen fake faces from 19 generators in WILD plus StarGAN, GDWCT, and AttGAN. Reported averages across OOD domains are acc 94.7, auc 94.7, ap 95.3, with per-domain examples GANs: acc 90.3, auc 90.4, ap 93.9; DM-CS: acc 96.8, auc 96.8, ap 95.9; and DM-OS: acc 96.9, auc 96.8, ap 96.1 (Pontorno et al., 29 Jun 2026).

A frequent intuition about image averaging is that it removes useful information. The paper’s analysis points in the opposite direction for this task: averaging suppresses idiosyncratic content while amplifying consistent traces, and t-SNE shows that average-image features form well-separated clusters. In this sense, the MeanFuser step is not a denoising convenience but the central representation-learning device (Pontorno et al., 29 Jun 2026).

5. MFuser as Mamba-based fusion for domain-generalized semantic segmentation

MFuser is a distinct but related formulation in domain-generalized semantic segmentation. It integrates Vision Foundation Models and Vision-LLMs under linear-time Selective State Space Models, motivated by the complementary strengths of fine-grained locality in VFMs and robust text alignment in VLMs. The framework has two key components: MVFuser, a co-adapter inserted layer-wise into both visual encoders, and MTEnhancer, a hybrid attention–Mamba text enhancement module (Zhang et al., 4 Apr 2025).

Given per-block features $$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$0 and $$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$1, MVFuser takes their concatenation and returns residual offsets:

$$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$2

$$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$3

Its internal structure is a bottleneck with parallel sequential and spatial branches,

$$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$4

followed by gated fusion

$$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$5

This design addresses the token-doubling problem that arises when VFM and VLM patch streams are concatenated, replacing quadratic self-attention with linear-time Mamba scans (Zhang et al., 4 Apr 2025).

MTEnhancer operates on class text embeddings $$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$6. It first applies self-attention,

$$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$7

then performs a conditional Mamba scan on the bracketed sequence

$$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$8

yielding

$$\sigma^2(x_*) = k(x_*, x_*) - k_*^\top (K + \sigma_n^2 I)^{-1} k_*.$$9

and updates the text queries by

$\mu(x)$0

The resulting image-conditioned text queries are consumed by a Mask2Former decoder (Zhang et al., 4 Apr 2025).

Training uses 512×512 crops, batch size 2, AdamW, base learning rate $\mu(x)$1, linear warm-up over 1.5k iterations followed by linear decay, with frozen VFM and VLM encoders and trainable MVFuser, MTEnhancer, and decoder. The overall loss is

$\mu(x)$2

Reported performance is 68.20 mIoU on synthetic-to-real and 71.87 mIoU on real-to-real benchmarks. On GTA5 $\mu(x)$3 {Cityscapes, BDD100K, Mapillary}, MFuser with EVA02-CLIP-L yields 70.19, 63.13, and 71.28 respectively, for an average of 68.20; on Cityscapes $\mu(x)$4 {BDD100K, Mapillary}, MFuser with EVA02-CLIP-L yields 65.81 and 77.93, for an average of 71.87. The efficiency claim is also explicit: per adapter, MVFuser uses 1.67M parameters and 17.21G FLOPs, compared with 4.20M and 98.64G for self-attention on concatenated features (Zhang et al., 4 Apr 2025).

Although MFuser does not use “mean” in the Bayesian or statistical sense, it belongs in the broader MeanFuser family because fusion is the primary operation and because the method explicitly joins complementary representations rather than replacing one encoder with another.

6. MeanFuser for end-to-end autonomous driving

The autonomous-driving method titled MeanFuser addresses two limitations of prior planners: discrete anchor vocabularies and numerical ODE integration in vanilla flow matching. The first creates a coverage–performance trade-off, because a larger vocabulary increases scene coverage but reduces per-anchor data density and inflates sampling and selection cost. The second creates an accuracy–latency trade-off, because higher numbers of function evaluations reduce solver error but increase latency (Wang et al., 23 Feb 2026).

MeanFuser replaces discrete anchors with Gaussian Mixture Noise,

$\mu(x)$5

with $\mu(x)$6 in implementation. Here, $\mu(x)$7 encodes behavioral prototypes and $\mu(x)$8 captures local uncertainty. A GMN sample $\mu(x)$9 is mapped to a trajectory proposal by a scene-conditioned generator

$m(x)$0

During training, the model selects the mixture component closest to the ground-truth trajectory and computes loss only for that selected mode:

$m(x)$1

This specialization is used only in training; inference uses all $m(x)$2 components (Wang et al., 23 Feb 2026).

The second innovation is the adaptation of MeanFlow Identity. For pairs $m(x)$3 with $m(x)$4 and $m(x)$5, the straight path is

$m(x)$6

with constant target velocity

$m(x)$7

Because

$m(x)$8

MeanFuser learns a mean displacement field and applies it in one step:

$m(x)$9

The one-step generator is therefore

$μ$00

and the flow loss is

$μ$01

This removes ODE solver error at inference and yields 1-NFE generation (Wang et al., 23 Feb 2026).

The third component is the Adaptive Reconstruction Module. If $μ$02 are proposal trajectories with features $μ$03, ARM computes

$μ$04

and a reconstruction branch produces $μ$05. The final trajectory is

$μ$06

with training loss

$μ$07

ARM therefore interpolates between selection and reconstruction rather than imposing a hard switch (Wang et al., 23 Feb 2026).

The perception backbone is ResNet-34 with three cameras—left-front, front, right-front—fused into BEV features under a TransFuser-style design. Two auxiliary heads supply map and detection supervision:

$μ$08

The end-to-end objective is

$μ$09

A reported best setting is $μ$10, giving PDMS 89.0 in the sensitivity analysis (Wang et al., 23 Feb 2026).

On the NAVSIM closed-loop benchmark, the method is evaluated without supervision of the PDM Score. The reported NFE comparison is: GoalFlow, 5 NFEs $μ$11 PDMS 85.7; MeanFuser, 1 NFE $μ$12 PDMS 87.3; vanilla flow matching, 1 NFE $μ$13 PDMS 86.9, 5 NFEs $μ$14 PDMS 87.5, 10 NFEs $μ$15 PDMS 87.0. Under the same ResNet-34 perception backbone, planning occupies 13.36% of total inference time for MeanFuser, versus 87.9% for GoalFlow and 53.3% for DiffusionDrive. ARM also shows nontrivial behavior: on 37.8% of navtest samples it produces a trajectory within 0.1 m L2 of the top-attention proposal, while deviations up to 1.7 m show reconstruction beyond any single proposal (Wang et al., 23 Feb 2026).

7. Statistical and probabilistic antecedents

Several earlier lines of work provide a broader statistical context for MeanFuser-style reasoning. In robust kernel methods, MONK studies outlier-robust mean embedding estimation in RKHSs. For a distribution $μ$16 with kernel $μ$17 and feature map $μ$18, the kernel mean embedding is

$μ$19

Instead of the classical empirical average, the method partitions the sample into blocks, computes block means

$μ$20

and robustly aggregates them, for example by the geometric median

$μ$21

The paper also develops robust MMD estimators and establishes optimal sub-Gaussian deviation bounds under mild assumptions, with resistance to adversarial contamination through the median-of-means principle (Lerasle et al., 2018).

In integrative regression with dependent outcomes, fused mean structure learning treats “mean fusion” as homogeneity discovery across studies and correlated outcome blocks. The method builds a quadratic inference function for each data source and solves a penalized GMM problem

$μ$22

where the pairwise fusion penalty is based on the MCP applied to whole-vector differences,

$μ$23

This blockwise formulation fuses parameter vectors in their entirety rather than coordinatewise, and the paper gives oracle-equivalence results together with an ADMM algorithm and a weighted oracle meta-estimator. In simulations, BIC-selected $μ$24 recovered the true partition 100% across 500 runs in the reported logistic and Poisson settings, and in the ABIDE neuroimaging application the selected $μ$25 produced $μ$26 fused groups (Hector, 2022).

In posterior aggregation, "Model Fusion with Kullback--Leibler Divergence" formulates mean-field posterior fusion as an assign-and-average procedure. Local posterior components are matched to global components by solving an assignment problem with KL-based costs, and the fused component is updated by a KL barycenter. For an exponential family

$μ$27

the reverse-KL barycenter averages natural parameters,

$μ$28

whereas the forward-KL barycenter averages mean parameters,

$μ$29

For Gaussian mean-field factors, reverse KL gives the precision-weighted update

$μ$30

This line of work is conceptually close to MeanFuser because “fusion by a KL mean” is the core update rule rather than a simple arithmetic average (Claici et al., 2020).

Across these statistical, generative, and multimodal formulations, MeanFuser denotes a family of methods in which mean structure is elevated from a background statistic to an explicit design primitive. Depending on context, that primitive can serve as a GP prior, a MOS-controlled gate, an averaged-image manifold, a sequence-fusion adapter, a continuous trajectory prior with one-step displacement, a robust RKHS center, a fused regression parameter, or a KL barycenter of posteriors.