1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

┌─────────────────────────────────────────────────────────────┐
│                    Memory 类                        │
│  ┌──────────────────────────────────────────┐   │
│  │ 1. 配置层         │                       │
│  │ - Memory (用户/会话/智能体配置)         │
│  │ - LLM/Embedder/VectorStore/Graph      │
│  └──────────────────────────────────────────┘   │
│                                                     │
│  ┌──────────────────────────────────────────┐   │
│  │ 2. 接口层         │                       │
│  │ - add() / search() / update() / delete()│
│  │ - get() / get_all() / history() / reset()│
│  └──────────────────────────────────────────┘   │
│                                                     │
│  ┌──────────────────────────────────────────┐   │
│  │ 3. 核心处理层     │                       │
│  │ - _add_to_vector_store (智能推理)          │
│  │ - _search_vector_store (向量检索)          │
│  │ - _create_memory / _update_memory / _delete_memory│
│  └──────────────────────────────────────────┘   │
│                                                     │
│  ┌──────────────────────────────────────────┐   │
│  │ 4. 存储层         │                       │
│  │ ┌─ 向量存储 ───┐ ┌─ 图存储 ───┐│
│  │ │ │Qdrant/Pinecone/... │ │ │Neo4j/Memgraph││
│  │ └───────────────────┘ └───────────────────┘│
│  └──────────────────────────────────────────┘   │
│                                                     │
│  ┌──────────────────────────────────────────┐   │
│  │ 5. 历史追踪层 │                       │
│  │ - SQLiteManager.history 表                  │
│  └──────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

二、核心数据结构

2.1 记忆项

存储位置：向量数据库（Qdrant/Pinecone/Chroma等）

数据结构：

1
2
3
4
5
6
7
8
9
10
11
12
13

# 代码位置：mem0/configs/base.py
class MemoryItem(BaseModel):
    id: str                    # UUID，主键
    memory: str               # 记忆内容文本
    hash: str                 # MD5(content)，用于去重
    created_at: str           # 创建时间（ISO 8601）
    updated_at: str           # 最后更新时间（ISO 8601）
    user_id: str              # 用户标识（会话隔离）
    agent_id: str             # 智能体标识（多智能体共享）
    run_id: str               # 运行标识（单次任务隔离）
    actor_id: str             # 执行者名称（谁创建/修改）
    role: str                 # user/assistant/system（消息来源）
    metadata: dict             # 扩展字段（自定义数据）

存储方式：

1
2
3
4
5
6
7
8
9
10
11

# 代码位置：mem0/memory/main.py:1223-1253
def _create_memory(...):
    # 1. 生成嵌入向量
    embeddings = self.embedding_model.embed(data, memory_action="add")

    # 2. 存储到向量数据库
    self.vector_store.insert(
        vectors=[embeddings],
        ids=[memory_id],
        payloads=[new_metadata],  # 包含 memory, hash, created_at 等
    )

2.2 历史记录

存储位置：SQLite 数据库（memory/history.db）

数据结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 代码位置：mem0/memory/storage.py:100-125
# SQLite 表结构
CREATE TABLE history (
    id              TEXT PRIMARY KEY,        # 历史记录ID（独立UUID）
    memory_id       TEXT,                 # 关联的记忆项ID
    old_memory      TEXT,                 # 操作前的值
    new_memory      TEXT,                 # 操作后的值（或None）
    event           TEXT,                 # 事件类型：ADD/UPDATE/DELETE/NONE
    created_at      DATETIME,              # 创建时间
    updated_at      DATETIME,              # 更新时间
    is_deleted      INTEGER,               # 标记是否已删除（0/1）
    actor_id       TEXT,                 # 执行者ID
    role           TEXT                  # 消息角色
)

存储方式：

1
2
3
4
5
6
7
8
9
10
11
12

# 代码位置：mem0/memory/main.py:1245-1254
# 每次记忆操作都记录历史
self.db.add_history(
    memory_id,           # 关联到记忆项ID
    old_memory,          # DELETE时=旧值，ADD时=None
    new_memory,          # ADD/UPDATE时=新值，DELETE时=None
    event,               # "ADD" / "UPDATE" / "DELETE"
    created_at,          # 创建时间
    updated_at,          # 更新时间
    actor_id,            # 执行者
    role,                # user/assistant
)

2.3 图三元组

1
2
3
4
5
6

# 代码位置：mem0/graphs/utils.py
{
    "source": "john",           # 实体1
    "relationship": "works_at",   # 关系
    "destination": "openai",        # 实体2
}

三、增加完整流程

3.1 入口函数

代码位置：mem0/memory/main.py:380-483

1
2
3
4
5
6
7
8
9
10
11
12

def add(
    self,
    messages,
    *,
    user_id: Optional[str] = None,
    agent_id: Optional[str] = None,
    run_id: Optional[str] = None,
    metadata: Optional[Dict[str, Any]] = None,
    infer: bool = True,                    # 关键参数！
    memory_type: Optional[str] = None,
    prompt: Optional[str] = None,
):

3.2 完整流程图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

用户调用：memory.add("我是John，是软件工程师", user_id="user123")
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 1. 参数验证与格式化         │
        │ - 检查 messages 类型               │
        │ - 构建元数据                       │
        │ - 处理特殊类型（过程性记忆）        │
        │ - 解析视觉消息                    │
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 2. 分支：推理模式 vs 直接模式   │
        │                                    │
        │ ┌───── infer=True ───┐       │
        │ │ 智能记忆管理       │       │
        │ │ - LLM提取事实      │       │
        │ │ - 向量检索相似     │       │
        │ │ - LLM判断操作类型  │       │
        │ │ - 执行 ADD/UPDATE/DELETE │       │
        │ └───────────────────────┘       │
        │                                    │
        │ ┌───── infer=False ───┐       │
        │ │ 直接存储模式       │       │
        │ │ - 跳过所有LLM调用  │       │
        │ │ - 直接写入向量存储  │       │
        │ └───────────────────────┘       │
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 3. 双轨并行处理              │
        │ ┌─ 线程1：向量存储 ─────────┐       │
        │ │ _add_to_vector_store()  │       │
        │ └───────────────────────┘       │
        │ ┌─ 线程2：图存储 ────┐       │
        │ │ _add_to_graph()            │       │
        │ └───────────────────────┘       │
        └──────────────────────────────────────┘
                            │
                            ▼
                     返回结果

3.3 infer=True 的详细流程

代码位置：mem0/memory/main.py:485-680

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

def _add_to_vector_store(self, messages, metadata, filters, infer=True):
    """
    智能推理模式：自动判断 ADD/UPDATE/DELETE
    """

    # ─────────────────────────────────────────────────────
    # 步骤1：LLM提取新事实
    # ─────────────────────────────────────────────────────
    system_prompt, user_prompt = get_fact_retrieval_messages(...)

    # 检查是否使用智能体记忆提取
    is_agent_memory = self._should_use_agent_memory_extraction(messages, metadata)

    response = self.llm.generate_response(
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt},
        ],
        response_format={"type": "json_object"},
    )

    # 解析LLM返回
    new_retrieved_facts = json.loads(response)["facts"]
    # 示例: ["名字是John", "是软件工程师"]

    # ─────────────────────────────────────────────────────
    # 步骤2：检索现有相似记忆
    # ─────────────────────────────────────────────────────
    for new_mem in new_retrieved_facts:
        # 缓存嵌入避免重复API调用
        messages_embeddings[new_mem] = self.embedding_model.embed(new_mem, "add")

        # 向量相似度度搜索
        existing_memories = self.vector_store.search.search(
            query=new_mem,
            vectors=messages_embeddings,
            top_k=5,                  # 取最相似的5条
            filters=search_filters,
        )

        # 收集现有记忆
        for mem in existing_memories:
            retrieved_old_memory.append({
                "id": mem.id,
                "text": mem.payload.get("data", "")
            })

    # ─────────────────────────────────────────────────────
    # 步骤3：LLM判断操作类型（关键！）
    # ─────────────────────────────────────────────────────
    function_calling_prompt = get_update_memory_messages(
        retrieved_old_memory,   # 旧记忆列表
        new_retrieved_facts,    # 新事实列表
        self.config.custom_update_memory_prompt
    )

    response: str = self.llm.generate_response(
        messages=[{"role": "user", "content": function_calling_prompt}],
        response_format={"type": "json_object"},
    )

    # LLM返回的操作序列
    # 示例：
    # {
    #   "memory": [
    #     {"id": "0", "text": "名字是JohnJohn", "event": "NONE"},  # 已存在
    #     {"id": "1", "text": "是软件工程师", "event": "ADD"},  # 新增
    #     {"id": "2", "text": "爱吃披萨", "event": "DELETE"},  # 冲突删除
    #     {"id": "3", "text": "喜欢芝士", "event": "UPDATE", "old_memory": "爱吃芝士和芝士"}
    #   ]
    # }

    # ─────────────────────────────────────────────────────
    # 步骤4：执行LLM返回的操作
    # ─────────────────────────────────────────────────────
    for resp in new_memories_with_actions.get("memory", []):
        event_type = resp.get("event")

        if event_type == "ADD":
            # 添加新记忆
            memory_id = self._create_memory(
                data=resp["text"],
                existing_embeddings=new_message_embeddings,
                metadata=deepcopy(metadata),
            )

        elif event_type == "UPDATE":
            # 更新现有记忆
            memory_id = _resolve_mapped_id(temp_uuid_mapping, resp, "UPDATE")
            self._update_memory(
                memory_id=memory_id,
                data=resp["text"],
                existing_embeddings=new_message_embeddings,
                metadata=deepcopy(metadata),
            )

        elif event_type == "DELETE":
            # 删除冲突记忆
            memory_id = _resolve_mapped_id(temp_uuid_mapping, resp, "DELETE")
            self._delete_memory(memory_id=memory_id)

3.4 infer=False 的详细流程

代码位置：mem0/memory/main.py:486-521

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

def _add_to_vector_store(self, messages, metadata, filters, infer=False):
    """
    直接存储模式：跳过所有LLM推理
    """

    for message_dict in messages:messages:
        if message_dict.get("role") == "system":
            continue

        msg_content = message_dict.get("content")

        # 直接获取嵌入
        msg_embeddings = self.embedding_model.embed(msg_content, "add")

        # 直接创建记忆，不做任何判断
        mem_id = self._create_memory(
            data=msg_content,
            existing_embeddings={msg_content: msg_embeddings},
            metadata=per_msg_meta,
        )

四、DELETE 触发机制详解

4.1 DELETE 的判断逻辑

代码位置：mem0/configs/prompts.py:263-292

1
2
3
4
5
6
7
8
9
10
11
12
13
14

DEFAULT_UPDATE_MEMORY_PROMPT = """
You are a smart memory manager which controls memory of a system.
You can perform four operations: (1) add into memory, (2) update memory,
(3) delete from memory, and (4) no change.

3. **Delete**: If retrieved facts contain information that **contradicts**
   information present in memory, then you have to delete it.

   示例：
   - 旧记忆: [{"text" : "Loves cheese pizza"}]
   - 新事实: ["Dislikes cheese pizza"]
   - 判断: 冲突！
   - 操作: {"event" : "DELETE"}
"""

4.2 DELETE 的实际场景

五、查询完整流程

5.1 入口函数

代码位置：mem0/memory/main.py:883-950

1
2
3
4
5
6
7
8
9
10
11
12

def search(
    self,
    query: str,
    *,
    user_id: Optional[str] = None,
    agent_id: Optional[str] = None,
    run_id: Optional[str] = None,
    top_k: int = 100,
    filters: Optional[Dict[str, Any]] = None,
    threshold: Optional[float] = None,
    rerank: bool = True,
):

5.2 查询流程图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

用户调用：memory.search("我的职业是什么？", user_id="user123")
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 1. 构建过滤器              │
        │ - 用户ID/智能体ID/运行ID       │
        │ - 处理高级操作符                   │
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 2. 向量嵌入                │
        │ embeddings = embed(query)     │
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 3. 向量相似度检索            │
        │ results = vector_store.search(  │
        │     query=query,              │
        │     vectors=embeddings,      │
        │     top_k=top_k,           │
        │     filters=filters          │
        │ )                             │
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 4. 重排序（可选）              │
        │ - BM25重排序                    │
        │ - 交叉编码器重排序              │
        └──────────────────────────────────────┘
                            │
                            ▼
                     返回带相似度分数的结果

5.3 高级过滤器支持

代码位置：mem0/memory/main.py:934-1050

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 支持的操作符
{
    "eq": "等于",          # {"key": "value"}
    "ne": "不等于",        # {"key": {"ne": "value"}}
    "gt": "大于",          # {"key": {"gt": 10}}
    "gte": "大于等于",     # {"key": {"gte": 10}}
    "lt": "小于",          # {"key": {"lt": 10}}
    "lte": "小于等于",     # {"key": {"lte": 10}}
    "in": "在列表中",      # {"key": {"in": ["a", "b"]}}
    "nin": "不在列表中",     # {"key": {"nin": ["a", "b"]}}
    "contains": "包含",      # {"key": {"contains": "text"}}
    "AND": "逻辑与",        # {"AND": [condition1, condition2]}
    "OR": "逻辑或",         # {"OR": [condition1, condition2]}
    "NOT": "逻辑非",        # {"NOT": [condition]}
    "*": "通配符"         # {"key": "*"}
}

六、修改完整流程

6.1 入口函数

代码位置：mem0/memory/main.py:1188-1260

1
2
3
4
5
6
7

def update(
    self,
    memory_id: str,
    data: str,
    *,
    metadata: Optional[Dict[str, Any]] = None,
):

6.2 修改流程图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

用户调用：memory.update(memory_id="abc123", data="更新后的内容")
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 1. 验证记忆存在              │
        │ existing = vector_store.get(memory_id)│
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 2. 准备新嵌入              │
        │ new_embeddings = embed(data)     │
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 3. 更新向量存储              │
        │ vector_store.update(           │
        │     id=memory_id,              │
        │     vector=new_embeddings,      │
        │     payload=new_metadata       │
        │ )                             │
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 4. 记录历史                │
        │ db.add_history(               │
        │     memory_id=memory_id,        │
        │     old_memory=old_value,      │
        │     new_memory=data,            │
        │     event="UPDATE"              │
        │ )                             │
        └──────────────────────────────────────┘
                            │
                            ▼
                     返回成功消息

七、删除完整流程

7.1 入口函数

代码位置：mem0/memory/main.py:1262-1290

1

def delete(self, memory_id: str):

7.2 删除流程图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

用户调用：memory.delete(memory_id="abc123")
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 1. 从向量存储获取获取              │
        │ existing = vector_store.get(memory_id)│
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 2. 从向量存储删除              │
        │ vector_store.delete(id=memory_id)   │
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 3. 清理图存储（如果启用）    │
        │ if self.graph:                     │
        │     graph.delete(data, filters)      │
        └──────────────────────────────────────┘
                            │
                            ▼
        ┌──────────────────────────────────────┐
        │ 4. 记录删除历史              │
        │ db.add_history(                   │
        │     memory_id=memory_id,           │
        │     old_memory=existing.payload,     │
        │     new_memory=None,                │
        │     event="DELETE"                │
        │     is_deleted=1                    │
        │ )                                  │
        └──────────────────────────────────────┘
                            │
                            ▼
                     返回记忆ID

八、图存储集成流程

8.1 图存储并行处理

代码位置：mem0/memory/main.py:468-483

1
2
3
4
5
6
7
8
9

# 在 add() 函数中，向量存储和图存储并行执行
with concurrent.futures.ThreadPoolExecutor() as executor:
    future1 = executor.submit(self._add_to_vector_store, messages, metadata, filters, infer)
    future2 = executor.submit(self._add_to_graph, messages, filters)

    concurrent.futures.wait([future1, future2])

    vector_store_result = future1.result()
    graph_result = future2.result()

8.2 图实体提取

代码位置：mem0/memory/graph_memory.py:219-250

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def _retrieve_nodes_from_data(self, data, filters):
    """提取实体并分类"""

    _tools = [EXTRACT_ENTITIES_TOOL]
    search_results = self.llm.generate_response(
        messages=[
            {
                "role": "system",
                "content": "Extract all entities from text"
            },
            {"role": "user", "content": data},
        ],
        tools=_tools,
    )

    # 返回实体类型映射
    # 示例：{"john": "person", "openai": "company"}
    entity_type_map = {...}

8.3 图关系提取

代码位置：mem0/memory/graph_memory.py:252-292

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def _establish_nodes_relations_from_data(self, data, filters, entity_type_map):
    """建立实体间的关系"""

    extracted_entities = self.llm.generate_response(
        messages=[
            {
                "role": "system",
                "content": "Extract relationships between entities"
            },
            {"role": "user", "content": data},
        ],
        tools=[RELATIONS_TOOL],
    )

    # 返回关系列表
    # 示例：[
    #     {"source": "john", "relationship": "works_at", "destination": "openai"}
    # ]

8.4 图搜索增强

代码位置：mem0/memory/graph_memory.py:96-130

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

def search(self, query, filters, top_k=100):
    search_results = []
    # 1. 从查询中提取实体
    entity_type_map = self._retrieve_nodes_from_data(query, filters)
    # 示例：{"john": "person", "sarah": "person"}

    # 2. 在图中搜索相关节点和关系
    search results = self._search_graph_db(
        node_list=list(entity_type_map.keys()),
        filters=filters
    )
    # 示例：返回John相关的所有关系

    # 3. BM25重排序（结合词频和向量）
    bm25 = BM25Okapi(search_outputs_sequence)
    reranked_results = bm25.get_top_n(tokenized_query, sequence, n=5)

    return search_results

九、完整代码索引

十、记忆项 vs 历史记录

10.1 ID关系

1
2
3
4
5
6
7

┌─────────────────────────────────────────────────┐
│                                         │
│  记忆项           ←────  1:N  ←────  历史记录
│  (memory_id)      (同一个ID可有多条历史)   │
│                                         │
│  记忆内容（快照）    历史变更链（时间线）       │
└─────────────────────────────────────────────────┘

关键点：

• 记忆项的ID是历史的外键（memory_id字段）
• 一个记忆项可以关联多条历史记录
• 历史记录形成变更链，可追溯完整生命周期

10.2 数据职责对比

10.3 历史记录的实际价值

场景1：审计追踪

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# 代码位置：mem0/memory/main.py:1392-1414
def history(self, memory_id: str):
    return self.db.get_history(memory_id)

# 返回示例
[
    {
        "id": "hist-001",
        "memory_id": "mem-123",           # 关联记忆
        "old_memory": None,                    # ADD操作
        "new_memory": "名字是JohnJohn",
        "event": "ADD",
        "created_at": "2025-04-10T10:00:00Z",
        "actor_id": "user",
        "role": "user"
    },
    {
        "id": "hist-002",
        "memory_id": "mem-123",           # 同一记忆
        "old_memory": "名字是JohnJohn",
        "new_memory": "名字是Mike",          # UPDATE操作
        "event": "UPDATE",
        "created_at": "2025-04-11T14:30:00Z",
        "actor_id": "user",
        "role": "user"
    },
    {
        "id": "hist-003",
        "memory_id": "mem-123",           # 同一记忆
        "old_memory": "名字是Mike",
        "new_memory": None,                  # DELETE操作
        "event": "DELETE",
        "created_at": "2025-04-15T09:00:00Z",
        "actor_id": "ai_agent",
        "role": "assistant",
        "is_deleted": 1                    # 软删除标记
    }
]

场景2：时序分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 问题：用户什么时候改变了偏好？
histories = memory.history("mem-123")

# 分析时序
for h in histories:
    print(f"{h['event']}: {h['old_memory']} → {h['new_memory']}")
    print(f"  时间: {h['created_at']}")
    print(f"  执行者: {h['actor_id']}")

# 输出：
# ADD: None → 名字是JohnJohn
#   时间: 2025-04-10T10:00:00Z
#   执行者: user
# UPDATE: 名字是JohnJohn → 名字是Mike
#   时间: 2025-04-11T14:30:00Z
#   执行者: user

10.4 历史记录的额外字段

is_deleted字段的作用：

1
2
3
4
5
6
7
8
9
10
11
12
13

# 代码位置：mem0/memory/storage.py:135-1380
# 删除记忆时特殊标记
self.db.add_history(
    memory_id,
    prev_value,          # 旧值（"喜欢吃披萨"）
    None,                # new_memory为None
    "DELETE",
    created_at,
    updated_at,
    actor_id,
    role,
    is_deleted=1,        # 软删除标记！
)

用途：

• 区分逻辑删除和物理删除
• 查询时过滤掉已软删除的记录
• 支持记忆的软删除模式

十一、设计优势总结

11.1 双存储架构的优势

1
2
3
4
5
6
7
8
9
10
11
12

单一向量存储          双存储架构（向量+图）
├──────────────┐      ├──────────────────────────┐
│ 擅点：              │      │ 优势：              │
│ - 无法理解关系      │      │ - 关系推理              │
│ - 无法扩展上下文    │      │ - 路径遍历              │
│ - 依赖相似度阈值  │      │ - 实体消歧              │
├──────────────┤      ├──────────────────────────┤
│ 适用场景：          │      │ 适用场景：            │
│ - 模糊搜索          │      │ - 社交网络查询          │
│ - 简单事实检索      │      │ - 推荐系统              │
└──────────────┘      │ - 多跳事实关联          │
                       └──────────────────────────┘

11.2 历史记录的价值

附录：infer 参数详解

infer的本质：

• 不是 “是否需要推理”
• 而是** “是否让系统自动管理记忆生命周期”**

随着大语言模型（LLM）能力的跃升，智能体（Agent）技术已经从单一的基础能力验证阶段，迈向了基于统一认知架构的模块化发展阶段。在这一进程中，学术界正致力于将人类的认知规律复刻到机器系统中。

Sumers 等人（2024）提出的语言智能体认知架构（CoALA, Cognitive Architectures for Language Agents）为现代 Agent 的设计确立了标准范式，其核心是将大语言模型（LLM）从单纯的文本生成器升级为具备结构化控制流的认知中枢。

CoALA 将语言智能体定位为以 LLM 为核心的认知架构，该架构包含记忆模块、结构化动作空间、通用决策流程三大核心维度：

多层级记忆模块（Memory Modules）
整个系统的记忆被明确划分为即时交互状态的「工作记忆（Working Memory）」，以及被持久化存储的「长期记忆（Long-term Memory）」。其中，长期记忆被进一步细分为情景记忆（Agent 过往的经验与经历）、语义记忆（事实与世界知识）和程序性记忆（决定行为的底层规则与模型权重）。

内外解耦的动作空间（Action Space）
在 CoALA 框架下，Agent 不仅具备与外部环境交互的「外部动作」，更被赋予了针对内部记忆操作的「内部动作」。这包括：从长期记忆中读取信息的检索（Retrieval）、利用 LLM 加工工作记忆的推理（Reasoning），以及将新经验沉淀至长期记忆的学习（Learning）。

闭环式决策程序（Decision Procedure）
在时间序列上，Agent 依托「观察（Observation）→ 规划（Planning：包含候选动作的提出与评估）→ 选择与执行（Selection & Execution）」的持续反馈循环，实现各个记忆模块与动作模块的动态协同，不断收集所需要的信息并存储起来，然后根据当前的信息规划当前应该采取的行动，从而得到最合理的执行策略。

CoALA 框架在理论上证明了将认知心理学中的「情景记忆」「工作记忆」等机制引入 Agent 架构是实现拟人化智能的必经之路。基于 CoALA 框架，长效记忆和学习能力的核心发展方向体现在两方面：

• 长效记忆：突破传统检索增强仅「读取」人类编写语料的限制，实现智能体对长时记忆的自如且高效的增删查改，同时融合检索与推理过程，让记忆召回与决策规划深度结合，提升规划的正确性与可执行性。
• 学习能力：将学习从传统的上下文学习、LLM 参数微调，拓展至智能体代码的自主更新（如学习更好的检索、推理流程），同时研究元学习、遗忘机制、多学习方式的交互效应，解决代码更新的风险性和 LLM 微调的高成本问题，让智能体实现高效的终身自主学习。

在长周期的情感陪伴场景落地时，这两点也是当前主流 Agent 架构依然面临的两大核心瓶颈。情感陪伴场景同时也有自己的特点：

1. 现有系统中的「情景记忆（Episodic Memory）」大多以扁平化的文本日志形式存在，或者以向量的形式存储在数据库中，缺乏高度结构化且清晰的拓扑关联以及长周期下的动态演化机制。
2. 现有 Agent 在「Profile/情感」模块中处理多模态情绪感知时，高度依赖特定的大型基础模型，缺乏轻量化、可插拔的多模态特征融合能力以及根据已有对话提升自身对用户情绪认知的能力。这直接导致了现有 AI 伴侣在长期交互中容易出现「人设崩塌」和「情绪共鸣缺失」的问题。

二、Agent 记忆管理技术与认知仿生研究

记忆管理是赋予 AI 伴侣长期陪伴能力的核心基石。根据 Luo 等人（2026）关于 LLM Agent 记忆机制演进的最新研究，Agent 记忆正经历从早期的「被动存储（Storage）」向「反思（Reflection）」与「经验抽象（Experience）」的跨越。当前的记忆技术主要呈现以下技术流派与痛点。

2.1 传统纯语义检索（RAG）的结构性缺陷

主流的记忆管理多依赖于将历史对话切片并转化为向量，存储于向量数据库中进行线性检索。这种基于传统 RAG 的机制在处理长周期陪伴时存在严重缺陷：时间推理能力不足（难以处理知识的时效性与过期记忆的冲突），且因果结构信息缺失（忽略了实体关系与多跳逻辑）。当交互轮次达到数百轮时，无限制的记忆膨胀还会导致「灾难性遗忘」，错误信息在系统中传播，严重污染学习效果。

2.2 结构化图记忆的兴起

为了克服离散的记忆检索与召回问题，研究者开始转向结构化记忆（Structured Storage），利用知识图谱或语义图来对历史交互中的实体和关系进行拓扑建模。例如，Mem0 等图记忆架构通过提取名词作为节点、动词作为边，大幅提升了复杂上下文中的关联检索能力。它提出的自适应记忆模型实现了智能体记忆的动态性，通过语境–事件双向量构建记忆单元，基于语境相似度匹配实现记忆的精准更新，让智能体可实时更新环境知识。然而，现有的图记忆多停留在静态的语义拓扑层面，缺乏符合人类遗忘与巩固规律的动态演化机制。

人类记忆并非静态的离散文本数据库，而是包含记忆巩固、激活与遗忘的动态生命周期。最新前沿研究已开始将认知心理学机制引入 Agent 架构的底层记忆管理中，推动记忆系统从「被动存储」向「主动认知」跨越。

2.3 动态环境对记忆机制的挑战（提要）

在真实世界中，LLM 智能体的记忆机制不能再是简单的「存–取」模式，而需要：主动管理知识的时效性，避免使用过时信息；理解并建模环境的因果结构，从而在长时间跨度的交互中做出正确决策。这既涉及知识随时间「过期」的问题，也涉及行动与反馈之间存在时间延迟的因果链问题。

2.4 动态情感记忆：DAM-LLM、遗忘与贝叶斯闭环

Lu 等人（2025）提出的 DAM-LLM（Dynamic Affective Memory） 模型打破了传统架构，构建了一个由**主控智能体（Master Agent）和提取智能体（Extraction Agent）**协同的闭环认知架构。该架构创新性地将记忆视为一种动态的「置信度分布」，而非不可变的绝对事实。

基于时间衰减的遗忘机制
Lewis 等人的研究证明，遗忘对于 Agent 的记忆是非常重要的。Zhong 等人（2023）提出的 MemoryBank 模型率先引入了艾宾浩斯遗忘曲线（Ebbinghaus Forgetting Curve）。该系统在记忆检索与管理架构中，为长期记忆片段赋予了随时间呈指数衰减的权重参数。这一设计模拟了人脑对历史信息的自然遗忘规律，使 Agent 在处理超长上下文时能够自动淘汰陈旧且低频的信息，优先提取近期或被反复强化的记忆。

基于贝叶斯概率与信念熵的闭环架构
在每次交互时，提取智能体负责将用户的自然语言输入转化为结构化的「情感证据」（包含极性与强度）。随后，主控智能体利用贝叶斯更新机制，将新证据与记忆库中的历史先验信念相融合，动态计算并更新对某一实体的「情感倾向置信度（后验概率）」。这种架构模拟了人类「随着证据积累逐渐形成稳定认知」的学习过程，避免了因单次随意表达而导致的记忆突变。

该架构还引入了认知科学中的「信念熵」来量化和评估记忆的混乱度或不确定性。主控智能体以「最小化全局记忆熵」为核心目标运行：当它巡检发现某些记忆单元的信念熵极高（即情感证据充满矛盾、无法收敛）且权重极低时，会将其判定为无价值的「噪音」并主动执行删除或融合操作。实验表明，这种信息熵驱动的压缩算法在 500 轮长对话中成功将系统的总记忆量压缩了近 70%（仅保留约 130 个核心记忆单元），在有效缓解记忆膨胀的同时提升了情感共鸣。

工程化要点（路由与两阶段检索）
DAM-LLM 一类架构中，路由智能体负责判断是直接生成响应、从长时记忆检索，还是写入新信息；长时记忆常采用「目录检索（元数据过滤）→ 内容检索（语义重排序）」等两阶段检索，再结合贝叶斯学习更新后验信念，使记忆随交互逐步演化。

三、小结：从「存储」走向「带遗忘与因果的结构化经验」

综合上述研究现状：在对 Agent 的记忆管理方面，学界与工业界已积累从 RAG 向量记忆、图结构记忆（如 Mem0），到引入遗忘曲线、贝叶斯置信度与熵驱动压缩等认知仿生机制的路径；同时，CoALA 等工作从架构层面统一了工作记忆、情景/语义/程序性记忆与内部动作（检索、推理、学习）的接口。面向长周期、拟人化陪伴，结构化拓扑、时效与因果、以及符合人类规律的遗忘与巩固仍是亟待深化的方向。

参考文献（节选）

• Sumers T R, Yao S, Narasimhan K, et al. Cognitive Architectures for Language Agents[J]. Transactions on Machine Learning Research, 2024.
• Chhikara P, Khant D, Aryan S, et al. Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory[EB/OL]. arXiv, 2025.
• Lu J, Li Y. Dynamic Affective Memory Management for Personalized LLM Agents[EB/OL]. arXiv, 2025.
• Luo J, Tian Y, Cao C, et al. From Storage to Experience: A Survey on the Evolution of LLM Agent Memory Mechanisms[EB/OL]. Preprints.org, 2026.
• Zhang Z, Bo X, Ma C, et al. A Survey on the Memory Mechanism of Large Language Model based Agents[EB/OL]. arXiv, 2024.
• Packer C, Fang V, Patil S G, et al. MemGPT: Towards LLMs as Operating Systems[EB/OL]. arXiv, 2023.
• Boscaglia M, Gastaldi C, Gerstner W, et al. A Dynamic Attractor Network Model of Memory Formation, Reinforcement and Forgetting[J]. PLOS Computational Biology, 2023.
• Lewis S J. Forgetting May Be a Crucial Step to Remembering Later[EB/OL]. Northwestern Now, 2024.

线性回归并非简单“拟合直线”，而是基于概率假设的参数估计问题，其核心逻辑围绕“高斯噪声假设”与“最大似然估计”展开。

1.1 数据生成的概率模型

线性回归假设观测值 $y$ 由“真实线性关系”与“高斯噪声”共同生成，公式表示为：
$y = \boldsymbol{w}^T \boldsymbol{x} + \epsilon$
其中，$\boldsymbol{w}^T \boldsymbol{x}$ 是回归函数（即条件期望 $\mathbb{E}[y|\boldsymbol{x}]$），$\epsilon$ 为噪声项且满足 $\epsilon \sim \mathcal{N}(0, \sigma^2)$（均值为0、方差为 $\sigma^2$ 的高斯分布），且不同样本的噪声独立同分布（i.i.d.）。
由此可推导出观测值 $y$ 的分布：$y \sim \mathcal{N}(\boldsymbol{w}^T \boldsymbol{x}, \sigma^2)$，意味着 $y$ 围绕真实线性关系波动，波动幅度由 $\sigma^2$ 决定。

1.2 最大似然估计（MLE）推导平方损失

目标是从训练数据 $D = \{(\boldsymbol{x}_1,y_1), ..., (\boldsymbol{x}_n,y_n)\}$ 中估计最优参数 $\boldsymbol{w}^*$，核心方法为最大似然估计——找到使“观测到当前数据”概率最大的 $\boldsymbol{w}$。

1. 似然函数构造：因样本独立同分布，联合概率为各样本概率乘积，单个样本概率密度为：
   $p(y_i|\boldsymbol{x}_i; \boldsymbol{w}) = \frac{1}{\sqrt{2\pi \sigma^2}} \exp\left(-\frac{(y_i - \boldsymbol{w}^T \boldsymbol{x}_i)^2}{2\sigma^2}\right)$
   数据集似然函数为各样本密度乘积。
2. 对数似然简化：对似然函数取对数（避免数值溢出，不改变极值点），得到：
   $\log L(\boldsymbol{w}) = \sum_{i=1}^n \left[ \log\left(\frac{1}{\sqrt{2\pi \sigma^2}}\right) - \frac{(y_i - \boldsymbol{w}^T \boldsymbol{x}_i)^2}{2\sigma^2} \right]$
3. 等价性推导：对数似然中第一项与 $\boldsymbol{w}$ 无关（为常数），最大化对数似然等价于最小化第二项分子，即：
   $\boldsymbol{w}^* = \arg\min_{\boldsymbol{w}} \sum_{i=1}^n (y_i - \boldsymbol{w}^T \boldsymbol{x}_i)^2$
   这表明平方损失是高斯噪声假设下最大似然估计的必然结果。

1.3 线性回归与判别式模型

线性回归属于判别式模型，其核心特点是仅建模“条件概率 $p(y|\boldsymbol{x})$”，不关心“特征边缘概率 $p(\boldsymbol{x})$”，并假设 $p(\boldsymbol{x}) = \frac{1}{n}$（所有特征样本等概率），因此联合概率 $p(\boldsymbol{x},y) = p(y|\boldsymbol{x}) \cdot p(\boldsymbol{x})$ 简化为条件概率。

二、突破线性限制：基函数的妙用

线性回归的“线性”指“对参数 $\boldsymbol{w}$ 线性”，而非对特征 $\boldsymbol{x}$ 线性，通过“基函数映射”可让模型拟合非线性数据。

2.1 基函数的核心逻辑

基函数通过将原始特征 $\boldsymbol{x}$ 映射到更高维特征空间 $\boldsymbol{z}$，在新空间中保持线性模型形式，公式为：
$\boldsymbol{z} = \phi(\boldsymbol{x}), \quad h(\boldsymbol{x}; \boldsymbol{w}) = \boldsymbol{w}^T \boldsymbol{z} = \boldsymbol{w}^T \phi(\boldsymbol{x})$
其中 $\phi(\cdot)$ 为基函数，常见类型包括：

• 多项式基函数：如一维特征 $x$ 映射为 $\phi(x) = [1, x, x^2, ..., x^k]^T$（$k$ 为多项式阶数）；
• 径向基函数（RBF）：如 $\phi(x) = \exp\left(-\frac{(x - c)^2}{2\sigma^2}\right)$（$c$ 为中心，$\sigma$ 为带宽）。

2.2 基函数与深度学习的关联

基函数的设计方式决定了模型类型：

• 若 $\phi(\cdot)$ 为手动设置（如多项式、RBF），则属于传统“特征工程”；
• 若 $\phi(\cdot)$ 可通过神经网络学习（如CNN卷积核、Transformer注意力映射），则属于“深度特征学习”，这是深度学习处理复杂非线性问题的核心逻辑之一。

三、驯服过拟合：正则化的艺术

基函数数量过多或阶数过高易导致过拟合（模型学噪声、泛化差），文档中案例显示：9阶多项式拟合9个数据点时，参数绝对值极大（如232.37、-5321.83），曲线在数据点外剧烈波动、。解决过拟合的核心是“限制参数复杂度”，即正则化。

3.1 L2正则化（岭回归）

L2正则化在平方损失中加入参数L2范数惩罚项，损失函数为：
$\hat{\boldsymbol{w}} = \arg\min_{\boldsymbol{w}} \sum_{i=1}^n (y_i - \boldsymbol{w}^T \boldsymbol{x}_i)^2 + \lambda \|\boldsymbol{w}\|_2^2$
其中，$\|\boldsymbol{w}\|_2^2 = w_1^2 + ... + w_d^2$（L2范数平方），$\lambda \geq 0$ 为正则化系数（控制惩罚强度）。
作用：使参数所有分量趋近于0（无稀疏性），实现“权重衰减”，避免个别参数过大导致模型波动，几何上等价于限制 $\boldsymbol{w}$ 落在L2球内。

3.2 L1正则化（套索回归）

L1正则化在平方损失中加入参数L1范数惩罚项，损失函数为：
$\hat{\boldsymbol{w}} = \arg\min_{\boldsymbol{w}} \sum_{i=1}^n (y_i - \boldsymbol{w}^T \boldsymbol{x}_i)^2 + \lambda \|\boldsymbol{w}\|_1$
其中，$\|\boldsymbol{w}\|_1 = |w_1| + ... + |w_d|$（L1范数）。
作用：使部分参数为0（实现特征选择），几何上因L1约束区域为“超菱形”，与损失等高线交点易落在坐标轴上，产生稀疏解、。

3.3 L1与L2正则化对比

3.4 正则化的理论依据：Lipschitz连续性

文档提出定理：参数范数越小，模型Lipschitz常数越小。Lipschitz常数衡量函数“平滑程度”，常数越小，函数对输入变化越不敏感，泛化能力越强、。
对线性模型 $h(\boldsymbol{x}) = \boldsymbol{w}^T \boldsymbol{x}$，其Lipschitz常数等于 $\|\boldsymbol{w}\|_2$，因此正则化限制 $\|\boldsymbol{w}\|_2$ 本质是让模型更平滑，减少过拟合。

四、线性回归的关键前提：特征工程与核心假设

线性回归性能依赖“特征工程”与“前提假设”，忽略这些会导致模型失效。

4.1 特征归一化：消除量纲影响

线性回归对特征量纲敏感（如“身高（米）”与“体重（千克）”数值范围差异大），需通过Z-score归一化消除影响：
对特征维度 $j$，先计算均值 $\mu_j = \frac{1}{n} \sum_{i=1}^n x_{ij}$ 和标准差 $\sigma_j = \sqrt{\frac{1}{n} \sum_{i=1}^n (x_{ij} - \mu_j)^2}$，再标准化为：
$x_{ij}' = \frac{x_{ij} - \mu_j}{\sigma_j}$
归一化后所有特征均值为0、方差为1，确保各特征贡献权重公平、、。

4.2 线性回归的3个核心假设

线性回归生效需满足以下假设，否则平方损失可能非最优：

1. 线性假设：$\mathbb{E}[y|\boldsymbol{x}] = \boldsymbol{w}^T \boldsymbol{x}$（真实回归函数为线性）；
2. 高斯噪声假设：$\epsilon \sim \mathcal{N}(0, \sigma^2)$（否则MLE推导的平方损失可能失效）；
3. 独立同分布假设：样本 $(\boldsymbol{x}_i,y_i)$ 独立同分布（确保模型可泛化）。

五、总结：线性回归的“简单”与“不简单”

• 简单之处：模型形式直观（线性关系）、优化高效（闭式解或梯度下降）、可解释性强（参数反映特征重要性）；
• 不简单之处：高斯噪声到平方损失的推导、基函数对非线性的扩展、正则化对过拟合的控制、特征工程的影响——这些思想贯穿机器学习领域（如深度学习权重衰减、Transformer特征映射）、。

线性回归是理解机器学习模型原理与前提的“最佳起点”，掌握其核心逻辑可为后续学习复杂模型（如逻辑回归、SVM、神经网络）奠定基础。

数学基础知识

• 向量是矩阵的特殊情况（1 行或 1 列），矩阵是向量的 “组合体”；
• 乘法的核心是 “维度匹配”：左列数 = 右行数，否则无法计算；
• 结果维度由 “左行数” 和 “右列数” 决定，与中间匹配的维度无关；
• 矩阵与向量的乘法本质是 “向量内积的批量计算”，是线性代数中线性变换的核心工具。

行向量

行向量是 “横向排列的向量”，本质是 1 行 n 列的矩阵

1. 简单行向量（1行×3列）

$\mathbf{a} = \begin{bmatrix} 1 & 2 & 3 \end{bmatrix}$ （元素间用空格分隔）
$\mathbf{b} = \begin{bmatrix} 0.5, -1, 4, 7 \end{bmatrix}$ （元素间用逗号分隔，1行×4列）

2. 带变量的行向量（1行×2列）

$\mathbf{x} = \begin{bmatrix} x_1 & x_2 \end{bmatrix}$ （常用于线性代数变量定义）

列向量

列向量是 “纵向排列的向量”，本质是 n 行 1 列的矩阵

1. 简单列向量（3行×1列）

$\mathbf{c} = \begin{bmatrix} 5 \\ 6 \\ 7 \end{bmatrix}$

2. 带负数的列向量（4行×1列）

$\mathbf{d} = \begin{bmatrix} -2 \\ 0 \\ 9 \\ -3.2 \end{bmatrix}$

3. 带变量的列向量（2行×1列）

$\mathbf{y} = \begin{bmatrix} y_1 \\ y_2 \end{bmatrix}$

矩阵

矩阵是 “m 行 n 列的二维数组”，可看作多个行向量 / 列向量的集合

1. 2行×3列矩阵（整数元素）

$\mathbf{A} = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{bmatrix}$

2. 3行×2列矩阵（含小数与负数）

$\mathbf{B} = \begin{bmatrix} 0.8 & -1 \\ 2.5 & 0 \\ 3 & -4.1 \end{bmatrix}$

3. 方阵（3行×3列，行数=列数）

$\mathbf{C} = \begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{bmatrix}$ （单位矩阵，对角线为1，其余为0）

4. 带变量的矩阵（2行×2列）

$\mathbf{D} = \begin{bmatrix} a & b \\ c & d \end{bmatrix}$

向量点乘

无论向量是二维、三维还是高维，点乘计算均遵循以下固定步骤，核心是 “对应元素相乘，再求和”：

1. 确认维度一致：检查两个向量是否为同维度（如均为 2 维、3 维），维度不同则无法计算；
2. 对应元素相乘：将两个向量中相同位置的元素逐一相乘（如 a 的第 1 个元素 × b 的第 1 个元素）；
3. 乘积求和：将所有元素相乘的结果相加，得到的总和即为点乘结果。

也就是说，向量点乘的结果是一个标量，也就是一个数字

在机器学习中，特征向量常为高维（如4维），设 $\mathbf{e} = [0.5, 1.2, -0.8, 2.1]$（特征向量1），$\mathbf{f} = [1.3, -0.5, 0.9, 0.3]$（特征向量2），计算 $\mathbf{e} \cdot \mathbf{f}$：

1. 确认维度：均为4维，满足计算条件；
2. 对应元素相乘：$0.5 \times 1.3 = 0.65$，$1.2 \times (-0.5) = -0.6$，$-0.8 \times 0.9 = -0.72$，$2.1 \times 0.3 = 0.63$；
3. 乘积求和：$0.65 - 0.6 - 0.72 + 0.63 = -0.04$。

最终结果：$\mathbf{e} \cdot \mathbf{f} = \boxed{-0.04}$（接近0，说明两个高维特征向量相关性较低）。

矩阵相乘

矩阵相乘本质上是第一个矩阵的第i个行向量，点乘第二个矩阵的第j个列向量，点乘结果作为结果矩阵的第i行第j列的值

设矩阵 $\mathbf{A}$ 为 $2 \times 3$ 矩阵（2行3列），矩阵 $\mathbf{B}$ 为 $3 \times 4$ 矩阵（3行4列）：

• $\mathbf{A}$ 的列数 = 3，$\mathbf{B}$ 的行数 = 3，满足“左列=右行”，可相乘；
• 结果矩阵 $\mathbf{C} = \mathbf{A} \times \mathbf{B}$ 的维度 = $\mathbf{A}$ 的行数 × $\mathbf{B}$ 的列数 = $2 \times 4$。

计算过程：
$\mathbf{A} = \begin{bmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \end{bmatrix}$，$\mathbf{B} = \begin{bmatrix} 7 & 8 & 9 & 10 \\ 11 & 12 & 13 & 14 \\ 15 & 16 & 17 & 18 \end{bmatrix}$
$\mathbf{A} \times \mathbf{B} = \begin{bmatrix} 1×7+2×11+3×15 & 1×8+2×12+3×16 & 1×9+2×13+3×17 & 1×10+2×14+3×18 \\ 4×7+5×11+6×15 & 4×8+5×12+6×16 & 4×9+5×13+6×17 & 4×10+5×14+6×18 \end{bmatrix} = \begin{bmatrix} 74 & 80 & 86 & 92 \\ 173 & 188 & 203 & 218 \end{bmatrix}$

QKV机制原理

QKV注意力机制核心定义与公式

QKV 注意力机制是一种用于计算序列中元素之间相关性的方法，广泛应用于 Transformer 架构中。其核心思想是将输入序列分解为 Query（查询）、Key（键）和 Value（值）三个部分，通过计算 Query 和 Key 之间的相似度（通常使用点积），得到注意力权重，再用该权重对 Value 进行加权求和，从而实现对输入序列的加权表示。

1. 注意力计算总公式

$Attention (Q, K, V)=Softmax\left(\frac{Q K^{T}}{\sqrt{d_{k}}}\right) V$

2. Softmax 函数公式（归一化注意力权重）

$Softmax\left(Z_{i}\right)=\frac{exp \left(Z_{i}\right)}{\sum_{j=0}^{n} exp \left(Z_{j}\right)}$

QKV 矩阵含义详解：Query、Key、Value 的核心定义与作用

在 QKV 注意力机制中，Query（查询）、Key（键）、Value（值）是从输入序列中分解出的三个核心矩阵，三者分工明确且协同工作，最终实现 “对序列中关键信息的聚焦与加权融合”。以下从核心定义、物理含义、维度特征、在注意力计算中的作用四个维度，分别解析 Q、K、V 矩阵的本质：

Query（查询）矩阵：“我当前需要关注什么？”

Query 矩阵（简称 Q）是注意力机制中的 “主动查询方”，其核心作用是定义 “当前需要获取哪些信息”，类似于我们在检索信息时提出的 “问题”—— 通过 Q，模型明确 “自己想关注序列中的哪些内容”。

1. 核心定义

Q 是从输入序列的每个元素（如自然语言中的单词、计算机视觉中的图像 patch）中映射得到的向量集合，每个元素对应一个 “查询向量”，整体构成 Query 矩阵。

2. 物理含义

以自然语言处理（NLP）场景为例：
若输入序列是句子 “猫坐在垫子上”，每个单词（“猫”“坐”“在”“垫子”“上”）会被转化为一个向量；
这些向量经过线性映射（实验中未体现映射过程，仅关注 Q 的最终形式）后，形成 Query 向量 —— 每个 Query 向量代表 “当前单词需要从其他单词中获取什么信息”。例如，“坐” 的 Query 向量可能会关注 “谁在坐”（对应 “猫”）和 “坐在哪里”（对应 “垫子”）。

3. 维度特征（符合实验手册定义）

Q 的形状为 (batch_size, seq_len, d_k)，各维度含义：
batch_size：批量处理的样本数（如一次处理 2 个句子，batch_size=2）；
seq_len：输入序列的长度（如句子有 5 个单词，seq_len=5）；
d_k：每个 Query 向量的维度（如用 64 维向量表示每个 “查询需求”，d_k=64）。
注：Q 与 K 的d_k必须相同，否则无法计算两者的相似度（点积运算要求列数 = 行数）。

4. 在注意力计算中的作用

Q 是注意力的 “发起者”，核心作用是与 Key 矩阵计算相似度：
通过 Q 与转置后的 K 进行点积（Q × K^T），得到 “每个 Query 与所有 Key 的匹配程度”（即原始相似度）；
相似度结果经过缩放、softmax 后，形成 “注意力权重”—— 权重高低直接反映 “Q 的需求与 K 的信息匹配度”，匹配度高的 K 对应权重更大。

Key（键）矩阵：“我能提供什么信息？”

Key 矩阵（简称 K）是注意力机制中的 “信息提供方”，其核心作用是定义 “序列中每个元素能提供哪些信息”，类似于信息检索系统中的 “索引标签”—— 通过 K，模型明确 “序列中每个元素能为其他元素提供什么内容”。

1. 核心定义

K 与 Q 类似，也是从输入序列的每个元素中映射得到的向量集合，每个元素对应一个 “键向量”，整体构成 Key 矩阵。

2. 物理含义

仍以 NLP 场景 “猫坐在垫子上” 为例：

每个单词（“猫”“坐”“在”“垫子”“上”）同样经过线性映射（与 Q 的映射矩阵不同），形成 Key 向量；

每个 Key 向量代表 “当前单词能提供的信息类型”。例如，“猫” 的 Key 向量可能标注 “主体（动物）” 信息，“垫子” 的 Key 向量可能标注 “位置（物体）” 信息。

3. 维度特征（符合实验手册定义）

K 的形状与 Q 完全一致：(batch_size, seq_len, d_k)，原因是：

d_k与 Q 相同：确保 Q 与 K 的点积运算（Q × K^T）维度匹配（Q 的列数 = d_k，K 转置后的行数 = d_k）；
seq_len与 Q 相同：每个 Key 对应序列中的一个元素，需与 Query 的 “查询对象”（序列元素）一一对应。

4. 在注意力计算中的作用

K 是注意力的 “响应者”，核心作用是与 Query 矩阵匹配，提供相似度计算的基础：
转置后的 K（K.transpose(0,2,1)）与 Q 进行点积，得到 “Query 需求与 Key 信息的匹配度”；
后续的 “缩放操作”（除以√d_k）也是基于 K 的维度d_k，避免相似度结果过大导致 softmax 梯度消失 —— 这进一步体现了 K 在相似度计算中的核心地位。

Value（值）矩阵：“我提供的具体信息是什么？”

Value 矩阵（简称 V）是注意力机制中的 “信息内容载体”，其核心作用是存储 “序列中每个元素的具体信息内容”，类似于信息检索系统中 “索引标签对应的具体数据”—— 当 Q 与 K 匹配出高权重后，模型会从 V 中提取对应元素的具体信息，进行加权融合。

1. 核心定义

V 同样从输入序列的每个元素中映射得到，但映射矩阵与 Q、K 不同，每个元素对应一个 “值向量”，整体构成 Value 矩阵。

2. 物理含义

仍以 NLP 场景 “猫坐在垫子上” 为例：
每个单词经过线性映射（独立于 Q、K 的映射），形成 Value 向量；
每个 Value 向量代表 “当前单词的具体语义信息”。例如，“猫” 的 Value 向量包含 “哺乳动物、宠物、小型食肉动物” 等语义特征，“垫子” 的 Value 向量包含 “家具、柔软、用于坐卧” 等语义特征 —— 这些是模型最终需要 “关注” 并融合的具体内容。

3. 维度特征（符合实验手册定义）

V 的形状为 (batch_size, seq_len, d_v)，与 Q、K 的区别在于最后一个维度：
d_v：每个 Value 向量的维度，可与d_k相同或不同（由任务需求决定）；
例如：若希望注意力输出的向量维度与 Q/K 不同（如 Q/K 维度为 64，输出维度为 128），可设置d_v=128—— 这体现了 V 在 “信息输出维度控制” 中的灵活性。

4. 在注意力计算中的作用

V 是注意力的 “内容提供者”，核心作用是根据注意力权重，提供需要融合的具体信息：
当注意力权重（由 Q 与 K 计算得到）确定后，V 与权重矩阵进行点积（权重 × V）；
点积过程本质是 “对 V 中各元素的信息进行加权求和”：权重高的元素，其 V 中的具体信息在最终输出中占比更大；权重低的元素，其信息被 “忽略” 或 “弱化”；
最终输出的形状为 (batch_size, seq_len, d_v)，即每个序列元素都得到一个 “融合了全局关键信息的向量”—— 这正是注意力机制 “聚焦关键信息” 的核心结果。

QKV 三者的协同关系：用 “信息检索” 类比理解

为了更直观地理解 Q、K、V 的关系，可将其类比为 “图书馆信息检索” 过程：

三者的协同流程严格遵循注意力公式：$Attention (Q, K, V)=Softmax\left(\frac{Q K^{T}}{\sqrt{d_{k}}}\right) V$

其中，Q 与 K 决定 “关注谁”（权重），V 决定 “关注的具体内容”（输出）—— 正是这种分工与协作，让 QKV 注意力机制能够高效捕捉序列中的长距离依赖关系，成为 Transformer 架构的核心基础。

QKV矩阵的形状与相乘的结果

结合选中内容中 QKV 注意力机制的核心定义与计算逻辑，各参数 / 术语的含义如下：

1. batch_size（批量大小）

定义：指一次模型计算中同时处理的样本数量，是深度学习中批量训练 / 推理的核心参数。

关联场景：在 QKV 注意力的矩阵表示中（如 Query 矩阵 Q、Key 矩阵 K、Value 矩阵 V），batch_size是矩阵的第一个维度（例如 Q 的形状为(batch_size, seq_len, d_k)）。

作用：通过批量处理多个样本，充分利用硬件（如 GPU）的并行计算能力，提升模型训练或推理的效率，同时降低单样本处理的冗余开销。

2. seq_len（序列长度）

定义：指输入序列中包含的元素个数，是描述序列数据长度的核心参数。

关联场景：在 QKV 注意力中，seq_len对应输入序列的元素数量（例如文本序列中的单词数、图像序列中的 patch 数），是 Q、K、V 矩阵的第二个维度（如 Q 的形状为(batch_size, seq_len, d_k)）。

作用：决定了注意力权重矩阵的维度 —— 注意力权重矩阵形状为(batch_size, seq_len, seq_len)，其中两个seq_len分别代表 “查询元素数量” 和 “被查询元素数量”，与选中内容中 “计算序列中元素之间相关性” 的核心逻辑直接对应。

3. d_k（Query以及Key 维度）

定义：指 Query 矩阵（Q）和 Key 矩阵（K）中每个元素向量的维度，且 Q 与 K 的d_k必须完全一致。

关联场景：是 Q、K 矩阵的第三个维度（如 Q 的形状为(batch_size, seq_len, d_k)、K 的形状为(batch_size, seq_len, d_k)），也是选中内容中注意力公式 $\frac{Q K^{T}}{\sqrt{d_{k}}}$ 里 “缩放因子 $\sqrt{d_k}$” 的来源。

作用：决定 Q 和 K 对序列元素语义 / 特征的编码容量：d_k越大，可编码的信息越丰富，但计算量也会增加；
缩放作用：选中内容中除以$\sqrt{d_k}$，是为了避免d_k过大导致 Q 与 K 的点积结果数值溢出，进而防止 Softmax 函数进入饱和区（梯度接近 0），保证注意力计算的稳定性。

4. d_v（Value 维度）

定义：指 Value 矩阵（V）中每个元素向量的维度，可与d_k相同或不同，由任务对输出特征维度的需求决定。

关联场景：是 V 矩阵的第三个维度（如 V 的形状为(batch_size, seq_len, d_v)），直接决定 QKV 注意力的最终输出维度 —— 选中内容中注意力输出Attention(Q,K,V)的形状为(batch_size, seq_len, d_v)。

作用：控制注意力输出的信息容量：d_v越大，输出向量可承载的融合信息越丰富（如复杂语义、多维度特征）；d_v越小，输出特征越紧凑，适合对计算资源有限或特征简洁性要求高的场景。

5. $QK^T$（Q 与转置后 K 的点积）

定义：指 Query 矩阵（Q）与转置后的 Key 矩阵（K^T） 进行点积运算的结果，是选中内容中注意力计算的核心中间步骤。

Q与转置后K的相乘，本质是对批量内的每个样本（batch_size个样本），分别执行 2D 矩阵乘法，再将结果整合为 3D 批量矩阵。这一过程在 NumPy 中通过np.matmul自动实现（无需手动循环处理每个样本）

关联场景：

先对 K 进行转置：将 K 的形状从(batch_size, seq_len, d_k)转为(batch_size, d_k, seq_len)（交换后两个维度），确保与 Q（batch_size, seq_len, d_k）满足矩阵乘法 “前一矩阵列数 = 后一矩阵行数” 的规则；
再进行点积：Q 与转置后的 K 相乘，得到形状为(batch_size, seq_len, seq_len)的结果，即 QK_trans。

作用：QK_trans 的每个元素(i,j)代表 “第 i 个 Query 与第 j 个 Key 的原始相似度”，是后续计算注意力权重（经缩放、Softmax）的基础，直接体现选中内容中 “计算序列中元素之间相关性” 的核心逻辑。

一句话概括就是，batch_size是一次进行几个查询，seq_len是查询的输入的向量（假设为A）长度，也是被查询的内容的向量（假设为B）长度，举个例子就是“猫在哪里”这个查询的输入和“猫在桌子上”这个被查询的内容被转化为的向量（就是A和B）的长度，A和B中的每一项可以理解为一个token，那么从几个维度来描述这个token呢？d_k个维度

6. $QK^T$ 与 V相乘

我们已知 $QK^T$ 的结果是（batch_size, seq_len, seq_len）了，再和V（batch_size， seq_len， d_v）相乘，得到的就是（batch_size， seq_len， d_v）了

相乘结果（output）的形状为 (batch_size, seq_len, d_v)，其中每个位置的向量是融合了全局相关信息的新表示：

• 对于序列中的每个元素，不再仅依赖自身的原始信息，而是通过注意力机制 “主动搜集” 序列中所有相关元素的信息并整合；

• 例如在自然语言处理中，“猫” 这个词的输出向量会融合 “坐”“垫子” 等相关词的信息，更精准地表达 “猫坐在垫子上” 这一语境中的完整含义。

QKV函数实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

def qkv_attention(Q, K, V, mask=None):
    """
    计算QKV自注意力（缩放点积注意力）。
    参数
    Q : ndarray，shape (batch_size, seq_len, d_k)，Query矩阵
    K : ndarray，shape (batch_size, seq_len, d_k)，Key矩阵
    V : ndarray，shape (batch_size, seq_len, d_v)，Value矩阵
    mask : ndarray，shape (batch_size, seq_len, seq_len)，可选，掩码矩阵（0表示屏蔽，1表示保留）
    返回
    output : ndarray，shape (batch_size, seq_len, d_v)，注意力输出
    attention_weights : ndarray，shape (batch_size, seq_len, seq_len)，注意力权重矩阵
    """
    # 1. 获取关键参数：batch大小、序列长度、Key的维度
    batch_size, seq_len, d_k = Q.shape
    # 2. 计算Q与K的点积（未缩放），shape变为(batch_size, seq_len, seq_len)
    # K.transpose(0, 2, 1)：将K的后两维交换，从(seq_len, d_k)转为(d_k, seq_len)，满足矩阵乘法维度要求
    qk_dot = np.matmul(Q, K.transpose(0, 2, 1))
    # 3. 缩放点积：除以sqrt(d_k)，避免点积结果过大导致softmax后梯度消失
    scaled_qk = qk_dot / np.sqrt(d_k)
    # 4. 应用掩码（若有）：屏蔽不需要关注的位置（将屏蔽位置值设为极小值，softmax后接近0）
    if mask is not None:
        # 先将掩码中0的位置转为True（需要屏蔽），1的位置转为False（保留）
        mask_bool = (mask == 0)
        # 将需要屏蔽的位置设为-1e9（极小值）
        scaled_qk = np.where(mask_bool, -1e9, scaled_qk)
    # 5. 对缩放后的点积应用softmax，得到注意力权重（每行和为1）
    attention_weights = softmax(scaled_qk, axis=-1)
    # 6. 注意力权重与Value矩阵相乘，得到最终输出
    # 权重shape (batch_size, seq_len, seq_len)，Value shape (batch_size, seq_len, d_v)
    # 矩阵乘法后输出shape (batch_size, seq_len, d_v)
    output = np.matmul(attention_weights, V)
    return output, attention_weights

softmax函数实现

softmax函数本身只是为了对结果进行缩放，会用在很多算法里，于QKV的原理关系并不大，也不是强绑定关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import numpy as np

def softmax(x, axis=-1):
    """
    数值稳定的softmax实现。
    参数
    x : ndarray，输入数组。
    axis : int，默认为-1，沿哪个轴应用softmax。
    返回
    result : ndarray，应用softmax后的结果。
    """
    # 数值稳定：减去每个轴上的最大值，避免指数运算导致数值溢出
    max_vals = np.max(x, axis=axis, keepdims=True)
    exp_x = np.exp(x - max_vals)
    # 计算softmax值：每个元素的指数除以该轴上所有元素指数的和
    result = exp_x / np.sum(exp_x, axis=axis, keepdims=True)
    return result

几个问题

QKV与RNN对比

一句话概括：QKV不关注数据的顺序，而是计算了任意数据两两之间的关系，所以可以并发，速度快，但是计算量大。

一、QKV 注意力机制的优势

并行计算能力更强，训练效率更高QKV 注意力机制通过矩阵运算（如 Q 与 K 的点积、权重与 V 的加权求和）直接捕捉序列中所有元素间的相关性，无需像 RNN 那样按序列顺序（从第一个元素到最后一个元素）逐步计算。这种并行特性可充分利用硬件（如 GPU）的并行计算能力，大幅减少训练时的时间成本，尤其在处理长序列数据时，效率优势更为明显。

全局依赖捕捉更直接，避免长距离依赖衰减传统 RNN 通过 “隐藏状态传递” 捕捉序列依赖，即当前元素的计算依赖前一时刻的隐藏状态，导致序列越长，早期元素的信息在传递过程中越容易被稀释（长距离依赖衰减问题）。而 QKV 注意力机制通过直接计算每个元素与其他所有元素的相似度（注意力权重），可一步获取全局范围内的关键信息，对长序列中远距离元素的依赖关系捕捉更精准，这也符合其 “通过注意力权重聚焦全局关键信息” 的核心设计逻辑。

可解释性更强QKV 注意力机制会输出注意力权重矩阵（形状为(batch_size, seq_len, seq_len)），矩阵中的每个元素直接代表序列中两个元素的相关性的关注程度。通过分析该权重矩阵，可直观观察模型在处理序列时的 “关注点”（例如在 NLP 任务中，模型对哪个单词的关注度更高）；而传统 RNN 的隐藏状态是黑箱式的向量表示，难以直接解读模型的决策依据。

二、QKV 注意力机制的劣势

计算复杂度更高，内存消耗更大QKV 注意力机制的时间复杂度和空间复杂度均为$O(seq\_len^2)$（其中seq_len为序列长度），这是因为其需要计算序列中所有元素两两之间的相似度（共seq_len×seq_len个相似度值）。而传统 RNN 的时间复杂度为O(seq_len)，仅与序列长度线性相关。当处理极长序列（如seq_len达到数千）时，QKV 注意力机制的计算量和内存占用会显著增加，可能导致训练或推理过程难以进行。

对短序列任务的冗余性更高在短序列任务（如句子长度较短的文本分类）中，序列元素间的依赖关系较为简单，传统 RNN 通过顺序计算即可有效捕捉关键信息，且计算成本更低。而 QKV 注意力机制的全局计算特性在此类场景下反而显得冗余，不仅不会显著提升效果，还可能因额外的矩阵运算增加不必要的计算开销。

缺乏对序列顺序的显式建模QKV 注意力机制通过全局相似度计算捕捉依赖关系，本质上是 “无顺序” 的 —— 若将序列元素的顺序打乱，只要元素本身的 Query、Key 向量不变，计算得到的注意力权重和最终输出也会保持不变。而传统 RNN 通过 “按顺序更新隐藏状态” 的方式，天然显式地建模了序列的时序信息，更适合对时序顺序敏感的任务（如时间序列预测）。（注：在实际 Transformer 架构中，会通过添加 “位置编码” 来弥补 QKV 注意力对顺序建模的不足，但这属于额外的补充机制，并非 QKV 注意力本身的特性。）

实际应用中 d_k、d_v 和 d_model 的选择依据

一、d_k 的选择：聚焦相似度计算稳定性与计算成本

d_k 是 Q 和 K 的向量维度，直接影响 Q 与 K 点积（相似度计算）的合理性，其选择需优先满足以下条件：

1. 避免点积结果异常导致的梯度问题

根据实验手册中 QKV 注意力的核心公式，点积结果需除以√d_k进行缩放，目的是防止 d_k 过大时，点积结果数值过大，进而导致 softmax 函数进入饱和区（梯度接近 0），影响模型训练。因此选择 d_k 时，需确保√d_k能有效 “中和” 点积结果的量级 —— 通常优先选择2 的整数次幂（如 16、32、64、128），既便于计算√d_k（避免浮点运算误差），也能更好适配硬件（如 GPU）的并行计算优化。

2. 匹配序列长度与模型复杂度需求

d_k 的大小决定了 Q 和 K 对序列元素语义信息的编码能力：d_k 过小可能导致语义信息表达不足（无法捕捉元素间细微的相关性）；d_k 过大则会增加 Q 与 K 点积的计算量（注意力权重矩阵计算复杂度为O(seq_len²×d_k)），同时提升内存占用。例如，处理短序列（如 seq_len=32）时，可选择 d_k=64 以增强语义编码；处理长序列（如 seq_len=512）时，可适当降低 d_k 至 32，平衡计算成本与模型效果。

二、d_v 的选择：兼顾输出信息容量与维度一致性

d_v 是 V 的向量维度，决定了注意力输出的信息容量，其选择需结合输出维度需求与计算连贯性：

1. 与注意力输出维度直接绑定

根据实验手册定义，注意力输出的形状为(batch_size, seq_len, d_v)，即 d_v 直接决定每个序列元素最终输出向量的维度。因此选择 d_v 时，需先明确下游任务对输出维度的要求：若下游任务（如文本分类）需要紧凑的特征表示，可选择较小的 d_v（如 32、64）；若任务（如机器翻译）需要丰富的语义信息传递，可选择与 d_k 相等或更大的 d_v（如 d_k=64 时，d_v=64 或 128）。

2. 保持与 d_k 的合理比例

虽然 d_v 与 d_k 无强制相等的约束，但两者比例会影响 Q-K 相似度与 V 信息融合的 “匹配度”：若 d_v 远大于 d_k，可能导致 V 中的冗余信息无法被 Q-K 相似度有效筛选；若 d_v 远小于 d_k，则可能浪费 Q-K 捕捉到的精细相关性（V 无法承载足够信息）。实际应用中，常选择 d_v 与 d_k 相等（如均为 64），或 d_v 为 d_k 的整数倍（如 d_k=32、d_v=64），确保信息传递的连贯性。

三、d_model 的选择：统筹 QKV 维度与模型整体架构

d_model 是模型的整体特征维度（常见于 Transformer 架构，与 QKV 维度存在拆解关系），其选择需以QKV 维度为基础，同时考虑模型深度与任务规模：

1. 与 QKV 维度的拆解逻辑匹配

在 Transformer 的多头注意力机制中（实验手册未直接提及，但为 QKV 注意力的典型应用），d_model 需能被头数（num_heads）整除，且每个头的 QKV 维度满足d_k = d_v = d_model / num_heads。例如，若设置 num_heads=8，则 d_model 需选择 8 的整数倍（如 512、1024），对应每个头的 d_k=d_v=64（512/8）或 128（1024/8）。这种拆解确保多头注意力能并行捕捉不同类型的相关性，同时保持模型整体维度的一致性。

2. 适配任务数据规模与模型复杂度

d_model 直接决定模型的整体参数规模与表达能力：小 d_model（如 256、512）适合小规模数据（如万级样本）或简单任务（如文本分类），可降低过拟合风险；大 d_model（如 1024、2048）适合大规模数据（如百万级样本）或复杂任务（如多语言翻译），能捕捉更复杂的语义关系，但需配套更大的计算资源（如高性能 GPU）支持。
四、总结：选择的核心优先级
实际应用中，三者的选择需遵循 “先定 d_k→再定 d_v→最后定 d_model” 的优先级：
先根据序列长度和梯度稳定性确定 d_k（优先 2 的整数次幂）；
再根据下游输出需求和d_k 比例确定 d_v（通常与 d_k 相等或成整数倍）；
最后结合多头注意力头数和任务规模确定 d_model（需为头数与 d_k 的乘积），确保模型整体架构的兼容性与高效性。

QKV在计算机视觉中的应用

ViT 是将 QKV 注意力（多头形式，基于单头 QKV 扩展）应用于图像分类的经典模型，其核心是将图像拆分为 Patch 序列后，通过 QKV 注意力捕捉 Patch 间的全局关联（如 “猫的耳朵 Patch” 与 “猫的头部 Patch” 的相关性）：
每个 Patch 经线性映射后生成 Q、K、V，通过 QKV 注意力计算，使每个 Patch 能融合全局其他 Patch 的视觉信息；

最终通过全局平均池化将注意力输出转换为图像级特征，输入分类器完成分类；

其中 QKV 注意力的计算模块完全基于实验手册中的单头 QKV 逻辑，仅通过多头扩展（拆分 Q/K/V 为多组子矩阵并行计算）提升效果，未改变 QKV 的核心原理。

QKV其应用于计算机视觉等非序列领域的核心本质是 “将非序列数据转换为序列形式，复用‘基于元素相关性的加权融合’逻辑”：

• 数据层面：通过 “拆分→线性映射”，将图像的 2D 网格转换为 1D 序列，匹配 QKV 注意力的(batch_size, seq_len, d_k/d_v)输入维度；
• 计算层面：完全遵循实验手册中的 QKV 注意力公式、步骤与函数实现（点积、缩放、softmax、Value 融合），无额外修改；
• 目标层面：与实验手册 1.6 节 “分析注意力权重分布，理解信息处理作用” 的目标一致 —— 在视觉领域，通过分析注意力权重可观察模型对图像关键区域（如目标边缘、纹理）的关注，验证模型信息处理的合理性。

机器学习的核心目标是让模型发现泛化模式（能对未见过的数据有效预测），而非仅记忆训练数据。关键矛盾在于：模型在有限训练样本上学习时，可能出现 “无法捕捉数据规律” 或 “过度记忆训练噪声” 的问题，即欠拟合与过拟合，需通过合理模型选择平衡泛化能力。

过拟合，欠拟合

训练误差与泛化误差

1. 定义与区别
   | 误差类型 | 定义 | 特点 ｜
   | ---- | ---- | ---- |
   | 训练误差 | 模型在训练数据集上计算的误差 | 可直接计算，易通过复杂模型降低 |
   | 泛化误差 | 模型在无限多同分布新数据上的误差期望 | 无法精确计算，需通过独立测试集 / 验证集估计 |

2. 关键理论支撑

• 独立同分布假设（i.i.d.）：训练数据与测试数据需从同一分布独立抽取，是评估泛化误差的基础。现实中可能存在分布偏移（如加州医院数据训练的模型用于马萨诸塞医院），需警惕其对泛化能力的影响。
• 统计学习理论：格里文科 - 坎特利定理证明训练误差会收敛到泛化误差；Vapnik 和 Chervonenkis 将其扩展到更广泛函数类，为泛化误差分析提供理论基础。

3. 影响泛化的核心因素（模型复杂性）

• 可调整参数数量：参数越多（自由度越高），模型越易过拟合（如高阶多项式 vs 低阶多项式）。
• 参数取值范围：权重取值过大时，模型易受噪声影响，泛化能力下降。
• 训练样本数量：样本量越少，越易过拟合；百万级样本需极复杂模型才可能过拟合，足够数据可提升泛化能力。
• 训练迭代次数：需 “早停” 的模型（少迭代）复杂度低，过度迭代可能加剧过拟合。

模型选择方法

模型选择的核心是避免 “用测试集调参导致过拟合测试数据”，需通过专门数据划分实现：

1. 验证集划分

• 数据三分法：将数据分为训练集（训练模型）、验证集（选择超参数 / 模型）、测试集（最终评估泛化能力）。
• 注意事项：验证集与测试集边界需清晰，书中实验因数据限制，报告的 “测试准确度” 实际为验证集准确度。

2. K 折交叉验证

• 适用场景：训练数据稀缺，无法划分出足够大的验证集。
• 操作步骤：
  • 将原始训练数据分成 K 个不重叠子集；
  • 执行 K 次训练 + 验证：每次用 K-1 个子集训练，1 个子集验证；
  • 取 K 次验证误差的平均值，作为模型泛化能力的估计。

过拟合还是欠拟合

当我们比较训练和验证误差时，我们要注意两种常见的情况。 首先，我们要注意这样的情况：训练误差和验证误差都很严重， 但它们之间仅有一点差距。 如果模型不能降低训练误差，这可能意味着模型过于简单（即表达能力不足）， 无法捕获试图学习的模式。 此外，由于我们的训练和验证误差之间的泛化误差很小， 我们有理由相信可以用一个更复杂的模型降低训练误差。 这种现象被称为欠拟合（underfitting）。

另一方面，当我们的训练误差明显低于验证误差时要小心， 这表明严重的过拟合（overfitting）。 注意，过拟合并不总是一件坏事。 特别是在深度学习领域，众所周知， 最好的预测模型在训练数据上的表现往往比在保留（验证）数据上好得多。 最终，我们通常更关心验证误差，而不是训练误差和验证误差之间的差距。

是否过拟合或欠拟合可能取决于模型复杂性和可用训练数据集的大小， 这两个点将在下面进行讨论。

模型复杂度

为了说明一些关于过拟合和模型复杂性的经典直觉，我们给出一个多项式的例子。给定由单个特征$x$和对应实数标签$y$组成的训练数据，我们试图找到下面的$d$阶多项式来估计标签$y$。

$$\hat{y} = \sum_{i=0}^{d} x^i w_i$$

这只是一个线性回归问题，我们的特征是$x$的幂给出的，模型的权重是$w_i$给出的，偏置是$w_0$给出的（因为对于所有的$x$都有$x^0 = 1$）。由于这只是一个线性回归问题，我们可以使用平方误差作为我们的损失函数。

高阶多项式函数比低阶多项式函数复杂得多。高阶多项式的参数较多，模型函数的选择范围较广。因此在固定训练数据集的情况下，高阶多项式函数相对于低阶多项式的训练误差应该始终更低（最坏也是相等）。事实上，当数据样本包含了$x$的不同值时，函数阶数等于数据样本数量的多项式函数可以完美拟合训练集。在图4.4.1中，我们直观地描述了多项式的阶数和欠拟合与过拟合之间的关系。

数据集大小

另一个重要因素是数据集的大小。 训练数据集中的样本越少，我们就越有可能（且更严重地）过拟合。 随着训练数据量的增加，泛化误差通常会减小。 此外，一般来说，更多的数据不会有什么坏处。 对于固定的任务和数据分布，模型复杂性和数据集大小之间通常存在关系。 给出更多的数据，我们可能会尝试拟合一个更复杂的模型。 能够拟合更复杂的模型可能是有益的。 如果没有足够的数据，简单的模型可能更有用。 对于许多任务，深度学习只有在有数千个训练样本时才优于线性模型。 从一定程度上来说，深度学习目前的生机要归功于 廉价存储、互联设备以及数字化经济带来的海量数据集。

多项式回归

生成数据集

给定 $x$，我们将使用以下三阶多项式来生成训练和测试数据的标签：

$$y = 5 + 1.2x - 3.4\frac{x^2}{2!} + 5.6\frac{x^3}{3!} + \epsilon \text{ where } \epsilon \sim \mathcal{N}(0, 0.1^2). \tag{4.4.2}$$

噪声项 $\epsilon$ 服从均值为0且标准差为0.1的正态分布。在优化的过程中，我们通常希望避免非常大的梯度值或损失值。这就是我们将特征从 $x^i$ 调整为 $\frac{x^i}{i!}$ 的原因，这样可以避免很大的 $i$ 带来的特别大的指数值。我们将为训练集和测试集各生成100个样本。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

max_degree = 20  # 多项式的最大阶数
n_train, n_test = 100, 100  # 训练和测试数据集大小
true_w = np.zeros(max_degree)  # 分配大量的空间
true_w[0:4] = np.array([5, 1.2, -3.4, 5.6])

features = np.random.normal(size=(n_train + n_test, 1))
np.random.shuffle(features)
poly_features = np.power(features, np.arange(max_degree).reshape(1, -1))
for i in range(max_degree):
    poly_features[:, i] /= math.gamma(i + 1)  # gamma(n)=(n-1)!
# labels的维度:(n_train+n_test,)
labels = np.dot(poly_features, true_w)
labels += np.random.normal(scale=0.1, size=labels.shape)

# NumPy ndarray转换为tensor
true_w, features, poly_features, labels = [torch.tensor(x, dtype=
    torch.float32) for x in [true_w, features, poly_features, labels]]

features[:2], poly_features[:2, :], labels[:2]

对模型进行训练和测试

首先让我们实现一个函数来评估模型在给定数据集上的损失。

1
2
3
4
5
6
7
8
9

def evaluate_loss(net, data_iter, loss):  #@save
    """评估给定数据集上模型的损失"""
    metric = d2l.Accumulator(2)  # 损失的总和,样本数量
    for X, y in data_iter:
        out = net(X)
        y = y.reshape(out.shape)
        l = loss(out, y)
        metric.add(l.sum(), l.numel())
    return metric[0] / metric[1]

现在定义训练函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def train(train_features, test_features, train_labels, test_labels,
          num_epochs=400):
    loss = nn.MSELoss(reduction='none')
    input_shape = train_features.shape[-1]
    # 不设置偏置，因为我们已经在多项式中实现了它
    net = nn.Sequential(nn.Linear(input_shape, 1, bias=False))
    batch_size = min(10, train_labels.shape[0])
    train_iter = d2l.load_array((train_features, train_labels.reshape(-1,1)),
                                batch_size)
    test_iter = d2l.load_array((test_features, test_labels.reshape(-1,1)),
                               batch_size, is_train=False)
    trainer = torch.optim.SGD(net.parameters(), lr=0.01)
    animator = d2l.Animator(xlabel='epoch', ylabel='loss', yscale='log',
                            xlim=[1, num_epochs], ylim=[1e-3, 1e2],
                            legend=['train', 'test'])
    for epoch in range(num_epochs):
        d2l.train_epoch_ch3(net, train_iter, loss, trainer)
        if epoch == 0 or (epoch + 1) % 20 == 0:
            animator.add(epoch + 1, (evaluate_loss(net, train_iter, loss),
                                     evaluate_loss(net, test_iter, loss)))
    print('weight:', net[0].weight.data.numpy())

三阶多项式函数拟合（正常）

我们将首先使用三阶多项式函数，它与数据生成函数的阶数相同。 结果表明，该模型能有效降低训练损失和测试损失。 学习到的模型参数也接近真实值。

1
2
3

# 从多项式特征中选择前4个维度，即1,x,x^2/2!,x^3/3!
train(poly_features[:n_train, :4], poly_features[n_train:, :4],
      labels[:n_train], labels[n_train:])

1

weight: [[ 5.010476   1.2354498 -3.4229028  5.503297 ]]

线性函数拟合(欠拟合)

让我们再看看线性函数拟合，减少该模型的训练损失相对困难。 在最后一个迭代周期完成后，训练损失仍然很高。 当用来拟合非线性模式（如这里的三阶多项式函数）时，线性模型容易欠拟合。

1
2
3

# 从多项式特征中选择前2个维度，即1和x
train(poly_features[:n_train, :2], poly_features[n_train:, :2],
      labels[:n_train], labels[n_train:])

1

weight: [[3.4049764 3.9939284]]

高阶多项式函数拟合(过拟合)

现在，让我们尝试使用一个阶数过高的多项式来训练模型。 在这种情况下，没有足够的数据用于学到高阶系数应该具有接近于零的值。 因此，这个过于复杂的模型会轻易受到训练数据中噪声的影响。 虽然训练损失可以有效地降低，但测试损失仍然很高。 结果表明，复杂模型对数据造成了过拟合。

1
2
3

# 从多项式特征中选取所有维度
train(poly_features[:n_train, :], poly_features[n_train:, :],
      labels[:n_train], labels[n_train:], num_epochs=1500)

解决方案

权重衰减

前一节我们描述了过拟合的问题，本节我们将介绍一些正则化模型的技术。 我们总是可以通过去收集更多的训练数据来缓解过拟合。 但这可能成本很高，耗时颇多，或者完全超出我们的控制，因而在短期内不可能做到。 假设我们已经拥有尽可能多的高质量数据，我们便可以将重点放在正则化技术上。

1. 提出目的：作为正则化技术，用于缓解模型过拟合问题。当无法通过收集更多训练数据改善过拟合时，权重衰减通过限制模型复杂度实现优化，尤其适用于高维数据场景（如多变量多项式回归中，阶数增长会导致项数急剧增加，简单限制特征数量难以平衡模型复杂度）。
2. 核心概念：又称L₂正则化，通过在损失函数中加入权重向量的L₂范数惩罚项，衡量模型函数与“最简单函数（f=0）”的距离，引导权重向量保持较小规模，避免模型过度依赖部分特征。
3. 数学表达
   • 原始线性回归损失函数：$L(w, b) = \frac{1}{n}\sum_{i=1}^{n}\frac{1}{2}(w^\top x^{(i)} + b - y^{(i)})^2$
   • 加入L₂正则化的损失函数：$L(w, b) + \frac{\lambda}{2}\|w\|^2$，其中$\lambda$为非负正则化常数（控制惩罚强度，$\lambda=0$时恢复原始损失函数），$\|w\|^2$是权重向量的L₂范数平方（便于计算导数）。
4. 与L₁正则化的区别：L₂正则化（权重衰减）使权重在大量特征上均匀分布，增强模型对观测误差的稳定性；L₁正则化（套索回归）会使部分权重清零，实现特征选择，适用场景不同。
5. 参数更新逻辑：以小批量随机梯度下降为例，更新公式为$w \leftarrow (1 - \eta\lambda)w - \frac{\eta}{|B|}\sum_{i \in B}x^{(i)}(w^\top x^{(i)} + b - y^{(i)})$，每一步训练中通过$(1 - \eta\lambda)$项“衰减”权重，限制其增长。通常不对输出层偏置$b$进行正则化，不同框架可灵活配置。

暂退法

（一）重新审视过拟合

1. 线性模型与深度网络的过拟合差异：线性模型在特征多、样本不足时易过拟合，样本多于特征时通常不易过拟合，但无法考虑特征间交互作用；深度神经网络即便样本远多于特征，仍可能过拟合，如2017年研究中，深度网络可在随机标记图像上完美训练，但测试精度难超10%，泛化差距达90%。
2. 偏差-方差权衡：线性模型偏差高（仅能表示小类函数）、方差低（不同样本上结果相似）；深度神经网络位于偏差-方差谱另一端，灵活性高但易过拟合，暂退法是改善其泛化性的实用工具。

（二）扰动的稳健性

1. “好”模型的标准：除简单性（小维度、参数范数小）外，还需平滑性，即对输入微小变化不敏感，如图像分类中，像素加随机噪声应基本不影响结果。
2. 暂退法的理论基础：1995年毕晓普证明输入噪声训练等价于Tikhonov正则化；2014年斯里瓦斯塔瓦等人将该想法扩展到网络内部层，提出暂退法，在训练时向每一层注入噪声以增强输入-输出映射的平滑性。
3. 暂退法的无偏向噪声注入：为保证固定其他层时，每一层期望值与无噪声时一致，标准暂退法中，中间活性值(h)以暂退概率(p)由随机变量(h’)替换，公式为：
   [h’ = \begin{cases}
   0 & 概率为(p) \
   \frac{h}{1-p} & 其他情况
   \end{cases}]
   且(E[h’] = h)。

（三）实践中的暂退法

1. 操作方式：训练时，每次迭代计算下一层前，将当前层部分节点置零（如含1个隐藏层、5个隐藏单元的多层感知机，可能丢弃部分隐藏单元），使输出层不过度依赖某一隐藏单元；测试时通常不使用暂退法，无需标准化，仅部分研究为估计预测“不确定性”会在测试时使用。
2. 暂退概率设置技巧：靠近输入层的暂退概率通常设得较低。

初始化模型参数

回想一下，Fashion-MNIST中的每个图像由 $28 \times 28 = 784$ 个灰度像素值组成。 所有图像共分为10个类别。 忽略像素之间的空间结构， 我们可以将每个图像视为具有784个输入特征 和10个类的简单分类数据集。 首先，我们将实现一个具有单隐藏层的多层感知机， 它包含256个隐藏单元。 注意，我们可以将这两个变量都视为超参数。 通常，我们选择2的若干次幂作为层的宽度。 因为内存在硬件中的分配和寻址方式，这么做往往可以在计算上更高效。

我们用几个张量来表示我们的参数。 注意，对于每一层我们都要记录一个权重矩阵和一个偏置向量。 跟以前一样，我们要为损失关于这些参数的梯度分配内存。

1
2
3
4
5
6
7
8
9
10

num_inputs, num_outputs, num_hiddens = 784, 10, 256

W1 = nn.Parameter(torch.randn(
    num_inputs, num_hiddens, requires_grad=True) * 0.01)
b1 = nn.Parameter(torch.zeros(num_hiddens, requires_grad=True))
W2 = nn.Parameter(torch.randn(
    num_hiddens, num_outputs, requires_grad=True) * 0.01)
b2 = nn.Parameter(torch.zeros(num_outputs, requires_grad=True))

params = [W1, b1, W2, b2]

激活函数

我们将实现ReLU激活函数， 而不是直接调用内置的relu函数。

1
2
3

def relu(X):
    a = torch.zeros_like(X)
    return torch.max(X, a)

模型

因为我们忽略了空间结构， 所以我们使用reshape将每个二维图像转换为一个长度为num_inputs的向量。 只需几行代码就可以实现我们的模型。

1
2
3
4

def net(X):
    X = X.reshape((-1, num_inputs))
    H = relu(X@W1 + b1)  # 这里“@”代表矩阵乘法
    return (H@W2 + b2)

损失函数

由于我们已经从零实现过softmax函数（ 3.6节）， 因此在这里我们直接使用高级API中的内置函数来计算softmax和交叉熵损失。

1

loss = nn.CrossEntropyLoss(reduction='none')

训练

幸运的是，多层感知机的训练过程与softmax回归的训练过程完全相同。可以直接用之前博客的train_ch3函数

1
2
3

num_epochs, lr = 10, 0.1
updater = torch.optim.SGD(params, lr=lr)
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, updater)

为了对学习到的模型进行评估，我们将在一些测试数据上应用这个模型。

1

d2l.predict_ch3(net, test_iter)

隐藏层

我们之前的线性模型都是仿射变换，是一种带有偏置项的线性变换，比如softmax回归的模型架构中，该模型通过单个仿射变换将我们的输入直接映射为输出，然后进行softmax操作。如果我们的标签通过仿射变换后确实与我们的输入数据相关，那么这种方法确实足够了，但是，仿射变换中的线性是一个很强的假设，即输入数据和标签之间的关系是线性的，这个假设是非常严格的。

线性模型可能出错

例如，线性意味着单调假设： 任何特征的增大都会导致模型输出的增大（如果对应的权重为正）， 或者导致模型输出的减小（如果对应的权重为负）。 有时这是有道理的。 例如，如果我们试图预测一个人是否会偿还贷款。 我们可以认为，在其他条件不变的情况下， 收入较高的申请人比收入较低的申请人更有可能偿还贷款。 但是，虽然收入与还款概率存在单调性，但它们不是线性相关的。 收入从0增加到5万，可能比从100万增加到105万带来更大的还款可能性。 处理这一问题的一种方法是对我们的数据进行预处理， 使线性变得更合理，如使用收入的对数作为我们的特征。

然而我们可以很容易找出违反单调性的例子。 例如，我们想要根据体温预测死亡率。 对体温高于37摄氏度的人来说，温度越高风险越大。 然而，对体温低于37摄氏度的人来说，温度越高风险就越低。 在这种情况下，我们也可以通过一些巧妙的预处理来解决问题。 例如，我们可以使用与37摄氏度的距离作为特征。

但是，如何对猫和狗的图像进行分类呢？ 增加位置（13，17）处像素的强度是否总是增加（或降低）图像描绘狗的似然？ 对线性模型的依赖对应于一个隐含的假设， 即区分猫和狗的唯一要求是评估单个像素的强度。 在一个倒置图像后依然保留类别的世界里，这种方法注定会失败。

与我们前面的例子相比，这里的线性很荒谬， 而且我们难以通过简单的预处理来解决这个问题。 这是因为任何像素的重要性都以复杂的方式取决于该像素的上下文（周围像素的值）。 我们的数据可能会有一种表示，这种表示会考虑到我们在特征之间的相关交互作用。 在此表示的基础上建立一个线性模型可能会是合适的， 但我们不知道如何手动计算这么一种表示。 对于深度神经网络，我们使用观测数据来联合学习隐藏层表示和应用于该表示的线性预测器。

在网络中加入隐藏层

我们可以通过在网络中加入一个或多个隐藏层来克服线性模型的限制， 使其能处理更普遍的函数关系类型。 要做到这一点，最简单的方法是将许多全连接层堆叠在一起。 每一层都输出到上面的层，直到生成最后的输出。 我们可以把前L - 1层看作表示，把最后一层看作线性预测器。 这种架构通常称为多层感知机（multilayer perceptron），通常缩写为MLP。 下面，我们以图的方式描述了多层感知机。

这个多层感知机有4个输入，3个输出，其隐藏层包含5个隐藏单元。 输入层不涉及任何计算，因此使用此网络产生输出只需要实现隐藏层和输出层的计算。 因此，这个多层感知机中的层数为2。 注意，这两个层都是全连接的。 每个输入都会影响隐藏层中的每个神经元， 而隐藏层中的每个神经元又会影响输出层中的每个神经元。

具有全连接层的多层感知机的参数开销可能会高得令人望而却步。 即使在不改变输入或输出大小的情况下， 可能在参数节约和模型有效性之间进行权衡

从线性到非线性

同之前的博客一样，我们通过矩阵 $\mathbf{X} \sub R^{n \times d}$ 来表示n个样本的小批量，其中每个样本具有d个输入特征。对于具有h个隐藏单元的单隐藏层多层感知机，用 $\mathbf{H} \sub R^{n \times h}$ 来表示隐藏层的输出，称为隐藏层表示（hidden representations）。在数学或代码中，$\mathbf{H}$ 也被称为隐藏层变量（hidden-layer variable），或隐藏变量(hidden variable)。因为隐藏层和输出层都是全连接的，所以我们有隐藏层权重 $\mathbf{W}^{(1)} \sub R^{d \times h}$ 和隐藏层偏置 $\mathbf{b}^{(1)} \sub R^{1 \times h}$，以及输出层权重 $\mathbf{W}^{(2)} \sub R^{d \times q}$ 和输出层偏置 $\mathbf{b}^{(2)} \sub R^{1 \times q}$。形式上，我们按如下方式计算单隐藏层多层感知机的输出 $\mathbf{O} \sub R^{n \times q}$：

$$\mathbf{H} = \mathbf{X}\mathbf{W}^{(1)} + \mathbf{b}^{(1)} \\\mathbf{O} = \mathbf{H}\mathbf{W}^{(2)} + \mathbf{b}^{(2)} \\$$

注意在添加隐藏层之后，模型现在需要跟踪和更新额外的参数。 可我们能从中得到什么好处呢？在上面定义的模型里，我们没有好处！ 原因很简单：上面的隐藏单元由输入的仿射函数给出， 而输出（softmax操作前）只是隐藏单元的仿射函数。 仿射函数的仿射函数本身就是仿射函数， 但是我们之前的线性模型已经能够表示任何仿射函数。

我们可以证明这一等价性，即对于任意权重值， 我们只需合并隐藏层，便可产生具有参数 $\mathbf{W} = \mathbf{W}^{(1)} \mathbf{W}^{(2)}, \mathbf{b} = \mathbf{b}^{(1)} \mathbf{W}^{(2)} + \mathbf{b}^{(2)}$ 的等价单层模型：

$$\mathbf{O} = (\mathbf{X}\mathbf{W}^{(1)} + \mathbf{b}^{(1)})\mathbf{W}^{(2)} + \mathbf{b}^{(2)} = \mathbf{X}\mathbf{W}^{(1)}\mathbf{W}^{(2)} + \mathbf{b}^{(1)} \mathbf{W}^{(2)} + \mathbf{b}^{(2)}$$

为了发挥多层架构的潜力， 我们还需要一个额外的关键要素： 在仿射变换之后对每个隐藏单元应用非线性的激活函数（activation function）$\sigma$，激活函数的输出，被称为活性值（activations）。一般来说，有了激活函数，就不可能将我们的多层感知机退化成线性模型

$$H = \sigma(XW^{(1)} + b^{(1)}) \\O = HW^{(2)} + b^{(2)}$$

由于X中的每一行对应小批量中的一个样本，处于记号习惯的考量，我们定义非线性函数 $\sigma$ 也已按行的方式作用于输入，即一次计算一个样本，之前我们以相同的方式使用了softmax符号来表示按行操作。但是本次应用于隐藏层的激活函数不仅按行操作，也按元素操作。这意味着在计算每一层的线性部分之后，我们可以计算每个活性值，而不需要查看其他隐藏单元所取的值，对于大多数激活函数都是这样。

为了构建更通用的多层感知机，我们可以继续堆叠这样的隐藏层，例如 $H^{(1)} = \sigma_1(XW^{(1)}+b^{(1)})$ 和 $H^{(2)} = \sigma_2(XW^{(2)}+b^{(2)})$，一层层堆叠，从而产生更有表达能力的模型。

通用近似定理

多层感知机可以通过隐藏神经元，捕捉到输入之间复杂的相互作用， 这些神经元依赖于每个输入的值。 我们可以很容易地设计隐藏节点来执行任意计算。 例如，在一对输入上进行基本逻辑操作，多层感知机是通用近似器。 即使是网络只有一个隐藏层，给定足够的神经元和正确的权重， 我们可以对任意函数建模，尽管实际中学习该函数是很困难的。 神经网络有点像C语言。 C语言和任何其他现代编程语言一样，能够表达任何可计算的程序。 但实际上，想出一个符合规范的程序才是最困难的部分。

而且，虽然一个单隐层网络能学习任何函数， 但并不意味着我们应该尝试使用单隐藏层网络来解决所有问题。 事实上，通过使用更深（而不是更广）的网络，我们可以更容易地逼近许多函数。

激活函数

激活函数（activation function）通过计算加权和并加上偏置来确定神经元是否应该被激活， 它们将输入信号转换为输出的可微运算。 大多数激活函数都是非线性的。 由于激活函数是深度学习的基础，下面简要介绍一些常见的激活函数。

ReLU函数

最受欢迎的激活函数是修正线性单元（Rectified linear unit，ReLU）， 因为它实现简单，同时在各种预测任务中表现良好。 ReLU提供了一种非常简单的非线性变换。 给定元素x，ReLU函数被定义为该元素与0的最大值：

$$ReLU(x) = max(x, 0)$$

通俗地说，ReLU函数通过将相应的活性值设为0，仅保留正元素并丢弃所有负元素。 为了直观感受一下，我们可以画出函数的曲线图。 正如从图中所看到，激活函数是分段线性的。

当输入为负时，ReLU函数的导数为0，而当输入为正时，ReLU函数的导数为1。 注意，当输入值精确等于0时，ReLU函数不可导。 在此时，我们默认使用左侧的导数，即当输入为0时导数为0。 我们可以忽略这种情况，因为输入可能永远都不会是0。 这里引用一句古老的谚语，“如果微妙的边界条件很重要，我们很可能是在研究数学而非工程”， 这个观点正好适用于这里。 下面我们绘制ReLU函数的导数。

使用ReLU的原因是，它求导表现得特别好：要么让参数消失，要么让参数通过。 这使得优化表现得更好，并且ReLU减轻了困扰以往神经网络的梯度消失问题（稍后将详细介绍）。

注意，ReLU函数有许多变体，包括参数化ReLU（Parameterized ReLU，pReLU） 函数 (He et al., 2015)。 该变体为ReLU添加了一个线性项，因此即使参数是负的，某些信息仍然可以通过：

$$pReLU(x) = max(0,x) + \alpha \ min(0,x)$$

sigmoid函数

对于一个定义域在R中的输入， sigmoid函数将输入变换为区间(0, 1)上的输出。 因此，sigmoid通常称为挤压函数（squashing function）： 它将范围（-inf, inf）中的任意输入压缩到区间（0, 1）中的某个值：

$$sigmoid(x) = \frac{1}{1 + e^{-x}}$$

在最早的神经网络中，科学家们感兴趣的是对“激发”或“不激发”的生物神经元进行建模。 因此，这一领域的先驱可以一直追溯到人工神经元的发明者麦卡洛克和皮茨，他们专注于阈值单元。 阈值单元在其输入低于某个阈值时取值0，当输入超过阈值时取值1。

当人们逐渐关注到到基于梯度的学习时， sigmoid函数是一个自然的选择，因为它是一个平滑的、可微的阈值单元近似。 当我们想要将输出视作二元分类问题的概率时， sigmoid仍然被广泛用作输出单元上的激活函数 （sigmoid可以视为softmax的特例）。 然而，sigmoid在隐藏层中已经较少使用， 它在大部分时候被更简单、更容易训练的ReLU所取代。 在后面关于循环神经网络的章节中，我们将描述利用sigmoid单元来控制时序信息流的架构。

sigmoid函数的导数为下面的公式

$$\frac{d}{dx} sigmoid(x) = \frac{e^{-x}}{(1 + e^{-x})^2} = sigmoid(x)(1 - sigmoid(x))$$

sigmoid函数的导数图像如下所示。 注意，当输入为0时，sigmoid函数的导数达到最大值0.25； 而输入在任一方向上越远离0点时，导数越接近0。

tanh函数

与sigmoid函数类似， tanh(双曲正切)函数也能将其输入压缩转换到区间(-1, 1)上。 tanh函数的公式如下：

$$tanh(x) = \frac{1 - e^{-2x}}{1 + e^{-2x}}$$

下面我们绘制tanh函数。 注意，当输入在0附近时，tanh函数接近线性变换。 函数的形状类似于sigmoid函数， 不同的是tanh函数关于坐标系原点中心对称。

tanh函数导数是

$$\frac{d}{dx}tanh(x) = 1 - tanh^2(x)$$

tanh函数的导数图像如下所示。 当输入接近0时，tanh函数的导数接近最大值1。 与我们在sigmoid函数图像中看到的类似， 输入在任一方向上越远离0点，导数越接近0。

总结一下，我们现在了解了如何结合非线性函数来构建具有更强表达能力的多层神经网络架构。 顺便说一句，这些知识已经让你掌握了一个类似于1990年左右深度学习从业者的工具。 在某些方面，你比在20世纪90年代工作的任何人都有优势， 因为你可以利用功能强大的开源深度学习框架，只需几行代码就可以快速构建模型， 而以前训练这些网络需要研究人员编写数千行的C或Fortran代码。

加载Fashion数据

1
2
3
4
5
6
7
8
9

def load_data_fashion_mnist(batch_size, resize=None):
    trans = [transforms.ToTensor()]
    if resize:
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans)
    mnist_train = torchvision.datasets.FashionMNIST(root='./data', train=True, transform=trans, download=True)
    mnist_test = torchvision.datasets.FashionMNIST(root='./data', train=False, transform=trans, download=True)
    return (data.DataLoader(mnist_train, batch_size, shuffle=True, num_workers=get_dataloader_workers()), 
            data.DataLoader(mnist_test, batch_size, shuffle=False, num_workers=get_dataloader_workers()))

这段这段代码定义了一个加载 FashionMNIST 数据集的工具函数 load_data_fashion_mnist，主要功能是将数据集处理为可直接用于训练和测试的迭代器（DataLoader）。下面详细解释各部分：

函数参数:

• batch_size：每个批次包含的样本数量（用于批量训练）
• resize：可选参数，若指定则将图像调整为该尺寸（如 resize=64 表示将图像缩放为 64×64 像素）

1
2
3
4

trans = [transforms.ToTensor()]
if resize:
    trans.insert(0, transforms.Resize(resize))
trans = transforms.Compose(trans)

• 首先创建一个转换列表 trans，初始包含 ToTensor()（将图像转为 PyTorch 张量并归一化）
• 若指定了 resize，则在列表开头插入 Resize(resize)（先调整图像尺寸，再转为张量）
• 用 transforms.Compose(trans) 将多个转换操作组合成一个流水线（按列表顺序执行）

1
2
3
4
5
6

mnist_train = torchvision.datasets.FashionMNIST(
    root='./data', train=True, transform=trans, download=True
)
mnist_test = torchvision.datasets.FashionMNIST(
    root='./data', train=False, transform=trans, download=True
)

• 加载训练集（train=True）和测试集（train=False）
• root=‘./data’：数据集存储路径
• transform=trans：应用上面定义的转换流水线
• download=True：若本地没有数据集则自动下载

1
2
3
4

return (
    data.DataLoader(mnist_train, batch_size, shuffle=True, num_workers=get_dataloader_workers()), 
    data.DataLoader(mnist_test, batch_size, shuffle=False, num_workers=get_dataloader_workers())
)

• 将数据集包装为 DataLoader，方便按批次读取数据
• 关键参数：
  • batch_size：每次返回的样本数量
  • shuffle=True（训练集）：每个 epoch 前打乱数据顺序，增强训练随机性
  • shuffle=False（测试集）：测试时不需要打乱顺序
  • num_workers=get_dataloader_workers()：指定加载数据的进程数（加速数据读取）

初始化模型参数

和之前线性回归的例子一样，这里的每个样本都将用固定长度的向量表示。 原始数据集中的每个样本都是 $28 \times 28$的图像。 本节将展平每个图像，把它们看作长度为784的向量。 在后面的章节中，我们将讨论能够利用图像空间结构的特征， 但现在我们暂时只把每个像素位置看作一个特征。