acceptodds
Under review as a conference paper at ICLR 2027

Steering Circuit-Level Activations for Personalized Knowledge Injection

Abstract

Although large language models (LLMs) are increasingly personalized to individual users, they still struggle with a deceptively simple but critical requirement: updating mutable personal facts, such as a user's job, location, or relationships. Fine-tuning approaches are costly and prone to catastrophic forgetting. Meanwhile, knowledge editing approaches rely on subject-bound representations; they fail in personal domains because private entities lacking prior exposure lead to unstable key extraction, while multi-attribute updates cause key collisions. We propose SPIKE (Steering Circuit-level Activations of Language Models for Personalized Knowledge Injection), a methodology that identifies the LLM components effective for injecting personal knowledge and incorporates mutable personal knowledge into the LLM through activations generated via a KG-LLM Alignment Module. Our experiments demonstrate that SPIKE effectively balances the accurate incorporation of new facts with the preservation of existing knowledge, offering a practical solution for personalization in settings where user information evolves over time. Our code is available at https://anonymous.4open.science/r/spike.

Primary area:
interpretability and explainable AI
Keywords:
LLM Personalization, Mechanistic Interpretability, Knowledge Graph

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_gFouOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies personal knowledge updates, examining how a model can use new facts when user attributes, such as occupation or location, change while preserving other personal information and general knowledge.

SPIKE maps representations of the initial and updated knowledge graphs to activation intervention vectors, which are injected into selected attention heads. The base model remains frozen during updating, and the training objective balances accuracy on new facts, knowledge retention, and intervention magnitude.

Critical strengths

1.Private entities and updates to multiple attributes differ from traditional editing of public facts. The paper designs its method around these differences rather than merely changing the dataset.

2.SPIKE performs consistently across four datasets, with substantial advantages over some editing methods when updating multiple facts about the same person. The comparison between attention head and FFN interventions also supports the design choice.

3.Using the difference between the initial and updated knowledge as the intervention signal better reflects the requirements of updating than encoding new facts alone.

Critical weaknesses

1.The personalization setting remains somewhat idealized. The experiments first train the model on the initial personal knowledge to an accuracy above 99% before evaluating updates. This helps isolate the updating problem, but real models often have incomplete knowledge of a user’s initial information.

2.The representation of differences between old and new facts appears to contradict the motivation that private entities lack meaningful representations. The paper argues that private entities lack meaningful representations in model parameters, yet the method learns an update representation that encodes the difference between old and new facts.

If an entity has never appeared before, where does its old fact representation come from? These two claims appear logically inconsistent.

3.The information available at inference time and the fairness of comparisons with retrieval-augmented methods need clarification. SPIKE uses structured knowledge and representations of its updates. Key questions include whether the system must identify the person and relation associated with a query, whether it must retrieve relevant triples, and how it selects the intervention vector.

If the system can already retrieve the relevant updates accurately, strong baselines should include context injection and retrieval-augmented methods using the same triples and retrieval results.

Questions for authors

See weakness.

3 comments
AuthorsOpenReview ↗

Response to Reviewer gFou

W1

We thank the revier for pointing this out. As the reviewer mentioned, our main experiments assume that the init-LLM knows more than 99% of the initial personal knowledge, in order to isolate the update problem. To evaluate the case where initial knowledge is incomplete, we added the following setting on PerInfoKG. For each user, about half (8–9) of the changed attributes are treated as missing and removed from the init KG, and the init-LLM is trained on the init KG without these attributes. The resulting init-LLM has an accuracy of 78.8%; on the 8 missing attributes it answers about 3 correctly on average, which are guesses based on the same relations learned for other users. The upd KG is used unchanged, so all changed attributes are injected regardless of whether they are missing.

The missing attributes therefore have no initial value in either the LLM parameters or the KG. For these attributes, we compute Δ using a zero vector as the KG embedding and, as the text embedding, a sentence in which the old value is replaced with "no information." Results on Qwen2.5-7B / PerInfoKG:

SettingAccLocRetTotal
No missing attributes99.496.891.995.9
~Half of changed attributes missing98.897.790.495.5

Even with about half of the changed attributes missing from the initial KG, Total stays at 95.5, close to the 95.9 without missing attributes. This shows that SPIKE can inject updates even when the old fact is absent from both the LLM and the KG.

W2.

Thank you for raising this insightful point. SPIKE's representation of the old fact, H^txtinit\hat{H}^{init}_{txt} , is not the LLM-internal lookup key used by ROME-style methods. It is obtained from KG embeddings learned on KGinitKG^{init} (TransE, R-GCN), text embeddings, and a learnable alignment module. Moreover, H^txtinit\hat{H}^{init}_{txt} is computed per (s, r, o) triple rather than as a key bound to a single subject, and it serves only as the reference point for computing Δ with respect to the updated triple. SPIKE therefore does not rely on the contextual stability of lookup keys that locate-and-edit methods assume, which we show does not hold for personal entities (Appendix A.2). In addition, in the missing-attribute experiment in our W1 response, where the initial information is absent from both the LLM and the KG (zero vector for the KG embedding, "no information" for the text), SPIKE still achieves an Accuracy of 98.82 on Qwen / PerInfoKG.

AuthorsOpenReview ↗

Response to Reviewer gFou (2)

W3.

Information required at inference. We thank the reviewer for these important questions. We answer the three questions in turn. (1) Identifying the person and relation: required. The Accuracy evaluation in Table 1 assumes that it is known which person and which relation the question is about. (2) Triple retrieval: no triple is retrieved at question time. Since Δ is computed from triples alone, independently of the question, it can be precomputed and stored whenever the KG is updated (Appendix A.11). (3) Intervention vector selection: the stored Δ for the (person, relation) pair is selected.

SPIKE therefore assumes that the update needed for a question is known exactly. This is the same level of information as the perfect retrieval assumed by the SC baseline, and we now state this assumption explicitly in the problem setting (Section 3.1).

Relaxing this assumption. We drop the assumption that the relation of the query is known and add a step that selects the relation corresponding to the given query. The relation is first selected by exact string matching, i.e., by checking whether the query is identical to the template of one of the person's relations (Table 12); unless exactly one template matches, the init-LLM is prompted to select the relation. On Qwen2.5-7B-Instruct / PerInfoKG, this yields (Acc, Loc, Ret, Tot) = (99.2, 96.3, 91.5, 95.6), compared with (99.4, 96.8, 91.9, 95.9) when the relation is known (Table 1), with all metrics changing by at most 0.5 points. This indicates that the known-relation assumption can be replaced by a simple selection step with little loss in performance. The details and results of this experiment are added to Appendix A.9.

Comparison with context injection using the same information. This baseline is already included. SC assumes perfect retrieval and provides only the triples needed for the question as context, and SC+3-Shot additionally provides three examples (Section 5.1.2). Both therefore use the same triples and the same retrieval results as SPIKE.

The difference lies in where the information is placed. Context injection puts personal information into the prompt of every question, so personal context is attached even to general-knowledge questions, which can lower Retention (e.g., SC+3-Shot reaches a Retention of only 34.3 on Qwen / PeaCoK-Ex). It also exposes sensitive raw records in the inference prompt. SPIKE injects updates as internal representations of the model, so personal context is not added to the prompt and raw records do not appear in it.

Since SC uses oracle retrieval, its performance is an upper bound for any context-injection or retrieval-augmented method that uses the same triples. On Qwen2.5-7B-Instruct / PerInfoKG, SPIKE without knowing query relevant relation (Total 95.6) still exceeds SC (51.2) and SC+3-Shot (83.0), both of which are given the oracle triples.

Thank you for your rebuttal. I will maintain my original score.

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

This paper proposes SPIKE, an activation-steering method for updating evolving personal knowledge in LLMs. It first identifies attention heads associated with personal knowledge. A KG–LLM Alignment Module then converts knowledge-graph updates into steering vectors, which are injected into the selected components to reflect the updates while preserving existing knowledge. Experiments across multiple models and datasets show strong results.

Critical strengths
  1. The problem of updating evolving personal knowledge is practical, and the paper considers both multi-attribute updates and preserving unchanged knowledge.
  2. Combining structured KG representations with activation steering is a novel direction for personal knowledge updating.
  3. The experiments cover several models, datasets, and editing baselines, with competitive results.
Critical weaknesses
  1. The evaluation assumes the correct update triple is known. The paper does not explain how the right triple would be selected for a real user query; it builds both the queries and the steering vectors from known triples. Locality is also tested by computing a new steering vector for each unchanged fact, not by keeping the actual update vectors active. As a result, the experiments do not fully show that unchanged knowledge is preserved in realistic settings.

  2. The current implementation seems not to match the described head-level intervention. In the code, the hook is placed on the whole attention module, whose output has already passed through out_proj. The slicing therefore acts on projected hidden states, not on individual heads, which weakens the claims about attention heads and personal knowledge circuits. The code also scales the steering vector at layer ℓ\ell by 1/(2+eℓ)1/(2+e^{\ell}). The paper does not mention this scaling, and it almost removes the intervention in deeper layers.

Questions for authors
  1. Why is slicing after out_proj treated as a head-level intervention? What is the reason for the layer-wise scaling?
  2. How is the relevant triple found at inference time? Can Locality be evaluated with the actual update vectors kept active?
  3. Why use a sigmoid in Eq. (6)? Since σ(0)=0.5\sigma (0) = 0.5, the steering vector is nonzero even when nothing changes, and it can never be negative.
4 comments
AuthorsOpenReview ↗

Response to Reviewer m3QC

W1.

We thank the reviewer for this comment. SPIKE assumes that the triple of the query is known, which is the same kind of assumption as the perfect-retrieval assumption of SC. We made this assumption to keep the experimental setup simple: in fact-level retrieval, selecting the relation relevant to a query can be implemented with an LLM in a straightforward way, and we expect this step not to be a major challenge in our problem setting. To verify this, we implemented and evaluated an end-to-end pipeline that does not assume the relation is given. For each query, relation is first selected by exact string matching, i.e., by checking whether the query is identical to the template of one of the person's relations (Table 12); unless exactly one template matches, the init-LLM is prompted to select the relation. For this prompt, we use the relation-specific templates in Table 12 in the reverse direction: instead of generating a query from a relation, the init-LLM is given the query together with the templates of the candidate relations and asked which relation the query corresponds to. The pipeline then retrieves the corresponding triple and constructs the steering vector from it. On Qwen2.5-7B-Instruct / PerInfoKG, this pipeline yields (Acc, Loc, Ret, Tot) = (99.2, 96.3, 91.5, 95.6), compared with (99.4, 96.8, 91.9, 95.9) when the relation is known (Table 1). All metrics change by at most 0.5 points, indicating that the known-relation assumption can be replaced by a simple selection step with little loss in performance. We state this assumption explicitly in Section 3.1 and add the end-to-end results to the Appendix A.9.

W2, Q1.

We thank the reviewer for identifying this mismatch; the reviewer is correct. The sentence "each segment is added to the corresponding head output" in Section 4.2.2 reads as adding each segment to a head's output before out_proj, whereas the implementation adds each segment to a head-sized slice of the attention module output after out_proj. Such a slice is not the output of an individual head, so "head-level" was inaccurate. Circuit discovery (the head importance computation) also zeroes the same slices at the same location, so discovery and intervention are consistent with each other, but both operate on attention output blocks rather than heads. We have replaced "attention head" with "attention output block" in the paper and revised the related descriptions throughout.

Head-level variant (pre-out_proj). To evaluate true head-level intervention, we re-ran circuit discovery on the head outputs before out_proj and applied steering at the same location (pre-out_proj), with hyperparameters re-tuned for this setting. Results on PerInfoKG:

ModelSettingAccLocRetTotal
GPT-Jpost-out_proj (submitted)99.298.489.295.4
GPT-Jpre-out_proj97.198.186.993.8
Qwenpost-out_proj (submitted)99.496.891.995.9
Qwenpre-out_proj89.296.091.992.3

The method still works with pre-out_proj, but its Total is lower than that of post-out_proj (GPT-J 93.8 vs. 95.4; Qwen 92.3 vs. 95.9). For Qwen, the drop comes almost entirely from Accuracy (89.2 vs. 99.4); for GPT-J, Accuracy (97.1 vs. 99.2) and Retention (86.9 vs. 89.2) drop by similar amounts. We conjecture the following cause: each element of Δ is bounded to (0, 1) by the sigmoid and multiplied by a fixed scale, so under pre-out_proj the magnitude actually added to the residual stream is determined by the out_proj weights, which can weaken the effect on the output tokens.

Undocumented scale term. The implementation multiplies the steering vector by 1/(2+el)1/(2+e^{l}), and omitting this from the paper was our mistake. We added this term during implementation to keep Locality stable: we observed that intervening with the same magnitude up to the deep layers made the responses to unchanged facts unstable.

This scale is a fixed function, not a learned value, and it is applied identically to all datasets, all backbones, and all evaluations (Accuracy, Locality, Retention); it was not tuned to any particular setting or metric. As the reviewer pointed out, however, the scale decreases sharply with depth (e.g., about 1/22,000 at l = 10), so the effective intervention is concentrated in the early layers.

We revised the description in Section 4.2.2, which selects blocks in all L = 28 layers, to state that the scaling factor concentrates the intervention in the first few layers (e.g., the factor is below 0.01 from layer 5 onward).

AuthorsOpenReview ↗

Response to Reviewer m3QC (2)

Q2

To verify that Locality can be evaluated with the actual update vectors kept active, we apply the average Δ\Delta across that person's updated triples rather than the Δ\Delta of each unchanged triple. Unchanged facts are thus queried with the updates in effect, which matches the condition of the weight-editing baselines. Results on Qwen2.5-7B / PerInfoKG:

AccLocalityRetentionTotal
99.295.391.595.2

Locality decreases from 96.8 to 95.3, but 95.3 is still higher than every weight-editing baseline in Table 1 on the same dataset and model (ROME 51.8, ICE 42.6, LightEdit 22.7, MEMIT-Merge 74.1, AlphaEdit 77.6, WISE 91.7), and slightly lower than SAKE (96.2).

Q3.

The sigmoid was a design choice to bound each element of Δ to (0, 1) and stabilize training. As the reviewer noted, Δ therefore cannot be negative and is not 0 even for unchanged facts; indeed, the Δ computed from unchanged triples in the Locality evaluation is nonzero. The high Locality in Table 1 therefore does not come from Δ = 0; it shows that the model tolerates this nonzero baseline.

sigmoid vs. tanh. We replaced the sigmoid with tanh, which allows negative adjustment and outputs 0 when there is no change, and compared the two on PeaCoK / GPT-J:

ActivationAccLocRet
sigmoid100.0100.086.5
tanh100.080.184.6

tanh keeps Accuracy and Retention at similar levels, but Locality drops sharply (100.0 → 80.1). Thus, the inability to make negative adjustments did not limit performance in our setting; rather, the bounded range of the sigmoid appears to help preserve Locality. We conjecture that because the range of tanh, (−1, 1), is twice as wide and bidirectional, the intervention can become larger and affect the responses to other facts.

Thanks for the detailed response. The additional results address several of my main concerns.

I’m still not convinced by the layer-wise scaling, though. With this schedule, the intervention in deeper layers is close to zero, so although blocks are selected across all 28 layers, the effective intervention is concentrated almost entirely in the first few layers.

On the sigmoid: the comparison shows that sigmoid works better than tanh empirically, but that is not the same as showing that a nonzero steering vector is needed when there is no change. That question remains open for me.

That said, my main soundness concerns are largely resolved, so I have raised my soundness score to 2 and my overall rating to 3.

AuthorsOpenReview ↗

Response to Reviewer m3QC (3)

Thank you for the follow-up. We appreciate your careful engagement.

Layer-wise scaling: We agree. With this schedule, the effective intervention is concentrated in the first few layers, even though blocks are selected in all 28 layers. We have revised Section 4.2.2 to state this explicitly.

Sigmoid: We agree that the ideal would be a zero Δ when there is no change, which amounts to not steering. SPIKE does not achieve this for two reasons: the sigmoid outputs 0.5 even when the two representations are identical, and, by the design of our alignment module, the two representations generally differ even for an unchanged fact, since the KG embeddings are trained separately on each snapshot. (In our earlier response, "no change" for tanh referred to identical representations; for an unchanged fact, even tanh would not yield a zero Δ.) We will discuss this as a limitation, and a design that yields a zero Δ for unchanged facts is a natural direction for future work.

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

This paper studies an important and interesting question: updating factual information in an LLM, specifically mutable personal facts such as a user's job or address. It argues that the previous mainline — locate-and-edit on model parameters — does not work in this domain, because private entities have no stable pretrained representations, so the extracted lookup keys are context-unstable, and because a subject-bound key collides when several attributes of the same person are updated. The paper proposes SPIKE. Instead of editing parameters, it learns a steering vector produced by a KG–LLM alignment module that cross-attends LLM text embeddings against TransE triple and R-GCN subgraph embeddings; the difference between the aligned initial and updated representations is added to the top-k attention heads per layer, at every forward pass and across all token positions. Training is per user, with an NLL objective plus KL and norm penalties. SPIKE is evaluated on PeaCoK-Ex, PerInfoKG, Athlete and ORCID across four backbones against twelve baselines, scored by Accuracy, Locality, Retention and their harmonic mean, and achieves strong results.

Critical strengths

1. The paper does not only show that locate-and-edit fails on personal facts — it measures why. Appendix A.2 samples random prefix contexts per entity and shows private entities' key vectors are substantially less stable than famous entities', with the gap largest at exactly the layers ROME identifies as carrying factual storage. With the key-collision argument for multi-attribute updates, this is a mechanistic account of a real gap in the editing literature, it is the part of the paper I found most interesting, and it would retain value even if SPIKE were superseded.

2. The method is solid and clearly presented. The steering construction is specified precisely enough to reimplement, and intervening at the granularity of individual attention heads rather than whole layers or FFN blocks is an interesting locus for this kind of update — a design choice worth the community's attention independently of the evidence offered for preferring it to FFNs (see Weakness 2).

3. The evaluation is broad. Twelve baselines, four datasets and four backbones, plus stress tests on naturalistic noisy entity strings and on triples extracted from LLM-generated unstructured documents. SPIKE attains the best score in most cells, which does demonstrate the method's effectiveness.

Critical weaknesses

1. The Locality protocol does not measure what the baselines are measured on, and the paper contradicts itself about it. Appendix A.5 states that for a PerInfoKG locality query the unchanged triples "are processed in the same manner to obtain representation differences, which are used to steer the init-LLM" — so the model answers with a Δ derived from the unchanged triple, not the Δ carrying the actual update. Weight-editing baselines have no equivalent option: their edit is live in the parameters when they answer, so they are being measured on a strictly harder condition. The next sentence then says locality holds "despite having been steered using updates to other relations," describing a different procedure. Since the headline result is a Locality gap (87–100% against LightEdit's 1.6% on Qwen/Athlete), the central comparison rests on a protocol stated two incompatible ways.

2. The evidence for a distinct personal-knowledge circuit does not support the framing built on it. The personal-versus-general similarity is 0.58 on GPT-J, suggesting largely shared circuits rather than specialized ones, and no permutation or random-head null is given against which 0.58 could be judged. The attention-versus-FFN comparison justifying the paper's central design choice is parameter-unmatched (0.90% versus 3.12% on Qwen; in Table 2 the FFN variant gets a single layer against k×28 attention heads), so "attention is the better target" is confounded with "fewer parameters forget less." And Figure 3b shows removing the circuit selection hurts less than removing the subgraph features, making the headline "where to intervene" contribution the weaker ablated component.

Questions for authors
  1. For PerInfoKG Locality, is the injected Δ derived from the unchanged triple or from the updated triples? The two sentences in A.5 describe different procedures, and the answer determines whether Table 1's Locality column is comparable to the weight-editing baselines.
  2. With ~17 updated triples per person and Δ stated in A.11 to depend only on the triples and not the query, which Δ is injected at inference, and how is it selected without already knowing the query's relation?
  3. What does the top-k circuit similarity look like against a permutation or random-head null, and can the attention-versus-FFN comparison be rerun at matched parameter counts?
  4. λ₁ = 0 in five of eight main configurations and λ₂ = 0 in several — can you ablate L_KL and L_norm?
  5. On Qwen/PerInfoKG, SAKE's harmonic mean is 96.3 against SPIKE's 95.9. How should readers weigh that on the dataset built to exhibit multi-attribute updates?
5 comments
AuthorsOpenReview ↗

Response to Reviewer 31iP

W1, Q1, Q2

We thank the reviewer for catching this. The paper described the locality protocol in two inconsistent ways; the protocol actually used is to apply the Δ of the unchanged triple. We have removed the conflicting description from Appendix A.5.

Under this protocol, SPIKE applies only the Δ of the triple that the question belongs to, whereas the weight-editing baselines answer with all edits already written into their parameters. The two are therefore not measured under the same exposure condition. We regard this as a design property of SPIKE: because updates are stored as separate vectors rather than written into shared parameters, the Δ of other updates is not applied when an unchanged fact is queried. This property, however, relies on knowing the triple of the question, which is the same kind of assumption as the perfect-retrieval assumption of the SC baseline. We now state this assumption explicitly in the Problem Formulation (Section 3.1) and the experimental setup (Section 5.1.1).

To address this concern directly, we ran two additional experiments: (1) Locality under the same exposure condition as the editing baselines, and (2) a setting in which the relation corresponding to the query is unknown.

(1) Locality under matched exposure. When answering a Locality question, instead of applying the Δ of each unchanged triple, we apply the average of the Δs of that person's updated triples. Unchanged facts are thus queried with the updates in effect, which matches the condition of the weight-editing baselines. Results on Qwen2.5-7B / PerInfoKG:

AccLocalityRetentionTotal
99.295.391.595.2

Locality decreases from 96.8 to 95.3, but 95.3 is still higher than every weight-editing baseline in Table 1 on the same dataset and model (ROME 51.8, ICE 42.6, LightEdit 22.7, MEMIT-Merge 74.1, AlphaEdit 77.6, WISE 91.7), and slightly lower than SAKE (96.2).

(2) Unknown relation. We drop the assumption that the relation of the query is known, and add a step that selects the relation corresponding to the given query. The relation is first selected by exact string matching, i.e., by checking whether the query is identical to the template of one of the person's relations (Table 12); unless exactly one template matches, the init-LLM is prompted to select the relation. For this prompt, we use the relation-specific templates in Table 12 in the reverse direction: instead of generating a query from a relation, the init-LLM is given the query together with the templates of the candidate relations and asked which relation the query corresponds to. On Qwen2.5-7B-Instruct / PerInfoKG, this yields (Acc, Loc, Ret, Tot) = (99.2, 96.3, 91.5, 95.6), compared with (99.4, 96.8, 91.9, 95.9) when the relation is known (Table 1). All metrics change by at most 0.5 points, indicating that the known-relation assumption can be replaced by a simple selection step with little loss in performance. We add this setting to the Appendix A.9 and state the known-relation assumption explicitly in Section 3.1.

AuthorsOpenReview ↗

Response to Reviewer 31iP (2)

W2, Q3.

We agree that Table 7 lacks a reference value, which makes it hard to judge whether the similarities are meaningful. We therefore ran the random-head test suggested by the reviewer: following the Table 7 setup, we replace the top-8 heads with 8 heads sampled at random per layer, repeated 1,000 times.

PairGPT-J observedGPT-J random mean [95% interval]Qwen observedQwen random mean [95% interval]
PeaCoK-Ex vs PerInfoKG0.6240.498 [0.450, 0.547]0.4750.285 [0.231, 0.339]
PeaCoK-Ex vs known 10000.5770.498 [0.449, 0.546]0.4380.284 [0.230, 0.338]
PerInfoKG vs known 10000.534 (p=0.094)0.500 [0.449, 0.549]0.4100.285 [0.230, 0.339]

Because GPT-J has 16 attention output blocks per layer and we select 8, its random baseline is high (≈0.50); against it, the 0.58 you noted (0.577 above) is only about 0.08 above chance, and we agree that this value alone does not support a strong claim. In both models, the personal–personal pair shows the highest similarity and is well above chance. The personal–general pairs show lower similarity, and in most cases still exceed chance, indicating that the important blocks for personal and general knowledge are partially distinct rather than fully separated. This test alone does not establish that the difference between pairs is significant. Accordingly, we will add the random baseline to Table 7 and revise the claims in Appendix A.8 from "distinct computational pathways" to partially distinct important patterns.

Parameter count in Figure 1b. As the reviewer noted, the comparison in Figure 1b used different numbers of trainable parameters (Qwen: attention 0.90%, FFN 3.12%), so it could not separate "attention is a better target" from "fewer parameters, less forgetting." To disentangle the two, on Qwen2.5-7B we increased the trained attention heads from 2 to 7 per layer, matching the trainable-parameter ratio to FFN (attention 3.15% vs. FFN 3.12%), and repeated the same selective fine-tuning. With matched parameter counts, attention still converged faster than FFN and preserved Retention better; 7 heads/layer also converged faster than 2 heads/layer. The gap in Figure 1b is therefore not explained by parameter count alone. Figure 1b Figure 5 has been updated with this result.

Intervention scope in Table 2. In Table 2, the attention variant uses a configuration tuned per dataset (2–5 blocks per layer across 28 layers), while the FFN variant intervenes only on the single most important FFN layer, so the two scopes differ. This difference, however, runs opposite to the suggested confound: the FFN variant intervenes on one layer's output (4,096 dimensions for GPT-J, 3,584 for Qwen), whereas the attention variant intervenes on more dimensions (e.g., on PerInfoKG, 21,504 for GPT-J and 7,168 for Qwen). Yet the attention variant achieves higher Retention in all 6 settings of Table 2. If fewer parameters simply meant less forgetting, the FFN variant should have retained more.

We agree that removing circuit selection reduces performance less than removing the subgraph features. However, the two ablations differ in kind, so their drops do not directly rank the two contributions. Ablating the subgraph features removes an input from which Δ is constructed, so Δ (pivotal in steering LLM responses) itself is degraded. In -Circuit, Δ is constructed in full and only the location of injection is changed to the lowest-importance blocks; even so, 이거 Accuracy drops from 100.0 to 95.1 with the same number of blocks. Moreover, "where to intervene" in our work also covers the choice between attention and FFN, which also has a substantial effect: applying SPIKE to the most important FFN layer instead of attention output blocks lowers Retention in all six settings of Table 2 (by up to 11.3 points, e.g., 86.5 → 75.2 on GPT-J / PeaCoK-Ex), and FFN-based fine-tuning collapses Retention to near zero on GPT-J at a learning rate of 1e−4 (Figure 1a). Figure 3b therefore tests only one part of this choice.

AuthorsOpenReview ↗

Response to Reviewer 31iP (3)

Q4.

We thank the reviewer for this careful observation. Indeed, many of the selected hyperparameter combinations have λ1 and λ2 set to 0. This does not mean that the KL loss and the norm loss are unnecessary; there are settings where they help. For example, on GPT-J / PerInfoKG, using both KL and decay yields a Total score of 95.4, removing either one yields 95.3 in both cases, and removing both yields 95.3. The gain is marginal, but using both gives the best result in this setting.

Q5.

We agree that SAKE performs comparably to SPIKE on PerInfoKG (96.3 vs. 95.9). SAKE is a steering-based method and therefore does not suffer from the subject-bound key collision of locate-and-edit methods that we identify. Its strong result on PerInfoKG is thus consistent with our claim that steering is advantageous for multi-attribute updates. The difference between SPIKE and SAKE appears under other conditions: SAKE's Accuracy drops sharply when the answer is a long token sequence such as an ORCID (GPT-J 44.2, Qwen 8.9), and remains low on PeaCoK-Ex (64.6–67.1) and Athlete (72.9–79.1), whereas SPIKE maintains Accuracy of 95 or higher on all datasets.

Overall, although SAKE achieves comparable performance to SPIKE on PerInfoKG, SPIKE exhibits more robust performance across diverse datasets and answer formats. In particular, its ability to accurately generate long token sequences is important for personal knowledge editing, where mutable facts may involve multi-token values such as identifiers. These results suggest that SPIKE is a more robust choice for handling diverse personal attributes, including those requiring long-sequence generation.

Comments on the paper

2 comments
AuthorsOpenReview ↗

General Response to all Reviewers

We sincerely thank the reviewers for their careful reading and for recognizing our analysis of why locate-and-edit fails on personal facts, the practical importance of the problem, the combination of KG representations with activation steering, and the breadth of our evaluation. In this rebuttal, we addressed the following shared concerns. Details and tables are in the per-reviewer responses, and all revisions in the updated manuscript are marked in blue.

1. Information available at inference time and the Locality protocol (31iP, m3QC, gFou)

  • Assumption stated explicitly. In the main experiments, SPIKE assumes that the person and relation of a query are known, the same level of information as the perfect-retrieval assumption of the SC baseline. We now state this in Section 3.1 and Section 5.1.1, and corrected the inconsistent description of the Locality protocol in Appendix A.5.
  • Locality under matched exposure. When each Locality query is answered with the average Δ of all updated triples of the person, the same condition as the baselines that store updates in their weights, Locality is 95.3 (vs. 96.8 in Table 1), on par with or higher than all such baselines on the same setting (FT+C 95.2; the highest editing method, WISE, 91.7).
  • Unknown relation. We removed the known-relation assumption by adding a relation-selection step (exact matching against the relation templates, with the init-LLM selecting the relation otherwise). All metrics change by at most 0.5 points (Total 95.9 → 95.6). SPIKE without a known relation still exceeds SC+3-Shot (83.0), which is given the oracle triples. Both experiments are on Qwen2.5-7B-Instruct / PerInfoKG.

2. Implementation of the intervention (m3QC)

  • Attention output blocks. The implementation adds Δ to head-sized slices of the attention output after the output projection, not to individual head outputs. We now call these slices attention output blocks and have revised the related descriptions. A variant that intervenes on head outputs before the projection, with circuits re-identified and hyperparameters re-tuned, still works but yields a lower Total (GPT-J 93.8 vs. 95.4; Qwen 92.3 vs. 95.9 on PerInfoKG).
  • Layer-wise scaling. The previously undocumented scale 1/(2 + e^l) is now described in Section 4.2.2. It is a fixed function applied identically to all settings and metrics. As the reviewer noted, it concentrates the effective intervention in the first few layers, and we now state this explicitly.

3. Evidence for where to intervene (31iP)

  • Circuit similarity against a random baseline. With 8 blocks per layer chosen at random, the personal–personal pair shows the highest similarity in both models and is well above chance (GPT-J 0.624 vs. 0.498; Qwen 0.475 vs. 0.285). Personal–general pairs are lower but mostly still above chance, so the patterns are partially distinct rather than fully separated. We revised our claims from "distinct computational pathways" accordingly.
  • Attention vs. FFN at matched parameter counts. With the trainable-parameter ratio matched (attention 3.15% vs. FFN 3.12% on Qwen), attention still converges faster and preserves Retention better, so the advantage of attention is not explained by parameter count alone.

4. Design choices (31iP, m3QC)

  • Sigmoid vs. tanh. Replacing the sigmoid with tanh keeps Accuracy and Retention but lowers Locality from 100.0 to 80.1 (PeaCoK-Ex / GPT-J). We agree that the ideal would be a zero Δ when there is no change; SPIKE does not achieve this, and we discuss it as a limitation.
  • Loss terms. Ablating the KL and norm terms changes Total only marginally (95.4 with both vs. 95.3 without either).

5. Incomplete initial knowledge (gFou)

  • With about half of the changed attributes removed from the initial KG (init-LLM accuracy 78.8%), so that the old values are absent from both the LLM and the KG, SPIKE still reaches a Total of 95.5, close to 95.9 without missing attributes (Qwen2.5-7B-Instruct / PerInfoKG).

We thank the reviewers again for their constructive feedback. The discussion helped us state our assumptions explicitly, align our descriptions with the implementation, and support our claims with stronger evidence.

AuthorsOpenReview ↗

Summary of Revisions

We thank all reviewers again for their valuable feedback and engagement throughout the discussion. All changes in the revised manuscript are marked in blue. The main revisions are:

  1. Inference-time assumption and Locality protocol. We state the assumption that the person and relation of a query are known in Section 3.1, clarify the Locality protocol in Section 5.1.1 and Appendix A.5, and add an appendix section (Table 11) that evaluates Locality with all updates applied and SPIKE without a known relation. We also report the additional inference time of the relation-selection step in Appendix A.11.
  2. Intervention location. We define the attention output block (Section 4.1) and revise the descriptions of importance scoring and steering throughout the paper to match the implementation. Section 4.2.2 now documents the layer-wise scaling and states that the effective intervention is concentrated in the first few layers.
  3. Circuit analysis. We add a random-block baseline to Table 7 (Appendix A.8) and revise the claims in Sections 5.2, and Appendix A.8 to partially distinct importance patterns.
  4. Attention vs. FFN. We add the parameter-matched comparison on Qwen (attention 3.15% vs. FFN 3.12%) to Figure 5b.
  5. Table 1. We add the average rank across datasets for each method.
  6. Limitations. We discuss that the steering vector is not zero for unchanged facts.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.