Testing whether discrete topology is a more durable memory medium than continuous weights — it isn't ... probably [R]

Reddit r/MachineLearning 08/23/26, 09:18 PM Papers

Summary

The article compares discrete and continuous memory adapters for frozen language models, finding that binary-mask methods like EPMem forget facts as quickly as continuous ones, emphasizing that the write/allocation rule, not discreteness, is crucial for preventing forgetting.

I ran a controlled comparison of two "write-in-place" memory adapters for a frozen LM: one edits continuous weights, the other (EPMem) keeps weights frozen and random and only edits a binary edge mask via straight-through estimation. Storage bits and write steps are matched across both. On a continual fact-writing benchmark (TinyStories-33M), EPMem writes facts fine but forgets them just as fast as the continuous adapter, underperforms it overall, and takes more write steps to get there. Mechanistically: per-write interference scales as sqrt(F) in the number of mask flips F, and retention decays faster than a random-collision null — so the mask-learning gradient isn't colliding by chance, it's preferentially re-flipping edges that are already storing something (anti-consolidation, not neutral overwrite). Replicated on Pythia-410M: same pattern, sharper — scale makes writing easier, retention worse. Takeaway: binary-mask methods that do avoid forgetting (SupSup, WSN, etc.) work because they explicitly enforce non-overlapping allocation between writes, not because discreteness itself is forgetting-resistant. The substrate isn't the lever — the write/allocation rule is. Paper: https://zenodo.org/records/22071715 (DOI: 10.5281/zenodo.22071715) Genuinely interested in pushback — particularly whether this holds outside fact-writing tasks, or whether it's an artifact of straight-through estimation specifically.

Original Article

Similar Articles

Selective Forgetting: A Graph-Based Memory Framework for Long-Term LLM Agents

arXiv cs.AI

This paper evaluates a graph-based memory framework for long-term LLM agents, finding that it does not outperform flat vector retrieval on recall metrics, but a selective forgetting module effectively reduces storage with minimal performance loss.

Can a Language Model Learn Facts Continually in Its Weights?

arXiv cs.CL

This paper investigates whether language models can learn new facts in their weights through continual learning. Using invented facts and sequential writes into Qwen3 models, it finds that training data breadth determines knowledge type and retention: bare-statement facts are quickly forgotten (1% accuracy after 20 writes), while facts learned from diverse restatements retain 46% accuracy. Forgotten facts are not erased but become behaviorally inaccessible due to later writes redirecting questions, and context remains the reliable channel for fact composition and survival.

Reclaim Evaluation: A Lossy Memory Is Worse Than an Empty One

arXiv cs.CL

This paper shows that a language model with a lossy memory that retains a wrong conclusion but drops the evidence produces confident incorrect answers, whereas an empty memory leads to abstention. The authors propose a source-first compression policy that preserves recomputable sources instead of conclusions to maintain correctability, and demonstrate the mechanism across multiple models and dialogue systems.

The Art of Not Forgetting A Local Learning Architecture for Continual Learning

arXiv cs.LG

This paper introduces CMP (Cognitive Memory Primitive), a continual-learning architecture that uses sparse relational codes and local learning to reduce catastrophic forgetting, demonstrating better backward transfer than a Transformer with EWC on a byte-level language modeling protocol.

Tested how long small models hold a fact across a conversation. The memory failure mode is a real problem for agents, and it's not what I expected.

Reddit r/AI_Agents

A developer tested how small edge models (LFM2.5, Gemma variants) retain a single fact across conversation turns, finding that models often confidently deny knowing information that remains in context, posing a trust issue for agent architectures and suggesting a trade-off between memory and format discipline.