---
title: 'MeanFuser: Mean-Based Fusion Across Domains'
url: https://www.emergentmind.com/topics/meanfuser
type: topic
---

# MeanFuser: Mean-Based Fusion Across Domains

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="2004.08349 2401.13249 2606.30528 2504.03193 2602.20060 1802.04784 2210.02198 2007.06168", 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" [2602.20060], while closely related usages appear as a practical “MeanFuser” strategy for Gaussian-process mean selection in Bayesian optimisation [2004.08349], as MOS-guided model fusion in fake audio detection [2401.13249], as the averaging component of $μ$Flow for one-class deepfake detection [2606.30528], as the Mamba-based semantic-segmentation framework MFuser [2504.03193], and in statistical settings involving robust mean embedding estimation, fused mean structure learning, and KL-based posterior fusion [1802.04784] [2210.02198] [2007.06168]. 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 [2602.20060] [2004.08349] [2401.13249] [2606.30528] [2504.03193] [1802.04784] [2210.02198] [2007.06168].

## 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 [2004.08349].

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 $\ge 5$, 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 $7.47\mathrm{e}{-4}$ vs Arithmetic $4.00\mathrm{e}{-3}$; Michalewicz (10D): Max $2.75\mathrm{e}{-2}$ vs Arithmetic $7.22\mathrm{e}{-2}$; Rosenbrock (10D): Max $6.95\mathrm{e}{+02}$ vs Arithmetic $8.38\mathrm{e}{+02}$; and Styblinski–Tang (10D): Max $2.84\mathrm{e}{+01}$ vs Arithmetic $6.47\mathrm{e}{+01}$ [2004.08349].

The mechanism is explicit in the acquisition formulas. For minimization,
$$
EI(x) = (f_{best}-\mu(x))\Phi(z) + \sigma(x)\phi(z),
\qquad
z = \frac{f_{best}-\mu(x)}{\sigma(x)},
$$
and the paper’s UCB implementation is
$$
\alpha_{UCB}(x) = -(\mu(x)-\sqrt{\beta_t}\sigma(x)).
$$
If $m(x)$ is large, then $\mu(x)$ is large far from data, so EI and UCB both suppress blind exploration unless $\sigma(x)$ 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 [2004.08349].

The practical “MeanFuser” strategy proposed there is a portfolio method. It maintains
$$
M=\{\text{Max, Arithmetic, Median, Linear, Quadratic, RF, RBF}\},
$$
fits each candidate at each BO iteration, scores them by model evidence, predictive CV error, or one-step lookahead utility, and then either selects
$$
j^*=\arg\max_j score_j
$$
or fuses them with
$$
w_j \propto \exp(\tau \cdot score_j), \qquad m_{mix}(x)=\sum_j w_j m_j(x),
$$
or alternatively
$$
\alpha_{mix}(x)=\sum_j w_j \alpha_j(x).
$$
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 [2004.08349].

## 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 [2401.13249].

The MOS predictor uses VoiceMOS Challenge 2022 main track labels in $[1,5]$, quantized into 33 bins at a step of 0.125. With CrossEntropy training, each sample produces logits $u_n \in \mathbb{R}^{33}$ and probabilities $p_n=\mathrm{softmax}(u_n)$, and a scalar MOS can be reconstructed by expectation over bin centers,
$$
\hat{z}_n=\sum_{c=1}^{33} p_{n,c}\cdot c.
$$
The fused SSL-MOS combines seven per-SSL MOS predictions $Z=[z_1,\dots,z_n]$ using a 2-layer NN:
$$
h = W_1 Z,
\qquad
z_f = w^\top Z + v^\top h + b.
$$
Training uses SGD, learning rate 0.001, CrossEntropy loss, and early stopping if dev loss does not improve for 20 epochs [2401.13249].

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 $[3.0,4.0]$ for training and validation. The reported counts are Train: 25,380 $\to$ 5,034; Real: 2,580 $\to$ 2,568; Fake: 22,800 $\to$ 2,466; and Dev: 22,438 $\to$ 5,198; Real: 2,548 $\to$ 2,533; Fake: 22,438 $\to$ 2,665. This balances classes and focuses learning on the overlap region [2401.13249].

The second intervention is the fusion gate itself. Weighted probability fusion is
$$
p(y|x)=\sum_{i=1}^{K} w_i(m(x))\, p_i(y|x),
$$
and weighted logit fusion is
$$
z(x)=\sum_{i=1}^{K} w_i(m(x))\, z_i(x), \qquad p(y|x)=\sigma(z(x)).
$$
MOS-FAD also uses a piecewise threshold gate:
- If $m(x)\le M1$, force fake.
- If $m(x)\ge M2$, force real.
- Else, fuse detectors normally.

The reported thresholds are $M1=2.5$ and $M2=4.0$. In the Gated MLP, if $Y=[y_1,\dots,y_K] \in [0,1]^K$, the gate is
$$
g=\sigma(W_g \cdot \phi(m(x))) \in (0,1)^K,
$$
the gated inputs are
$$
\hat{Y}=g \odot Y,
$$
and the head is
$$
h_1=W_1 \cdot \hat{Y}, \qquad
h_2=\sigma(W_2 \cdot h_1 + b_2), \qquad
z=w^\top h_2+b, \qquad
p(y=\text{“fake”}|x)=\sigma(z).
$$
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 $=0.1351$ on ASVspoof2021 DF eval, better than prior SOTA 0.1564 and corresponding to a 13.6% relative EER reduction, significant at $p=0.01$ [2401.13249].

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

$μ$Flow 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
$$
\bar{I}=\frac{1}{N}\sum_{i=1}^{N} I_i,
$$
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 [2606.30528].

Feature extraction is performed by a frozen ResNet-50 pretrained on ImageNet-1K. If $\phi(\cdot)$ denotes the feature extractor, the method constructs averaged real images
$$
\bar{I}_R^{\,j}=\frac{1}{K}\sum_{i\in S_j} I_R^{\,i}, \qquad
\bar{x}_R^{\,j}=\phi(\bar{I}_R^{\,j}),
$$
fits a target distribution $p(u)$ on averaged real features, and trains a FastFlow normalizing flow $f_\theta$ so that single-image features $v=\phi(I)$ align with that distribution. In the main derivation and experiments, the target is a single Gaussian
$$
p_Z^\star(z)=\mathcal{N}(\mu^\star,\Sigma^\star),
$$
although the figure also shows a GMM variant [2606.30528].

The likelihood is obtained through the change-of-variables formula,
$$
\log p_X(x)=\log p_Z(f_\theta(x))+\log\left|\det\left(\frac{\partial f_\theta(x)}{\partial x}\right)\right|,
$$
and training minimizes
$$
\mathcal{L}_{\mathrm{NLL}}(\theta)
=
-
\mathbb{E}_{x_R}
\Big[
\log p_Z^\star(f_\theta(x_R))
+
\log |\det J_{f_\theta}(x_R)|
\Big].
$$
With a single Gaussian base, the paper rewrites this in terms of Mahalanobis distance. At test time,
$$
\ell(I)=\log p_Z^\star(f_\theta(\phi(I)))+\log|\det J_{f_\theta}(\phi(I))|
$$
or equivalently
$$
s(I)=d^2_{P_Z^\star}(f_\theta(\phi(I))) - \log|\det J_{f_\theta}(\phi(I))|,
$$
with “lower is more real; higher is more fake.” Thresholding uses
$$
\tau = m + \gamma_{1-\alpha}\sigma,
$$
with $\alpha=0.01$ in experiments [2606.30528].

The implementation uses random subsets from real-only training data, $K=500$ images per average chosen via a Silhouette score analysis, AdamW with learning rate $1\mathrm{e}{-4}$, weight decay $1\mathrm{e}{-5}$, 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 [2606.30528].

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 [2606.30528].

## 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-Language Models 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 [2504.03193].

Given per-block features $x_i^{VFM}$ and $x_i^{VLM}$, MVFuser takes their concatenation and returns residual offsets:
$$
[\Delta x_i^{VFM}; \Delta x_i^{VLM}] = MVFuser([x_i^{VFM}; x_i^{VLM}]),
$$
$$
x_i^{VFM'} = x_i^{VFM} + \Delta x_i^{VFM}, \qquad
x_i^{VLM'} = x_i^{VLM} + \Delta x_i^{VLM}.
$$
Its internal structure is a bottleneck with parallel sequential and spatial branches,
$$
x_i^{(seq)} = SSM(conv(proj([x_i^{VFM}; x_i^{VLM}]))),
\qquad
x_i^{(spa)} = conv(proj([x_i^{VFM}; x_i^{VLM}])),
$$
followed by gated fusion
$$
[\Delta x_i^{VFM}; \Delta x_i^{VLM}] = proj(x_i^{(seq)} \otimes x_i^{(spa)}).
$$
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 [2504.03193].

MTEnhancer operates on class text embeddings $q_t=[t^1,\dots,t^C]$. It first applies self-attention,
$$
q_t = q_t + Attention(q_t),
$$
then performs a conditional Mamba scan on the bracketed sequence
$$
[q_t; x_v; q_t^{copy}],
$$
yielding
$$
[\Delta q_t; \Delta x_v; \Delta q_t^{copy}] = Mamba([q_t; x_v; q_t^{copy}]),
$$
and updates the text queries by
$$
q_t = q_t + \Delta q_t + \Delta q_t^{copy},
\qquad
q_t = q_t + MLP(q_t).
$$
The resulting image-conditioned text queries are consumed by a Mask2Former decoder [2504.03193].

Training uses 512×512 crops, batch size 2, AdamW, base learning rate $1\mathrm{e}{-4}$, 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
$$
\mathcal{L}_{total}=\mathcal{L}_{seg}+\mathcal{L}_{align}.
$$
Reported performance is 68.20 mIoU on synthetic-to-real and 71.87 mIoU on real-to-real benchmarks. On GTA5 $\to$ \{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 $\to$ \{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 [2504.03193].

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 [2602.20060].

MeanFuser replaces discrete anchors with Gaussian Mixture Noise,
$$
p_{GMN}(z)=\sum_{k=1}^{K} \pi_k \,\mathcal{N}(z\mid \mu_k,\Sigma_k),
$$
with $K=8$ in implementation. Here, $\mu_k$ encodes behavioral prototypes and $\Sigma_k$ captures local uncertainty. A GMN sample $z$ is mapped to a trajectory proposal by a scene-conditioned generator
$$
\hat{x}=g_\theta(z,c).
$$
During training, the model selects the mixture component closest to the ground-truth trajectory and computes loss only for that selected mode:
$$
k^*(x)=\arg\min_{k\in\{1,\dots,K\}} \|\mu_k-\phi(x)\|_2.
$$
This specialization is used only in training; inference uses all $K$ components [2602.20060].

The second innovation is the adaptation of MeanFlow Identity. For pairs $(z,x)$ with $z\sim p_{GMN}$ and $x\sim p_{data}(\cdot|c)$, the straight path is
$$
x_t=(1-t)z + tx, \qquad t\in[0,1],
$$
with constant target velocity
$$
u^*(x_t,c,t)=x-z.
$$
Because
$$
\int_0^1 u^*(x_t,c,t)\,dt = x-z,
$$
MeanFuser learns a mean displacement field and applies it in one step:
$$
g_\theta(z,c)=z+\int_0^1 u_\theta(x_t,c,t)\,dt \approx z + u_\theta(z,c).
$$
The one-step generator is therefore
$$
\hat{x}=g_\theta(z,c)=z+u_\theta(z,c),
$$
and the flow loss is
$$
\mathcal{L}_{flow}
=
\mathbb{E}
\big\|
u_\theta(z,c)-(x-z)
\big\|_2^2.
$$
This removes ODE solver error at inference and yields 1-NFE generation [2602.20060].

The third component is the Adaptive Reconstruction Module. If $\{P_i\}_{i=1}^N$ are proposal trajectories with features $h_i$, ARM computes
$$
s_i = w^\top \psi([h_i \,\|\, c]),
\qquad
\alpha_i = \frac{\exp(s_i)}{\sum_{j=1}^{N}\exp(s_j)},
$$
and a reconstruction branch produces $r_\theta(c,\{P_i\})$. The final trajectory is
$$
\hat{T}
=
\sum_{i=1}^{N}\alpha_i P_i + \alpha_0 r_\theta(c,\{P_i\}),
$$
with training loss
$$
\mathcal{L}_{arm}=\|\hat{T}-x\|_2^2.
$$
ARM therefore interpolates between selection and reconstruction rather than imposing a hard switch [2602.20060].

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:
$$
\mathcal{L}_{map}=\mathrm{BCE}(\hat{M},M),
\qquad
\mathcal{L}_{det}=0.1\,\mathcal{L}_{ce}+1.0\,\mathcal{L}_{L1}.
$$
The end-to-end objective is
$$
\mathcal{L}
=
\lambda_{map}\mathcal{L}_{map}
+
\lambda_{det}\mathcal{L}_{det}
+
\lambda_{flow}\mathcal{L}_{flow}
+
\lambda_{arm}\mathcal{L}_{arm}.
$$
A reported best setting is $(\lambda_{map},\lambda_{det},\lambda_{flow},\lambda_{arm})=(1.0,0.1,7.0,2.0)$, giving PDMS 89.0 in the sensitivity analysis [2602.20060].

On the NAVSIM closed-loop benchmark, the method is evaluated without supervision of the PDM Score. The reported NFE comparison is: GoalFlow, 5 NFEs $\to$ PDMS 85.7; MeanFuser, 1 NFE $\to$ PDMS 87.3; vanilla flow matching, 1 NFE $\to$ PDMS 86.9, 5 NFEs $\to$ PDMS 87.5, 10 NFEs $\to$ 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 [2602.20060].

## 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 $P$ with kernel $k$ and feature map $\varphi$, the kernel mean embedding is
$$
\mu_P = \mathbb{E}_{X\sim P}[\varphi(X)].
$$
Instead of the classical empirical average, the method partitions the sample into blocks, computes block means
$$
\hat{\mu}_j=\frac{1}{|B_j|}\sum_{i\in B_j}\varphi(x_i),
$$
and robustly aggregates them, for example by the geometric median
$$
\hat{\mu}_{MoM}
=
\arg\min_{u\in\mathcal{H}} \sum_{j=1}^{b}\|u-\hat{\mu}_j\|_{\mathcal{H}}.
$$
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 [1802.04784].

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
$$
Q_N(\beta;\lambda)
=
\frac{1}{2} g_N(\beta)^\top V_N(\beta)^{-1} g_N(\beta)
+
\lambda P(\beta),
$$
where the pairwise fusion penalty is based on the MCP applied to whole-vector differences,
$$
P(\beta)
=
\sum_{\{(j,k),(j',k')\}\in H}
p_\delta(\|\beta_{jk}-\beta_{j'k'}\|_1,\lambda).
$$
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 $\lambda$ recovered the true partition 100% across 500 runs in the reported logistic and Poisson settings, and in the ABIDE neuroimaging application the selected $\hat{\lambda}=1$ produced $\hat{G}=4$ fused groups [2210.02198].

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
$$
q(\theta;\eta)=h(\theta)\exp(\langle \eta,T(\theta)\rangle - A(\eta)),
$$
the reverse-KL barycenter averages natural parameters,
$$
\eta^*=\sum_i w_i \eta_i,
$$
whereas the forward-KL barycenter averages mean parameters,
$$
\nabla A(\eta^*)=\sum_i w_i \nabla A(\eta_i).
$$
For Gaussian mean-field factors, reverse KL gives the precision-weighted update
$$
\Sigma_*^{-1}=\sum_i w_i \Sigma_i^{-1},
\qquad
\mu_*=\Sigma_* \left(\sum_i w_i \Sigma_i^{-1}\mu_i\right).
$$
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 [2007.06168].

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.

Source: https://www.emergentmind.com/topics/meanfuser