acceptodds
Under review as a conference paper at ICLR 2027

The Capacity Limits of Sequential Knowledge Editing

Abstract

Sequential knowledge editing updates a language model one fact at a time without retraining it from scratch. Most recent methods make each edit by changing the same feed-forward weights. This works well for shorter edit sequences, but performance can fall sharply as more updates accumulate. We study a simple alternative. Instead of writing every edit into the model weights, we keep the model frozen and store the optimized hidden value for each edit in an external memory. We call the resulting method MoKE. Several context-dependent keys are stored for each edit so that paraphrases can retrieve the same value. On the standard 3,000-edit protocol with GPT2-XL and Llama3-8B, MoKE gives the best reported result on 15 of 18 metrics. In a controlled comparison with DeltaEdit using the same code, machine, precision, seed, and edit stream, MoKE improves CounterFact specificity by 35.0 and 49.8 points. At 10,000 edits, MoKE retains 97.8 efficacy while state-of-the-art falls to 13.1, and this endpoint is replicated with a second seed. Keeping the base model frozen also preserves downstream accuracy much better after editing. External memory has clear costs. Memory grows linearly with the number of stored keys, the retrieval threshold must be calibrated, and specificity still falls as the memory grows. Direct measurements show that this loss is not explained by an increasing rate of paraphrases being matched to another edit. These results show that the scale of sequential editing depends strongly on where the edits are stored. Code: https://anonymous.4open.science/r/moke-editing-84FD/README.md

Primary area:
foundation or frontier models, including LLMs
Keywords:
sequential knowledge editing, model editing, knowledge storage, retrieval collision, catastrophic interference

Reviews

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

The paper proposes MoKE for sequential knowledge editing. It keeps the base model frozen, stores optimized hidden values in an external memory, and retrieves them through cosine similarity with threshold gating. Multiple context keys improve paraphrase coverage. Experiments report improved specificity over weight-editing baselines and sustained efficacy after 10,000 edits.

Critical strengths
  1. With a modest additional memory footprint (269 MB for GPT2-XL and 688 MB for Llama3-8B), MoKE improves CounterFact specificity over DeltaEdit by 35.0 and 49.8 percentage points, respectively, in the controlled 3,000-edit comparison.

  2. The experimental evaluation is reasonably thorough, covering two models and two datasets, a 10,000-edit scaling study, component ablations, and measurements of memory use and inference overhead.

Critical weaknesses
  1. The novelty relative to NeuralDB [1] is insufficiently established. NeuralDB already uses an external KV database of optimized editing representations, cosine nearest-neighbor retrieval, and threshold gating. The central advantages emphasized here—avoiding repeated weight updates, preserving general capabilities, and supporting larger edit counts—are also central motivations and reported benefits of NeuralDB. Although MoKE differs in its retrieval representation, value-replacement mechanism, and context-key construction, these differences do not by themselves establish a substantial methodological contribution. The paper neither discusses NeuralDB nor provides a direct comparison or targeted ablations demonstrating the benefits of these departures. The context-key ablation supports one component, but leaves the overall contribution beyond existing work unclear.

  2. The capacity study has limited coverage. The 10,000-edit comparison is restricted to GPT2-XL/CounterFact and DeltaEdit under its adopted configuration. Without competitive external-memory baselines and broader settings, the results primarily demonstrate an advantage over this particular weight-editing configuration.

[1] https://arxiv.org/abs/2507.18028

Questions for authors
  1. What is the central contribution beyond NeuralDB, given the substantial overlap in both mechanism and claimed advantages? Could you compare against NeuralDB under the same protocol and isolate the effects of retrieval representation, value replacement versus residual addition, and context-key construction?

  2. Can the long-sequence evaluation be extended to additional model–dataset settings and competitive external-memory methods?

  3. Some citations in the introduction are awkwardly formatted, such as “DeltaEdit Cao et al. (2026).” Appendix F also incorrectly refers to Table 12 for latency measurements.

  4. What causes the large bf16–fp16 performance gap in DeltaEdit? Can an ablation using FP32 weight accumulation distinguish update-rounding errors from precision effects in target optimization or update computation?

4 comments
AuthorsOpenReview ↗

Response to Reviewer Fxh8

Thank you for the detailed review. We agree that NeuralDB is the closest prior external-memory method and should have been discussed and compared directly. This was a useful omission to identify, and we ran the requested comparison and ablations.

The review also prompted us to revisit a few implementation choices within MoKE. In particular, we use the standard locate-then-edit target for the NeuralDB comparison, test residual addition as well as replacement, and add a second cosine check using the FFN representation. These are small changes within the same external-memory framework, and we evaluate each of them separately below.

Direct comparison with NeuralDB

We first checked our NeuralDB implementation in its published setting using 2,000 facts and its published threshold of 0.65. The reported metrics are ES, PS and NS.

DatasetNeuralDB publishedOur implementation
GPT2-XL CounterFact99.80 / 97.20 / 74.1098.80 / 97.75 / 75.04
GPT2-XL ZsRE96.30 / 92.80 / 25.0097.45 / 93.25 / 24.97

We then ran NeuralDB under the same 3,000-edit protocol used for MoKE. Efficacy measures success on the edited prompt, generalization measures success on paraphrases, and specificity measures whether neighborhood prompts retain their original answer. Mean is the average of the three.

SettingMethodEff.Gen.Spe.Mean
GPT2-XL CounterFactNeuralDB98.1273.8892.2088.07
MoKE98.8375.7192.8489.13
GPT2-XL ZsRENeuralDB97.5193.1625.1871.95
MoKE99.7694.0425.1772.99
Llama3-8B CounterFactNeuralDB98.5464.0894.9685.86
MoKE99.2972.7793.8588.64
Llama3-8B ZsRENeuralDB99.4594.6329.0374.37
MoKE99.8596.2429.0375.04

Using NeuralDB exactly as published, MoKE is ahead by 1.06 [0.75, 1.37], 1.04 [0.73, 1.36], 2.78 [2.42, 3.14] and 0.67 [0.46, 0.88] mean points respectively.

We also selected NeuralDB's threshold using the same 600 held-out edits used to choose MoKE's settings.

SettingNeuralDB published thresholdNeuralDB threshold selected on held-out editsMoKE
GPT2-XL CounterFact88.0788.1689.13
GPT2-XL ZsRE71.9573.0472.99
Llama3-8B CounterFact85.8687.3288.64
Llama3-8B ZsRE74.3774.3775.04

After selecting NeuralDB's threshold in the same way, MoKE remains ahead on three settings. On GPT2-XL ZsRE the difference is -0.05 points with a 95% interval of [-0.26, 0.16], so the two methods are statistically tied.

What accounts for the difference from NeuralDB

The reviewer specifically asked about the retrieval representation, replacement versus residual addition, and context-key construction. We therefore varied each choice while keeping the others fixed. The values below are changes in mean score on held-out CounterFact edits.

ChangeGPT2-XLLlama3-8B
Residual key alone vs. NeuralDB FFN key-1.44-0.04
Residual key with FFN check vs. FFN key alone+0.37+0.27
Residual key with FFN check vs. residual key alone+1.81+0.30
Residual addition vs. replacement+0.38+1.05
One context key per prompt vs. edit-prompt key+2.10+0.29
Averaged context key vs. edit-prompt key+1.78+0.50

The residual-stream representation alone is not better than NeuralDB's FFN representation. The gain appears when the residual key is used for retrieval and the same candidate is checked in the FFN representation before being applied. Residual addition also performs better than replacement on both models, and context-derived keys consistently improve over using only the edit prompt.

We thank the reviewer for suggesting these ablations, since they make it much clearer which design choices actually matter.

The stored target also matters. The paper used DeltaEdit's target so that the controlled comparison changed only where the same edit was stored. For the NeuralDB comparison, we use the standard locate-then-edit target used by NeuralDB. This removes the DeltaEdit-specific target optimization from the comparison and lets us isolate the retrieval and injection choices more directly.

Longer edit sequences

We also agree that the original capacity experiment needed a competitive external-memory baseline. At 10,000 edits on GPT2-XL CounterFact, the mean scores are

MethodMean at 10,000 edits
DeltaEdit7.86
GRACE66.46
NeuralDB84.63
MoKE85.63

For this 10,000-edit experiment, the method settings are selected using 2,000 edits and evaluated on the remaining 8,000. MoKE is ahead of NeuralDB by 1.08 [0.89, 1.27] points and is ahead on efficacy, generalization and specificity.

We also extended the DeltaEdit comparison to the other three model and dataset settings. At 10,000 edits, MoKE reaches a mean of 79.15 against 28.86 for DeltaEdit on Llama3-8B CounterFact, 72.65 against 13.10 on GPT2-XL ZsRE, and 74.83 against 73.23 on Llama3-8B ZsRE. The last setting is useful because DeltaEdit remains stable there, and the difference between the two approaches is correspondingly small.

Cause of the bf16 and fp16 difference

The reviewer also asked whether the large bf16 and fp16 difference for DeltaEdit comes from target optimization or from repeatedly accumulating updates in low precision.

DeltaEdit writes each edit directly into the same weight matrices. We therefore repeated the Llama3-8B CounterFact experiment while separating the precision used for computation from the precision used to accumulate the updates. The table reports the mean of efficacy, generalization and specificity after 3,000 edits.

ComputeWeight accumulationMean
bf16bf16 in place33.67
bf16FP32 master weights64.48
fp16fp16 in place63.70
fp32fp3263.73
fp32rounded to bf16 after every update4.48

Keeping FP32 master weights recovers the bf16 gap even though the edit computation itself remains in bf16. Conversely, FP32 computation collapses when the weights are rounded to bf16 after every update. This shows that the gap comes from repeatedly rounding the accumulated weight updates, rather than from the precision used to optimize the target.

This also explains why MoKE changes much less between bf16 and fp16, since it does not repeatedly write updates into the model weights.

Presentation points

We also thank the reviewer for noting the citation and table-reference issues. The citation formatting will be corrected, and the latency reference in Appendix F will point to the correct table.

We have updated the manuscript to incorporate the changes and additional experiments discussed in our response, and have uploaded the revised version. We encourage the reviewer to consult the updated paper, where the new results, analyses, and clarifications are integrated directly into the main text and appendix.

Thank you for your detailed response as well as the updates and clarifications to the manuscript. Nevertheless, from the additional experimental results and the revised descriptions in the paper, I still cannot identify a clear advantage or distinctive difference of the proposed method over NeuralDB. Therefore, I will keep my original score.

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

In this paper, the authors study how factual edits accumulate when they are stored in model weights versus an external memory. The proposed method, MoKE, stores the optimized hidden values produced by a locate-then-edit procedure while keeping the model frozen. At inference time, it retrieves these values using hidden state keys. Several context keys can point to the same edited value in order to cover paraphrases more reliably. MoKE shows promising results on CounterFact, but the missing external-memory baselines leaves the central contribution uncertain.

Critical strengths
  1. The CounterFact improvements are substantial and useful.
Critical weaknesses
  1. Missing comparison with the closest external-memory approach. GRACE (Hartvigsen et al., 2023) already stores internal keys and optimized values, leaves the base weights unchanged, and retrieves a value to replace an activation within a selected scope. MoKE’s more specific contribution appears to be its reuse of "locate-then-edit" targets and its context-key construction. Those choices could be valuable, but the experiments do not establish their benefit over this closely related design.
  2. Appendix G explains that GRACE’s published results do not match the current model, dataset, and edit-count configuration. That is a sound reason not to copy the published numbers directly into the comparison. It leaves open the possibility of validating an implementation in an original setting and then adapting it to the present protocol. The single-key MoKE ablation does not resolve this issue, since it lacks GRACE’s adaptive retrieval radii and conflict handling. As it stands, the paper makes a strong case against the selected weight editors but a less complete case for MoKE’s contribution within external-memory editing.
Questions for authors
  1. Can you provide a validated GRACE comparison under the same editing protocol, with comparable optimization and memory budgets?
  2. What exactly does Table 6 count, and how does accepted false retrieval on neighborhood prompts change as memory grows?
  3. Can you explain how were the headline thresholds selected? What are the efficacy, generalization, and specificity results when thresholds are selected entirely on held-out edits?
5 comments
AuthorsOpenReview ↗

Response to Reviewer 6jH6

Thank you for the review. We respond to the weaknesses raised below.

Direct comparison with GRACE

We first checked the released GRACE implementation in its original GPT2-XL setting. We obtain TRR and ARR of 15.843 and 10.037, compared with the reported 15.84 and 10.00. Our ERR is 1.80 compared with the reported 7.14, which favors GRACE rather than MoKE. We then ran GRACE on the same 3,000-edit streams used in our experiments.

Efficacy measures success on the edited prompt. Generalization measures success on paraphrases of the edited fact. Specificity measures whether neighborhood prompts retain their original answer. Mean is the average of the three.

SettingMethodEff.Gen.Spe.Mean
GPT2-XL CounterFactGRACE100.000.3899.7066.69
MoKE99.1771.1789.9386.75
GPT2-XL ZsREGRACE99.9227.8525.1750.98
MoKE99.0292.8125.1772.33
Llama3-8B CounterFactGRACE100.000.5698.6466.40
MoKE99.0462.6084.1581.93
Llama3-8B ZsREGRACE99.8243.5529.0357.47
MoKE99.1590.8729.0373.02

The GPT2-XL rows use the released GRACE implementation that we validated above. GRACE does not provide a Llama3-8B implementation, so the Llama3-8B rows use the same mechanism ported to that architecture.

GRACE is very strong on the original edit prompt, but most paraphrases fall outside its radius. This gives almost perfect efficacy and high CounterFact specificity, but much lower generalization.

We also checked whether the difference is simply due to memory. On GPT2-XL, GRACE uses 32 KB per edit. MoKE with one key and one value uses 12.8 KB per edit and still reaches a mean of 84.96 on CounterFact, compared with 66.69 for GRACE.

We then swapped the main components between the two methods.

VariantEff.Gen.Spe.Mean
GRACE100.000.3899.7066.69
GRACE with six context keys100.000.3299.7266.68
MoKE keys and values with GRACE radius and conflict handling97.6752.7594.5381.65
GRACE-trained values with MoKE retrieval99.0459.0492.6583.58
MoKE99.1771.1789.9386.75

Adding more context keys to GRACE by itself does not improve paraphrase coverage. Using GRACE's radius and conflict handling with MoKE's stored edits also lowers generalization. Similarly, replacing MoKE's stored value with the value learned by GRACE reduces generalization. These results show that MoKE's advantage over GRACE comes from both its stored values and its retrieval mechanism.

What Table 6 measures

The reviewer is right that Table 6 was not sufficiently clear. It does not measure specificity directly. For each paraphrase, we compute its highest similarity to the stored keys over the relevant token positions. Table 6 counts a cross-edit match when the highest accepted match belongs to a different edit rather than the edit that generated the paraphrase.

We therefore ran a separate experiment using the neighborhood prompts used to measure specificity. We keep the prompt set fixed and increase the number of stored edits. We report both how often the retrieval gate accepts a stored edit and how often this changes the model's answer.

Stored editsAccepted retrieval on neighborhood promptsAnswer changed
2001.801.50
5002.551.85
1,0003.352.50
2,0006.954.60
3,0008.505.75

These results are for Llama3-8B CounterFact and are percentages of the fixed neighborhood prompt set. False retrieval increases gradually as the memory grows. Not every accepted retrieval changes the answer, which is why the second column is lower.

We see the same trend on GPT2-XL. The percentage of neighborhood prompts whose answer changes rises from 2.50% at 200 stored edits to 8.00% at 3,000 edits. On a separate set of facts that are never edited, the corresponding change is 1.24% to 7.37%. The similar trend on both prompt sets indicates that false retrieval increases mainly as more edits are stored.

We also found that the standard specificity evaluation becomes ambiguous in long edit streams. Of the 24,000 neighborhood prompts at 3,000 edits, 975 refer to a subject that is edited elsewhere in the stream. For 446 of these, the relation is also the same. In those cases, returning the updated answer can be correct with respect to another edit, while the specificity metric still compares against the original answer.

Threshold selection on held-out edits

The reviewer is also right to ask about the threshold selection. The thresholds in the paper were not all selected using a fully held-out procedure. GPT2-XL ZsRE used 0.95 from our initial experiments. GPT2-XL CounterFact and Llama3-8B CounterFact used 0.90 and 0.70 during development. Llama3-8B ZsRE used 0.80 based on the threshold sweep shown in the paper.

We therefore repeated threshold selection from scratch. For each setting, we use 600 edits only for choosing the threshold and report results on the remaining 2,400 edits. We select the threshold with the highest mean of efficacy, generalization and specificity on the calibration set.

SettingHeld-out thresholdEff.Gen.Spe.Mean
GPT2-XL CounterFact0.9099.1771.1789.9386.75
GPT2-XL ZsRE0.9599.0292.8125.1772.33
Llama3-8B CounterFact0.7599.3858.9889.4782.61
Llama3-8B ZsRE0.8599.2690.3929.0372.89

For both GPT2-XL settings, the held-out procedure selects the same threshold used in the paper. For Llama3-8B CounterFact it selects 0.75 rather than 0.70 and slightly improves the mean score from 81.93 to 82.61. For Llama3-8B ZsRE it selects 0.85 rather than 0.80, with a mean of 72.89 compared with 73.02. The headline results are therefore not driven by choosing thresholds on the evaluation stream.

We thank the reviewer for raising these points. The direct GRACE comparison shows that MoKE's gains within external-memory editing come from the stored values and retrieval mechanism, rather than simply from keeping the model weights frozen. The neighborhood analysis shows how false retrieval changes as the memory grows, while the held-out threshold experiment confirms that the main results are not sensitive to the original threshold choices.

We have updated the manuscript to incorporate the changes and additional experiments discussed in our response, and have uploaded the revised version. We encourage the reviewer to consult the updated paper, where the new results, analyses, and clarifications are integrated directly into the main text and appendix.

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

This paper proposes MoKE, which stores optimized edit values in an external key-value memory while keeping the language model frozen. Multiple context keys improve paraphrase retrieval. Experiments show substantial CounterFact gains over sequential weight editing, including high efficacy after 10,000 edits, although benefits are weaker on ZsRE.

Critical strengths
  • The controlled comparison with DeltaEdit matches important experimental factors and shows substantial improvements in CounterFact specificity.
  • Ablations support the contribution of context keys, and the paper reports seed variation, memory costs, precision sensitivity, and negative results.
Critical weaknesses
  • The distinction from existing memory-based editors remains insufficiently established. GRACE is acknowledged as the closest method, but no direct comparison is provided. The single-key ablation does not substitute for evaluating prior methods, making the novelty and relative benefit difficult to assess.
  • Evidence about capacity is narrow: the 10,000-edit experiment covers only GPT2-XL on CounterFact against an unretuned DeltaEdit configuration. On Llama3-8B/ZsRE, MoKE reduces generalization from 95.50 to 90.80 in the controlled comparison. Broader long-sequence experiments are needed to establish when the approach improves scalability.
  • The specificity analysis measures paraphrases retrieving another edit, whereas specificity concerns unrelated neighborhood prompts. A nearly constant cross-edit match rate on paraphrases does not directly explain neighborhood errors. Measuring false activations on neighborhood prompts would make the analysis more convincing.
Questions for authors

See weaknesses.

3 comments
AuthorsOpenReview ↗

Response to Reviewer WcKa

Thank you for the review. We ran the missing experiments for the main concerns raised here. We now compare directly with GRACE, extend the 10,000-edit study to all four model and dataset settings, measure false activations on neighborhood prompts, and investigate the lower generalization of MoKE on Llama3-8B ZsRE.

The additional analysis also revealed two specific sources of error. The DeltaEdit-derived target accounts for most of the ZsRE generalization gap, while relying on one retrieval representation leads to avoidable false activations. Based on these findings, we also tested an updated MoKE using the standard locate-then-edit target and a second FFN retrieval check. We state explicitly below when this updated version is used.

Direct comparison with GRACE

The reviewer is right that the single-key ablation was not enough. We therefore ran GRACE directly.

We first checked the released implementation in its original GPT2-XL setting. We obtain TRR and ARR of 15.843 and 10.037, compared with the reported 15.84 and 10.00. We then ran GRACE on the same 3,000-edit streams used for MoKE. Its radius was selected on 600 calibration edits and the remaining 2,400 edits were used for evaluation.

Efficacy measures success on the original edited prompt. Generalization measures success on paraphrases of the edited fact. Specificity measures whether unrelated neighborhood prompts retain their original answer. Mean is the average of the three.

SettingMethodEff.Gen.Spe.Mean
GPT2-XL CounterFactGRACE100.000.3899.7066.69
MoKE99.1771.1789.9386.75
GPT2-XL ZsREGRACE99.9227.8525.1750.98
MoKE99.0292.8125.1772.33
Llama3-8B CounterFactGRACE100.000.5698.6466.40
MoKE99.0462.6084.1581.93
Llama3-8B ZsREGRACE99.8243.5529.0357.47
MoKE99.1590.8729.0373.02

GRACE is very strong on the original edit prompt, but most paraphrases fall outside its radius. This gives almost perfect efficacy and high CounterFact specificity, but much lower generalization.

We also checked whether the difference is simply due to memory. On GPT2-XL, GRACE uses 32 KB per edit. MoKE with one key and one value uses 12.8 KB per edit and still reaches a mean of 84.96 on CounterFact, compared with 66.69 for GRACE.

We then swapped the main components between the two methods. Using GRACE's adaptive radius and conflict handling with MoKE's keys and values reduces generalization by 18.42 points. Using the value learned by GRACE with MoKE's retrieval reduces generalization by 11.79 points. Giving GRACE six context keys per edit does not recover the gap because the paraphrases still fall outside its learned radii.

These experiments show why MoKE behaves differently from GRACE. Both keep the base model frozen, but the value construction and retrieval rule lead to very different paraphrase coverage.

Results at 10,000 edits

We agree that the original 10,000-edit experiment was too narrow. We therefore ran the same experiment on Llama3-8B CounterFact, Llama3-8B ZsRE and GPT2-XL ZsRE.

The score below is the mean of efficacy, generalization and specificity after 10,000 edits.

SettingDeltaEditMoKE
GPT2-XL CounterFact7.8685.63
Llama3-8B CounterFact28.8679.15
GPT2-XL ZsRE13.1072.65
Llama3-8B ZsRE73.2374.83

The updated MoKE is used for GPT2-XL CounterFact, GPT2-XL ZsRE and Llama3-8B ZsRE. For Llama3-8B CounterFact, the number is from the method used in the paper because the 10,000-edit run with the updated value was not completed during the response period.

DeltaEdit drops sharply on both CounterFact settings and on GPT2-XL ZsRE. Llama3-8B ZsRE is different. DeltaEdit remains strong there, and the difference between the two approaches is small.

We also retuned DeltaEdit on GPT2-XL CounterFact. The default update parameter gives a mean of 7.86 at 10,000 edits. Changing it from 3 to 1.5 improves this to 20.32, while a value of 6 gives 8.20. Retuning helps, but does not prevent the drop.

The broader experiment gives a clearer picture of when external storage is useful. In three settings, repeated weight updates deteriorate sharply as the sequence grows. In Llama3-8B ZsRE, weight editing remains stable and the difference is correspondingly small.

Llama3-8B ZsRE

MoKE gives lower generalization than DeltaEdit on this setting in the paper. We investigated where this difference comes from.

MoKE stores the target produced by DeltaEdit's value optimization. We rebuilt the same external memory using the standard locate-then-edit target while leaving everything else unchanged.

Value stored in memoryEff.Gen.Spe.
DeltaEdit-derived target99.0890.9728.87
Standard locate-then-edit target99.6296.2328.87

Changing only the stored target raises generalization by 5.26 points. The controlled DeltaEdit result is 95.50.

This shows that the lower ZsRE generalization mainly comes from the target value rather than from storing the edit outside the weights. This result motivated the use of the standard locate-then-edit target in the updated MoKE.

False activations on neighborhood prompts

The reviewer is also right that the original specificity analysis did not directly measure false activations on neighborhood prompts. Table 6 counted paraphrases that retrieved the key of another edit. We therefore repeated the analysis using the prompts that specificity is intended to test.

We use two fixed prompt sets while increasing the memory from 200 to 3,000 edits. The first contains CounterFact neighborhood prompts. The second contains prompts about facts that never appear in the edit stream. The entries below are the percentage of prompts whose answer changes relative to the unedited model.

Stored editsLlama3-8B neighborhoodLlama3-8B unedited factsGPT2-XL neighborhoodGPT2-XL unedited facts
2001.500.932.501.24
5001.851.343.151.80
1,0002.502.224.203.30
2,0004.603.306.705.67
3,0005.754.698.007.37

False activations increase as the store grows. The increase is similar on neighborhood prompts and on facts that were never edited. This points to the growing store as the main source of the effect rather than a failure specific to neighborhood prompts.

We also found an issue with the standard specificity evaluation in long edit streams. Of the 24,000 neighborhood prompts in the 3,000-edit evaluation, 975 mention a subject that is edited elsewhere in the same stream. For 446 of these prompts, the relation is also the same. In these cases the updated answer is correct with respect to another edit in the stream, but the specificity metric still compares it with the pre-edit answer and counts the change as an error.

Taken together, the new experiments give a clearer picture of the two scaling regimes. Repeated weight updates can deteriorate sharply as edits accumulate, which we observe in three of the four 10,000-edit settings. External storage avoids accumulating these updates in the model weights and remains much more stable in these cases. Its limitation is different, with false activations increasing gradually as the memory grows. Llama3-8B ZsRE is an important counterexample where DeltaEdit remains stable and the advantage of external storage is correspondingly small. These results help clarify when storing edits outside the weights is useful and what limits it as the number of edits grows.

We have updated the manuscript to incorporate the changes and additional experiments discussed in our response, and have uploaded the revised version. We encourage the reviewer to consult the updated paper, where the new results, analyses, and clarifications are integrated directly into the main text and appendix.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.