Notes/机器学习/深度学习模型/05-大语言模型/7-外部访问-Agent相关/3-Memory-Agent.md

title, draft, tags

title	draft	tags
Generative Agents 与 MemGPT：跨轮次记忆与 Agent 系统	false	Generative-Agents MemGPT Memory Agent 大语言模型

Generative Agents 与 MemGPT：跨轮次记忆与 Agent 系统

---

一、记忆问题的形式化

1.1 单轮对话的局限

标准 LLM 的设置：

给定当前输入 x_t 和对话历史 $(x_1, y_1, \ldots, x_{t-1}, y_{t-1})$，生成响应：

P(y_t | x_t, \text{history}) = \prod_{k=1}^T P_\theta(y_{t,k} | x_t, y_{t,<k}, \text{history}) \tag{1.1}

问题：当对话轮次很多时：

1. 上下文长度限制：LLM 有最大上下文长度（如 4K/8K/32K tokens）
2. 距离衰减：早期的重要信息在上下文中被稀释
3. 计算成本：长上下文带来二次方 attention 成本

1.2 记忆的层级

定义（记忆层级）：

层级	描述	容量	访问频率
上下文记忆	当前上下文中的信息	~4K-32K tokens	最高
短期记忆	最近几轮对话	~10-50 轮	高
长期记忆	整个对话历史	无限制	低
情节记忆	重要事件的高层摘要	中等	中

1.3 记忆管理的核心问题

问题 1：信息该存在哪里？

• 不是所有信息都值得存在记忆中
• 重要的、经常使用的信息应该优先保留

问题 2：信息如何被检索？

当需要时，如何从记忆中快速找到相关信息？

问题 3：信息如何更新？

记忆应该随着时间推移而更新，而不是无限累积。

---

二、Generative Agents：模拟人类行为的 Agent

2.1 核心思想

Generative Agents（Park et al., 2023）的核心是：构建一个能够跨时间保持一致性的虚拟 Agent 社会。

关键创新：

1. 观察-反思-检索-规划的循环框架
2. 动态记忆流：随时间累积和更新信息
3. 行为生成：基于记忆和当前状态生成行为

2.2 Generative Agents 的架构

核心组件：

┌─────────────────────────────────────────────┐
│            Generative Agent                  │
├─────────────────────────────────────────────┤
│  感知模块 (Perception)                       │
│  → 从环境中接收事件                         │
├─────────────────────────────────────────────┤
│  记忆流 (Memory Stream)                      │
│  → 存储所有观察和反思                        │
│  → 支持增量和检索                           │
├─────────────────────────────────────────────┤
│  反思模块 (Reflection)                      │
│  → 定期总结记忆为高层见解                    │
│  → 指导未来行为                             │
├─────────────────────────────────────────────┤
│  规划模块 (Planning)                         │
│  → 将高层目标分解为具体行动                  │
│  → 生成行为序列                             │
└─────────────────────────────────────────────┘

2.3 记忆流的数学表示

定义（记忆）：

记忆 m 是一个三元组：

m = (t, \text{content}, \text{importance}) \tag{2.1}

其中：

• $t$：时间戳
• $\text{content}$：记忆内容
• $\text{importance}$：重要程度评分

定义（记忆流）：

记忆流 \mathcal{M} 是按时间排序的记忆序列：

\mathcal{M} = (m_1, m_2, \ldots, m_n) \quad \text{s.t.} \quad t_1 \leq t_2 \leq \cdots \leq t_n \tag{2.2}

2.4 观察（Observation）

观察的定义：

Agent 从环境接收观察 $o$：

o = (\text{agent}, \text{action}, \text{objects}, \text{location}) \tag{2.3}

示例：

[观察到] Isabella Rodriguez 正在收银台前排...

观察的处理：

每个观察都被编码并存储到记忆流中：

\mathcal{M} \leftarrow \mathcal{M} \cup \{\text{encode}(o)\} \tag{2.4}

2.5 检索（Retrieval）

检索函数：

给定当前状态 $s_t$，检索相关的记忆：

\text{retrieved} = \text{Retrieve}(\mathcal{M}, s_t, k) \tag{2.5}

其中 \text{retrieved} 是 top-k 个最相关的记忆。

检索的相关性评分：

\text{score}(m, s) = \alpha_1 \cdot \text{recency}(m) + \alpha_2 \cdot \text{relevance}(m, s) + \alpha_3 \cdot \text{importance}(m) \tag{2.6}

其中：

• $\text{recency}(m)$：新近度，越新越高
• $\text{relevance}(m, s)$：与当前状态的相关性
• $\text{importance}(m)$：记忆的重要性评分

2.6 反思（Reflection）

反思的触发条件：

当累积的观察数量超过阈值时，触发反思：

\text{if } |\mathcal{M}_{\mathrm{KL}} > \tau_{\mathrm{KL}}: \text{ trigger reflection} \tag{2.7}

反思的数学表示：

反思 r 是对近期记忆的高层总结：

r = \text{Summarize}(\mathcal{M}_{\mathrm{KL}}) \tag{2.8}

反思的内容：

• 当前状态的解释
• 相关的高层模式
• 未来行为的建议

反思存储：

反思结果作为新的记忆存储：

\mathcal{M} \leftarrow \mathcal{M} \cup \{r\} \tag{2.9}

2.7 规划（Planning）

规划的层级：

1. 高层目标：Agent 想要实现什么
2. 行动序列：具体要做什么
3. 时间安排：什么时候做

数学表示：

给定高层目标 $G$，生成行动序列：

\text{plan} = \text{Plan}(G, \mathcal{M}, s_t) = (a_1, a_2, \ldots, a_K) \tag{2.10}

其中每个 a_k 是具体的行动。

---

三、MemGPT：层级记忆管理

3.1 核心思想

MemGPT（Packer et al., 2023）的核心是：将不同层级的记忆显式化，通过记忆管理机制在层级之间移动信息。

关键创新：

1. 上下文层级：将 LLM 上下文视为"寄存器"
2. 主存层级：作为持久化存储
3. 存储系统层级：作为外部存储
4. 智能检索：根据需要动态加载/卸载

3.2 层级记忆架构

三层架构：

┌────────────────────────────────────────────────────┐
│         LLM Context Window (Register)               │
│         - 当前对话上下文                           │
│         - 最近的记忆片段                            │
│         - 当前任务相关的检索结果                    │
│  [容量限制：4K-128K tokens]                        │
└────────────────────────────────────────────────────┘
                         ↑↓
┌────────────────────────────────────────────────────┐
│              Working Memory (RAM)                    │
│         - 中期记忆                                 │
│         - 重要但非紧急的信息                        │
│         - Agent 的当前状态摘要                     │
│  [容量：约 50-100 个记忆单元]                     │
└────────────────────────────────────────────────────┘
                         ↑↓
┌────────────────────────────────────────────────────┐
│             Archive Storage (Disk)                  │
│         - 长期记忆                                 │
│         - 历史对话摘要                             │
│         - 事实和知识                               │
│  [容量：几乎无限]                                 │
└────────────────────────────────────────────────────┘

3.3 记忆管理操作

MemGPT 支持的操作：

操作	说明	从 → 到
RECALL	从存档中检索并加载到工作记忆	Archive → Working
EMIT	将工作记忆写入存档	Working → Archive
RETAIN	将上下文片段保留在工作记忆	Context → Working
BURY	将工作记忆放入存档	Working → Archive

Algorithm: Memory Management

while agent running:
    # 评估当前上下文状态
    context_utility = evaluate_context(current_messages)

    # 如果上下文太满，溢出到工作记忆
    if context_overflow():
        emit_to_working_memory(least_recent_messages())

    # 如果工作记忆太满，溢出到存档
    if working_memory_overflow():
        emit_to_archive(least_important_memories())

    # 如果需要检索，从存档加载
    if need_to_recall():
        recalled = recall_from_archive(query)
        load_to_working_memory(recalled)

3.4 智能检索策略

检索决策：

当处理查询时，MemGPT 决定是否需要从存档检索：

\text{need\_recall} = \text{MLP}(\text{query\_embedding}, \text{context\_embedding}) \tag{3.1}

检索排序：

\text{score}(m, q) = \beta_1 \cdot \text{relevance}(m, q) + \beta_2 \cdot \text{recency}(m) + \beta_3 \cdot \text{importance}(m) \tag{3.2}

3.5 MemGPT vs Generative Agents

维度	Generative Agents	MemGPT
记忆表示	自然语言叙事	结构化记忆单元
检索方式	基于重要性和相关性的检索	动态层级管理
反思机制	定期总结	可选的反思触发
架构层级	2层（记忆流+检索）	3层（上下文+工作+存档）

---

四、Agent 系统的核心算法

4.1 Agent-Environment 交互

定义（Agent 循环）：

\text{AgentLoop}: \quad s_0 \xrightarrow{a_0} s_1 \xrightarrow{a_1} s_2 \xrightarrow{a_2} \cdots \tag{4.1}

其中 s_t 是状态，a_t 是行动。

行动生成：

a_t = \pi_\theta(a | \text{context}, \text{memory}, \text{goals}) \tag{4.2}

4.2 观察过滤

问题：不是所有观察都值得记忆。

解决方案：使用重要性评分过滤：

\text{importance}(o) = \text{MLP}(\text{embed}(o)) \tag{4.3}

只保留高于阈值的观察：

\text{if } \text{importance}(o) > \tau: \mathcal{M} \leftarrow \mathcal{M} \cup \{o\} \tag{4.4}

4.3 记忆压缩

问题：记忆流会无限增长。

解决方案：定期压缩记忆。

压缩策略：

1. 摘要压缩：将多个记忆合并为一个高层摘要
2. 重要性过滤：只保留最重要的记忆
3. 时间窗口：只保留最近 N 个记忆

数学表示：

\mathcal{M}_{\mathrm{KL}} = \text{Compress}(\mathcal{M}) = \text{Summarize}(\mathcal{M}_{\mathrm{KL}}) \cup \mathcal{M}_{\mathrm{KL}} \tag{4.5}

4.4 目标一致性

问题：Agent 的行为应该与高层目标一致。

定义（目标）：

G = (g_1, g_2, \ldots, g_m) \tag{4.6}

其中每个 g_i 是一个子目标。

目标跟踪：

a_t \in G \quad \text{if } \text{is\_relevant}(a_t, G) \tag{4.7}

重新规划：

当目标无法完成时，重新规划：

\text{plan} = \text{Replan}(G, \mathcal{M}, s_t) \quad \text{if } \text{goal\_failed}(G) \tag{4.8}

---

五、训练过程与问题

5.1 记忆系统的训练

记忆编码器训练：

使用对比学习训练记忆编码器：

\mathcal{L} = -\log \frac{\exp(\text{sim}(m^+, q))}{\exp(\text{sim}(m^+, q)) + \sum \exp(\text{sim}(m^-, q))} \tag{5.1}

重要性评分器训练：

使用人类标注的重要性数据训练：

\mathcal{L}_{\mathrm{KL}} = \sum_{(o, \text{label})} \text{BCE}(\text{MLP}(\text{embed}(o)), \text{label}) \tag{5.2}

5.2 训练中的常见问题

问题 1：遗忘早期重要信息

表现：Agent 记住了最近的，忘记了重要的早期信息。

解决方案：

1. 重要性评分应该考虑信息的长期价值
2. 使用定期检查点保存重要记忆

问题 2：记忆过度膨胀

表现：记忆流变得很大，检索变慢。

解决方案：

1. 设置记忆上限
2. 使用记忆压缩
3. 分层存储

问题 3：检索质量差

表现：检索到的记忆不相关。

解决方案：

1. 改进检索模型
2. 使用更丰富的查询表示
3. 多样性检索（避免返回相似的多个记忆）

5.3 对话一致性问题

问题：Agent 在不同轮次中表现不一致。

原因：

1. 记忆没有被正确检索
2. 记忆被错误更新
3. 检索时忽略了关键信息

解决方案：

1. 确保检索包含所有相关的历史
2. 使用一致性约束
3. 定期验证记忆的正确性

---

六、实际应用中的挑战

6.1 记忆与上下文的边界

问题：如何决定信息该存在记忆里还是上下文里？

原则：

• 上下文：当前对话直接相关的信息
• 工作记忆：Agent 的当前状态和目标
• 存档：历史信息和知识

6.2 实时更新 vs 批量更新

实时更新：每个观察立即存储

批量更新：定期总结和压缩

混合策略：重要信息实时存储，不重要的批量处理。

6.3 安全性与隐私

问题：记忆可能包含敏感信息。

解决方案：

1. 记忆加密
2. 访问控制
3. 定期清理

---

七、数学公式速查

7.1 记忆表示

记忆：

m = (t, \text{content}, \text{importance}) \tag{7.1}

记忆流：

\mathcal{M} = (m_1, m_2, \ldots, m_n) \quad \text{s.t.} \quad t_1 \leq \cdots \leq t_n \tag{7.2}

7.2 检索公式

检索评分：

\text{score}(m, s) = \alpha_1 \cdot \text{recency}(m) + \alpha_2 \cdot \text{relevance}(m, s) + \alpha_3 \cdot \text{importance}(m) \tag{7.3}

7.3 记忆管理

RECALL 操作：

\text{recalled} = \text{Retrieve}(\mathcal{M}_{\mathrm{KL}}, q, k) \tag{7.4}

EMIT 操作：

\mathcal{M}_{\mathrm{KL}} \leftarrow \mathcal{M}_{\mathrm{KL}} \cup \{m\} \tag{7.5}

---

八、总结

Generative Agents vs MemGPT：

方面	Generative Agents	MemGPT
核心创新	观察-反思-检索-规划循环	层级记忆管理系统
记忆表示	自然语言叙事	结构化层级
检索方式	重要性加权的动态检索	智能层级管理
适用场景	长时间一致性的 Agent	突破上下文限制

核心洞察：

记忆是 Agent 系统的基础设施。Generative Agents 强调如何动态管理记忆流，MemGPT 强调如何在有限的上下文和无限的记忆之间做层级管理。两者都指向同一个问题：如何让模型在长期交互中保持一致性和知识。

关键挑战：

1. 信息的压缩与摘要
2. 检索的相关性排序
3. 记忆与当前上下文的融合
4. 长时间一致性

---

延伸阅读：

1. Park et al., "Generative Agents: Interactive Simulacra of Human Behavior" (UIST 2022)
2. Packer et al., "MemGPT: Towards LLMs as Operating Systems" (2023)
3. Shinn et al., "Reflexion: Language Agents with Verbal Reinforcement Learning" (NeurIPS 2023)
4. Liu et al., "Let Me Tell You a Story: Long-Term Memory for Agent Applications" (2023)
5. Zhong et al., "Memory Sandbox: Unified Memory Platform for LLM Applications" (2023)