Global-Local Logit Fusion Overview

• Global-local logit fusion is a prediction strategy that integrates full-context signals with fine-grained evidence by averaging logits to preserve directional confidence.
• Methods like LOGER, DLLG, and TriMix exemplify diverse implementations that adapt fusion for spatial deepfake detection, token-level language modeling, and adaptive competence weighting.
• This approach avoids feature alignment issues and leverages complementary model outputs to enhance calibration, error decorrelation, and overall performance across benchmarks.

Global-local logit fusion denotes a family of late-fusion schemes in which parallel predictors produce logits that encode complementary “global” and “local” evidence and those logits are combined before the final sigmoid or softmax. In LOGER, the global signal is full-image evidence from heterogeneous vision foundation models and the local signal is patch-level forgery evidence aggregated by Multiple Instance Learning; fusion is a uniform average in logit space with no temperature scaling (Wu et al., 4 Apr 2026). In DLLG, the local signal is token-level expert weighting while the global signal is response-level correctness supervision broadcast across the sequence (Li et al., 3 Jun 2026). In TriMix, the global component is the scaling benefit of a large instruction-tuned model, the local component is low-resource-language competence from a continually pretrained small model, and the final prediction is a convex combination of source logits at test time (Zhang et al., 20 Apr 2026).

1. Core formulation and scope

A recurrent formulation is a weighted sum of logits emitted by complementary branches or experts. LOGER reduces each model’s two-class output to a directional evidence score,

$d_m = l_m^{\text{fake}} - l_m^{\text{real}},$

and fuses by

$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$

DLLG fuses next-token expert logits by

$$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$

where the weights are predicted step-wise by a gate. TriMix uses

$$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$

with nonnegative weights summing to one (Wu et al., 4 Apr 2026, Li et al., 3 Jun 2026, Zhang et al., 20 Apr 2026).

System	Global signal	Local signal
LOGER	Full-image semantics/statistics	Patch-level forgery traces
DLLG	Response-level correctness	Token-level expert fusion
TriMix	Scaling and task competence	LRL competence
InfiGFusion	Sequence-wide co-activation graph	Per-step top-$k$ logits

The operational meaning of “global” and “local” is therefore domain dependent. Taken together, these works suggest that the phrase does not identify a single architecture class; rather, it identifies a prediction-level fusion pattern in which broad context and fine-grained evidence are modeled separately and reconciled directly in logit space. The same literature also shows that “global” may refer to spatial extent, sequence-level supervision, or sequence-wide structure, while “local” may refer to patches, tokens, or per-step distributions.

2. LOGER and spatial global-local logit fusion for deepfake detection

LOGER was introduced for robust deepfake detection in the wild, where forensic evidence appears at two complementary levels: global-level anomalies in semantics and statistics, and local-level forgery traces concentrated in manipulated regions. The framework uses two branches. The global branch contains three full-image models: M1 is DINOv3-H trained and inferred at $256\times256$, M2 is DINOv3-H trained at $256\times256$ and inferred at $384\times384$, and M3 is MetaCLIP2-H trained and inferred at $378\times378$. The local branch contains two patch-level models: M4 is DINOv3-L trained at $224\times224$ and inferred at $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$0, and M5 is DINOv3-L initialized from M4 and fine-tuned at $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$1. M1, M2, M4, and M5 use Flip TTA; M3 does not. The final ensemble uses uniform logit averaging across all five models with no temperature scaling (Wu et al., 4 Apr 2026).

The local branch is explicitly designed to address evidence dilution. If $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$2 patches are averaged uniformly, the per-patch contribution of a forged region scales by $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$3. LOGER instead selects the top $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$4 of patches by fake evidence:

$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$5

with $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$6. Aggregation is performed on logits rather than probabilities. Dual-level supervision comprises image-level BCE on $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$7, a pairwise AUC surrogate,

$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$8

and a patch-level MIL BCE applied on the top-$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$9 patches. The total local objective is

$$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$0

The stated rationale for logit-space fusion is threefold. Feature-space fusion would require feature alignment across heterogeneous backbones such as DINOv3 and MetaCLIP2 and across multiple resolutions. Probability averaging would compress high-confidence logits via the sigmoid and mask inter-model disagreements. Logit-space fusion preserves directional evidence and full confidence ranges, is calibration-friendly, and exploits error decorrelation induced by heterogeneous pretraining objectives, resolutions, and granularities. The ensemble is fixed-weight rather than learned end-to-end.

The training pipeline uses a multi-source candidate pool of approximately $$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$1K images from HydraFake, FaceForensics++, DF40, Celeb-DF, and ScaleDF, plus the NTIRE-2026 official 1K images. M1, M2, M4, and M5 are trained on official 1K plus 20K sampled images; M3 uses 150K sampled from official, DF40, and HydraFake. Degradation augmentation randomly composes blur, noise, JPEG compression, color shift, and spatial distortion. Optimization uses PyTorch plus timm, AdamW with $$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$2, $$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$3, weight decay $$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$4, gradient clipping at max-norm $$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$5, and WeightedRandomSampler for class imbalance. The five-model ensemble runs at approximately $$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$6 FPS on one NVIDIA H800 and is described as suitable for offline forensics.

Reported performance establishes the practical effect of the fusion rule. On the NTIRE 2026 Robust Deepfake Detection Challenge validation set, LOGER reaches image-level AUC $$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$7, compared with $$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$8 for ConvNeXt-L and $$\boldsymbol{\ell}_t = \sum_{i=1}^{K} w_{t,i}\boldsymbol{\ell}_t^{(i)}, \qquad p(y_t\mid x,y_{<t})=\mathrm{softmax}(\boldsymbol{\ell}_t),$$9 for GenD; the public and private leaderboard AUCs are $$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$0 and $$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$1, placing second overall. On the Effort protocol, LOGER attains video AUC $$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$2 versus $$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$3; on DF40 cross-manipulation, average video AUC is $$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$4 versus $$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$5, with $$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$6 on UniFace, $$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$7 on e4s, and $$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$8 on SimSwap. Under JPEG compression to QF$$z_t^F = w_T z_t^T + w_L z_t^L + w_G z_t^G, \qquad p_t^F=\mathrm{softmax}(z_t^F),$$9, the drop is approximately $k$0 points; for resizing scales $k$1–$k$2, performance stays at least $k$3; for Gaussian blur with $k$4 up to $k$5, the maximum drop is $k$6 points. Ablations on the NTIRE public test isolate the fusion effect: global-only achieves $k$7, local-only $k$8, and the full fused ensemble $k$9; majority vote gives $256\times256$0, probability averaging $256\times256$1, and logit averaging $256\times256$2.

These results make the LOGER formulation a canonical spatial example of global-local logit fusion. Its distinguishing characteristic is not merely ensembling, but ensembling after converting both full-image and top-$256\times256$3 patch branches into the same directional evidence space.

3. DLLG and global-to-local token-level fusion in LLM ensembles

DLLG addresses a different setting: multiple frozen LLM experts with a shared tokenizer and vocabulary. Each expert produces next-token logits $256\times256$4 and hidden states $256\times256$5. The gate first concatenates the expert hidden states and projects them to a shared embedding,

$256\times256$6

passes that representation through a lightweight autoregressive stem model $256\times256$7, and predicts non-negative expert weights by

$256\times256$8

The stem is Qwen2.5-0.5B-Instruct with KV caching and LoRA adapters; the backbone remains frozen, and the gate uses a low-rank projection of rank $256\times256$9 and LoRA rank $256\times256$0 (Li et al., 3 Jun 2026).

The central innovation is the way a global signal supervises a local fusion rule. For each training example and expert $256\times256$1, a binary correctness label $256\times256$2 is derived from an automatic verifier or task-specific evaluation. These sequence-level labels are broadcast to all token positions under teacher forcing, and the gate is trained by

$256\times256$3

The paper explicitly states that DLLG uses teacher forcing only, with no scheduled sampling, no RL such as REINFORCE, and no implicit differentiation. It also states that no additional entropy, sparsity, or calibration regularizers are introduced beyond this MSE.

Inference remains fully autoregressive. At each step, all experts advance in lock-step on the same prefix, the gate predicts $256\times256$4, the logits are fused, and the selected token is fed back to all experts and the gate while KV caches are maintained. This design avoids hard routing: the system never commits to a single expert and can reweight experts as subtask demands change within the same response. The paper describes smoothly evolving weights in practice, including reasoning-to-coding transitions.

Training uses approximately $256\times256$5K examples from GSM8K, MATH, and Code-R1, AdamW with learning rate $256\times256$6, batch size $256\times256$7, and $256\times256$8 steps. The experts are frozen; only the gate parameters are trained. At $256\times256$9B scale, DLLG obtains average $384\times384$0 versus $384\times384$1 for UniTe, with GSM8K $384\times384$2, MinervaMath $384\times384$3, MATH $384\times384$4, Code-R1 $384\times384$5, HumanEval $384\times384$6, MBPP $384\times384$7, and BBH $384\times384$8. At $384\times384$9B scale, the average is $378\times378$0, exceeding RouterDC’s $378\times378$1; individual scores include GSM8K $378\times378$2, MinervaMath $378\times378$3, MATH $378\times378$4, Code-R1 $378\times378$5, HumanEval $378\times378$6, MBPP $378\times378$7, BBH $378\times378$8, and BigCodeBench $378\times378$9. Ablations show that a simple MLP-head gate reaches $224\times224$0, adding cross-attention gives $224\times224$1, an auxiliary LLM yields $224\times224$2, and the full “LowRank+Aux-LLM+MLP” gate reaches $224\times224$3.

DLLG therefore generalizes the phrase “global-local logit fusion” beyond spatial fusion. Here, “local” is the per-token mixture, while “global” is the response-level supervision that shapes that mixture.

4. Structured, multi-source, and adaptive variants in language modeling

InfiGFusion defines local and global logit information explicitly. The local signal is the per-token or per-time-step logit vector $224\times224$4, optionally converted to $224\times224$5. The global signal is a co-activation graph built from top-$224\times224$6 logits across the sequence. After selecting the top-$224\times224$7 channels at each step, the method stacks those logits into $224\times224$8 and constructs the affinity matrix

$224\times224$9

Graph-on-Logits Distillation aligns student and teacher graphs with a sorting-based approximation to Gromov-Wasserstein distance, reducing the original $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$00 cost to $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$01 and yielding the overall objective

$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$02

Across $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$03 benchmarks, the reported average is $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$04, with gains of $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$05 on Multistep Arithmetic and $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$06 on Causal Judgement over SFT; removing ULD lowers average performance by $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$07, and removing GLD lowers it by $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$08 (Wang et al., 20 May 2025).

InfiFusion does not explicitly define global-local logit fusion, but its details map unified full-vocabulary teacher aggregation to a global aspect and pairwise selective fusion plus RSAF to a local aspect. The unified distribution is

$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$09

with normalized weights. Pairwise fusion uses MinCE targets teacher by teacher, and RSAF applies adaptive top-$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$10 retention over parameter deltas using variation rates and skewness-defined matrix-wise $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$11. Reported multi-source homogeneous results include GSM8K $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$12, HumanEval $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$13, and MATH $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$14 for unified fusion; Appendix B reports $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$15 epochs, batch size $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$16, learning rate $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$17, C-AdamW, and approximately $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$18 hours on $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$19 H800 GPUs (Yan et al., 6 Jan 2025).

TriMix instantiates test-time multi-source dynamic logit fusion for low-resource language adaptation. It decomposes capabilities into a task-solving vector

$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$20

a language-modeling vector

$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$21

and a scaling vector

$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$22

With the efficiency choice $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$23, the final fusion becomes

$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$24

Weights are selected without labeled LRL task data by either prompt perplexity minimization over a grid or first-token entropy minimization. The paper reports that the oracle upper bound prefers $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$25, $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$26; TriMix with perplexity guidance selects $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$27, $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$28; entropy guidance selects $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$29, $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$30; Proxy Tuning fixes $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$31, $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$32. On Qwen2.5 $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$33B-cpt + $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$34B-ins, TriMix with PPL reaches average $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$35, a $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$36 relative gain over the $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$37B-ins baseline, while Proxy Tuning slightly underperforms at $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$38. On Gemma3 $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$39B-cpt + $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$40B-ins, the average is $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$41, a $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$42 relative gain; on Llama2 $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$43B-cpt + $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$44B-ins for Indian languages, the average is $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$45, a $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$46 relative gain (Zhang et al., 20 Apr 2026).

These language-modeling variants show that global-local logit fusion can be static or dynamic, learned or heuristic, and local in either token space or domain-specialized competence. They also show that structured global information may be encoded not only as a scene-level signal but as correctness labels, co-activation graphs, or uncertainty-weighted full-vocabulary targets.

5. Relation to adjacent feature-level local-global fusion literature

A common misconception is that any local-global fusion is logit fusion. Several influential systems instead fuse features and only later decode or classify. LoGoNet performs local-to-global cross-modal fusion for 3D object detection through Global Fusion, Local Fusion, and Feature Dynamic Aggregation; its details explicitly state that it fuses features, not logits, and that a concrete logit-fusion recipe is only an adaptation proposed after the original feature pipeline (Li et al., 2023). DOLG similarly performs end-to-end image retrieval by orthogonalizing local feature components against a global representation and concatenating the orthogonal component with the global vector; its details state that DOLG fuses features or embeddings, not logits (Yang et al., 2021).

The same distinction appears in face recognition and semantic segmentation. LGAF computes global and local face embeddings, estimates quality from feature norms, and fuses the embeddings by

$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$47

before a margin-softmax classifier; the paper presents logit fusion only as an adaptation for closed-set identification, not as the default formulation (Yu et al., 2024). LoGoCAF also operates at feature level: shallow convolutional stages encode local details, deeper transformer stages encode global context, FEM and FIFM perform cross-modality enhancement and interaction, and an MLP decoder outputs a single fused logit map. The paper then describes global-local logit fusion only as an additional head design that can be placed atop the encoder-decoder system (Zhang et al., 2024). GL-Fusion for multi-view echocardiogram video segmentation likewise uses MGFM and MLFM to aggregate features across views; pseudo logits serve only to build local masks for MLFM, and the details explicitly note that there is no class-wise or pixel-wise logit fusion rule such as $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$48 (Zheng et al., 2023).

This distinction matters because the design trade-off differs. Feature-level fusion preserves spatial or structural interactions before the prediction head. Logit-level fusion is later, cheaper, and usually avoids feature alignment across heterogeneous backbones or tokenizers. The literature therefore supports two adjacent but non-identical families: local-global feature fusion and local-global logit fusion.

6. Limitations, failure modes, and open directions

The reported limitations are domain specific but recurrent. In LOGER, extreme degradations such as very heavy blur, noise, JPEG compression, low light, and grayscale conversions can erase distinguishing cues; highly localized manipulations below the effective patch size may be missed, while distributed artifacts may be underweighted by top-$$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$49 pooling. The paper also notes that fixed $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$50 and uniform fusion weights may be sub-optimal and suggests adaptive $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$51, learnable patch weighting, uncertainty-aware or quality-adaptive fusion, lightweight learned fusion with temperature calibration, temporal MIL for video, and multimodal extensions (Wu et al., 4 Apr 2026).

DLLG inherits the cost of running all experts at every token. Its memory footprint scales with the experts’ KV caches and activations, it assumes a shared tokenizer and vocabulary, and it depends on response-level labels from verifiers that may be noisy or unavailable. The paper lists adaptive preselection, hierarchical gating, vocabulary alignment, regularization when weight collapse occurs, and distillation of the fused behavior into a single model as future directions (Li et al., 3 Jun 2026).

InfiGFusion reports that its structural signal is most helpful on structure-dependent reasoning and may yield marginal benefit when tasks are dominated by literal token matching or factual recall. It also does not explicitly resolve conflicting factual knowledge among sources, even though it aligns relational consistency (Wang et al., 20 May 2025). TriMix assumes direct access to logits, compatible tokenizers, and synchronized multi-model decoding; it increases inference latency and memory because three models run in parallel, and the $$d_{\text{fused}}(x) = \frac{1}{M}\sum_{m=1}^M d_m(x), \qquad p(x)=\sigma(d_{\text{fused}}(x)).$$52 constraint trades flexibility for efficiency. The paper identifies vocabulary expansion, mapped logits across tokenizers, closed-source applicability, more advanced routing, and compression or distillation of fused behavior as future work (Zhang et al., 20 Apr 2026).

Taken together, these limitations suggest that the central open problem is not whether global-local logit fusion is useful, but how its weighting, calibration, and structural assumptions should adapt to content, degradation regime, expert disagreement, and resource budget. The recent literature already points to the main axes of refinement: adaptive or learned gating, structure-aware global signals, uncertainty-aware calibration, and mechanisms for reducing the inference cost of multi-branch or multi-expert fusion.