acceptodds
Under review as a conference paper at ICLR 2027

A Tropical Geometry View of Forgetting: A Per-Unit Projector for Knowledge-Preserving Fine-Tuning

Abstract

Fine-tuning a language model on new text degrades what it already does. Replay-free projectors such as Adam-NSCL and GPM forbid one shared subspace of a layer's inputs in every row of the update. The tropical geometry of a ReLU layer shows why this is too coarse. In data space, the units' walls are tropical hypersurfaces whose cells are dual to the upper vertices of a zonotope; in weight space, each old token is a hyperplane, and the tokens cut out a polyhedron, the closure of the weights that keep every token on its side. An exact identity joins the two pictures: the squared change of the layer's output under any weight change splits into in-cell, openclosed and closedopen terms, and the first two live on the tokens each unit fires on (its open tokens). The identity names a gate-aware per-unit projector, and a budget-separation theorem prices exact protection: it costs a unit the rank of its own open tokens, while a shared subspace pays at least the rank of their union in every row. On OPT-1.3b, where of (token, unit) pairs are closed, the projector forgets less than Adam-NSCL at all six matched budgets from to constrained directions per row ( of seed-pairs, ), the gap widening from to ; with of the directions it halves the forgetting of Adam-NSCL at GPM's energy threshold. On OPT-6.7b, it matches Adam-NSCL's forgetting at matched budget while learning more. As the theory predicts, the open/closed partition is the operative variable: open tokens beat random, sign-blind and anti-gate token sets on of seed-pairs and are equivalent to the first-order criterion, which inherits the partition. In pruning repair, the identity shows that every derivative-based local model of the output error at the dense weights is blind to pairs that open: the minimisers of the gate-weighted objective can leave the polyhedron, the objective's closed-form solution is nats worse than no repair on OPT-1.3b, and a convex one-sided penalty bounds the escape.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM Compression, Tropical Geometry, Layer-wise Repair, Network Pruning

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 4 reviews, above 85% of the others.
Reviewer_pdKzOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper studies catastrophic forgetting during replay-free fine-tuning of language models. The focus is on projection-based methods such as Adam-NSCL/GPM. The authors argue that using a single layer-wise input subspace shared across all rows is too coarse for ReLU MLP layers because most unit-token pairs are inactive, so constraining every row with the same subspace wastes budget on closed units. They derive an exact decomposition of per-layer output change into in-cell, open->closed, and closed->open terms, present a gate-aware per-unit projector that preserves each unit’s pre-activation on selected tokens where that unit is active, and prove a budget-separation result comparing per-unit versus shared subspaces. They also apply the same decomposition to pruning repair, arguing that local curvature-based repair objectives are blind to closed->open errors. Empirically, on OPT-1.3B the proposed projector reduces old-probe NLL forgetting relative to Adam-NSCL at matched average budget. On OPT-6.7B it roughly matches forgetting while learning slightly more. Selector ablations support the claim that the open/closed partition is the key variable.

Critical strengths

The underlying method is simple and sensible. The neuron-specific projector is a natural relaxation of existing null-space projection methods. The exact output-change decomposition is correct, and the linear algebraic arguments explaining the reduction in constrained dimensions are plausible.

The comparisons between open, random, sign-blind, anti-gate, within-open random, and first-order selection are particularly informative. They provide evidence that the activation partition itself is responsible for much of the improvement.

There are nontrivial empirical improvements in the target setting. On OPT-1.3B, the proposed method reduces forgetting relative to Adam-NSCL. The results on OPT-6.7B indicate that the method can improve learning while maintaining comparable forgetting.

The paper provides detailed information about datasets, hyperparameters, training configurations, and evaluation procedures. The supplementary material contains implementation details and some code, with a complete release promised, ensuring reproducability of the results.

Critical weaknesses

I think the overall idea is good and could potentially improve fine-tuning of pre-trained models. However, the paper as it is now is not suited to a top-tier ML conference. I am willing to raise my score if the two largest problems I see (overly elaborate theory and lacking experimental evaluation) are addressed.

The tropical geometry framework is unnecessary and substantially obscures the contribution. The central idea follows directly from the ReLU Jacobian: since inactive neurons have zero derivatives, the null-space constraint can be constructed separately for each neuron using only its active calibration inputs. The projector then follows from standard linear algebra. I cannot identify any result where tropical geometry, Newton polytopes, or zonotope duality is actually needed to derive the algorithm, prove some properties, or explain the experiments or results. In particular, Proposition 2 appears disconnected from the subsequent methodological development. The tropical machinery makes an otherwise simple and intuitive contribution unnecessarily difficult to understand. I strongly believe this framework should be removed from the title, abstract, and main technical development. The paper should be rewritten around neuron-specific null-space projection and ReLU activation patterns.

The theoretical presentation overcomplicates relatively elementary observations. Theorem 5 is essentially a case distinction over ReLU activation states. Theorem 9 follows from comparing the ranks of neuron-specific input matrices with that of their union, while Proposition 10 follows from a standard eigendecomposition argument. These are useful observations, but they do not require these elaborate formulations. The paper repeatedly presents straightforward mathematical properties through unnecessarily complicated constructions. The abstract is particularly problematic, combining specialized terminology, theorem claims, numerical results, and a second application before the reader has any clear understanding of the actual method. Overall, the writing makes the contribution harder to evaluate than necessary.

The experimental scope is substantially narrower than the framing suggests. The main fine-tuning experiments focus on ReLU-based OPT models with updates restricted to fc1. The method is not convincingly evaluated on contemporary language models with SwiGLU or GELU activation functions, nor in general full-model fine-tuning. In particular, the OPT-6.7B experiments update only the fc1 matrices of the final four transformer blocks. The broader applicability to modern language models remains unclear.

The theoretical guarantees do not directly extend to the experimental setting. The preservation results apply to individual layers evaluated at fixed calibration inputs. However, the experiments jointly update multiple layers, so their input representations drift during fine-tuning. Moreover, the projector does not prevent previously inactive neurons from becoming active. The authors acknowledge these limitations, but their practical consequences are not sufficiently investigated.

The budget matching is not entirely convincing. Comparisons with Adam-NSCL use the mean number of selected tokens, rather than the actual rank of the neuron-specific constraints. Furthermore, the proposed operator is not an exact projector: due to the ridge regularization, it attenuates directions rather than eliminating them. Consequently, equal nominal dimensions do not necessarily correspond to equal effective constraints.

The selection strategy appears more complicated than necessary. The experiments show that randomly selecting tokens from within a neuron's active set performs equivalently to selecting those with the largest activations. This suggests that the activation partition is important, but the additional ranking by activation magnitude is not. The method could potentially be simplified further, and this finding deserves a more prominent discussion.

The pruning-repair application is disconnected from the main contribution and takes up space that would be better spent establishing the method's broader applicability. Section 5 introduces a largely separate problem and additional theoretical machinery without substantially strengthening the central contribution on knowledge-preserving fine-tuning. I would strongly prefer the authors to remove this section and instead develop the theory and experiments for modern MLP architectures, particularly SwiGLU. Modern MLPs do not produce exactly zero activations, so extending the neuron-specific projection principle is nontrivial and would constitute a much more meaningful theoretical contribution. Demonstrating that the method remains effective on contemporary language models would also considerably strengthen the empirical claims and practical relevance of the paper.

Questions for authors

How does the method compare against the per-unit PCA projector implied by Proposition 10? This seems like a particularly natural baseline for determining whether the benefits arise from neuron-specific constraints or the proposed token-selection strategy. Relatedly, given the equivalence between random-within-open and activation-magnitude selection, is the latter necessary?

How well does the approach generalize to contemporary architectures and more realistic continual-learning settings? The paper discusses relevance to gated architectures, but the main fine-tuning results concern ReLU OPT fc1 layers. Results on SwiGLU/GELU models, full-model fine-tuning, and multiple sequential adaptation tasks would considerably strengthen the claims.

What are the computational and memory costs compared with Adam-NSCL? Constructing and factorizing separate C×CC\times C systems for potentially thousands of neurons is not free.

How much preservation error is caused by representation drift and previously inactive neurons becoming active? The theoretical results distinguish these effects, but a quantitative decomposition during end-to-end fine-tuning would help establish how well the fixed-input analysis explains the observed forgetting.

5 comments
AuthorsOpenReview ↗

Response to Reviewer pdKz

(1/3)

We thank the reviewer for the detailed review and for finding the method sensible, the exact decomposition and the budget separation conceptually sound, and the selector ablations informative.

The review names two conditions for reassessing the submission: (1) a more streamlined theoretical presentation, and (2) a broader empirical evaluation that covers recent architectures, full-model fine-tuning, sequential adaptation and representation drift. We agree with both points. This part describes the restructured theory and the shorter pruning-repair section. Part 2 answers Q1 (PCA), token selection, budget matching and Q4 (drift), and Part 3 answers Q2 (architectures, scale and sequences) and Q3 (cost).

Unless stated otherwise, the experiments fine-tune fc1 of OPT-1.3B on WikiText-103 with paired seeds 0, 1 and 2. Forgetting is the increase in old-text NLL relative to the base model, and learning is the decrease in new-task NLL, both in nats/token (lower forgetting and higher learning are better).

Theoretical restructuring and the role of geometry

We agree that the algorithm follows directly from the local Jacobian of the ReLU layer and should be presented before the tropical geometry. We have reorganized the manuscript accordingly.

Direct Jacobian derivation first

Section 3 of the revision now opens with a three-line derivation for a single neuron that does not use tropical formalism:

  1. For an input x~t=(xt,1)\tilde{x}_t = (x_t, 1), a ReLU unit computes ht=max⁡(0,w~⊤x~t)h_t = \max(0, \tilde{w}^\top \tilde{x}_t). Let OO denote the calibration tokens on which it is active.
  2. With the gate states fixed, a weight displacement uu changes the output of the unit by Δht=1[t∈O] u⊤x~t\Delta h_t = \mathbf{1}[t \in O]\, u^\top \tilde{x}_t.
  3. Preserving these active responses exactly requires X~Ou=0\tilde{X}_O u = 0. Each row update is therefore projected onto the null space of its own active inputs, with at most CC constraints per unit.

This derivation makes the method easy to follow and to implement.

Role of the formal results

Each formal result (numbered as submitted) is now introduced by the role it plays:

  • Theorem 5 (finite-update decomposition) is the lemma on which the later results build. Under a finite update Δw\Delta w, the squared post-activation drift decomposes into in-cell, open-to-closed and closed-to-open components. Satisfying X~Ou=0\tilde{X}_O u = 0 eliminates the in-cell drift and the open-to-closed flips, so only near-wall closed-to-open crossings remain (Proposition 11; analyzed in Q4). In pruning repair, derivative-based refits ignore this term.
  • Theorem 9 (budget separation) gives the price of parameter protection. Exact protection costs unit ii only rank⁡(X~Oi)\operatorname{rank}(\tilde{X}_{O_i}) directions of its own row, whereas a shared subspace removes at least rank⁡(X~⋃iOi)\operatorname{rank}(\tilde{X}_{\bigcup_i O_i}) directions from every row. For this reason, budget comparisons must match the number of directions per row.
  • Proposition 10 (optimal subspaces) identifies the optimal per-unit and gate-weighted shared subspaces under isotropic updates, and it motivates the PCA baseline in Q1.

The formal tropical hypersurface and zonotope duality constructions (Propositions 2 and 4, Corollary 6) are now in Appendix A. Following the reviewer's recommendation, we will also remove "tropical geometry" from the title in the final revision.

Compressing the post-pruning repair section

We agree with the suggestion and have compressed Section 5 to a single paragraph. The space saved is used for modern MLPs and full-model fine-tuning. We keep this short discussion because pruning repair is the main setting in which closed-to-open crossings govern performance.

One-shot pruning displaces weights by large discrete amounts, which pushes previously inactive pre-activations across the threshold. Closed tokens have zero derivatives at the base weights, so derivative-based local models are blind to this curvature (Lemma 13). On OPT-1.3B at 70% sparsity, the exact gated refit increases the loss by 1.94 nats/token relative to no repair, and pre-activation refitting gives a WikiText-2 perplexity of 153.64 (dense model: 14.62).

Theorem 5 identifies closed-to-open crossings as the cause of the failure of the gated refit, and our convex one-sided penalty penalizes these crossings explicitly. On fixed Wanda masks, keeping the mask alone is preferable at 50% and 60% sparsity (perplexity 19.76 and 29.37). At 70% sparsity, however, one-sided refitting is effective and lowers perplexity from 97.25 to 84.50. Within SparseGPT, refitting fc1 with our one-sided objective lowered perplexity from 30.21 to 28.04 at 60% sparsity, from 79.93 to 57.55 at 70% and from 763.3 to 395.4 at 80%, in all 3/3 seeds. These values are lower than those of an equal refit with the SparseGPT objective (28.81, 77.38 and 738.3).

(2/3)

Q1. Per-neuron PCA, token selection and budget matching

Per-neuron PCA baseline (Proposition 10)

At the C=64 budget, we implemented the optimal per-neuron subspace of Proposition 10 by computing principal directions from all active tokens of each neuron. To separate the effect of neuron-specific directions, we compare it with two controls: (i) a bridge control that uses gate-weighted shared directions with matched per-row numerical rank and ridge shrinkage (23.17 directions and 23.02 effective dimensions on average), and (ii) gate-weighted shared projection with k=24k=24. The table gives means over seeds (128 steps, WikiText-103).

C=64 budgetPer-neuron PCA (Prop. 10)Bridge: shared directions, matched rankGate-weighted shared (k=24k=24)
Set A forgetting (↓)0.03910.04350.0508
Set B forgetting (↓)0.04100.04360.0528
Original probe forgetting (↓)0.01940.03730.0506
New-task learning (↑)0.61880.62000.6239

Per-neuron PCA forgets less than the bridge control in 3/3 seeds on Set A and on the probe, and in 2/3 seeds on Set B (seed 1: +0.0010 nats/token), with learning matched within 0.2%. Relative to gate-weighted sharing at k=24k=24, per-neuron PCA forgets less in all 3/3 seeds on all three retention measures.

Relation to the C=256 selector

In OPT-1.3B, the median neuron is active on only 11 calibration tokens, and only 7.59% of neurons reach the C=256 cap. For the other 92.4% of units, our selector constrains every active token. It therefore realizes the per-neuron subspace of Proposition 10 at full rank without an eigendecomposition. At 128 steps, C=256 forgot less than both standard and gate-weighted shared projection (k=47k=47) in 3/3 seeds on Sets A and B (Set A: 0.0331 vs. 0.0378 and 0.0373; Set B: 0.0339 vs. 0.0396 and 0.0391), with learning matched within 0.2%. Over 512 steps (LR 3×10−53 \times 10^{-5}, chosen on validation text), C=256 forgot 34% less than gate-weighted sharing on the 520 documents (0.0182 vs. 0.0276 nats/token) and learned more, in all 3/3 seeds.

Random selection within the open set

We agree that random tokens from the open set OiO_i of a neuron perform equivalently to the tokens with the largest activation magnitudes. On the original probe at C=64, random open-token selection changed forgetting by only -0.0015 nats/token (90% CI [-0.0051, +0.0021], well within the ±0.0068\pm 0.0068 TOST equivalence margin). What matters is restricting the constraints to the open set: rank-matched random tokens drawn globally increased forgetting by 0.0317 nats/token in all 6/6 seeds. Section 4.2 states that membership in OiO_i, not the ranking inside it, governs retention.

Budget matching and effective dimensions

The table reports the average number of selected tokens kik_i, the exact numerical rank and the effective ridge dimension deff=tr⁡(AiAi⊤(AiAi⊤+ρiI)−1)d_{\text{eff}} = \operatorname{tr}(A_i A_i^\top (A_i A_i^\top + \rho_i I)^{-1}).

Budget settingSelected kik_iNumerical rankEffective dimension deffd_{\text{eff}}Shared budget kk
C=64, WikiText23.51923.16823.01824
C=256, WikiText47.25746.67246.15147
C=128, Python34.42133.95933.65734

Since deff≤rank⁡≤kid_{\text{eff}} \le \operatorname{rank} \le k_i and shared projection removes kk full orthogonal directions, our projector constrains fewer effective dimensions per row than its shared baseline in every comparison.

Q4. Layer-by-layer representation drift and closed-to-open crossings

To measure how the fixed-input guarantee interacts with representation drift through the whole network, we decomposed the squared post-activation drift in all 24 layers of the step-128 models on the 520 documents as follows: (i) direct drift, from the updated weights on the original inputs, and (ii) input drift, from the updated weights on the drifted inputs that preceding layers actually produce. Values are sums over all 24 layers and all positions, in millions (means over seeds).

MethodDirect driftInput driftTotal layer driftClosed→open crossings (% of total)
Unconstrained fine-tuning10.45972.11082.72215.305 (18.50%)
Our projector (C=64)2.64325.84828.8463.853 (13.36%)

All four quantities decrease in all 3/3 seeds on both document sets. Direct drift falls by 74.7% and total layer drift by 65.1%. Although input drift accounts for 89.6% of the remaining error, it also falls by 64.2%, because each protected upstream layer passes less representation drift downstream. In addition, the closed-to-open term, which our rule leaves unconstrained, is a small share of the total (13.36%) and falls by 75% without an explicit constraint. This confirms the near-wall containment of Proposition 11. Across the 520 documents, C=64 forgot 82.2% less than unconstrained training.

(3/3)

Q2. Architecture diversity, full-model fine-tuning, scale and sequential adaptation

We evaluated our method on recent architectures, under full-parameter fine-tuning, at the 6.7B parameter scale and on a multi-stage sequential benchmark.

SettingComparatorForgetting, Sets A / B (↓)New-task learning (↑)Seeds favoring ours
Qwen2.5-0.5B SwiGLU, up projection, 128 stepsUnconstrained0.136 / 0.124 vs. 0.249 / 0.2330.401 vs. 0.3693/3
Pythia-1.4B GELU, first MLP matrix, C=256, 128 stepsUnconstrained0.073 / 0.062 vs. 0.285 / 0.2590.542 vs. 0.4993/3
OPT-1.3B, all parameters, WikiText, 128 stepsPlain AdamW0.174 / 0.177 vs. 0.410 / 0.4050.622 vs. 0.5683/3
OPT-1.3B, all parameters, Python, 128 stepsPlain AdamW0.023 / 0.026 vs. 0.124 / 0.1260.210 vs. 0.1443/3
OPT-1.3B, all parameters, WikiText, 512 stepsShared (k=47k=47)0.024 / 0.025 vs. 0.030 / 0.0340.688 vs. 0.6893/3 (forgetting)
  • SwiGLU and GELU. On Qwen2.5-0.5B (native SwiGLU with frozen gates), constraining the up-projection rows on the 24 tokens with the largest ∣SiLU(gt)∣|\text{SiLU}(g_t)| reduced forgetting by 45.3% / 46.7%. On Pythia-1.4B (GELU), our rule reduced forgetting by 74.3% / 76.1%. Compared with shared projection with the same budget of 175 directions per row, our rule matched retention on the 520 documents (0.0675 vs. 0.0676), forgot less on the original probe (0.0047 vs. 0.0154) and learned more in all 3/3 seeds (0.5420 vs. 0.5234).
  • Full-parameter fine-tuning. When all 1.3B parameters are updated (our rule on fc1, AdamW on all other matrices), our method reduced forgetting by 57% on WikiText and by 80% on Python over 128 steps. Over 512 steps, it forgot 22.8% less than shared projection on Sets A and B at matched learning, and it removed 86% of the forgetting incurred by plain AdamW.
  • OPT-6.7B scale. We updated fc1 in the last four blocks (C=128, 68.7 directions per row vs. shared k=69k=69). Forgetting on the original probe was equivalent to Adam-NSCL under TOST (0.0192 vs. 0.0184, within the ±0.0068\pm 0.0068 margin; both remove 85% of unconstrained forgetting), whereas new-task learning was higher in all three seeds (+0.0109 nats/token, paired p=1.5×10−4p = 1.5 \times 10^{-4}). Rank-matched random tokens forgot 0.0098 more in all 3/3 seeds.
  • Three-stage continual sequence (WikiText → Python → Turkish Wikipedia). This experiment shows the capacity-plasticity trade-off predicted by Theorem 9. Shared projection removes the same 85 directions from every row in the layer, which blocks learning on the third domain: Turkish NLL worsened by +0.0142 nats/token in all 3/3 seeds. In contrast, our per-unit projector allocates constraints per neuron and preserves plasticity: Turkish NLL decreased by 0.0167 nats/token, a net learning advantage of 0.0309 nats/token (p=0.0015p = 0.0015, 3/3 seeds). In exchange for this forward learning capacity, our method kept mean forgetting on the earlier domains below 0.023 nats/token (0.0222 vs. 0.0143).

Q3. Computational and memory footprint

All measurements use an NVIDIA L40S GPU in fp32.

  • Construction time. Building the C=256 projector takes 6.3 seconds (9.8 s with cached factors), comparable to the 6.7 seconds of shared projection (k=47k=47), whereas explicit PCA bases require about 13 minutes.
  • Throughput and memory. With cached Cholesky factors, training runs at 84% of shared throughput (159.1 vs. 189.9 tokens/second) and peaks at 34.1 GiB of memory because of tensor padding in our current code. With block recomputation, training runs at 52% of shared throughput and peaks at only 7.7 GiB, close to the 7.4 GiB of shared projection. Both modes give identical numerical results.
  • Factor storage. The unpadded Cholesky factors take 3.15 GB in fp16 across all 24 layers, roughly the size of the AdamW momentum buffers of fc1 (3.22 GB). The factors exist only during training, so inference has no added parameters and no added latency.

Conclusion

On the two conditions named in the review:

  1. Presentation. We have rewritten the theory around the direct 3-line Jacobian derivation, tied each formal result to a concrete empirical question, moved tropical geometry and zonotope duality to Appendix A and compressed pruning repair to a single paragraph. We will remove "tropical geometry" from the title in the final revision.
  2. Empirical evaluation. The evaluation now covers SwiGLU, GELU, full-model fine-tuning over 128 and 512 steps, the OPT-6.7B scale, a 3-stage sequence, 520 independent documents, per-neuron PCA and a quantitative drift analysis.

We would be grateful if the reviewer would consider whether these revisions and new results meet the two conditions stated in the review and update the score accordingly. We are glad to discuss any further point.

Reviewer_6RUeOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary
  • Method protects each ReLU neuron on selected old inputs where it was active, and projects updates to preserve those responses while allowing more freedom elsewhere.
Critical strengths
  • Clear connection between activation geometry and update constraints.
  • Less forgetting across six matched budgets; 24/27 favorable seed-pairs on OPT-1.3B (Figure 2).
  • Active-input selection beats random, sign-blind and inactive-input controls (Table 1).
Critical weaknesses
  • No direct reference-model KL/distillation or replay comparison, the benefit over simpler auxiliary losses remains unclear.
  • Fine-tuning lasts only 128 steps; longer adaptation remains untested (section 4).
  • Fine-tuning guarantees rely on ReLU nonlinearities; applicability to GELU/SiLU remains unclear.
  • Downstream accuracy nearly matches the shared projector at equal budgets (Table 9).
  • Per-neuron storage costs complicate claims of practical efficiency.
Questions for authors
  • If all methods improve equally on the new task, does your method preserve old performance better than KL regularization or training on old examples?
  • Can the fine-tuning projector extend to GELU/SiLU without exactly inactive neurons?
5 comments
AuthorsOpenReview ↗

Response to Reviewer 6RUe

We thank Reviewer 6RUe for the detailed review and for recognizing the connection between activation geometry and update constraints, the consistency of the six-budget evaluation and the value of the selector controls.

The review asks two main questions:

  1. Does our method preserve old-task performance better than reference-model KL distillation or experience replay when the methods are compared at equal new-task learning?
  2. Can the projector be extended to smooth activations such as GELU and SiLU without requiring exactly inactive neurons?

The review also raises the training length (128 steps), whether downstream tasks separate the methods, and the storage cost. We ran additional experiments for each point. This part answers Question 1. Question 2, longer training, downstream evaluation and efficiency are addressed in Parts 2 and 3.

Unless stated otherwise, the experiments fine-tune fc1 of OPT-1.3B on WikiText-103 for 128 steps with learning rate 10−410^{-4} and paired seeds 0, 1 and 2. Forgetting is the increase in old-text NLL relative to the base model, and learning is the decrease in NLL on unseen new-task text, both in nats/token (lower forgetting and higher learning are better).

Q1. Comparison with output KL distillation and experience replay at matched learning

We agree that retention should be compared at matched new-task learning. The methods learn at different rates per step, so a comparison at equal step counts can confound learning speed with retention. At matched learning, the comparison measures how much old-text retention each method gives up for the same gain on the new domain.

Matched learning against output KL

Output KL distillation adds the penalty λ⋅KL(p0∥pθ)\lambda \cdot \text{KL}(p_0 \parallel p_\theta) on old text. For each KL run, we recorded the reduction in new-task NLL at step 128. We then took the two checkpoints of our C=256 run (evaluated every 32 steps) whose learning brackets this value and linearly interpolated the forgetting of our projector between them on the original 1,024-token probe. The table gives three-seed means.

Output KL weight λ\lambdaKL new-task learningKL forgettingC=256 forgetting at matched learningForgetting ratio (KL / ours)
0.10.59800.11070.009811.3×11.3\times
1.00.59170.06480.00857.7×7.7\times
10.00.58020.03480.00724.9×4.9\times

At equal new-task learning, output KL distillation has 4.9x to 11.3x higher mean forgetting than our C=256 projector, and its forgetting is higher in all 9 paired comparisons (3 weights x 3 seeds). In addition, output KL evaluates the student and teacher outputs on old text at every step (65,536 old tokens over 128 steps), whereas our projector reads the 2,048 calibration tokens only once, before training.

Fixed 128-step comparison on 520 independent documents

We also compared retention at the end of training on two disjoint sets of 260 MiniPile test documents (Sets A and B, 33,020 predictions each), which do not overlap with the training or calibration text. Replay uses the same 2,048 calibration tokens, replayed 1:1 with every new-task microbatch. The table gives means ±\pm standard deviations over the three seeds.

MethodSet A forgetting (↓)Set B forgetting (↓)New-task learning (↑)
Our projector (C=256)0.0331 ±\pm 0.00670.0339 ±\pm 0.00650.6196 ±\pm 0.0043
Output KL (λ=0.1\lambda = 0.1)0.1797 ±\pm 0.00560.1852 ±\pm 0.00430.5980 ±\pm 0.0140
Output KL (λ=1.0\lambda = 1.0)0.1479 ±\pm 0.00750.1510 ±\pm 0.00580.5917 ±\pm 0.0136
Output KL (λ=10.0\lambda = 10.0)0.1239 ±\pm 0.00350.1223 ±\pm 0.00180.5802 ±\pm 0.0113
Replay of the 2,048 tokens0.3004 ±\pm 0.01140.2884 ±\pm 0.00900.5849 ±\pm 0.0187

On both sets, output KL forgets 3.6x to 5.5x more than our method and learns less on the new task, and every seed favors our projector. Replaying the fixed 2,048 tokens overfits to these sequences and gives 9.1x (Set A) and 8.5x (Set B) higher forgetting than our rule.

Replaying fresh old text instead improves generalization but requires much more old data. We compared fresh replay with our C=64 budget, using the same matched-learning interpolation on the original probe. Replaying fresh tokens on every fourth microbatch (16,384 tokens) forgot 5.6x more than C=64 (0.1721 vs. 0.0306). Matching C=64 (0.0314 vs. 0.0316) required streaming fresh old text on every microbatch (65,536 fresh tokens, 32 times our 2,048 tokens). At step 128, C=256 had lower forgetting than full fresh replay (0.0114 vs. 0.0314) and higher learning (0.6196 vs. 0.5981), without access to old text during training.

Q2. Extension to smooth activations (GELU and SiLU / SwiGLU)

The exact finite-update decomposition (Theorem 5; Lemma 2 in the revised manuscript, gated case in Appendix B) is derived for thresholded activations such as ReLU and hard-gated GLUs, where an inactive neuron outputs zero. However, the projection principle extends directly to smooth nonlinearities. The row update of each neuron is constrained on the calibration inputs where its response is strongest, so its output on these inputs is preserved at fixed layer inputs. On the other inputs, the change in output is scaled down by the derivative of the activation:

  • For GELU, the output drift on unconstrained inputs is, to first order, φ′(z)Δz\varphi'(z) \Delta z, where ∣φ′(z)∣≤0.133|\varphi'(z)| \le 0.133 for z≤−0.5z \le -0.5.
  • For SwiGLU (y=SiLU(g)⋅vy = \text{SiLU}(g) \cdot v) with frozen gate weights, the output change on token tt is exactly SiLU(gt)⋅Δv⊤xt\text{SiLU}(g_t) \cdot \Delta v^\top x_t. This change is close to zero whenever the gate pre-activation is strongly negative.

We tested both activations with the same 128-step WikiText-103 setting and the same 520 MiniPile documents, re-tokenized for each architecture (Appendix F.5):

  • Qwen2.5-0.5B (native SwiGLU). We constrained each row of the up-projection matrix on the 24 calibration tokens with the largest ∣SiLU(gt)∣|\text{SiLU}(g_t)|. The gate and down projections were kept fixed in both runs.
  • Pythia-1.4B (GELU). With the selection rule unchanged, we constrained each neuron on the calibration tokens where its pre-activation is positive (at most 256, and 175 per neuron on average). These positions account for 68.0% of the total squared GELU output on the calibration text.

The table gives means ±\pm standard deviations over the three seeds.

ModelMethodSet A forgetting (↓)Set B forgetting (↓)New-task learning (↑)
Qwen2.5-0.5B (SwiGLU)Constrained (24/neuron)0.1364 ±\pm 0.00930.1242 ±\pm 0.00690.4014 ±\pm 0.0058
Unconstrained0.2492 ±\pm 0.00950.2329 ±\pm 0.00530.3691 ±\pm 0.0156
Pythia-1.4B (GELU)Our rule (C=256)0.0731 ±\pm 0.00530.0619 ±\pm 0.00350.5420 ±\pm 0.0137
Unconstrained0.2848 ±\pm 0.01270.2588 ±\pm 0.01190.4989 ±\pm 0.0164

On Qwen2.5-0.5B, gate-guided projection reduced forgetting by 45.3% (Set A) and 46.7% (Set B) relative to unconstrained training. On Pythia-1.4B, our rule reduced forgetting by 74.3% (Set A) and 76.1% (Set B). Both models also reached higher new-task learning in all 3/3 seeds. In addition, on Pythia we compared our rule with shared projection at the same budget of 175 directions per row. Our rule had lower forgetting on the original probe (0.0047 vs. 0.0154) and higher learning (0.5420 vs. 0.5234) in all three seeds, and the same retention on the 520 documents (0.0675 vs. 0.0676 nats/token).

Longer training (512 steps)

We fine-tuned OPT-1.3B for 512 steps on 2,048 distinct WikiText windows (262,144 tokens) with a common peak learning rate of 3×10−53 \times 10^{-5}, selected on separate validation text. We compared our C=256 rule with standard shared projection and with gate-weighted shared projection (k=47k=47).

Step 512, LR 3×10−53 \times 10^{-5}Ours (C=256)Shared (k=47k=47)Gate-weighted shared (k=47k=47)
Set A forgetting (↓)0.0177 ±\pm 0.00140.0255 ±\pm 0.00300.0259 ±\pm 0.0033
Set B forgetting (↓)0.0188 ±\pm 0.00190.0289 ±\pm 0.00330.0294 ±\pm 0.0037
New-task learning (↑)0.6775 ±\pm 0.00240.6726 ±\pm 0.00170.6724 ±\pm 0.0017

Over 512 steps and in all 3/3 seeds, our projector forgets 33.0% less than standard shared projection and 34.0% less than gate-weighted shared projection on the 520 documents, and it reaches higher new-task learning.

We also ran full-parameter fine-tuning for 512 steps, in which all 1.3B parameters are updated, with our rule on fc1 and AdamW on the other parameters (Appendix D.3). Our rule forgot 22.8% less than shared projection on Sets A and B (0.0247 vs. 0.0319 nats/token; 3/3 seeds) at matched learning (0.6881 vs. 0.6887), and it removed 86% of the forgetting observed with plain AdamW.

Downstream zero-shot accuracy and continuous NLL

On five standard benchmarks (LAMBADA, HellaSwag, WinoGrande, ARC-Easy and SciQ), both projection methods retain more than 63% of the accuracy that unconstrained training loses. The average drop is 1.02 points for C=128 (3/3 seeds, p=0.013p = 0.013 against unconstrained training) and 1.08 points for shared projection (k=34k=34), compared with 2.94 points for unconstrained training.

These benchmarks score discrete argmax predictions on short prompts, so small improvements in the margin do not change the selected answer. The continuous negative log-likelihood on the 520 independent documents (66,040 predicted tokens) shows the per-neuron advantage:

  • At 128 steps (C=256 vs. shared k=47k=47), our rule forgets 13.4% less (0.0335 vs. 0.0387 nats/token; 95% bootstrap interval [-0.0075, -0.0029]) at matched learning (0.6196 vs. 0.6197).
  • Over 512 steps at learning rate 3×10−53 \times 10^{-5}, our rule forgets 33.0% less (0.0182 vs. 0.0272 nats/token, 3/3 seeds).
  • In 512-step full-parameter fine-tuning, our rule forgets 22.8% less (0.0247 vs. 0.0319 nats/token, 3/3 seeds).

Storage and compute cost

The memory cost of the per-neuron projector is modest in practice, because activation sparsity limits the rank of the constraint space of each unit. At C=256, the median neuron is active on only 11 calibration tokens, the mean number of constraints is 47.3, and only 7.59% of neurons reach the cap.

In fp16, the unpadded Cholesky factors of all 24 layers take 3.15 GB in total (0.48 GB at C=64; 1.28 GB at C=128). This is comparable to the AdamW momentum buffers of the fc1 layer (3.22 GB). The factors exist only during training, so the fine-tuned model has no extra parameters. Unlike KL distillation or replay, our method does not access old text during training.

We measured construction time, steady-state training throughput and peak GPU memory on a single NVIDIA L40S GPU, with the same configuration for all runs.

ProjectorConstruction timeTraining throughputPeak training memory
C=256, cached Cholesky factors9.8 s159.1 tokens/s (84% of shared)34.1 GiB
C=256, block recomputation6.3 s99.6 tokens/s (52% of shared)7.7 GiB
Shared projection (k=47k=47)6.7 s189.9 tokens/s7.4 GiB

The cached-factor implementation peaks at 34.1 GiB because our current code pads all factors to a uniform 256×256256 \times 256 tensor (24 GiB in total). Alternatively, recomputing the factors in blocks lowers peak memory to 7.7 GiB, close to the 7.4 GiB of shared projection, at 52% of the throughput of shared projection. At C=128, throughput reaches 95% of shared projection. The two modes give identical numerical results. The revised manuscript includes this table in Appendix D.4.

Conclusion

Our answers to the reviewer's questions are as follows:

  1. At matched new-task learning, our method has 4.9x to 11.3x lower forgetting than output KL distillation. Experience replay requires 32 times as much old text to match our C=64 projector, and even then it forgets 2.8x more than C=256 and learns less.
  2. The projection extends to the smooth GELU and SwiGLU activations and reduces forgetting by 74-76% and 45-47%, respectively, relative to unconstrained training.
  3. Over 512 steps at an fc1 learning rate of 3×10−53 \times 10^{-5}, our rule forgets 33.0% less than shared projection when fc1 is fine-tuned and 22.8% less under full-model fine-tuning (3/3 seeds each). The factors stored during training take memory comparable to the standard AdamW optimizer states.

We would be grateful if the reviewer would reconsider the score in light of these results, and we are glad to provide any further details.

Reviewer_FyeyOpenReview ↗
Rating
3(+2)
Confidence
2
Informativeness
2(+1)
Presentation
2(+1)
Soundness
2(+1)
Read review
Paper summary

This paper studies knowledge preservation when fine-tuning large language models. The authors propose a gate-aware per-unit projector that constrains updates using the old tokens activated by each neuron, rather than a shared input subspace. The paper provides a geometric interpretation, an exact decomposition of activation changes, and a budget-separation analysis. It also studies the limitations of local reconstruction objectives for pruning repair. Experiments on OPT models report reduced forgetting at matched constraint dimensions, mainly on OPT.

After rebuttal:

I thank the authors for their thorough responses. After reading their responses and the comments from other reviewers, most of my concerns have been addressed. I also suggest the authors extend their theoretical contributions to more scenarios such as more activation functions and further improve the efficiency. Considering the contributions are clearer after rebuttal, I would prefer to raise my score.

Critical strengths
  • The proposed projector is intuitive. Using neuron-specific activation patterns is a reasonable way to reduce unnecessary constraints on parameter updates.

  • Both theoretical and empirical analyses are provided. The selector comparisons in Tables 1 and 5 are useful for isolating the contribution of the open/closed partition. The supplementary material also provides the core implementation and numerical checks.

Critical weaknesses
  • The fine-tuning evaluation is too limited. It covers only three OPT sizes and two adaptation corpora, WikiText-103 and Python code, with most comparisons concentrated on OPT and WikiText-103. Broader model and domain coverage is needed to rule out setting-specific conclusions.

  • The core theory relies on ReLU-style hard gates and does not directly cover GELU or SwiGLU used in many language models. Despite the repair experiments in Tables 10 and 14, the applicability of the theoretical guarantees to these activations remains unclear.

  • The evidence for knowledge preservation is insufficient. Training lasts only 128 steps, and old-distribution NLL is measured on 1,024 tokens. Although five downstream tasks are evaluated, Table 9 shows nearly identical mean accuracy drops for the proposed method and matched-budget Adam-NSCL (1.02 vs. 1.08 points). Longer training and larger, independently sampled evaluation sets are needed.

  • The repair benefits are inconsistent. In Table 12, all reported repair methods perform worse than no repair at sparsities 0.5 and 0.6. The authors should clarify when repair is useful and compare against a complete pruning-and-repair baseline.

  • The pooled statistical results need clarification. Comparisons across budgets and selectors reuse seeds and reference runs, but Appendix C.2 does not adequately address their dependence. The authors should validate the pooled tests and provide per-run results and statistical scripts.

  • The practical computational cost is unclear. Fewer constrained dimensions do not necessarily mean lower memory or runtime, particularly with separate matrix factorizations for each neuron. Construction time, peak memory, and training throughput should be reported.

Questions for authors

See weaknesses.

4 comments

Response to Reviewer Fyey

We thank the reviewer for the detailed review. We are glad that the reviewer found the per-unit projector conceptually intuitive and noted that the token-selection ablations isolate the contribution of the open/closed partition.

The review raises six concerns: (i) the limited range of models and domains, (ii) the applicability to smooth activations (GELU, SwiGLU), (iii) the training length and the size of the test set, (iv) when post-pruning repair is beneficial, (v) seed dependence in the pooled statistical tests, and (vi) the practical computational and memory overhead. We answer each point below with new experiments and analyses.

Unless stated otherwise, all runs fine-tune fc1 of OPT-1.3B on WikiText-103 for 128 steps with learning rate 10−410^{-4} and paired seeds 0, 1 and 2. Forgetting is the increase in old-text NLL relative to the base model, and learning is the decrease in NLL on unseen new-task text. Both are measured in nats/token; lower forgetting and higher learning are better. "3/3 seeds" means that all three paired seeds favor our method.

W3. Longer training, independent test sets and downstream tasks

Evaluation on 520 independent test documents

To measure retention beyond the original 1,024-token probe, we evaluated the comparisons below on two disjoint sets of 260 MiniPile documents (Sets A and B, 33,020 predicted tokens each). Neither set overlaps with any training or calibration text. In the standard OPT-1.3B setting, we compare our projector at C=256, which keeps on average 47.3 constraints per neuron, with standard and gate-weighted shared projection (k=47k=47).

128 steps, OPT-1.3BOurs (C=256)Gate-weighted shared (k=47k=47)Shared (k=47k=47)Seeds favoring ours (vs. gate-weighted, vs. shared)
Set A forgetting (↓)0.03310.03730.03783/3, 3/3
Set B forgetting (↓)0.03390.03910.03963/3, 3/3
New-task learning (↑)0.61960.62070.61970/3, 1/3

Relative to standard shared projection, our per-unit rule reduces forgetting by 12.4% on Set A and 14.5% on Set B. Relative to gate-weighted sharing, the reductions are 11.2% and 13.4%. Both comparisons hold in all 3/3 seeds, and learning matches both baselines within 0.2%. The document-bootstrap 95% confidence intervals exclude zero (for example, [-0.0079, -0.0014] on Set A against standard sharing).

Extended training over 512 steps

We extended fine-tuning to 512 steps on 2,048 distinct WikiText windows (262,144 tokens, four times the original training length). All methods use the same peak learning rate of 3×10−53 \times 10^{-5}, selected on separate validation text.

512 steps, LR 3×10−53 \times 10^{-5}Ours (C=256)Gate-weighted shared (k=47k=47)Shared (k=47k=47)Seeds favoring ours (vs. gate-weighted, vs. shared)
Set A forgetting (↓)0.01770.02590.02553/3, 3/3
Set B forgetting (↓)0.01880.02940.02893/3, 3/3
New-task learning (↑)0.67750.67240.67263/3, 3/3

Our rule is better than both shared baselines on every metric and in all three seeds. On the 520 documents combined, it forgets 33.0% less than standard shared projection (document-bootstrap interval [-0.0113, -0.0067]) and 34.0% less than gate-weighted sharing, and it reaches higher new-task learning.

We also ran full-parameter fine-tuning for 512 steps, in which all 1.3B parameters are updated: our rule is applied to fc1 and AdamW to the remaining parameters (Appendix D.3). Our rule forgot less than shared projection on both sets in every seed (Set A: 0.0241 vs. 0.0304; Set B: 0.0252 vs. 0.0335), with learning matched within 0.1% (0.6881 vs. 0.6887), and it removed 86% of the forgetting caused by plain AdamW. In 512-step fc1 runs at learning rate 10−410^{-4}, C=256 removed 72.9% of the unconstrained forgetting on Set A (0.1489 vs. 0.5502) and learned more (0.6288 vs. 0.5753), in all 3/3 seeds.

Downstream zero-shot accuracy

On five standard benchmarks (LAMBADA, HellaSwag, WinoGrande, ARC-Easy, SciQ), unconstrained fine-tuning lowers accuracy by 2.94 points. Both projection methods reduce this loss by more than 63%. The drop is 1.02 points for our rule (C=128; smaller than the unconstrained drop in 3/3 seeds, p=0.013p = 0.013) and 1.08 points for shared projection (k=34k=34). These benchmarks rely on coarse, discrete argmax decisions over short prompts, so small shifts in probability margins are rounded off. For this reason we added the continuous NLL evaluation on the 520 documents, on which the per-neuron advantage is measurable: 13.4% lower forgetting at 128 steps and 33.0% lower forgetting at 512 steps, in all 3/3 seeds.

W5. Statistical tests and seed dependence

The 27 seed-pairs reported across budgets reuse the same random seeds.

To account for this, we recomputed the omnibus tests by flipping the signs of the differences jointly within each seed across all six budgets, so that each distinct seed enters the permutation test once. With all six budgets weighted equally, our rule reduced forgetting relative to matched shared projection by 0.0180 nats/token, and all six seed totals favor the per-unit projector (exact one-sided sign-flip test, p=1/64=0.0156p = 1/64 = 0.0156). Using only the three seeds present in all budgets gives a mean difference of -0.0196 nats/token (p=1/8p = 1/8, the smallest value attainable with three binary signs). Against the alternative token selectors, the joint test gives p=1/64p = 1/64.

In the revised manuscript, these joint tests replace the pooled pp-values in the main text. We will release all 45 individual paired differences together with the analysis scripts. The results on Sets A and B do not pool data across comparisons: each configuration is reported with its exact seed counts, and the main comparisons also with document-bootstrap intervals.

W1 & W2. Model families, domains and smooth activations

To test whether the rule generalizes, we ran fine-tuning experiments on additional model families, activation functions and domains. Each row of the table compares our rule with plain fine-tuning of the same parameters, using the same data, 128 steps, learning rates and seeds. The table reports Set A forgetting; Set B gives the same ranking in all seeds.

Model, updated parameters, target domainForgetting: Ours / Plain (↓)Learning: Ours / Plain (↑)Seeds favoring ours
OPT-1.3B, fc1, Python (C=128)-0.0192 / 0.09620.2095 / 0.17013/3
OPT-1.3B, all parameters, WikiText (C=256)0.1737 / 0.41020.6218 / 0.56823/3
OPT-1.3B, all parameters, Python (C=256)0.0232 / 0.12440.2096 / 0.14373/3
Pythia-1.4B (GELU), first MLP matrix, WikiText (C=256)0.0731 / 0.28480.5420 / 0.49893/3
Qwen2.5-0.5B (SwiGLU), up projection, WikiText (24/neuron)0.1364 / 0.24920.4014 / 0.36913/3

On Python code, our rule lowered old-text NLL below that of the pretrained base model (-0.0192 nats/token), whereas plain training increased it by 0.0962 nats/token. In full-parameter fine-tuning, our rule constrains only fc1, and AdamW trains all other parameters without constraint. This reduced forgetting by 57% on WikiText and by 80% on Python, and new-task learning improved in every seed.

On Pythia-1.4B (GELU), we also compared our projector with shared projection at a matched budget of 175 directions per row. Retention on the 520 documents is the same (0.0675 vs. 0.0676 nats/token). Our projector gives lower forgetting on the original probe (0.0047 vs. 0.0154) and higher new-task learning (0.5420 vs. 0.5234), and both differences hold in all 3/3 seeds. On OPT-6.7B (fc1 updated in the last four blocks, C=128 vs. shared k=69k=69), forgetting is equivalent under TOST (0.0192 vs. 0.0184, within the ±0.0068\pm 0.0068 margin), and both methods remove 85% of the unconstrained forgetting. New-task learning is higher for our rule in every seed (+0.0109 nats/token, p=1.5×10−4p = 1.5 \times 10^{-4}).

Theory for smooth activations

To clarify, Theorem 5 (Lemma 2 in the revised manuscript, with the gated case in Appendix B) is stated as an exact identity for thresholded activations (ReLU and hard-gated GLUs). For smooth activations such as GELU or SiLU, the zero-output property on inactive tokens does not hold globally. However, the projection principle extends directly to these activations. Holding the pre-activations fixed on responsive inputs leaves their outputs unchanged, and on the other inputs the change in output is scaled down by the local derivative of the activation (∣GELU′(z)∣≤0.133|\text{GELU}'(z)| \le 0.133 for z≤−0.5z \le -0.5; SiLU(gt)\text{SiLU}(g_t) is close to zero for strongly negative gates). On Pythia, constraining each unit on the tokens with positive pre-activation covers 68.0% of the total output energy and reduces forgetting by 74.3% / 76.1% (Sets A / B). On Qwen2.5-0.5B (SwiGLU with frozen gates), the output change is exactly SiLU(gt)Δv⊤xt\text{SiLU}(g_t) \Delta v^\top x_t. Constraining each unit on the 24 tokens with the largest ∣SiLU(gt)∣|\text{SiLU}(g_t)| reduced forgetting by 45.3% / 46.7% and gave higher learning, in all 3/3 seeds (Appendix F.5).

W4. When post-pruning weight repair is beneficial

The reviewer asks for a clearer guideline on when post-pruning repair should be used. On OPT-1.3B with Wanda pruning masks (dense baseline perplexity 14.62), the results establish the following rule:

  • At moderate sparsity (50% and 60%), keeping the pruning mask alone is preferable. The mask alone gives WikiText-2 perplexities of 19.76 and 29.37. Among the refitting objectives, our one-sided refit gives the lowest perplexity at both levels (20.34 and 30.04, vs. 20.76 and 34.33 for pre-activation refitting).
  • At high sparsity (70% and above), one-sided refitting becomes beneficial. At 70% sparsity, our one-sided refit lowers perplexity from 97.25 to 84.50, whereas pre-activation reconstruction raises it to 153.64. The exact minimizer of the unconstrained gated objective is 1.94 nats/token worse than no repair.
  • We also embedded the one-sided objective in the full SparseGPT pipeline, which selects its own masks across all 144 linear layers, and used it to refit each fc1. Perplexity fell from 30.21 to 28.04 at 60% sparsity, from 79.93 to 57.55 at 70% and from 763.3 to 395.4 at 80%, in all 3/3 seeds. An equal refit with SparseGPT's own pre-activation objective gives 28.81, 77.38 and 738.3, and our objective is better in every seed, so the margin comes from the objective itself. After SparseGPT's reconstruction, one-sided refitting is already beneficial at 60% sparsity.

W6. Computational cost, throughput and memory

All measurements were taken on a single NVIDIA L40S GPU in fp32, with optimizer states kept on the CPU.

  • Building the C=256 projector takes 6.3 seconds (9.8 seconds if the factors are precomputed and cached), comparable to the 6.7 seconds of shared projection (k=47k=47).
  • With cached Cholesky factors, training runs at 84% of the shared-projection throughput (159.1 vs. 189.9 tokens/second) and uses 34.1 GiB of peak memory, mainly because our implementation pads tensors uniformly to 256×256256 \times 256. With block recomputation, training runs at 52% throughput and uses 7.7 GiB of peak memory, close to the 7.4 GiB of shared projection. Both modes give identical numerical results. At C=128, throughput is 95% of shared projection.
  • The unpadded Cholesky factors take 3.15 GB in fp16 across all 24 layers, about the size of the AdamW momentum buffers of the fc1 layer (3.22 GB). The factors exist only during training, so the final model has no extra parameters and no inference overhead.

Summary

The answers to the six points are as follows.

  • (i) The evaluation now covers OPT-1.3B, OPT-6.7B, Pythia-1.4B, Qwen2.5-0.5B, Python code and full-parameter tuning.
  • (ii) For smooth activations, output changes on inactive tokens are scaled down by the derivative of the activation or by the gate. Relative to unconstrained training, our rule reduces forgetting by 74-76% (GELU) and 45-47% (SwiGLU), with higher learning in every seed.
  • (iii) On 520 independent documents, our rule at C=256 forgets 13.4% less than shared projection at 128 steps, and 33.0% less over 512 steps at learning rate 3×10−53 \times 10^{-5}, in every seed.
  • (iv) Repair has a well-defined operating range, and it improves SparseGPT.
  • (v) The statistical claims now rest on joint permutation tests.
  • (vi) The execution overhead has been profiled in time, throughput and memory.

We would be grateful if the reviewer would reconsider the score in light of these results, and we are glad to answer any further questions.

We thank the reviewer again for the review. As the discussion period ends soon, we summarize how the revised paper resolves the six concerns, with the main results and their location:

  1. Models and domains. The evaluation now covers five models from three families (OPT-125M to OPT-6.7B, Pythia-1.4B with GELU, Qwen2.5-0.5B with SwiGLU), Python code, full-parameter fine-tuning and a three-stage sequence. On Python, the projector lowers the NLL of 520 held-out documents below that of the pretrained model, by 2.4 times as much as Adam-NSCL at GPM's energy threshold, and learns 14.9% more (3/3 seeds; Section 4.1, Appendices D.1 and F.5).
  2. Smooth activations. On Pythia-1.4B (GELU), forgetting is 74.3% and 76.1% lower than with unconstrained training on Sets A and B, and against shared projection at the same budget the projector learns more at the same retention on the 520 documents. On Qwen2.5-0.5B (SwiGLU, gates frozen), forgetting is 45.3% and 46.7% lower. New-task learning is higher in every seed for both models, and Appendix F.5 gives the argument for frozen gates and the slope bound for GELU (Section 4.1; Appendix F.5).
  3. Training length and test-set size. On 520 independent test documents, C=256 forgets 13.4% less than Adam-NSCL at 128 steps and 33.0% less over 512 steps, where it also learns more, in every seed. With all parameters trained, it removes 86% of the forgetting of AdamW (Section 4.1; Appendices D and D.3).
  4. When repair helps. Inside the complete SparseGPT pipeline, the one-sided refit lowers WikiText-2 perplexity at 60%, 70% and 80% sparsity in all three seeds (for example from 79.93 to 57.55 at 70%), and it is also better than an equal refit with SparseGPT's own objective. With fixed Wanda masks, it helps from 70% sparsity on (Section 5; Appendices G.2 and J).
  5. Statistics with reused seeds. The pooled tests are now joint sign-flip tests over seeds: all six seed totals favor the projector (p = 1/64), and the 45 per-seed differences and the analysis scripts are in the supplementary material (Section 4.1; Appendix C.2).
  6. Cost. Building the projector takes 6.3 to 9.8 seconds (shared projection: 6.7 seconds), training with cached factors runs at 84% of the shared-projection throughput, and the fine-tuned model has no extra parameters and no inference cost (Appendix D.4).

We would be glad to answer any further questions, and we would be grateful if the reviewer would take these results into account in the final assessment.

Reviewer_uhwTOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

The paper proposes a new perspective on catastrophic forgetting in ReLU-based neural networks with two applications: knowledge-poreseving FT and post-pruning repair. The authors characterize the regions of the activations that are inactive and determine that these regions should be constrained in current forgetting approaches like GPM. They propose projection to each neuron subspace of the active region instead of general constraint.

Experiments on OPT language models show that this approach can reduce forgetting at comparable projection budgets. The paper also applies the theoretical framework to pruning repair, proposing a one-sided penalty to account for previously inactive neurons becoming active after pruning.

Critical strengths
  1. The observation that shared-subspace projection methods constrain parameters even for inactive neurons provides a reasonable motivation for considering per-unit constraints.

  2. The exact decomposition in Theorem 5 and the budget-separation argument in Theorem 9 provide a useful theoretical perspective on the proposed projection method.

  3. The method is novel and produces gains in forgetting scenarios.

  4. The ablations to validate the phenomena are scientifically valid and significant.

Critical weaknesses
  1. The paper suffers from significant clarity and presentation issues. The abstract, introduction, and experimental sections are extremely dense with numerical results and statistical values, which make it hard to distinguish between the supportive claims to the contribution. The paper presents theoretical results and two different applications without explaining what the relation between the results and the applications is, which makes it hard to understand the mathematical motivation. For example, Proposition 2 establishes a tropical representation and zonotope duality for ReLU activation patterns. However, it is not clear how this geometric characterization is necessary for deriving or implementing the proposed per-unit projector.

  2. Proposition 10 theoretically motivates a gate-weighted shared projector, yet the experiments use the unweighted Adam-NSCL baseline. Including the gate-weighted variant is important to separate whether performance gains stem from activation-informed subspaces or per-unit adaptation. Without this comparison, the specific advantage of per-unit adaptation remains ambiguous.

  3. The fine-tuning evaluation is limited to narrow OPT settings and lacks robustness across seeds, while OPT-6.7B shows comparable forgetting to Adam-NSCL rather than a clear improvement. The current ablations support that we can use the activations to identify input constraints, but they do not show that constructing a new projection subspace for each neuron is better than sharing one.

Questions for authors

See weaknesses.

5 comments

Response to Reviewer uhwT

(1/3)

We thank the reviewer for the evaluation of our manuscript. The reviewer finds the central idea, using activation sparsity so that inactive parameters are not over-constrained, well motivated, and values the theoretical basis given by the finite-update decomposition (Theorem 5), the budget separation result (Theorem 9) and the selector ablations. The review raised three concerns:

  1. The mathematical presentation was overly heavy, and the relation between tropical geometry, the algorithm and pruning repair was hard to follow.
  2. The comparisons used unweighted shared projection (Adam-NSCL), which left open whether the gate-weighted shared projector of Proposition 10 could close the gap without per-neuron subspaces.
  3. The evaluation was limited to narrow OPT settings, and retention at the 6.7B scale was comparable to the baseline rather than higher.

Below we report new experiments with the gate-weighted baseline, a control that isolates the subspace basis, longer training, a scaling analysis, full-parameter training and a GELU model. Part 3 describes the changes to the presentation and maps the submitted numbering of the formal results, which these replies use throughout, to the revised numbering.

W2. Gate-weighted shared projection baseline

We have implemented the optimal shared projector of Proposition 10 as a baseline. It computes the leading eigenspace of the gate-weighted empirical covariance ∑tntx~tx~t⊤\sum_t n_t \tilde{x}_t \tilde{x}_t^\top, where ntn_t is the number of active neurons on token tt. The baseline tests whether a single layer-wide subspace, weighted by activation frequency, protects as well as a separate subspace for each neuron. On the theoretical side, Proposition 10 shows that at equal codimension the best gate-weighted shared subspace never attains a lower total expected drift bound on the active tokens than the best per-neuron subspaces. The experiments below measure the size of the per-neuron advantage in practice.

We evaluate this baseline on OPT-1.3B fine-tuned on WikiText-103 for 128 steps (peak learning rate 10−410^{-4}, as in the paper) with paired seeds 0, 1 and 2. Our C=256 selector keeps on average 47.3 active inputs per neuron, so both shared baselines use k=47k=47 directions per row. Forgetting is measured on two disjoint sets of 260 MiniPile test documents (Sets A and B, 33,020 predictions each, disjoint from all training and calibration text) and on the original 1,024-token probe. New-task learning is measured on unseen WikiText-103 text. The table gives three-seed means in nats/token.

128 steps, OPT-1.3BC=256 (ours)Gate-weighted shared (k=47k=47)Ordinary shared (k=47k=47)Seeds favoring ours (vs. gate-weighted, vs. ordinary)
Set A forgetting (↓)0.03310.03730.03783/3, 3/3
Set B forgetting (↓)0.03390.03910.03963/3, 3/3
Original probe forgetting (↓)0.01140.04630.04593/3, 3/3
New-task learning (↑)0.61960.62070.61970/3, 1/3

The per-unit projector forgets less than the gate-weighted baseline on every evaluation set and in all three seeds: 11.2% less on Set A, 13.4% less on Set B and 75.5% less on the original probe. New-task learning stays within 0.2% (a difference of 0.0012 nats/token).

Decomposition of the gap

On the 520 independent documents of Sets A and B combined, ordinary shared projection forgets 0.0052 nats/token more than our per-unit rule. Weighting the shared inputs by gate activity closes 9.4% of this gap (95% bootstrap confidence interval [2.0%, 21.9%]). Constraining each neuron separately closes the remaining 90.6% (95% CI [78.1%, 98.0%]). The per-neuron step alone reduces forgetting by 0.0047 nats/token (95% CI [0.0024, 0.0071]) and favors our rule in 3/3 seeds. This shows that weighting a single shared subspace by gate activity does not recover the gain of neuron-specific constraint spaces.

Longer training (512 steps)

We also trained for 512 steps on 2,048 distinct WikiText windows, with learning rate 3×10−53 \times 10^{-5} selected on separate validation text. On the 520 documents, our per-unit rule forgets 34% less than the gate-weighted baseline (0.0182 vs. 0.0276 nats/token) and learns more (0.6775 vs. 0.6724), and all seeds favor our method. With this longer training, gate weighting gives no measurable improvement over ordinary sharing (+0.0004 nats/token). Constraining each neuron separately therefore accounts for the entire advantage (-0.0094 nats/token, 95% CI [-0.0118, -0.0071]).

W3. Per-neuron directions, seed stability, scale and architecture

Controlled comparison of constraint directions (Proposition 10)

Proposition 10 shows that the theoretically optimal per-neuron constraint space is spanned by the leading eigenvectors of the neuron's own open-token Gram matrix. At the C=256 budget, our selector already spans this subspace at full rank for 92.4% of units, because these units fire on fewer than 256 of the 2,048 calibration tokens. To isolate the effect of neuron-specific directions under budget truncation, we use the C=64 setting, in which busy neurons fire more often than the cap. We compute the per-neuron PCA of Proposition 10 from all active inputs of each unit. We compare it with a bridge control that uses gate-weighted shared directions but matches each row's numerical rank and ridge shrinkage exactly (on average 23.17 directions and 23.02 effective dimensions per row).

128 steps, C=64 budgetPer-neuron PCA (Prop. 10)Bridge: shared directions, matched rankGate-weighted shared (k=24k=24)
Set A forgetting (↓)0.03910.04350.0508
Set B forgetting (↓)0.04100.04360.0528
Original probe forgetting (↓)0.01940.03730.0506
New-task learning (↑)0.61880.62000.6239

Since the bridge control matches each row's rank and shrinkage, the first two methods differ only in the basis of the subspace. Per-neuron PCA forgets less than the bridge control in all three seeds on Set A and on the original probe, and in two of three seeds on Set B (seed 1: +0.0010 nats/token), with learning within 0.2%. Against the gate-weighted baseline at k=24k=24, per-neuron PCA forgets 22.9% less on Set A and 22.5% less on Set B, in 3/3 seeds.

Seed variation and statistical tests

The seed determines the sequence and batch order of the training text, so much of the run-to-run variance is shared across methods. On Set A at 128 steps, the across-seed standard deviation of forgetting is 0.0067 for C=256 and 0.0066 for ordinary sharing, whereas their paired difference has a standard deviation of 0.0027 and the same sign in every seed. Resampling the 260 documents of each test set gives 95% bootstrap intervals that exclude zero for all C=256 comparisons against both shared baselines. On the original probe, an exact joint sign-flip permutation test across all six budgets gives p=1/64=0.0156p = 1/64 = 0.0156, and all six seed totals favor the per-unit projector. With each neuron's constraint count fixed at its C=64 value, constraining the neuron on its own active tokens forgets less on this probe than constraining it on rank-matched random tokens (by 0.0317 nats/token) or on tokens from two selectors that favor inactive tokens (by 0.0575 and 0.0660). This holds in all 18/18 seed pairs (p = 1/64 over six seeds).

Scaling behavior on OPT-6.7B

On OPT-6.7B we update the fc1 matrices of the last four blocks, with cap 128 (68.7 directions per row) against shared k=69k=69. Retention of the two methods is statistically equivalent: old-probe forgetting is 0.0192 for our per-unit rule and 0.0184 for Adam-NSCL. Under two one-sided tests (TOST; Schuirmann, 1987), this difference (+0.0008 nats/token, 90% CI [-0.0001, +0.0018]) lies within the equivalence margin of ±0.0068\pm 0.0068 nats/token, which is 5.4% of unconstrained forgetting. Both methods remove over 84% of the forgetting of unconstrained training (0.1256 nats/token).

At this scale, the advantage of per-neuron projection appears in new-task learning, which is higher in all three seeds (mean gain +0.0109 nats/token; paired tt-test across seeds, p=1.5×10−4p = 1.5 \times 10^{-4}). This reflects the mechanism of Theorem 9: a shared projector removes the same 69 directions from every row of the layer, which restricts capacity, whereas per-unit projection constrains each row only along the inputs on which that neuron is active, so the remaining degrees of freedom stay available for the new task. Selecting the active tokens remains necessary at this scale: replacing them with rank-matched random inputs increases forgetting by 0.0098 nats/token in 3/3 seeds.

Full-parameter training and a GELU model

When all OPT-1.3B parameters are trained for 512 steps, our rule forgets 22.8% less than shared projection on the 520 documents (3/3 seeds) at matched learning. On Pythia-1.4B (GELU, C=256), our rule forgets 74.3% (Set A) and 76.1% (Set B) less than unconstrained training. Against shared projection at the same budget (175 directions per row), it forgets 70% less on the original probe (0.0047 vs. 0.0154) and learns more (0.5420 vs. 0.5234), both in 3/3 seeds, and matches its retention on the 520 documents (0.0675 vs. 0.0676).

W1. Mathematical presentation and relation to pruning repair

Following the reviewer's comment, we have reorganized the paper so that the algorithm comes first and the geometry serves as background.

Direct Jacobian derivation first

Section 3 of the revision now opens with a three-line derivation of the projector that does not use tropical geometry:

  1. For an augmented input x~t=(xt,1)\tilde{x}_t = (x_t, 1), a ReLU neuron computes the pre-activation zt=w~⊤x~tz_t = \tilde{w}^\top \tilde{x}_t and outputs ht=max⁡(0,zt)h_t = \max(0, z_t). Let OO be the set of calibration tokens on which the neuron is active (zt>0z_t > 0).
  2. With the gate states fixed, a weight update uu changes the post-activation output by Δht=1[t∈O] u⊤x~t\Delta h_t = \mathbf{1}[t \in O]\, u^\top \tilde{x}_t.
  3. Preserving these active responses exactly requires X~Ou=0\tilde{X}_O u = 0. We therefore project the row update onto the null space of X~O\tilde{X}_O and keep at most CC active tokens per unit.

The derivation is self-contained and is sufficient to understand the algorithm.

Role of the formal results

Each formal result is now introduced with its role in the method:

  • Theorem 5 (finite-update decomposition, now Lemma 2) serves as a foundational lemma. The Jacobian derivation is infinitesimal, whereas Theorem 5 shows that for a finite update Δw\Delta w the squared drift decomposes exactly into in-cell, open-to-closed and closed-to-open terms. It proves that X~Ou=0\tilde{X}_O u = 0 removes both the in-cell drift and the open-to-closed flips, so only near-wall closed-to-open crossings remain (Proposition 11, now Proposition 7).
  • Theorem 9 (budget separation, now Theorem 5) gives the cost of protection. Protecting neuron ii requires removing rank⁡(X~Oi)\operatorname{rank}(\tilde{X}_{O_i}) directions from row ii, whereas a shared subspace requires removing at least rank⁡(X~∪iOi)\operatorname{rank}(\tilde{X}_{\cup_i O_i}) directions from every row.
  • Proposition 10 (optimal subspaces, now Proposition 6) gives the optimal per-unit and gate-weighted shared subspaces under isotropic update distributions. It motivates the gate-weighted baseline in Part 1.

The tropical hypersurface and zonotope duality constructions (Propositions 2 and 4, Corollary 6; now numbered 9, 11, and 12) are now in Appendix A. They are geometric background and are not needed to use or evaluate the method. The abstract has been rewritten in the same way.

Relation to weight repair after pruning

Section 5 is now shorter and presents weight repair as a second application of Theorem 5. Pruning causes large weight perturbations that often push inactive pre-activations across the threshold (closed-to-open flips). Repair objectives built from derivatives at the dense weights coincide locally with gated least squares and are blind to curvature (Lemma 13, now Lemma 18). Closed tokens have zero local derivatives at the base weights, so a local model can neither anticipate nor penalize gate openings. On OPT-1.3B at 70% sparsity, unconstrained closed-form gated refitting increases the loss by 1.94 nats/token relative to no repair, and pre-activation refitting gives a perplexity of 153.64 (dense model: 14.62).

Theorem 5 identifies closed-to-open escape as the governing error term of the gated refit, and our convex one-sided penalty penalizes this term explicitly. At 50% and 60% sparsity, keeping the Wanda mask without refitting is preferable (WikiText-2 perplexity 19.76 and 29.37), whereas at 70% sparsity and above one-sided refitting becomes effective: on Wanda masks it lowers perplexity from 97.25 to 84.50. Within SparseGPT, our one-sided refitting lowers perplexity from 30.21 to 28.04 at 60% (below the 29.37 of the Wanda mask), from 79.93 to 57.55 at 70% and from 763.3 to 395.4 at 80%, in 3/3 seeds, and it outperforms an equal refit with the SparseGPT objective.

Conclusion

The main points of this response are:

  1. Weighting a shared subspace by gate activity accounts for only 9.4% of the gap between ordinary sharing and our rule, whereas constraining each neuron separately accounts for 90.6% at 128 steps and for the entire gap over 512 steps.
  2. At matched rank (C=64), the per-neuron directions of Proposition 10 forget 8.0% less than gate-weighted shared directions on the 520 documents and 47.9% less on the original probe.
  3. At the 6.7B scale, retention is equivalent and new-task learning is higher in all seeds.
  4. The paper is now organized around a direct 3-line Jacobian derivation, and the tropical formalism is in the appendix.

We would be grateful if the reviewer would consider updating the score in light of these results and revisions, and we are glad to answer any further questions.

Comments on the paper

2 comments
AuthorsOpenReview ↗

General Response

Update (19 November). After the discussion, Reviewers uhwT and pdKz raised their ratings. Reviewer pdKz wrote that the restructuring "addresses my main presentation concern, and the new experiments considerably strengthen the empirical support", and Reviewer 6RUe wrote that our response addresses most of the original concerns and found the 512-step full-parameter result "particularly helpful". The revision of 17 November adds the matched-learning comparison with output KL distillation and replay on Sets A and B (Appendix F.4), states the scope of the SwiGLU and GELU results (Sections 1 and 4.1, Appendix F.5), and gives the cross term of the drift decomposition (Appendix C.1).

We thank the four reviewers for their comments and questions. The reviewers noted the following strengths of the submission: the motivation of using neuron activation sparsity to avoid over-constraining weight updates (uhwT, Fyey, pdKz), the value of the exact finite-update decomposition and the budget separation theory (uhwT, 6RUe, pdKz), and the token-selection ablations, which isolate the open/closed partition (all four reviewers).

The reviewers also raised four groups of questions: presentation (uhwT, pdKz); empirical scope, including longer horizons, larger test sets, modern architectures and full-parameter training (all four reviewers); baselines (all four reviewers); and cost and statistics (Fyey, 6RUe, pdKz).

Unless stated otherwise, each experiment below fine-tunes fc1 of OPT-1.3B on WikiText-103 with paired seeds 0, 1 and 2. Forgetting is the increase in old-text NLL and learning the decrease in new-task NLL, in nats/token; "3/3 seeds" means that all three seeds favor our per-unit rule.

New experimental results

  • Evaluation on 520 independent documents. In addition to the original 1,024-token probe, we measure forgetting on two disjoint sets of 260 MiniPile documents (Sets A and B, 33,020 predicted tokens each), kept apart from all training and calibration text.
  • Gate-weighted shared baseline (uhwT, pdKz). The optimal shared projector of Proposition 10 weights old inputs by gate activity. At 128 steps, our C=256 selector (47.3 constraints per neuron on average) forgets 0.0331 / 0.0339 on Sets A / B, against 0.0373 / 0.0391 for gate-weighted and 0.0378 / 0.0396 for unweighted shared projection at k=47, in 3/3 seeds on both sets, with learning matched within 0.2%. Gate weighting closes 9.4% of the gap to ordinary sharing, and constraining each neuron separately closes the remaining 90.6% (95% bootstrap CI: [78.1%, 98.0%]).
  • Longer training (Fyey, 6RUe). Over 512 steps on 2,048 distinct WikiText windows (LR 3×10−53 \times 10^{-5}, selected on validation text), our projector forgets 34% less than gate-weighted shared projection (0.0182 vs. 0.0276) and 33% less than standard sharing (0.0272) on the 520 documents, and its learning is higher (0.6775 vs. 0.6724), in 3/3 seeds.
  • Per-neuron PCA control (pdKz, uhwT). At C=64, the principal directions of Proposition 10 computed from the active inputs of each neuron give a forgetting of 0.0391 / 0.0410 on Sets A / B, lower than a bridge control with gate-weighted shared directions at matched per-row rank and shrinkage (0.0435 / 0.0436) and gate-weighted shared projection at k=24 (0.0508 / 0.0528).
  • Output KL distillation and experience replay (6RUe). At matched new-task learning, output KL distillation forgets 4.9x to 11.3x as much as our C=256 projector on the original probe and 6.8x to 7.3x as much on the 520 documents, in every paired comparison. With the 2,048 old tokens that our projector uses, replay forgets 10.9x to 16.9x as much. Replay needs more than 16 times as much old text to reach the projector, and adding the projector to the same replay of 65,536 tokens lowers forgetting below that of the pretrained model (-0.0534 / -0.0544 on Sets A / B, 3/3 seeds).
  • Other architectures and scale (uhwT, Fyey, 6RUe, pdKz). On Pythia-1.4B (GELU), our rule reduces forgetting by 74.3% and 76.1% on Sets A and B relative to unconstrained training, and against shared projection at the same budget it learns more at the same retention and forgets 3.3x less on the original probe. On Qwen2.5-0.5B (SwiGLU), constraining the up-projection with frozen gates reduces forgetting by 45.3% and 46.7% relative to unconstrained training. Learning is higher on both models in 3/3 seeds. With full-parameter fine-tuning of OPT-1.3B, our rule reduces forgetting relative to AdamW by 57% on WikiText and 80% on Python over 128 steps (86% over 512 steps), and over 512 steps it forgets 22.8% less than shared projection at matched learning. On OPT-6.7B, retention is equivalent to Adam-NSCL under TOST, while learning is higher on all three seeds (+0.0109 nats/token, p = 1.5e-4).
  • Layer-wise drift (pdKz). We measured drift in all 24 layers of OPT-1.3B on the 520 documents. The total squared drift splits exactly into a direct term, an input term and their cross term, which is 0.18% of the total without constraint and 1.23% at C=64. Relative to unconstrained training, our projector reduces the direct weight-update drift by 74.7%, the input drift from earlier layers by 64.2% and the total layer drift by 65.1%. Input drift accounts for 89.6% of the remaining output change. Closed-to-open boundary crossings are a small part of the total (13.4%) and fall by 75%, as predicted by the near-wall containment of Proposition 11.
  • Cost on NVIDIA L40S GPUs (Fyey, 6RUe, pdKz). Building the C=256 projector takes 6.3 to 9.8 seconds, comparable to the 6.7 seconds of shared projection. During training, caching the per-neuron Cholesky factors gives 84% of the shared throughput (159.1 vs. 189.9 tokens/s) at 34.1 GiB peak memory, which comes from uniform tensor padding in our current code. Block recomputation instead uses 7.7 GiB peak memory (close to the 7.4 GiB of shared projection) at 52% throughput. Unpadded Cholesky factors take 3.15 GB in fp16, comparable to the AdamW moments of fc1 (3.22 GB). They exist only during training, so there is no inference overhead.
  • Joint statistical test (Fyey). Because the same seeds are reused across budgets, we recomputed the omnibus tests so that, for each of the six seeds, all of its differences across budgets are flipped jointly. The exact one-sided permutation test gives p = 1/64 on the original probe, the smallest value attainable with six seeds. On Sets A and B, we report seed counts for all comparisons and document-bootstrap confidence intervals for the main comparisons, without pooling across comparisons.
  • Post-pruning weight repair with SparseGPT (Fyey, pdKz). With Wanda masks, one-sided refitting helps from 70% sparsity on, lowering WikiText-2 perplexity from 97.25 to 84.50 at 70%. Within the SparseGPT pipeline, refitting fc1 with our one-sided objective lowers perplexity from 30.21 to 28.04 at 60% sparsity (below 29.37 for the Wanda mask), from 79.93 to 57.55 at 70%, and from 763.3 to 395.4 at 80%, across all 3/3 seeds. It also outperforms an equal refit that uses SparseGPT's own pre-activation objective.

Changes to the manuscript

We revised the manuscript as follows.

  1. Presentation of the theory. Section 3 now opens with the three-line derivation of the per-neuron projection rule from the local Jacobian of the ReLU layer, so the algorithm is stated before the geometric analysis. Theorem 5 is presented as a short lemma that makes this derivation exact for finite weight updates; it decomposes the output change into in-cell, open-to-closed and closed-to-open terms. Theorem 9 gives the per-row price of exact protection, and Proposition 10 characterizes the optimal budget-limited subspaces. The formal tropical hypersurface and zonotope duality constructions (Propositions 2 and 4, Corollary 6) are now in Appendix A. Result numbers and terms in our replies follow the submitted version. In the revision, Theorem 5 is Lemma 2, Theorem 9 is Theorem 5, Propositions 10 and 11 are Propositions 6 and 7, Propositions 2 and 4 and Corollary 6 are Propositions 9 and 11 and Corollary 12 (Appendix A.1), and Lemma 13 is Lemma 18 (Appendix G). Open and closed tokens are now called active and inactive; the in-cell, open-to-closed and closed-to-open terms are now the stay-active, switch-off and switch-on terms; and near-wall tokens are now near-threshold tokens.
  2. Shorter pruning-repair section. The repair discussion in Section 5 is now a single paragraph. It explains why derivative-based local objectives are insensitive to closed-to-open crossings and how a one-sided penalty corrects this. The space saved is used for the new results on modern architectures, full-parameter fine-tuning and longer training.
  3. New results. The revision adds (i) evaluations on Sets A and B alongside the original probe (Section 4.1, Appendix D); (ii) 512-step training and full-parameter fine-tuning (Section 4.1, Appendix D.3); (iii) SwiGLU, GELU and multi-stage sequential adaptation results (Appendix F.5); (iv) output KL and experience replay comparisons, including matched learning on Sets A and B (Section 4.3, Appendix F.4); (v) hardware profiling on L40S GPUs (Appendix D.4); and (vi) joint seed permutation tests (Section 4, Appendix D).
  4. Abstract. The abstract no longer contains detailed lists of numerical results. It now centers on the exact finite-update decomposition, the per-unit projector, budget separation, and the empirical validation in fine-tuning and pruning.

We thank the reviewers again for their comments. The individual replies below answer each point and give the complete tables.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.