💬 NLP

Conflict-Resolving and Sharpness-Aware Minimization for Generalized Knowledge Editing with Multiple Updates

The paper proposes CoRSA, a parameter-efficient training framework that resolves knowledge conflicts and minimizes loss curvature to significantly improve generalization, stability, and update efficacy in large language models undergoing multiple knowledge edits.

Original authors: Duy Nguyen, Hanqi Xiao, Archiki Prasad, Elias Stengel-Eskin, Hyunji Lee, Mohit Bansal

Published 2026-02-04

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Duy Nguyen, Hanqi Xiao, Archiki Prasad, Elias Stengel-Eskin, Hyunji Lee, Mohit Bansal

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a very smart, well-read librarian (the Large Language Model) who knows a lot of facts. But sometimes, the world changes. Maybe a new CEO takes over a company, or a sports team trades a player. You need to update the librarian's memory without firing them and hiring a new one (which would be too expensive and slow).

The paper introduces a new method called CORSA to help update this librarian's memory efficiently and accurately. Here is how it works, using simple analogies:

The Problem: The "Stubborn" Librarian

When you try to teach the librarian a new fact, three things often go wrong with current methods:

The "Paraphrase" Problem: If you tell the librarian, "The CEO is Andy Jassy," they might only remember that exact sentence. If you ask, "Who runs Amazon?" they might still say the old CEO, Jeff Bezos. They haven't truly learned the concept, just the specific words.
The "Backslide" Problem: If you update the librarian once, then update them again later, the first update might get erased or the old, wrong information might pop back up. It's like writing over a whiteboard with a marker that doesn't dry; the old ink bleeds through.
The "Conflict" Problem: The librarian has strong memories of the old facts. When you try to overwrite them, the old memory fights back, causing confusion or "hallucinations" where the librarian gives a mix of old and new info.

The Solution: CORSA

The authors created CORSA (Conflict-Resolving and Sharpness-Aware Minimization). Think of it as a special training regimen for the librarian that fixes the three problems above using two main tricks:

1. The "Flat Valley" Trick (Sharpness-Aware Minimization)

Imagine the librarian's knowledge is a landscape of hills and valleys.

Old Method: When they learn a new fact, they might get stuck in a tiny, sharp "spike" on the map. It looks like a perfect spot, but if you nudge them slightly (like asking a question in a different way), they fall right off the spike and forget everything.
CORSA's Trick: CORSA forces the librarian to find a wide, flat valley instead of a sharp spike. In a flat valley, even if you nudge the librarian (ask a question differently), they stay in the same spot. This makes the new knowledge stable and helps it generalize to different ways of asking questions.

2. The "Fighting the Ghost" Trick (Conflict-Resolving)

Imagine the old fact is a ghost haunting the librarian.

Old Method: Standard training tries to teach the new fact, but it accidentally makes the ghost louder. The librarian learns the new fact but still whispers the old one in the background.
CORSA's Trick: CORSA uses a dual strategy. It teaches the new fact while simultaneously telling the librarian, "Ignore that old ghost!" It explicitly pushes the old answer away and pulls the new answer closer. This creates a clear gap between the two, ensuring the old fact doesn't sneak back in later.

How It Handles Multiple Updates

The paper tests what happens when you update the librarian's memory many times (like tracking a CEO who changes jobs every year).

Other methods: They act like a sponge that gets saturated. After a few updates, the sponge can't hold any new water, or it squeezes out the old water (forgetting).
CORSA: It acts like a modular notebook. Because it found those "flat valleys" and pushed the "ghosts" away, it can keep adding new pages without tearing out the old ones. It remembers the new CEO without forgetting the old one, and it doesn't get confused when the CEO changes again.

The Results

The authors tested this on real-world facts (like who is the CEO of Amazon) and even on code (updating how a computer program works).

Better Memory: CORSA was much better at remembering the new facts when asked in different ways (generalization).
Less Forgetting: When they kept updating the model, CORSA forgot much less of the unrelated information compared to other methods.
Code Skills: It even worked on fixing code bugs, a task where previous methods failed because code is too complex for simple "fact swapping."

In a Nutshell

CORSA is a smarter way to update an AI's brain. Instead of just "writing over" old data, it finds a stable, flat place in the AI's mind to store the new info and actively suppresses the old, conflicting memories. This makes the AI more reliable, less likely to forget, and better at handling new information over time.

Technical Summary: CORSA for Generalized Knowledge Editing

1. Problem Formulation

Large Language Models (LLMs) rely on internal parametric knowledge, which becomes outdated over time. While full retraining is computationally prohibitive, existing knowledge editing methods face three critical limitations when applied to multiple updates:

Poor Generalization: Updates often fail to generalize beyond the specific phrasing of the training examples to diverse input forms (e.g., paraphrases or syntactic variations).
Instability under Multiple Updates: Methods struggle to support continual revisions (e.g., updating the same fact multiple times or injecting new facts) without causing catastrophic forgetting of unrelated knowledge.
Knowledge Conflicts: Strong priors from pre-training often cause the model to revert to outdated information despite updates, or new updates inadvertently reactivate old knowledge.

Current approaches, such as direct model editing (e.g., MEMIT) or parameter-efficient fine-tuning (e.g., LoRA with standard SFT), typically address only one or two of these requirements but fail to resolve all three simultaneously. Model editing methods are often unstable under continual updates, while standard fine-tuning frequently interferes with prior knowledge, leading to reversion or incorrect outputs.

2. Methodology: CORSA

The authors propose CORSA (Conflict-Resolving and Sharpness-Aware Minimization), a training framework designed for knowledge editing using LoRA adapters. The method targets the stability and generalization of the adapter parameters $\phi$ by addressing two theoretical conditions derived from the geometry of the loss landscape:

Increasing the post-update margin ( $\gamma$ ): Ensuring the model strongly prefers new knowledge ( $y^+$ ) over old knowledge ( $y^-$ ).
Reducing local sharpness ( $\kappa$ ): Finding flatter regions in the loss landscape to improve stability against future parameter perturbations.

CORSA integrates three core mechanisms:

A. Conflicting Knowledge Suppression (DPO)

Standard Supervised Fine-Tuning (SFT) on new knowledge ( $D_{new}$ ) often fails to sufficiently suppress the probability of old knowledge ( $D_{old}$ ), leading to conflicts. To explicitly maximize the margin between new and old knowledge, CORSA combines SFT with Direct Preference Optimization (DPO).

Objective: The loss function $L_{Update}$ is defined as:
$L_{Update}(\phi) = L_{SFT}(\phi) + \lambda L_{DPO}(\phi)$
Mechanism: $L_{SFT}$ minimizes the negative log-likelihood of the new target. $L_{DPO}$ maximizes the log-likelihood margin between the new target $y^+$ and the outdated target $y^-$ for the same input $x$ . This explicitly enforces a separation between new and prior knowledge.

B. Sharpness-Aware Minimization (SAM)

To enhance generalization and stability, CORSA employs SAM to minimize the sharpness of the loss landscape.

Objective: Instead of minimizing loss at a single point, SAM minimizes the worst-case loss within a neighborhood of radius $\rho$ :
$\min_{\phi} \max_{\|\epsilon\|_2 \le \rho} L_{Update}(\phi + \epsilon)$
Mechanism: The algorithm approximates the worst-case perturbation $\epsilon^*$ using a single ascent step based on the gradient. The model parameters are then updated using the gradient evaluated at the perturbed point $\phi + \epsilon^*$ . This forces the optimizer to find flatter minima, which theoretically correlates with better generalization and stability against future updates.

C. Gradient Conflict Resolution (PCGrad)

The authors observe that the gradients from SFT and DPO objectives can conflict, and applying SAM directly to their weighted sum can be suboptimal.

Mechanism: CORSA utilizes PCGrad (Projecting Conflicting Gradients) to resolve interference. Before computing the SAM perturbation and the final update step, gradients from SFT ( $g_{SFT}$ ) and DPO ( $g_{DPO}$ ) are projected to remove components that oppose each other (i.e., where the inner product is negative).
Integration: PCGrad is applied in both stages of SAM:
1. To construct the perturbation direction $\epsilon^*$ .
2. To determine the final descent direction from the perturbed point.
  This ensures that the sharpness-aware step respects both the adaptation (SFT) and preference separation (DPO) objectives.

3. Key Contributions

Holistic Framework: CORSA is the first method to simultaneously address generalization across diverse inputs, stability under multiple updates, and the resolution of knowledge conflicts using a single parameter-efficient framework.
Theoretical Insight: The paper establishes a connection between the stability of knowledge updates and the curvature of the loss landscape, demonstrating that minimizing sharpness (via SAM) implicitly regularizes the margin curvature, thereby preventing reversion.
Novel Integration: The work introduces a specific combination of SFT, DPO, SAM, and PCGrad tailored for the unique gradient dynamics of knowledge editing, where adaptation and suppression objectives often conflict.

4. Experimental Results

The authors evaluated CORSA on three factual knowledge benchmarks (CounterFact, ZsRE, MQuAKE) and a code domain benchmark (CodeUpdateArena) using Llama-3.1-8B and Qwen-3-4B models.

Generalization: CORSA achieved substantial gains in generalization compared to baselines. On Qwen-3-4B, it improved average generalization by 12.42% over LoRA and 10% over model editing methods (MEMIT).
Stability in Continual Updates: In settings involving multiple revisions (e.g., updating facts over time or injecting new knowledge), CORSA significantly reduced catastrophic forgetting. Compared to LoRA, it reduced forgetting by 27.82% in continual revision settings.
Conflict Resolution: CORSA effectively suppressed outdated knowledge. On CounterFact, it reduced "Old Knowledge Retention" to 1.28%, compared to 9.81% for LoRA. In continual update scenarios, it minimized "Old Knowledge Activation" (reversion) to 3.71% on Llama-3.1-8B, significantly lower than baselines.
Code Domain Transfer: CORSA successfully generalized to the code domain (API updates), outperforming the strongest baseline (F-Learning) by 5.48% in Pass@5 update efficacy while preserving general coding capabilities.
Scalability: The method demonstrated consistent performance improvements across model sizes (4B, 8B, 14B), indicating that the training objective provides fundamental benefits to update stability regardless of scale.

5. Significance and Claims

The paper claims that CORSA represents a significant step forward in making knowledge editing practical for real-world deployment where models require frequent, stable, and generalizable updates. By explicitly addressing the geometric properties of the loss landscape (sharpness) and the semantic conflicts between old and new knowledge (margin), CORSA overcomes the "trilemma" of generalization, stability, and conflict resolution that has limited prior work.

The authors emphasize that their approach does not rely on complex external memory routing or data replay, which introduce architectural overhead. Instead, it embeds the knowledge directly into the LoRA adapter through a principled optimization objective. The results suggest that minimizing loss curvature is a critical, yet previously underexplored, factor in achieving robust knowledge updates in LLMs. The work concludes that improving generalization, stability, and conflict resolution is a necessary step toward mitigating unintended side effects (such as hallucinations) and reducing risks in the deployment of updatable LLMs.