Header Ad Placement

SAE Interprets MoE: Exact Contribution Decomposition, Dominant Latent Sets, and What 128 Experts Actually Do

INTERPRETABILITY

Do MoE experts specialize? The paper's premise is that counting which tokens get routed where has produced mixed conclusions. A sparse autoencoder trained on the layer's output changes the instrument: each latent's pre-activation decomposes exactly over the experts, and read that way the division of labor is real, fine-grained, and very unevenly funded.

By Ossam Hashim

KEY FINDINGS

  • Prior analyses of Mixture-of-Experts specialization share one instrument: count how often each expert is selected on domain-labeled corpora. That fixes the taxonomy in advance, stays coarse, and records selection rather than contribution. A ByteDance Seed team instead studies specialization in feature space, training a top-k sparse autoencoder (about 1M latents) on the output of an MoE layer.
  • The decomposition is exact, not approximate. The layer output is a router-weighted sum of expert outputs and the SAE encoder is affine in that output, so every latent's pre-activation splits algebraically into per-expert contributions. Aggregated over a 1.5B-token validation corpus, each expert earns a dominant set: the latents whose activation it principally drives (contribution fraction at least 0.2, versus the 0.008 an even split across 128 experts would give).
  • Contribution is far more concentrated than gating. At layer 30 of Qwen3-30B-A3B, the top-ranked expert supplies on average 0.512 of a latent's activation while the top gating weight is 0.231; 85 to 93 percent of latents have at most two dominators across layers 4, 30 and 46; the overlap between experts' dominant sets concentrates on a few pairs; about half of each expert's set is its alone.
  • The specialization sits below domain labels. Auto-interpretation (GPT-5.5 reading activating contexts and logit effects) finds a Java expert whose dominant set is 86.7% Java-themed versus 1.9% in a random draw, a front-end web expert at 78.6%, and inside mathematics a geometry expert (78.1%) distinct from an arithmetic-and-polynomials one (59.1%). Code does not get an expert; Java, DOM events and binary-search loop conditions do.
  • The allocation of experts across coarse domains is strongly unequal: computing takes 28 of the 128 experts in layer 30 and mathematics-and-reasoning 20, 37.5% of the layer together, while art appears in exactly one expert's label. The authors conjecture the split mirrors pretraining-data proportions - which Qwen3 does not disclose, so that reading stays a conjecture. SAEs and code are public.

Selection Is Not Contribution

The router of an MoE layer is the obvious place to look for specialization, and the obvious measurement is a count: route a corpus labeled by domain, tally which experts fire on which labels. The mixed verdicts of that literature - experts are domain specialists; no, routing is driven by surface token identity - are, the authors argue, verdicts on the instrument. Selection counts say nothing about what a selected expert contributes, and the labels decide in advance which distinctions count as knowledge. A Java expert and a front-end expert are both just "code" under such a taxonomy. The feature-space route dodges both problems. An SAE learns an overcomplete, comparatively monosemantic dictionary over the layer output. Because the output is a weighted sum of expert outputs and the encoder is affine, each latent's pre-activation equals a bias plus one contribution term per active expert - an exact identity the paper carries through in five lines of algebra. Normalize each contribution by the latent's total, average over the corpus, renormalize across the 128 experts, and you have a contribution fraction per (expert, latent) pair. Threshold it, and every expert owns a readable set of latents. The analysis needs only expert outputs and an SAE on the layer output, so it ports to any MoE layer built as a weighted sum of experts.

What the Decomposition Shows

First, the concentration is not a routing artifact. Gating weights are uneven by construction - the router renormalizes its top eight - so the authors compare rank profiles: averaged by rank, gating decays gently (0.231, 0.169, 0.137 at layer 30) while contribution falls off a cliff (0.512, 0.185, 0.115, and just 0.005 by rank seven against gating's 0.074). Most latents get the bulk of their activation from one or two experts even though the router picked eight. The ReLU truncation in the decomposition removes on average only one to two of the eight experts per latent, so it cannot explain the steepness. The resulting dominance graph (edges where an expert's contribution fraction to a latent clears 0.2) is structured, not mushy. Between 85.1% and 92.7% of latents have at most two dominators depending on layer, and degree three or more never exceeds 3.7%. Most expert pairs share almost nothing - median pairwise Jaccard near 10^-4 - while the top 10% of pairs carry about four-fifths of all overlap; at layer 30, 19 of the 20 most-overlapping pairs sit inside the same domain. Each expert's dominant set is mostly its own: 46 to 59 percent of it is dominated by that expert alone.

Reading the Experts

Interpretation is where the method pays off. Sampled latents from each dominant set are auto-interpreted, and the explanations concentrate on a few themes per expert. Expert 50 at layer 30 is Java and Android - Java imports, JDBC generated keys; expert 57 is front-end web, carried by HTML, CSS, JavaScript and framework names; expert 72 carries two themes at once, exercise-and-health and algorithms-and-data-structures, with one latent that fires only at the <= operator of a binary search, explained as "Binary search loop condition". A token-level word cloud of the same expert surfaces "the, and, of" - the feature level is where the semantics live. Theme-purity checks against a random draw from the other 127 experts' sets show the separations are real: 86.7% versus 1.9% for Java, 78.6% versus 3.5% for front-end, 78.1% versus 2.0% for geometry. Grouped into eleven GPT-5.5-named domains, the layer's budget is lopsided: computing (28 experts) and mathematics-and-reasoning (20) hold 37.5% of the layer; three domains that are not subject areas at all - text form (punctuation, delimiters, encoding artifacts), language, and entities-and-identifiers - quietly absorb another 36 experts, 28.1%; art appears once. The plausible driver is the training mixture: Llama 3's published mix, for contrast, is roughly 25% math-and-reasoning and 17% code tokens. On Qwen3's undisclosed mixture, the authors are explicit that this link is conjecture. The practical payoff they point to is testable: if an expert chiefly affects the latents it dominates, dominant sets are a targeting map for expert pruning, merging, and feature-level steering.

Assumptions and limitations

All findings are the authors' own, on one model (Qwen3-30B-A3B, layers 4, 30 and 46 of 48) with one SAE per layer; which observations generalize across MoE families is untested. The analysis inherits SAE imperfections - reconstruction error and features split or absorbed across latents. Statistics are computed on the authors' 1.5B-token corpus, not the model's undisclosed pretraining data, so domain allocation reflects routing on that corpus, and the training-mixture explanation is the authors' stated conjecture. Auto-interpretation, theme judging, expert labeling and domain grouping all run through GPT-5.5, so the semantic readings inherit that judge's failure modes (the authors publish every prompt). Dominance is a thresholded statistic (0.2), not a causal claim that an expert alone produces a feature. The worked example is an invented toy with illustrative numbers, not the paper's measurements or code.

Worked Example: One Latent, Split Exactly

The whole trick fits in a few lines. A latent's pre-activation is the encoder bias plus a router-weighted dot product per active expert - so the per-expert terms can be read off individually. The toy below uses two experts with gating 0.6 and 0.4, then prints each one's share of the latent. The second expert was routed with 40% of the weight yet supplies 13% of this latent's activation: selection and contribution part ways, and with a 0.2 dominance threshold only one expert owns this latent.

import math

g = (0.6, 0.4)   # router weights
e1 = (2.0, 0.0)  # expert outputs
e2 = (0.0, 1.0)
w = (0.9, 0.4)   # encoder row
b = 0.1          # encoder bias

def decompose(g, outs, w):
    terms = []
    for gj, ej in zip(g, outs):
        dot = sum(wi*ei
                  for wi, ei
                  in zip(w, ej))
        terms.append(gj * dot)
    return terms

t = decompose(g, (e1, e2), w)
tot = math.fsum(t)
print('pre-act:', round(b + tot, 2))
for j, tj in enumerate(t):
    s = tj / tot
    tag = 'dom' if s >= .2 else '-'
    print(j+1, round(s, 2), tag)

Sources & Provenance

  • SAE Interprets MoE: Sparse AutoEncoders Reveal That MoE Experts Exhibit Human-Interpretable Fine-Grained Specialization (Zhuo, Zhang, Lin, Lu; ByteDance Seed & Shanghai University of Finance and Economics, 5 Nov 2026) - arXiv abstract
  • Full paper (PDF): decomposition algebra, dominance-graph statistics, theme-purity tables - arXiv full text
  • SAEs and code - project repository

All figures are attributed to the preprint as published. Sources accessed 8 November 2026. This analysis is independent editorial content for GlobalTechDigest.

Comments

Kubernetes Liveness Is Not Readiness: Why a Health Check Can Amplify an Outage

KUBERNETES FAILURE RECOVERY A failed health check is an observation. Restarting a container and withholding traffic are different responses, and choosing the wrong one can amplify an outage. By Hossam The important question is what failure should trigger A web application loses access to its shared database. Its processes are still running, but requests that require database access fail. A health endpoint reports the dependency problem. Should Kubernetes restart every application container, or stop directing those requests to it? The endpoint alone cannot choose the right recovery action. Kubernetes separates startup, liveness and readiness probes because they answer different operational questions. Startup protects initialization, liveness can trigger container termination and restart handling, and readiness controls eligibility for traffic from matching Services. A green check is meaningful only within the check and response that were designed. This is a documentation-based de...

Editorial Governance & Pages