Research / Repairing frozen models

Same-Size Capability Transfer Reveals a Performance-Localization Tradeoff in Deterministic Function Calling

Builds a locked, deterministic function-calling testbed for same-size capability transfer and shows a performance–localization tradeoff: dense modules recover more task performance, sparse modules provide partial localization signal.

Published
25 March 2026
Author
Ali Uyar
DOI
10.5281/zenodo.19226752
Code
github.com/aliuyar1234/sparse-capability-transplants

Abstract

We study whether task-specific function-calling behavior can be transplanted from a donor back into an untuned same-size base model using fixed modules instead of full retraining. Our setting is intentionally narrow and fully deterministic: within-family Gemma models, single-turn function calling, frozen manifests, exact JSON grading, and a primary metric defined on SchemaShift and NoCall stress slices. The donor substantially outperforms the base on the primary strict metric, from 0.0375 to 0.1781 (delta 0.1406, 95% CI [0.1208, 0.1604]). A sparse same-size intervention selected by a locked discovery pipeline reaches 0.2068 strict success on the discovery seed and 0.1658 mean strict success across three seeds, while a matched dense shortcut reaches 0.2177 mean strict success across the same seeds. Sparse structure is nevertheless non-random: a locked one-feature subset retains 47.1% of the full sparse gain and beats random one-feature controls, and one-vector steering is clearly weaker at 0.1078 strict success. The resulting picture is therefore not sparse superiority. Instead, we find a real performance–localization tradeoff: same-size transfer is real in this setting, dense parameter-matched modules recover more raw task performance, and sparse modules provide partial localization signal. We present this deterministic function-calling setup as a concrete testbed for studying constructive capability transfer under tight claim discipline.

Why it matters

If a capability can be moved into an untuned model through a small fixed module, the transfer also bears on how concentrated or diffuse the computation behind it is. Comparing sparse, dense and steering modules at the same hook site under matched parameter budgets measures raw performance and localization separately.

Cite

@misc{uyar2026same,
  title     = {Same-Size Capability Transfer Reveals a Performance-Localization Tradeoff in Deterministic Function Calling},
  author    = {Uyar, Ali},
  year      = {2026},
  doi       = {10.5281/zenodo.19226752},
  publisher = {Zenodo},
  url       = {https://doi.org/10.5281/zenodo.19226752}
}
AU-8
Blank: the untuned base, same size as the masterMaster: the task-trained donorPin rail: 256 features; TopK keeps the top 16 per tokenParams: sparse 590,081 · dense 591,232 · steering 1,152The paper builds a locked, deterministic testbed for transferring single-turn function calling from a task-trained Gemma-family 1B donor into its untuned same-size base, scored by strict full-call success on 1,920 SchemaShift and NoCall stress prompts. The donor is the master key and the base is the blank: the carriage copies a module fitted to the donor-minus-base delta at the layer-12 MLP output, as a sparse TopK cut set, a parameter-matched dense module, or one steering offset. Strict success rises from 0.0375 for the base to 0.1658 sparse and 0.2177 dense (three-seed means), and to 0.1078 with one steering offset, against 0.1781 for the donor. Dense recovers the most performance; sparse localizes part of it, with one locked feature keeping 47.1% of the sparse gain, above random one-feature controls.