Pith. sign in

REVIEW 4 major objections 4 minor 1 cited by

SetKE: Knowledge Editing for Knowledge Elements Overlap

T0 review · 4 major / 4 minor · reviewed 2026-08-16 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read A set-level editor fixes overlapping knowledge triplets that single-edit methods overwrite.

desk verdict The KEO problem is real and the method is sensible, but the headline comparison is not controlled: baseline adaptation and set-level scoring are underspecified, so the claimed superiority is plausible, not yet established. read the letter →

arxiv 2504.20972 v1 pith:EDFAYZ4C submitted 2025-04-29 cs.CL

Yifan Wei , Xiaoyan Yu , Ran Song , Hao Peng , Angsheng Li This is my paper · ORCID
classification cs.CL
keywords knowledgeeditingelementoverlapsetbipartitematchingHungarianalgorithmfactualtripletslanguagemodelEditbenchmark
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Factual knowledge stored in a language model is usually edited one triplet at a time, but real facts often share the same subject and relation and have several valid objects (the Roman Empire spanned Europe and Asia). The paper argues that this overlap, which it calls Knowledge Element Overlap (KEO), is widespread in existing editing benchmarks and causes standard editors to overwrite each other's changes, because overlapping triplets activate overlapping neurons in the model's feed-forward layers. To fix this, the paper proposes Knowledge Set Editing (KSE): the edit target is a whole set of objects, and a new method, SetKE, aligns the model's predicted object set with the target set using bipartite matching, then updates the weights with the locate-then-edit machinery of prior methods. On a new Wikidata-derived benchmark, EditSet, the paper reports that SetKE beats prior editors on efficacy and generalization across GPT-2 Large, GPT-2 XL, and GPT-J while preserving locality. If correct, this reframes knowledge editing as a set-alignment problem rather than a single-fact rewrite.

What carries the argument

The machinery is a bipartite matching constraint wrapped in the standard locate-then-edit pipeline. The model's predicted objects \hat{y} and the editing targets y are treated as two sides of an assignment problem; the Hungarian algorithm selects the permutation \hat{\pi} that minimizes the sum of negative predictive probabilities -1{y_j≠∅} P_{π(j)}(y_j). That matching turns the set edit into a structured loss L = Σ 1{y_j≠∅} $L_edit^{{π(j)}}$ + L_const, where L_edit is a token-prediction loss on the matched target and L_const is a KL divergence keeping the subject's unchanged behavior intact. With the matching fixed, SetKE locates the relevant FFN layer, computes a residual vector, spreads it across several layers, and updates W_proj with the closed-form low-rank update borrowed from batch-editing methods. The matching is what distinguishes SetKE: instead of optimizing each object independently or as one long string, it first decides which current prediction should be edited into which target, preventing two targets from fighting over the same prediction.

What would settle it

Run the EditSet comparison with a set-level success criterion that requires the post-edit model to rank every target object higher than every non-target object for the shared prefix, and that measures locality on the objects that should stay unchanged; if ROME or MEMIT with a multi-object objective then matches or beats SetKE, the paper's core claim of a formulation-level advantage is false.

Watch

Extended reading notes

Core claim

The paper's central claim is that the failure of current knowledge editors on overlapping facts is not a tuning problem but a formulation problem: knowledge editing should operate on sets of objects, not single objects. Concretely, when a subject and relation map to a set O = {o1,...,oN}, editing to O* = {o*1,...} by applying a single-object editor N times (or by concatenating targets) produces conflicting overwrites, because the shared prefix tr(s) routes all objects through the same stored association. SetKE treats the current output set and the target set as two sides of an assignment problem, finds the cheapest one-to-one matching via the Hungarian algorithm, and back-propagates an edit loss plus a locality-preserving KL constraint through the located feed-forward layers. The paper reports that this set-based loss lets SetKE outperform ROME, MEMIT, MEND, PMET, KN, and fine-tuning on the EditSet benchmark across three LLM sizes, with the largest gains on Efficacy and Generalization and roughly unchanged Locality.

Load-bearing premise

The paper's comparison rests on the assumption that scoring each object in a set separately and then averaging captures whether the whole set was edited correctly, and that the comparison editors were set up fairly for multi-object edits; if that scoring favors the set-based method, the main result is an artifact.

Editorial extensions

If this is right

  • If KEO is as prevalent as the paper's dataset statistics show (as low as 4–19% of instances are non-overlapping in some benchmark datasets), then a large share of past knowledge-editing evaluations may have been measuring performance on an atypical subset.
  • On EditSet, SetKE improves Score over the best baseline by roughly 7–10 points on GPT-2 Large and GPT-2 XL, with Efficacy and Generalization gains up to about 39 and 35 points over MEMIT; treating the edit as a set rather than as independent triplets is the claimed reason.
  • All tested editors degrade as the number of overlapping objects grows from 3 to 8 or more, but SetKE degrades less than ROME and MEMIT, consistent with less knowledge overwriting under the set constraint.
  • The ablation shows that editing a set of objects simultaneously beats concatenating the objects into one long target, suggesting that alignment, not just parallelism, is what helps.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A natural extension the paper does not pursue is to use the degree of neuron overlap to predict which layer and which residual should be edited, potentially removing the need to search target layers separately for each model.
  • The same set-alignment view could apply to any prompt with multiple valid answers, such as list-valued attributes or open-ended generation, where a single-target edit loss is ill-defined; the Hungarian-constrained loss is a candidate for those settings.
  • A sharper comparison would give ROME or MEMIT the same matching objective inside their own updates; the paper's concatenation ablation is a weaker adaptation, so the claimed advantage may be understated or overstated depending on how baselines are extended.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 4 minor

Summary. The paper identifies Knowledge Element Overlap (KEO) in knowledge editing, focusing on cases where multiple triplets share a subject and relation (the RSO type) and therefore share a knowledge prefix. It presents a pilot analysis showing that KEO is prevalent in existing KE datasets and that current editors (ROME, MEMIT, MEND) degrade on KEO instances. It then introduces EditSet, a Wikidata-derived benchmark of KEO triplets, and proposes SetKE, a locate-then-edit method that treats the object as a set and uses bipartite matching (Hungarian algorithm) to align model predictions with the target set before applying multi-layer residual weight updates. Experiments on GPT2-Large, GPT2-XL, and GPT-J report that SetKE outperforms existing methods on EditSet under KEO scenarios, with additional results on Counterfact and ablations against object-concatenation targets.

Significance. If the reported comparisons are controlled, the paper addresses a real and under-studied failure mode: knowledge editing methods are typically defined for a single object, whereas many factual queries legitimately accept a set of objects. The proposed KSE formulation is a sensible generalization, EditSet could serve as a reusable benchmark, the pilot analysis is reasonable, and the authors provide code. The claim of state-of-the-art performance, however, rests on evaluation details that are not yet specified: how single-object baselines were adapted to multi-object targets, and what counts as a correct set edit. These issues are load-bearing for the central contribution, so the paper needs a revision before the results can be accepted as claimed.

major comments (4)
  1. [Section 5.1 and Appendix A.5] Section 5.1 lists the baselines but never states how single-object editors (FT-W, KN, MEND, PMET, MEMIT, ROME) are applied to a multi-object target O={o1,...,oN}. Since these methods are defined for (s,r,o)->(s,r,o*), the reader cannot tell whether each baseline is run independently per object, with a concatenated target string, with only the first object, or with some other adaptation. The main comparison in Table 3 is therefore not yet controlled: the reported margins over MEMIT and ROME could be artifacts of baseline adaptation rather than evidence of set-level editing quality. Please specify, for each baseline, the exact edit input, target string, and loss used when N>1.
  2. [Appendix A.5] The Efficacy Score is defined as E_i[P[o*_i|p(s_i,r_i)] > P[o_i|p(s_i,r_i)]] and then averaged over objects, but the paper does not define set-level correctness: it is not stated whether all o*_i must receive high probability jointly, whether the old objects o_i must all be suppressed together, or whether the model must generate exactly the target set. As written, a method that independently boosts each target object over its old counterpart achieves 100% ES even if it never produces the set {o*_1,...,o*_N} as a set. This is exactly the kind of behavior that a set-editing method should be distinguished from, so a set-level success criterion or a justification for averaging per-object scores is needed.
  3. [Table 2] Table 2 reports the Neigh.P. total as 3,988, but the per-overlap entries 3,780 + 2,768 + 2,240 + 1,757 + 1,509 + 1,221 sum to 13,275. The Locality component entering the composite Score in Tables 3 and 4 is therefore computed on an unexplained subset that appears to be roughly 3.4% of the Counter.P. prompts, while Efficacy and Generalization use 40,900 and 78,031 prompts. The composite harmonic mean is not comparable across components if LS is measured on a different and much smaller sample than ES and GS. Please correct the table or report LS on the full neighborhood-prompt set.
  4. [Section 5.5] The ablation comparing 'object set' with 'object concatenation' changes two variables simultaneously: the target representation (a set of objects vs a concatenated string) and the optimization objective (bipartite matching vs a sequence-level loss). The drop in SetKE performance from 73.68 to 59.50 in the concatenation condition could be due to the representation change alone, so the experiment does not isolate the contribution of bipartite matching. Moreover, under the concatenation setting SetKE is worse than ROME (59.50 vs 61.30), which complicates the claim that matching is the source of SetKE's advantage. Please add an ablation that fixes the target representation and varies only the matching strategy, such as SetKE with independent per-object loss versus SetKE with Hungarian matching, and report baselines under the identical set-based target encoding.
minor comments (4)
  1. [Section 2.1/2.2] The paper defines four overlap types but then states that KEO 'typically refers to the RSO type' and builds EditSet entirely on RSO instances; the abstract's general KEO claim is broader than what is evaluated. Please clarify the scope of the claims.
  2. [Appendix A.2] The text says results are averaged over 5 repetitions, but the confidence intervals in Tables 3, 4, and 7 are not described; please state whether they are bootstrap intervals over edits, standard errors over repetitions, or something else.
  3. [Equation (4)] The notation yij with j=π(j) is confusing; the token index and the matching index should be separated so that L_edit^π(j) is clearly a function of the matched target and prediction.
  4. [Throughout] There are repeated typos and formatting inconsistencies, including 'with a subjects', 'the l-thlayer', and the inconsistent rendering of EditSet as 'E DIT SET'; a careful proofread would improve readability.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: SetKE's bipartite-matching loss and evaluation are not equivalent to their inputs by construction.

full rationale

The paper's central derivation is the KSE formulation and the SetKE optimizer in Section 4. The matching cost in Eq. (2) uses the model's own probabilities P_{pi(j)}(y_j) to assign predicted objects to editing targets, and Eq. (3)-(4) then minimize a negative log-likelihood on the matched targets plus a KL locality constraint. This is a standard set-prediction objective, not a parameter fitted to the evaluation metric: the evaluation in Appendix A.5 defines Efficacy, Generalization, and Locality as probability comparisons on counterfactual, paraphrase, and neighborhood prompts, and those metrics are not fed back into the optimization. The method is also tested on the existing Counterfact dataset (Table 7), providing an external benchmark independent of the authors' new EditSet. Self-citations (Wei et al. 2023, 2024) appear only in related-work and dataset-relation contexts and do not carry the load-bearing argument. Concerns raised by the reader about unspecified baseline adaptation to multi-object targets, per-object averaging of set-level scores, and the inconsistent Neigh.P. totals in Table 2 are evaluation-artifact and data-consistency risks, not reductions of the claimed result to its own inputs. No equation in the paper defines the prediction in terms of the metric, and no fitted constant is renamed as a prediction. Therefore the derivation chain is self-contained and no circular step is exhibited.

Assumptions & free parameters 2 free parameters · 3 assumptions · 0 invented entities

The method builds on prior assumptions about where knowledge lives in transformers and how model probabilities guide edits. The only hand-chosen numbers are standard hyperparameters (learning rate, editing layers). The paper introduces no new physical or abstract entities beyond the conceptual formulation of KSE.

free parameters (2)
  • Learning rate = 0.5
    Set to 5e-1 for all edits; a hand-chosen hyperparameter that affects the residual vector update in Eq. (6).
  • Editing layer range = GPT2-Large layers 1-5; GPT2-XL layers 13-17; GPT-J not fully specified
    Tables 5-6 list target modules; these layers are chosen by hand and are not independently validated for KEO edits.
assumptions (3)
  • domain assumption Knowledge is localized in FFN layers and can be edited by updating the projection matrix.
    SetKE follows the ROME/MEMIT paradigm (Section 4.2); if localization fails for KEO triplets, edits will not work as claimed.
  • domain assumption The model's token probabilities for objects are a valid cost for bipartite matching.
    Equation (2) defines matching costs as P_pi(j)(y_j); this assumes those probabilities reflect edit-relevant confidence in the objects.
  • domain assumption The object set O for a prefix in EditSet is complete and correct.
    The dataset is built from Wikidata; missing or extra objects would make the edit target ill-defined.

how reviews work

0 comments
Cite this review

Pith. "Pith review of SetKE: Knowledge Editing for Knowledge Elements Overlap." pith.science (2026). https://pith.science/paper/EDFAYZ4C

@misc{pith2026250420972,
  author       = {Pith},
  title        = {Pith review of: SetKE: Knowledge Editing for Knowledge Elements Overlap},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/EDFAYZ4C}},
  note         = {Machine review of arXiv:2504.20972}
}
read the original abstract

Large Language Models (LLMs) excel in tasks such as retrieval and question answering but require updates to incorporate new knowledge and reduce inaccuracies and hallucinations. Traditional updating methods, like fine-tuning and incremental learning, face challenges such as overfitting and high computational costs. Knowledge Editing (KE) provides a promising alternative but often overlooks the Knowledge Element Overlap (KEO) phenomenon, where multiple triplets share common elements, leading to editing conflicts. We identify the prevalence of KEO in existing KE datasets and show its significant impact on current KE methods, causing performance degradation in handling such triplets. To address this, we propose a new formulation, Knowledge Set Editing (KSE), and introduce SetKE, a method that edits sets of triplets simultaneously. Experimental results demonstrate that SetKE outperforms existing methods in KEO scenarios on mainstream LLMs. Additionally, we introduce EditSet, a dataset containing KEO triplets, providing a comprehensive benchmark.

Figures

Figures reproduced from arXiv: 2504.20972 by the authors.

Figure 1
Figure 1. A demonstration of normal triplets and KEO triplets, [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Comparison of editing performance on Normal and KEO type for MEND, ROME, and MEMIT. [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Simplified illustration of the SetKE framework. [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (23 more)
Figure 4
Figure 4. Figure 4: Comparing the impact of knowledge overlap number on [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: The result of knowledge localization of KEO type knowledge on GPT2. [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Sample form of the EDITSET dataset. A.2 Implementation Details The experiments are implemented using the PyTorch frame￾work and run on a machine with eight NVIDIA GeForce RTX 3090 GPUs. We randomly sample 50% and 50% for training and testing on knowledge editing task. …
Figure 7
Figure 7. Figure 7: Analysis for knowledge overwriting using case 1. [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]
Figure 8
Figure 8. Figure 8: Analysis for knowledge overwriting using case 2. [PITH_FULL_IMAGE:figures/full_fig_p012_8.png]
Figure 9
Figure 9. Figure 9: Analysis for knowledge overwriting using case 3. [PITH_FULL_IMAGE:figures/full_fig_p013_9.png]
Figure 10
Figure 10. Figure 10: Analysis for knowledge overwriting using case 4. [PITH_FULL_IMAGE:figures/full_fig_p013_10.png]
Figure 11
Figure 11. Figure 11: Analysis for knowledge overwriting using case 5. [PITH_FULL_IMAGE:figures/full_fig_p013_11.png]
Figure 12
Figure 12. Figure 12: Analysis for knowledge overwriting using case 6. [PITH_FULL_IMAGE:figures/full_fig_p013_12.png]
Figure 13
Figure 13. Figure 13: Analysis for knowledge overwriting using case 7. [PITH_FULL_IMAGE:figures/full_fig_p013_13.png]
Figure 14
Figure 14. Figure 14: Analysis for knowledge overwriting using case 8. [PITH_FULL_IMAGE:figures/full_fig_p014_14.png]
Figure 15
Figure 15. Figure 15: Analysis for knowledge overwriting using case 9. [PITH_FULL_IMAGE:figures/full_fig_p014_15.png]
Figure 16
Figure 16. Figure 16: Analysis for knowledge overwriting using case 10. [PITH_FULL_IMAGE:figures/full_fig_p014_16.png]
Figure 17
Figure 17. Figure 17: Analysis for knowledge overwriting using case 11. [PITH_FULL_IMAGE:figures/full_fig_p014_17.png]
Figure 18
Figure 18. Figure 18: Analysis for knowledge overwriting using case 12. [PITH_FULL_IMAGE:figures/full_fig_p014_18.png]
Figure 19
Figure 19. Figure 19: Analysis for knowledge overwriting using case 13. [PITH_FULL_IMAGE:figures/full_fig_p015_19.png]
Figure 20
Figure 20. Figure 20: Analysis for knowledge overwriting using case 14. [PITH_FULL_IMAGE:figures/full_fig_p015_20.png]
Figure 21
Figure 21. Figure 21: Analysis for knowledge overwriting using case 15. [PITH_FULL_IMAGE:figures/full_fig_p015_21.png]
Figure 22
Figure 22. Figure 22: Analysis for knowledge overwriting using case 16. [PITH_FULL_IMAGE:figures/full_fig_p015_22.png]
Figure 23
Figure 23. Figure 23: Analysis for knowledge overwriting using case 17. [PITH_FULL_IMAGE:figures/full_fig_p015_23.png]
Figure 24
Figure 24. Figure 24: Analysis for knowledge overwriting using case 18. [PITH_FULL_IMAGE:figures/full_fig_p016_24.png]
Figure 25
Figure 25. Figure 25: Analysis for knowledge overwriting using case 19. [PITH_FULL_IMAGE:figures/full_fig_p016_25.png]
Figure 26
Figure 26. Figure 26: Analysis for knowledge overwriting using case 20. [PITH_FULL_IMAGE:figures/full_fig_p016_26.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Structural Entropy Guided Agent for Detecting and Repairing Knowledge Deficiencies in LLMs

    cs.CL 2025-05 conditional novelty 6.0 of 10

    SENATOR guides a language model through a knowledge graph, measures its uncertainty with structural entropy, and fine-tunes it on synthetic data chosen to fix its weak spots, gaining up to 12 percent average relative ...

Reference graph

Works this paper leans on

20 extracted references · 16 canonical work pages · cited by 1 Pith paper

  1. [3]

    T-rex: A large scale alignment of nat- ural language with knowledge base triples

    Hady Elsahar, Pavlos V ougiouklis, Arslen Remaci, Christophe Gravier, Jonathon Hare, Frederique Laforest, and Elena Simperl. T-rex: A large scale alignment of nat- ural language with knowledge base triples. In Proceedings of the Eleventh International Conference on Language Resources and Evaluation (LREC 2018),

    work page 2018

  2. [6]

    Transformer feed-forward layers build predictions by pro- moting concepts in the vocabulary space

    Mor Geva, Avi Caciularu, Kevin Wang, and Yoav Goldberg. Transformer feed-forward layers build predictions by pro- moting concepts in the vocabulary space. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing, pages 30–45,

    work page 2022

  3. [7]

    Editing common sense in transformers

    Anshita Gupta, Debanjan Mondal, Akshay Sheshadri, Wen- long Zhao, Xiang Li, Sarah Wiegreffe, and Niket Tandon. Editing common sense in transformers. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, pages 8214–8232,

    work page 2023

  4. [9]

    Commonsense knowledge editing based on free-text in llms

    Xiusheng Huang, Yequan Wang, Jun Zhao, and Kang Liu. Commonsense knowledge editing based on free-text in llms. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing , pages 14870– 14880,

    work page 2024

  5. [11]

    Fabio Petroni, Tim Rockt ¨aschel, Sebastian Riedel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, and Alexander Miller. Language models as knowledge bases? In Proceedings of the 2019 Conference on Empirical Methods in Natu- ral Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP- IJCNLP), pages 2463–2473,

    work page 2019

  6. [13]

    Modi- fying memories in transformer models

    Ankit Singh Rawat, Chen Zhu, Daliang Li, Felix Yu, Manzil Zaheer, Sanjiv Kumar, and Srinadh Bhojanapalli. Modi- fying memories in transformer models. In International Conference on Machine Learning (ICML) , volume 2020,

    work page 2020

  7. [14]

    Does large language model contain task-specific neurons? In Proceedings of the 2024 Conference on Empirical Methods in Natural Lan- guage Processing, pages 7101–7113,

    Ran Song, Shizhu He, Shuting Jiang, Yantuan Xian, Shengxi- ang Gao, Kang Liu, and Zhengtao Yu. Does large language model contain task-specific neurons? In Proceedings of the 2024 Conference on Empirical Methods in Natural Lan- guage Processing, pages 7101–7113,

    work page 2024

  8. [15]

    Wise: Rethinking the knowledge memory for lifelong model editing of large language models

    Peng Wang, Zexi Li, Ningyu Zhang, Ziwen Xu, Yunzhi Yao, Yong Jiang, Pengjun Xie, Fei Huang, and Huajun Chen. Wise: Rethinking the knowledge memory for lifelong model editing of large language models. arXiv preprint arXiv:2405.14768,

    arXiv

Show all 20 references
  1. [16]

    Editing conceptual knowledge for large language models

    Xiaohan Wang, Shengyu Mao, Shumin Deng, Yunzhi Yao, Yue Shen, Lei Liang, Jinjie Gu, Huajun Chen, and Ningyu Zhang. Editing conceptual knowledge for large language models. In Findings of the Association for Computa- tional Linguistics: EMNLP 2024 , pages 706–724, Miami, Florida, USA,

    2024

  2. [17]

    Yifan Wei, Xiaoyan Yu, Huanhuan Ma, Fangyu Lei, Yixuan Weng, Ran Song, and Kang Liu

    Association for Computational Lin- guistics. Yifan Wei, Xiaoyan Yu, Huanhuan Ma, Fangyu Lei, Yixuan Weng, Ran Song, and Kang Liu. Assessing knowledge editing in language models via relation perspective. arXiv preprint arXiv:2311.09053,

    arXiv

  3. [18]

    Can we edit factual knowledge by in-context learning? In Proceedings of the 2023 Conference on Empirical Methods in Natural Lan- guage Processing, pages 4862–4876,

    Ce Zheng, Lei Li, Qingxiu Dong, Yuxuan Fan, Zhiyong Wu, Jingjing Xu, and Baobao Chang. Can we edit factual knowledge by in-context learning? In Proceedings of the 2023 Conference on Empirical Methods in Natural Lan- guage Processing, pages 4862–4876,

    2023

  4. [26]

    A.2 Implementation Details The experiments are implemented using the PyTorch frame- work and run on a machine with eight NVIDIA GeForce RTX 3090 GPUs

    Figure 6: Sample form of the E DIT SET dataset. A.2 Implementation Details The experiments are implemented using the PyTorch frame- work and run on a machine with eight NVIDIA GeForce RTX 3090 GPUs. We randomly sample 50% and 50% for training and testing on knowledge editing t...

    2022

  5. [1955]

    Zero-shot relation extraction via reading compre- hension

    Omer Levy, Minjoon Seo, Eunsol Choi, and Luke Zettle- moyer. Zero-shot relation extraction via reading compre- hension. In 21st Conference on Computational Natural Language Learning, CoNLL 2017 , pages 333–342. Asso- ciation for Computational Linguistics (ACL),

    2017

  6. [2018]

    Transformer feed-forward layers are key-value memories

    Mor Geva, Roei Schuster, Jonathan Berant, and Omer Levy. Transformer feed-forward layers are key-value memories. arXiv preprint arXiv:2012.14913,

    2012 arXiv

  7. [2019]

    In-context editing: Learning knowledge from self-induced distributions

    Siyuan Qi, Bangcheng Yang, Kailin Jiang, Xiaobo Wang, Ji- aqi Li, Yifan Zhong, Yaodong Yang, and Zilong Zheng. In-context editing: Learning knowledge from self-induced distributions. arXiv preprint arXiv:2406.11194,

    arXiv

  8. [2020]

    Transformer feed-forward layers are key-value memories

    Mor Geva, Roei Schuster, Jonathan Berant, and Omer Levy. Transformer feed-forward layers are key-value memories. In Proceedings of the 2021 Conference on Empirical Meth- ods in Natural Language Processing , pages 5484–5495,

    2021

  9. [2021]

    Calibrating factual knowledge in pretrained language models

    Qingxiu Dong, Damai Dai, Yifan Song, Jingjing Xu, Zhi- fang Sui, and Lei Li. Calibrating factual knowledge in pretrained language models. In Findings of the Associa- tion for Computational Linguistics: EMNLP 2022 , pages 5937–5947,

    2022

  10. [2022]

    Editing fac- tual knowledge in language models

    Nicola De Cao, Wilker Aziz, and Ivan Titov. Editing fac- tual knowledge in language models. In Proceedings of the 2021 Conference on Empirical Methods in Natural Lan- guage Processing, pages 6491–6506,

    2021

  11. [2023]

    Mquake: Assessing knowledge editing in language models via multi-hop ques- tions

    Zexuan Zhong, Zhengxuan Wu, Christopher D Manning, Christopher Potts, and Danqi Chen. Mquake: Assessing knowledge editing in language models via multi-hop ques- tions. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing , pages 15686– 15702,

    2023

  12. [2024]

    Wilke: Wise-layer knowledge editor for lifelong knowledge editing

    Chenhui Hu, Pengfei Cao, Yubo Chen, Kang Liu, and Jun Zhao. Wilke: Wise-layer knowledge editor for lifelong knowledge editing. arXiv preprint arXiv:2402.10987 ,

    arXiv

Pith tools

Reviewed August 16, 2026 · model on record in the stance chip above.