面向多层MeMo的版本感知操作与事务存储器

# 面向多层MeMo的版本感知操作与事务记忆
来源：https://arxiv.org/html/2606.24040
\\copyrightclause

本文版权归作者所有。依据知识共享署名4.0国际许可协议（CC BY 4.0）允许使用。

\\conference

MeMo 可解释性与神经符号方法设计研讨会，罗马（意大利），2026年6月24日

\[orcid=0009-0002-5807-3432, [email protected], \]

（2026年）

###### 摘要

MeMo 提出了一种具有显式多层关联矩阵记忆（CMM）的语言模型，其中记忆、检索和遗忘是架构性操作。本文探讨了当知识发生变化时，这类记忆如何能够减少重新训练的需求。对于可表达为 MeMo 记忆关联的变化，可以通过编辑显式记忆而非重新训练整个模型来更新模型的可访问知识。我们提出一个版本感知操作层，在该层中，高级操作（如替换、废弃、保留历史、回滚和追踪）被编译为针对序列和标记的 MeMo 原生基本调用序列。关键观察在于，一个版本感知操作很少是单一的 MeMo 关联，而是一个有序的基本编辑事务，例如遗忘一个序列-标记链、记忆另一个、保留一个历史链以及记录一个逆程序。该框架引入了两个辅助 CMM：一个版本 CMM（V-CMM）用于将版本转换映射到事务句柄，以及一个事务 CMM（T-CMM）用于存储可复用的变更内容和逆程序。它支持直接的序列级编辑和结构化的差异级输入，并概述了针对更新成功、回滚、可追溯性、局部性和事务复用的评估路径。

###### 关键词:

MeMo\\sep关联矩阵记忆\\sep事务记忆\\sep版本感知操作\\sep内存编辑\\sep神经符号 AI

## 1 引言

大型语言模型通常通过持续训练、检索增强或参数级模型编辑来适应新的或变化的知识 [gururangan2020dontstop, lewis2020rag, meng2022rome, meng2023memit]。这些方法有效，但当知识变化较小且已可表达为显式记忆关联时，它们并非理想选择。在这种情况下，自然的目标是通过直接编辑记忆来更新模型的可访问知识，而不是在完全修订的语料库上重新训练。MeMo 是一个有用的起点，因为它通过关联矩阵记忆将记忆外部化，并使记忆和遗忘成为显式操作，而不仅仅是训练的副作用 [zanzotto2025memo]。其最终架构是多层 MeMo：一个 CMM 栈组成输入序列，并支持从显式记忆结构中检索。

本文保持该多层 MeMo 架构不变。我们探讨当显式记忆是长期存在、有版本且被反复编辑时，需要什么样的操作层。MeMo 提供了基本操作，如记忆、检索和遗忘一个序列-值关联，但知识演进还需要替换、历史保留、废弃、追踪和回滚。

核心思想是将此类操作视为 MeMo 基本编辑的事务。一个事务不是单一的关联 \((S, y)\)；它是一个有序的程序，可能移除 \((S, y_{old})\)，添加 \((S, y_{new})\)，保存历史记忆，并记录一个逆操作。因此，我们设计了一个两级辅助记忆。版本 CMM（V-CMM）将版本转换映射到事务句柄，而事务 CMM（T-CMM）将事务句柄映射到可执行的编辑。MeMo CMM 存储被记住的内容；V-CMM 和 T-CMM 存储哪些记忆编辑属于一个版本变更以及这些编辑应如何执行。

所提出的代数有两个输入级别。在较低级别，它支持直接的序列-标记更新，例如替换 MeMo 序列的记忆延续。在较高级别，结构化的知识变更（例如本体移动或废弃）被编译为序列-标记事务的集合。变更语言如 KGCL 为此类结构化变更提供了实际的接口 [hegde2025change]，而本文的贡献仍是针对多层 MeMo 的一个版本感知操作代数。

## 2 作为基底的多层 MeMo

一个 CMM 通过外积存储关联，遵循经典的关联矩阵记忆及相关分布式记忆思想 [kohonen1972correlation, anderson1972simple, plate1995holographic]。例如，

\[
C = \sum_i k_i v_i^\top.
\tag{1}
\]

查询操作乘上记忆矩阵，遗忘操作减去相应的外积。多层 MeMo 通过多个 CMM 层扩展了这一机制，这些层将输入序列组合成更高级别的序列表示 [zanzotto2025memo]。我们将原始栈记为：

\[
\mathcal{C}_{\mathrm{MeMo}} = \{C^{(1)}, C^{(2)}, \ldots, C^{(L)}, C^{(out)}\}.
\tag{2}
\]

在接口层面，我们通过三个基本过程对现有实现进行抽象：

\[
\begin{aligned}
\mathrm{memo}(S, y), \quad \mathrm{forget}(S, y), \quad \mathrm{retrieve}(S),
\end{aligned}
\tag{3}
\]

其中 \(S\) 是一个输入序列，\(y\) 是关联的标记或值。内部的多层 CMM 机制决定了如何更新相关层。下面介绍的操作层将委托给这些基本操作，而不是直接修改层的设计。

## 3 版本感知操作

### 3.1 直接序列级操作

所提出代数的最低级输入已经是 MeMo 原生的：一个序列-标记编辑。在操作层面，一个基本编辑可以表示为：

\[
e_j = (S_j, y_j, \lambda_j), \quad \lambda_j \in \{+1, -1\},
\tag{4}
\]

其中 \(\lambda_j = +1\) 表示记忆，\(\lambda_j = -1\) 表示遗忘。当实现暴露特定层的更新时，可执行形式为 \((\ell_j, S_j, y_j, \lambda_j)\)；否则 \(\ell_j\) 保持隐式，并由标准的多层 MeMo 例程决定更新哪些内部 CMM。一个高级操作是此类编辑的有序事务：

\[
\tau = \langle e_1; e_2; \ldots; e_m \rangle.
\tag{5}
\]

当后续编辑依赖于之前编辑创建的续接时，顺序很重要。例如，一个 MeMo 续接的直接替换是：

\[
\textsc{replace}(S, y_{old}, y_{new}) = \langle (S, y_{old}, -1); (S, y_{new}, +1) \rangle.
\tag{6}
\]

该操作更改当前视图，但不会将旧值作为历史事实抹去。版本保留引入了显式的版本化序列：

\[
\textsc{keep-History} = \langle (S_{v_t}, y_{old}, +1); (S_{v_{t+1}}, y_{new}, +1) \rangle.
\tag{7}
\]

因此，从当前视图中遗忘并不一定是擦除。它可以意味着从最新视图停用，同时保留早期记忆用于版本特定查询和回滚。

**多标记续接。** 尽管示例有时将 \(y\) 写为单个值，但 MeMo 的原生基本操作是下一个标记记忆。一个续接 \(Y = [y_1, \ldots, y_n]\) 必须被分解为一个基本编辑链：

\[
\mathrm{chain}(S, Y, \lambda) = \langle (S, y_1, \lambda); (S y_1, y_2, \lambda); \ldots; (S y_1 \cdots y_{n-1}, y_n, \lambda) \rangle.
\tag{8}
\]

续接之间的替换变为：

\[
\textsc{replace}(S, Y_o, Y_n) = \mathrm{chain}(S, Y_o, -1); \mathrm{chain}(S, Y_n, +1).
\tag{9}
\]

T-CMM 对于小事务记录这个扩展的编辑集，或者在可扩展的实现中，记录一个可复用的模板和参数句柄，从这些句柄在执行时生成编辑链。在这两种情况下，原始的 MeMo 栈仍然只接收标准的 \((sequence, token)\) 操作。

### 3.2 结构化键与更高级别的变更

一个结构化断言可以表示为 \((v, s, r, o)\)，其中 \(v\) 是版本或视图，\(s\) 是主体，\(r\) 是关系，\(o\) 是对象值。为了使其与多层 MeMo 兼容，结构化键被序列化为输入序列：

\[
\sigma(v, s, r) = [\texttt{VERSION}, v, \texttt{SUBJECT}, s, \texttt{RELATION}, r].
\tag{10}
\]

对于结构化资源，\(s\)、\(r\) 和 \(o\) 表示稳定标识符而非可变标签；标签仅用于言语化。写入断言是一个标准的 MeMo 调用：

\[
\mathrm{memo}(\sigma(v, s, r), o),
\tag{11}
\]

从视图移除它则是：

\[
\mathrm{forget}(\sigma(v, s, r), o).
\tag{12}
\]

一个结构化变更，例如类移动或定义变更，首先被规范化为一个或多个序列级事务。例如，将 \((s, r)\) 的最新值从 \(o_{old}\) 替换为 \(o_{new}\) 变为：

\[
\langle (\sigma(v_{latest}, s, r), o_{old}, -1); (\sigma(v_{latest}, s, r), o_{new}, +1); (\sigma(v_t, s, r), o_{old}, +1); (\sigma(v_{t+1}, s, r), o_{new}, +1) \rangle.
\tag{13}
\]

同样的机制支持废弃：旧的当前状态被停用，新的废弃状态被记忆，可选替换被记忆，并且先前状态在源版本下保留。

## 4 版本与事务关联记忆

### 4.1 为什么使用 CMM 而不仅仅是日志？

一个版本感知操作本身并不是一个标准的 MeMo 记忆条目。MeMo 存储形如 \((S, y)\) 的下一个标记关联。一个事务可能涉及两个续接之间的关系，例如将 \(Y_o\) 替换为 \(Y_n\)，并且必须分解为多个基本的 \((sequence, token)\) 编辑。它可能移除旧编辑、添加新编辑、保留版本化编辑，并存储一个逆程序。

精确的日志仍然有用，在安全关键场景中它应保持为确定的真实来源。然而，仅凭日志并不能提供可复用变更内容的 MeMo 原生表示。版本历史可能很大，且许多变更实例化相同的模式：替换续接、移动类、废弃术语或添加同义词。因此，我们将版本索引与事务内容分离。版本 CMM（V-CMM）将版本转换映射到事务句柄。事务 CMM（T-CMM）将事务句柄映射到 MeMo 所需的可执行编辑字段。精确日志保证可重放性；V-CMM 和 T-CMM 提供紧凑的关联索引和复用。

### 4.2 用于版本索引的 V-CMM

令 \(v_a \rightarrow v_b\) 为一个版本转换，包含事务 \(\tau_{a,b,1}, \ldots, \tau_{a,b,n}\)。一个基于槽位的 V-CMM 存储版本转换、槽位和事务句柄之间的关联：

\[
V = \sum_{(v_a, v_b, i, \tau) \in \mathcal{V}} A(v_a, v_b, i) B(\tau)^\top.
\tag{14}
\]

用 \(A(v_a, v_b, i)\) 查询 \(V\) 可检索该转换的第 \(i\) 个事务句柄。一个计数条目或停止符号可以指示有多少个槽位是激活的。这种基于槽位的形式比将所有事务压缩成一个单一向量更容易审计和确定性执行。一个更紧凑的变体可以将一个转换的所有事务向量捆绑成一个叠加表示，但我们将其视为关联检索优化，而非执行语义。

### 4.3 用于可执行变更内容的 T-CMM

一个事务条目表示为映射：

\[
(\tau, j, a) \mapsto b,
\tag{15}
\]

其中 \(\tau\) 是事务标识符，\(j\) 索引事务内的基本编辑，\(a\) 是字段名，\(b\) 是字段值。例如：

\[
\begin{aligned}
&(\tau, j, \mathrm{sequence}) \mapsto S_j, \\
&(\tau, j, \mathrm{value}) \mapsto y_j, \\
&(\tau, j, \mathrm{sign}) \mapsto \lambda_j, \\
&(\tau, j, \mathrm{layer}) \mapsto \ell_j.
\end{aligned}
\tag{16-17}
\]

T-CMM 为：

\[
T = \sum_{(\tau, j, a, b) \in \mathcal{T}} \Gamma(\tau, j, a) \Omega_a(b)^\top,
\tag{18}
\]

其中 \(\Gamma\) 编码事务-字段键，\(\Omega_a\) 是一个字段相关的值编码器。这种字段依赖性必不可少，因为并非所有事务值都具有相同角色。元数据字段（如操作类型、源版本或模板标识符）可以使用普通的类型化符号编码器。然而，可执行字段必须与 MeMo 兼容：序列字段被解码为可传递给相关 MeMo 序列编码器 \(k^{(\ell)}\) 的序列或句柄，标记字段被解码为与 MeMo 值编码器 \(v^{(\ell)}\) 兼容的值，而控制字段（如符号和层）则使用单独的类型化编码器。

因此，解码一个事务会产生一个有序的可执行程序：

\[
\mathrm{decode}_T(\tau) = \langle (\ell_j, S_j, y_j, \lambda_j) \rangle_{j=1}^m.
\tag{19}
\]

此处 \(\ell_j\) 可能指定一个目标 MeMo 层，或者当标准的多层 MeMo 记忆/遗忘例程应决定如何更新其内部 CMM 栈时被省略。执行操作委托给 MeMo 基本操作，作为有序序列：

\[
\mathrm{execute}(\tau) = p_1; p_2; \cdots; p_m,
\tag{20}
\]

其中

\[
p_j = 
\begin{cases}
\mathrm{memo}(S_j, y_j), & \lambda_j = +1, \\
\mathrm{forget}(S_j, y_j), & \lambda_j = -1.
\end{cases}
\tag{21}
\]

如果实现暴露了特定层的基本操作，\(p_j\) 还可以携带 \(\ell_j\) 并应用相应的 MeMo 兼容编码器 \(k^{(\ell_j)}\) 和 \(v^{(\ell_j)}\)。否则，现有的多层 MeMo 过程内部执行层更新。

回滚通过反转有序程序并翻转符号获得：

\[
\tau^{-1} = \langle (\ell_m, S_m, y_m, -\lambda_m); \ldots; (\ell_1, S_1, y_1, -\lambda_1) \rangle.
\tag{22}
\]

回滚有三种情况。如果 \(\tau\) 是孤立的或最后应用的事务，则可直接应用逆程序。如果事务存在依赖关系，系统应重放精确日志到目标版本。如果版本表示为逻辑视图，回滚可以将最新视图别名切换到较早版本，而无需物理减去记忆。

### 4.4 模板与复用

重复的变更不应每次都存储完全展开的编辑程序。T-CMM 可以存储事务模板和紧凑参数。一个最小的替换模板是：

\[
\text{template}_{\text{rep}} = [(\text{slot}_S, \text{slot}_{\text{old}}, -1), (\text{slot}_S, \text{slot}_{\text{new}}, +1)]
\]