📊 statistics

The Geometry of Updates: Fisher Alignment at Vocabulary Scale

This paper introduces FisherSketch, a training-free, streaming-efficient method that estimates head Fisher alignment via kernel mean embeddings to enable scalable source selection and task similarity diagnostics for LLM families with shared vocabularies, overcoming the limitations of representation-only metrics and the computational cost of full Fisher matrices.

Original authors: John Sweeney

Published 2026-06-26

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: John Sweeney

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a giant, highly trained language model (like a super-smart robot that knows how to speak many languages). Now, imagine you want to teach this robot a new, specific skill, like writing chemical formulas (SMILES) or understanding protein structures.

The big question is: Which existing dataset should you use to teach it this new skill?

Usually, people try to answer this by looking at how the robot "thinks" (its internal activations) when it sees data. They ask, "Does the robot see chemical formulas the same way it sees protein sequences?" If the answer is "yes," they assume the robot will learn the new task easily.

The Problem: The "Dark Room" of Learning
This paper argues that looking only at how the robot "thinks" is like trying to navigate a dark room by feeling the walls. You might feel the same wall in two different rooms, but that doesn't mean the furniture (the goal) is in the same place.

The authors call this the "Activation-Dark" regime. Two tasks might look identical to the robot's internal sensors (activations), but the errors it makes when trying to solve them might point in completely opposite directions. If you train the robot on the wrong data, it might learn to push the solution in the wrong direction, even if it "feels" the same.

The Solution: FisherSketch (The "Telescope" for Updates)
The authors introduce a new tool called FisherSketch. Instead of just looking at what the robot sees, they look at how the robot plans to change itself to solve the problem.

Here is the core idea broken down with an analogy:

1. The "Update" is the Real Story

Imagine the robot is a student taking a test.

Representation Similarity (Old Way): You look at the student's face while they read the question. If they look focused and serious for both Math and History, you assume they will do well in both.
Fisher Alignment (New Way): You look at the corrections the student makes on their answer sheet.
- For Math, they might realize, "I need to add more numbers."
- For History, they might realize, "I need to write more dates."
- Even if they look the same while reading, their plans to fix their mistakes are totally different.

The paper proves that if you only look at the "face" (activations), you can't predict the "corrections" (updates). Two tasks can look identical but require opposite changes.

2. The "Vocabulary Scale" Challenge

The robot has a massive vocabulary (over 128,000 words). To calculate the "correction plan" for every single word, you would normally need a computer with more memory than exists on Earth (61 Gigabytes per task!). This is impossible to do for thousands of different tasks.

FisherSketch is like a magic compression trick.

Instead of writing down the entire 61GB correction plan, it creates a tiny 16 KB "signature" (about the size of a small photo).
It does this by taking a single "streaming pass" over the data, using a clever mathematical trick (random projections) to estimate the direction of the corrections without ever writing them all down.
It captures three things:
1. Activations: What the robot sees.
2. Errors: Where the robot goes wrong.
3. Coupling: How the "seeing" and the "going wrong" interact.

3. The "Verbalizer Shift" Experiment

To prove their point, the authors ran a specific test called a "Verbalizer Shift."

They gave the robot a fixed prompt: "The answer is..."
They changed only the final word (the "verbalizer"), like changing "Yes/No" to "True/False."
The Result: The robot's internal "thinking" (activations) stayed exactly the same because the prompt was identical. Old methods said, "These tasks are 100% identical!"
The Reality: The robot's ability to learn changed drastically depending on the final word.
FisherSketch correctly predicted this change because it looked at the error geometry (how the specific final word changed the robot's mistakes), while the old methods were blind to it.

Summary of Claims

Old Methods Fail: Metrics like CKA (which compare internal "thoughts") cannot predict if a robot will learn a new task well if the "errors" are different, even if the "thoughts" are the same.
New Method Works: FisherSketch estimates the "Fisher Alignment" (the similarity of update plans) directly from the data stream.
Efficiency: It compresses massive data into tiny 16 KB signatures, making it possible to compare thousands of tasks instantly.
Accuracy: In tests with Llama-3.1-8B, FisherSketch was much better at picking the right source data for fine-tuning than methods that only looked at activations, especially in tricky cases where the "thinking" didn't change but the "learning goal" did.

In short, the paper says: Don't just ask what the robot sees; ask how it plans to fix its mistakes. And you can do this efficiently, even for the biggest models, using their new "FisherSketch" tool.

Technical Summary: The Geometry of Updates: Fisher Alignment at Vocabulary Scale

1. Problem Statement

The paper addresses the challenge of training-free source selection for Large Language Model (LLM) families that share a vocabulary but differ in prediction targets (e.g., adapting a shared tokenizer to SMILES, protein sequences, or genomic data).

Current transferability metrics face a dilemma in this "activation-dark" regime:

Representation-similarity metrics (e.g., CKA, RSA, SVCCA) compute similarity based on frozen activations. The authors argue these are non-identifiable for head-level transfer because they ignore the geometry of label-conditioned errors. Models can share identical representations yet have orthogonal update directions.
Classical update-geometry metrics (e.g., Fisher alignment) theoretically capture the necessary update structure but are computationally prohibitive at vocabulary scale ( $K \sim 10^5$ ). Storing the error second-moment matrix ( $\Gamma_e$ ) requires $\approx 61$ GiB per task, making exact computation infeasible for large candidate sets.

The core question is: How can one efficiently estimate the geometric compatibility of parameter updates (Fisher alignment) at vocabulary scale without materializing massive matrices or relying on potentially misleading activation-only signals?

2. Methodology

Theoretical Foundation

The authors establish that for a linear head, the per-example gradient $g$ factorizes exactly into the Kronecker product of the penultimate activation $a$ and the logit-space error $e$ (i.e., $g = a \otimes e$ ).

Non-Identifiability of Representation Metrics: The paper proves (Theorem 3.2) that representation-only metrics cannot determine head Fisher alignment. It constructs a "witness" where tasks share identical representations ( $Z_i = Z_j$ ) but have disjoint label sets, resulting in orthogonal head gradients ( $A_F(i, j) = 0$ ). Thus, $M(Z_i, Z_j)$ cannot distinguish between identical tasks and orthogonal tasks.
Fisher Alignment as a Product-Kernel Cosine: The central theoretical contribution (Theorem 4.2) rewrites head Fisher alignment as the cosine similarity between kernel mean embeddings in a joint $(a, e)$ $(a, e)$ feature space.
$A_F^{head}(i, j) = \cos(\mu_{ae, i}, \mu_{ae, j})$
where $\mu_{ae, k}$ $μ_{a e, k}$ is the mean embedding of the product kernel $k_{ae}((a, e), (a', e')) = (a^\top a')^2 (e^\top e')^2$ $k_{a e} ((a, e), (a^{'}, e^{'})) = (a^{⊤} a^{'})^{2} (e^{⊤} e^{'})^{2}$ .
This decomposition reveals that transferability depends on three factors:
1. Activation Geometry: Similarity of activation second moments ( $M_a$ ).
2. Error Geometry: Similarity of error second moments ( $\Gamma_e$ ).
3. Coupling: A non-separability ratio ( $\rho$ ) measuring the deviation from the assumption that activations and errors are independent.

Algorithm: FisherSketch

To make this tractable at vocabulary scale, the authors introduce FisherSketch, a streaming, single-pass estimator.

Random Maclaurin Features: Instead of computing the full $O(d^2 K^2)$ embedding, FisherSketch uses factored random projections (Rademacher vectors) to estimate the product kernel expectation.
Efficiency: It exploits the Kronecker structure to compute projections separately for $a$ and $e$ , reducing per-sample complexity from $O(mdK)$ to $O(m(d+K))$ .
Subsampled Randomized Hadamard Transform (SRHT): For the high-dimensional error space ( $K \approx 128,256$ ), SRHT is used to reduce the projection cost from $O(mK)$ to $O(K \log K + m)$ .
Output: The method produces a compact 16 KB task signature (a vector in $\mathbb{R}^m$ with $m=4096$ ) per task, encoding the joint activation-error geometry. It also maintains a small 192 KB streaming state for split-sample estimation to reduce bias.

3. Key Contributions

Non-Identifiability Proof: Formal demonstration that representation-similarity metrics (CKA, RSA, SVCCA) are insufficient for predicting head-level transfer without assumptions on error geometry or label mapping.
Exact Decomposition Identity: Proof that head Fisher alignment is exactly a product-kernel cosine between joint mean embeddings, providing a rigorous three-factor decomposition (activation, error, coupling).
FisherSketch: A scalable, training-free estimator that compresses task geometry into a 16 KB signature, enabling vocabulary-scale comparisons ( $K=128,256$ ) with a 192 KB per-task streaming state.
Diagnostic Instrument: The signatures allow researchers to disentangle whether task similarity is driven by activations, errors, or their coupling, serving as a probe for "activation-dark" regimes.

4. Results

Vocabulary-Scale Source Selection

Evaluated on Llama-3.1-8B across 100 domains:

Performance: FisherSketch achieved 45.7% Top-1 source selection accuracy (approx. 10.9 $\times$ random baseline) with a max regret of 0.119.
Comparison: It was competitive with activation-only baselines on natural domain shifts but significantly outperformed them in specific regimes.
Efficiency: Reduced storage requirements from ~61 GiB per task (for exact $\Gamma_e$ ) to 16 KB.

Identifiability Stress Test (Verbalizer Shift)

In a controlled experiment using fixed-prefix prompts where activations were identical across different verbalizers (e.g., "Yes/No" vs. "True/False"):

Activation-Only Failure: Activation similarity ( $Scov(M_a)$ ) collapsed to a constant (random baseline performance of 20% Top-1).
FisherSketch Success: FisherSketch achieved 66.7% Top-1, successfully predicting transfer variations driven solely by changes in label-conditioned error geometry.
Error-Only Marginal: The error-only marginal ( $Scov(\Gamma_e)$ ) also performed well (72.2% Top-1), confirming that when activation geometry is constant, error geometry drives the signal.

Scientific Sequence Proof of Concept

On molecular SMILES domains, FisherSketch correlated significantly with cross-domain perplexity reduction ( $\rho_s=0.53, p=0.006$ ), whereas activation-only similarity was not significant ( $p=0.081$ ).

Estimator Validation

On ViT-B/16, FisherSketch showed high Spearman correlations with exact Fisher alignment for joint similarity ( $\hat{S}_{ae}$ : 0.97) and coupling ( $\hat{\rho}$ : 0.95). The method achieved an 89 $\times$ speedup over exact computation at $n=2000$ samples.

5. Significance and Claims

The paper claims to provide a practical, training-free mechanism for source selection in shared-vocabulary LLM families where traditional metrics fail due to the "activation-dark" nature of the problem.

Operational Impact: It enables automated fine-tuning source selection, interference-aware continual learning, and inference-time routing based on predicted parameter-update compatibility rather than just representation similarity.
Theoretical Insight: It clarifies that transfer is fundamentally a geometry of updates (gradients), not just representations. The paper argues that while representation metrics can be informative in favorable regimes, they are fundamentally limited without explicit modeling of the error structure.
Scalability: By compressing complex update geometry into small signatures, the work makes vocabulary-scale transferability analysis feasible, moving beyond the constraints of finite-label approximations (like LogME/LEEP) or prohibitive exact Fisher calculations.

The authors explicitly note limitations: the method assumes a shared output basis (vocabulary or aligned taxonomy) and focuses on head-level (or shared-parameter) Fisher alignment. For heterogeneous output spaces or full-network comparisons without shared parameters, different approaches or internal-layer diagnostics are recommended.