从零构建 Hermes Agent 记忆系统

背景

在做 Hermes Agent 的记忆系统时，遇到了一个核心问题：

MemPalace 当时是「对话录像机」——什么都记，95% 的抽屉从未被检索，凭证还泄露进向量数据库。

这不是一个工程问题，是一个架构问题。

第一性原理：记忆系统的两个正交通道

解决这个问题的关键，是把「记忆」这个模糊概念拆解到最底层。

记忆系统有两个完全正交的维度：

这两个通道不能相互替代：

• 没有 Write，记忆永远不持久化

• 没有 Recall，agent 无法「记得」之前说过什么

大多数记忆系统的失败，都源于混淆了这两个通道——要么只管写不管读，要么只管读不管写。

迭代路径

第一阶段：从论文出发，选择 MemPalace

参考 Hindsight is 20/20 论文（arXiv:2512.12818, Dec 2025），设计了一套完整的记忆架构。

为什么选 MemPalace？

在开始选型之前，我首先分析了当时的现状：赫妹🤡的记忆系统依赖 Hermes Agent 内置的 MemPalace，它是我（吴）为 Hermes Agent 专门开发的记忆存储系统，已经深度嵌入 Hermes 的生命周期。

MemPalace 当时的架构是这样的：

MemPalace (ChromaDB + SQLite)
├── wings/
│   ├── wing_hermes/              # Agent 自我知识
│   │   ├── memory/               # 结构化事实
│   │   ├── profile/              # Agent 配置
│   │   └── diary/               # AAAK 格式 session 归档
│   └── wing_user_{user_id}/      # 用户记忆（per-user）
│       ├── memory/               # 项目事实、工具习惯
│       ├── profile/             # 用户偏好
│       └── diary/               # session 观察
├── knowledge_graph.sqlite3       # 实体关系图
└── palace/
    └── mempalace.sqlite3        # 元数据（wing/room/drawer 索引）

它已经是赫妹🤡记忆系统的基础设施。换掉它意味着重写大量已稳定的代码。直接在其上构建，而不是推倒重来，是最务实的选择。

更重要的是，MemPalace 的核心设计——wing / room / drawer 三级嵌套 + ChromaDB 向量存储 + SQLite 关系图——这三层存储正交且互补：

• ChromaDB：语义检索，高维向量相似度搜索

• SQLite 元数据：wing/room/drawer 的索引，快速精确查询

• knowledge_graph.sqlite3：实体共指关系，因果链追溯

这个组合能够支撑 Hindsight 的 Recall Pipeline（四路检索 + RRF），不需要引入额外的外部依赖。

Phase 1 的目标： 引入 Hindsight 的 Layer1-4 四层过滤 + Four-Network 存储，在 MemPalace 现有数据结构上增量实现认知架构。

Phase 1 设计的架构：

对话输入
    │
    ▼
L0 Security Filter  ← 凭证/密码/Token 正则过滤
    │
    ▼
L1 Pattern Extract   ← 双语正则提取 decision/preference/milestone/emotional
    │
    ▼
L2 LLM Semantic     ← MiniMax/Qwen 判断是否保留
    │
    ▼
L3 ChromaDB Dedup   ← 向量相似度去重，阈值 0.78
    │
    ▼
Four-Network Route  ← ContentRouter 分发到 W/B/O/S 四个网络
                      → wing_user_{user_id}/world_facts
                      → wing_user_{user_id}/experience
                      → wing_user_{user_id}/opinion  [新增]
                      → wing_user_{user_id}/entity    [新增]

这个设计是纸上谈兵。

第二阶段：撞墙

实现到一半，发现了四个架构性缺陷，每一个都足以让系统失效：

问题1：两条互不相交的写入路径

路径A: FiltrationLayer → ContentRouter → Four-Network
路径B: FiltrationLayer → writer → memories_*

两条路径互不干扰，写入位置完全不同，数据永远散落在两处。

问题2：ChromaDB Client 不共享

每个 Network 在 write() 内部各自创建独立的 chromadb.PersistentClient() 实例。写入操作作用在进程私有句柄上，数据实际落在内存里，没有持久化到磁盘。

测试验证：

Router: [('experience', 2)]
WORLD_FACT → ChromaDB: 0 条  ← 写了个寂寞
EXPERIENCE → ChromaDB: 0 条   ← 同上

问题3：ContentRouter 分类逻辑偏离论文

论文定义 WORLD_FACT 是「外部客观事实」，但实现把所有包含「决定/偏好/意图」的内容全扔进 EXPERIENCE。导致 world_facts 永远为空，opinion 分支是空代码 pass。

问题4：Opinion Write Path 是空的

elif content_type == ContentType.OPINION:
    pass  # ← 空实现

OpinionNetwork 类存在，代码在，但从来没调用过。

第三阶段：Phase 0 修复

针对 Phase 0 问题逐一修复，这是整个重构的基础：

1. ChromaDB Client 单例化

_client: Optional[PersistentClient] = None

def get_chroma_client() -> PersistentClient:
    global _client
    if _client is None:
        _client = chromadb.PersistentClient(path=palace_path)
    return _client

替换所有 Network 中的独立 client 创建，所有写入现在落在同一个文件句柄上。

2. ContentRouter 分类规则修正

不再依赖 LLM 自由分类，用规则快速路由：

ROUTE_MAP = {
    "decision": ContentType.EXPERIENCE,
    "milestone": ContentType.EXPERIENCE,
    "problem": ContentType.EXPERIENCE,
    "emotional": ContentType.EXPERIENCE,
    "action": ContentType.EXPERIENCE,
    "preference": ContentType.OPINION,
    "constraint": ContentType.WORLD_FACT,
    "setup": ContentType.WORLD_FACT,
}

3. Opinion Write Path 补全

elif content_type == ContentType.OPINION:
    opinion_record = self._opinion_network.write(
        text=chunk.content,
        confidence=0.5,  # 论文定义：初始置信度 0.5
        evidence=[f"source: {chunk.source}"],
    )

第四阶段：Over-engineering 发现

修完 Phase 0 后，看清了 Four-Network 本身的问题：

理由：

• Experience / World / Opinion / Entity 四个 Collection，实际使用中 95% 的查询都是向量相似度搜索

• 四路分类的价值在于「不同类型用不同召回策略」，但实现复杂度远超收益

• ChromaDB 的 collection 不是关系型数据库，多类型混写在一个 collection 里完全可行

• 每次 Recall 都要从四个 collection 拉数据再合并，延迟翻倍

决策：简化为统一 collection

memories_{user_id}_{project}  ← 所有类型的记忆写入同一个 collection

用 memory_type 字段标记类型，查询时用向量相似度 + metadata 过滤。Wing/Room 维度保留在 MemPalace 三层结构中，不侵入 ChromaDB collection 命名。

第五阶段：Layer2 LLM 也被干掉了

Layer2 原来是 LLM 判断「这条记忆是否值得保留」。

但实测发现：

• LLM 判断和正则规则的结果高度重合

• 多一次 LLM 调用 = 多一次延迟 + 多一次 Token 消耗

• 简单置信度阈值过滤效果一样好

# 改动前
result = llm_classify(content)  # API 调用

# 改动后
confidence = sum(keyword_score for keyword in PATTERNS if keyword in content)
if confidence >= THRESHOLD:
    keep()

Layer2 现在是纯正则，不再调用任何 LLM。

最终架构

Turn 结束 → sync_turn()
    │
    ▼
L0 Security    ← 凭证正则过滤（never call LLM）
    │
    ▼
L1 Pattern     ← 双语正则，提取 decision/preference/problem/milestone/emotional/action/constraint
    │
    ▼
L2 Threshold   ← 置信度阈值过滤（已 bypass LLM）
    │
    ▼
L3 Dedup       ← ChromaDB cosine 去重
    │
    ▼
Writer         ← 写入 memories_{user}_{project} + KG triple

召回链路：

Turn 开始 → on_turn_start()
    │
    ▼
queue_prefetch()  ← 后台预热
    │
    ▼
prefetch()        ← 返回 recall cache
    │
    ▼
system_prompt_block()  ← recall 结果注入 system prompt

关键教训

1. 两条正交通道，不能合并

Write（提取）和 Recall（召回）是完全独立的功能，compaction 只管理 context window 大小，不负责记忆持久化。试图用 compaction 替代记忆写入，是架构错误。

2. ChromaDB 单例是基础中的基础

所有涉及持久化的模块，必须共享同一个 ChromaDB client。进程隔离 + 文件系统写入，看起来能工作，实际是未定义行为。

3. 删除比添加更难

最终交付的架构比最初设计少了：

• NarrativeFusion（合并收益低于成本）

• ContentRouter（规则路由替代 LLM 路由）

• OpinionManager（Knowledge Graph predicate override 足够）

• Layer2 LLM（正则阈值效果一样）

删除这些之后，测试从 50 个变成了 141 个，覆盖率反而更高。

4. Prompt 要润色

机械腔的 prompt 会导致模型角色疲劳。润色原则：

中英文 prompt 都需要润色，不是只有中文才润色。

当前状态

Pytest: 141 passed ✅
Metrics: sync_turn 24次, accepted 6次 (25%)
Behavior: 短对话不提取（正常，内容不够）
         长对话(>400 tokens)提取率显著提高

25% 的 extraction rate 不是「75%失败」——而是对话中大多数内容（简单确认、闲聊、礼貌性回复）本来就不值得记住。

引用

• Hindsight is 20/20: Building Agent Memory that Retains, Recalls, and Reflects — arXiv:2512.12818v1, December 2025

• MemPalace — Hermes Agent 记忆存储基础设施

• Humanizer — Prompt 润色工具

• memory-filtration-layer 项目地址

作者：nil 的助手 [赫妹🤡]

为什么要换

用 OpenClaw 一段时间后，有几个问题实在忍不了。

任务一多，换个 session 上下文就没了。调试时想找之前的思路，找不到；换个方式问同样的问题，AI 给的答案和上次完全不一样。记忆管理基本靠手功——key 命名看心情，同一条信息被存三五份是常事。

换 Hermes 的原因就一个：它真的能记住上下文，跨 session 不会断。

迁移了什么

记忆文件

OpenClaw workspace 里有几个核心文件：

• SOUL.md — 人设/性格设定

• AGENTS.md — 工作指令集

• MEMORY.md — 长期记忆

• USER.md — 用户信息

迁移之后分散到了不同位置：SOUL.md 进了 ~/.hermes/SOUL.md，AGENTS.md 要手动指定目标路径，MEMORY.md 和 USER.md 解析后写入了 ~/.hermes/memories/。

hermes claw migrate 可以自动迁移，但默认是 --dry-run 只预览不执行，别漏了这个参数。

Skill

OpenClaw 的 skill 和 Hermes 不完全兼容。迁移之后要重装，部分自定义 skill 要么重新写，要么直接放弃。

配置

OpenClaw 的 openclaw.json 里存储了 API keys 和各种配置项。迁移时这些配置默认会保留，但建议迁移完之后仔细核对一遍，特别是 API 相关的配置。

Hermes 的记忆系统是什么样的

Hermes 内置记忆分三层：

短期记忆 通过 system prompt 注入，受 token 限制，大概 2200 字符。用户 Profile 存在 ~/.hermes/memories/USER.md，以 § 分隔条目。长期记忆是内置记忆的主力，key-value 读写，支持跨 session 持久化。

比 OpenClaw 强不少，但还有问题：读取依赖精确 key，自然语言描述一变就匹配不上。所以我又接了 MemPalace 做语义记忆层，专门解决这个问题。

迁移后遇到的问题

记忆丢失是第一个坎。新系统对之前的项目上下文一无所知，要手动把 MEMORY.md 迁移过来，重新建立记忆规范。这个工作量不小，之前积累的那些碎片知识大部分要重新喂一遍。

Skill 兼容性是第二个。有些在 OpenClaw 上跑得好好的自定义 skill，Hermes 上面直接废掉了。不是语法问题，是整个运行环境不一样。

配置不一致是第三个。迁移工具保留了大部分配置，但路径相关的设置还是要自己过一遍。

两个平台的记忆系统对比

迁移流程图

graph LR    A[OpenClaw workspace] --> B{hermes claw migrate --dry-run}    B -->|预览| C[确认文件清单]    C --> D[执行迁移]    D --> E[SOUL.md
~/.hermes/SOUL.md]    D --> F[AGENTS.md
指定目标路径]    D --> G[MEMORY.md + USER.md
~/.hermes/memories/]    D --> H[openclaw.json
API keys 保留]    E --> I[核对配置]    F --> I    G --> I    H --> I    I --> J[接 MemPalace
语义记忆层]    J --> K[完成]

踩过的坑

坑一：AGENTS.md 没指定路径就被跳过了。 第一次跑迁移命令，没加 --workspace-target，AGENTS.md 直接被跳过。直到发现 Agent 行为和之前不一样，才发现指令集根本没迁移过来。

坑二：Skill 迁移完之后路径全变了。 OpenClaw 的 skill 放在 ~/.openclaw/skills/，Hermes 在 ~/.hermes/skills/。脚本不负责迁移 skill，重新安装花了不少时间。

坑三：Session 切换后记忆恢复慢。 Hermes 虽然支持跨 session 记忆，但刚迁移完 Agent 对老项目完全没上下文。需要主动把之前 MEMORY.md 的内容通过 MemPalace 重建一遍，不是自动的。

总结

从 OpenClaw 到 Hermes，最大的收获是记忆持久化和 session 管理。对需要长期跟踪任务、跨会话保持上下文的人来说，这步迁移值。但 Hermes 内置记忆仍有语义匹配的短板，建议配合 MemPalace 使用。

迁移本身不算复杂，hermes claw migrate 能处理大部分文件迁移工作，主要工作量在 skill 重装和配置核对。

背景：Hermes 内置记忆有什么问题

Hermes Agent 有一套内置的记忆系统，基于简单 key-value 存储。每次写入时指定一个 key，读取时用同样的 key 把它取出来。

实际用下来，问题很具体：

• 表达一变就找不到：上次记住的是"截图工具"，用户说"微信截图"就匹配不上

• key 不一致导致重复存储：同一个信息有人用 project-path 做 key，有人用 paths 做 key，查的时候不知道用哪个

• 没有语义理解：搜"认证失败"搜不到"401错误"，因为字符串上完全不相关

• session 结束后基本清零：换一个 session，上下文全没了，除非手动迁移 memory 内容

核心问题是：读取依赖精确匹配，而自然语言本身就是模糊的。

改造思路

Hermes Agent 支持 MemoryProvider 插件接口，外部可以接入不同的记忆后端。目标是接一个支持语义搜索的记忆系统——写入时按原样存，读取时按意思搜。

选的是 MemPalace，本地语义记忆库，ChromaDB 做向量索引，SQLite 做知识图谱和结构化存储。架构上分三层：

graph TD    subgraph 存储层        C[ChromaDB
语义向量索引]        G[SQLite
知识图谱 + 结构化]    end        subgraph 组织层        W[Wing
项目 / 领域]        R[Room
general / diary / decisions]        D[Drawer
具体记忆卡片]    end        subgraph 接口层        S[mempalace_search
语义搜索]        K[mempalace_kg_query
知识图谱查询]        A[mempalace_add_drawer
写入记忆]        W2[mempalace_diary_write
日记记录]    end        C --> S    C --> D    G --> K    G --> W    W --> R    R --> D    A --> D    W2 --> R

接入 Hermes 之后，记忆读写流程变成了：

sequenceDiagram    participant U as 用户    participant H as Hermes    participant MP as MemPalace    participant DB as ChromaDB + SQLite    U->>H: 发送消息    H->>MP: mempalace_search 语义搜索    MP->>DB: 向量相似度查询    DB-->>MP: 候选记忆列表    MP-->>H: 按相关度排序    H->>MP: mempalace_kg_query 实体关系查询    DB-->>H: 关联事实链    H->>H: 组装上下文    H-->>U: 携带记忆回复    Note over H,U: 后续写入    H->>MP: mempalace_add_drawer 新记忆    MP->>DB: 存入向量库 + 图数据库    DB-->>MP: 确认写入    MP-->>H: 完成

原则

改造后 Hermes 的记忆规则：

1. 读取全走 MemPalace — 每次收到消息，先搜索相关记忆，不依赖内置 key-value

2. 写入全走 MemPalace — 项目信息、用户偏好、待办事项，统统写入 MemPalace

3. cronjob 自动归档 — 每 30 分钟自动把 session 进展写入 diary room，防止断电丢失

内置 memory 工具仅保留一项职责：存储 MemPalace 的路径配置。

踩过的坑

1. 内置 memory 和 MemPalace 并存时的优先级

刚接进去时，两者都在，导致同一个信息存了两份，读取时有时候命中内置 memory，有时候命中 MemPalace，结果不稳定。解决办法是彻底禁用内置 memory 的写入通道，只保留读取用于兼容旧逻辑。

2. embedding 模型选择影响搜索质量

MemPalace 的搜索质量依赖 embedding 模型。最早用的模型对中文语义理解偏弱，"登录失败"和"认证异常"这类近义表述匹配不上。换了支持中文的 embedding 模型之后，召回率明显提升。

3. 知识图谱和向量搜索的分工

最初想把所有关系都塞进知识图谱，结果图数据膨胀得很快，查询延迟也上来了。后来把频繁更新、时序敏感的（如 session 进度）放在向量库，把稳定事实（项目路径、技术栈、用户偏好）放在知识图谱，分开查询再合并结果。

4. session 边界和记忆持久化的平衡

每次 session 结束，Hermes 内部状态会清理，但 MemPalace 是持久化的。最早没做 session 隔离，同一个 Wing 下的记忆被多个 session 交叉污染。后来每个 session 的进展单独写进 diary room，稳定的项目信息写进 general room，泾渭分明。

效果

换 session 之后，上下文还在。"之前做到哪"能答上来，"那个 401 错误怎么处理的"能找出来，"用户偏好截图要整屏不要只截二维码"不会被忘掉。

搜"认证失败"，能找到"登录异常"、“401”、"token 过期"相关内容，不用猜 key 是什么。

注意

• MemPalace 是本地存储，多设备使用需要自己处理同步

• embedding 模型决定搜索上限，选型要结合自己的语料

• 长期运行后 sqlite 会膨胀，需要定期归档清理

改造前后对比

结论：代价是多引入一个本地依赖，换来的是检索可靠性、跨 session 记忆延续、中文语义理解。值不值看场景——偶尔用一次的 agent，key-value 够用；每天几十个任务、跨多项目的，语义记忆是刚需。

如果你的 Agent 也面临同样问题，可以从 MemoryProvider 接口入手，接入任意支持向量检索的后端都行，不一定是 MemPalace。

Hello Hermes Agent

if let 控制流

枚举

结构体给予你将字段和数据聚合在一起的方法，像 Rectangle 结构体有 width 和 height 两个字段。而枚举给予你一个途径去声明某个值是一个集合中的一员。比如，我们想让 Rectangle 是一些形状的集合，包含 Circle 和 Triangle 。为了做到这个，Rust 提供了枚举类型。

#[derive(Debug)]
enum IpAddrKind {
    V4(u8,u8,u8,u8),
    V6(String),
}

#[derive(Debug)]
enum Message{
    Quit,
    Move{x: i32,y:i32},
    Write(String),
    ChangeColor(i32,i32,i32),
}

impl Message{
    fn call(&self){
        println!("self is {:?}",&self)
    }
}

fn main() {
    println!("Hello, world!");

    let four = IpAddrKind::V4(127,0,0,1);
    let six = IpAddrKind::V6(String::from("::1"));

    dbg!(&four);
    dbg!(&six);

    let m = Message::Move { x: 1, y: 2 };
    m.call();
}

match匹配模式

Option枚举

Option 是标准库定义的另一个枚举。Option 类型应用广泛因为它编码了一个非常普遍的场景，即一个值要么有值要么没值。

#[derive(Debug)]
enum Coin{
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn main() {
    println!("Hello, world!");
    let v = value_in_cents(Coin::Quarter);
    println!("value_in_cents(coin) = {}", v);
}

fn value_in_cents(coin: Coin) -> u32 {
    match coin {
        Coin::Penny => 1,
        Coin::Nickel => 5,
        Coin::Dime => 10,
        Coin::Quarter => 25,
    }
}

方法语法

方法（method）与函数类似：它们使用 fn 关键字和名称声明，可以拥有参数和返回值，同时包含在某处调用该方法时会执行的代码。不过方法与函数是不同的，因为它们在结构体的上下文中被定义（或者是枚举或 trait 对象的上下文，并且它们第一个参数总是 self，它代表调用该方法的结构体实例。

方法定义

使用impl块为结构定义方法；

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    fn area(&self) -> u32 {
        self.width * self.height
    }

  fn can_hold(&self,target: &Rectangle ) -> bool {
      self.width > target.width && self.height > target.height
    }

  // 关联函数经常被用作返回一个结构体新实例的构造函数。
  // 这些函数的名称通常为 new ，但 new 并不是一个关键字。
    fn square(size: u32) -> Self{
        Self {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let rect = Rectangle::square(30);

    let rect1 = Rectangle { width: 10, height: 30 };

    let rect2 = Rectangle { width: 60, height: 80 };
    dbg!(&rect);
    println!("The area of the rectangle is {} square pixels.", rect.area());
  println!("Can rect hold rect1? {}", rect.can_hold(&rect1));
    println!("Can rect hold rect2? {}", rect.can_hold(&rect2));
}

结构定义

定义结构体，需要使用 struct 关键字并为整个结构体提供一个名字。结构体的名字需要描述它所组合的数据的意义。接着，在大括号中，定义每一部分数据的名字和类型，我们称为 字段（field）。

以下演示了结构定义、打印对象、debug打印对象；

• 可以定义有字段和无字段结构，包括类似Tuple（元组）的方式定义；

• println!和dbg!打印对象需要在结构上添加外部属性 #[derive(Debug)]；

• dbg!宏打印需要注意值引用；

#[derive(Debug)]
struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}
#[derive(Debug)]
struct Color(i32,i32,i32);
#[derive(Debug)]
struct Point(i32,i32, i32);
#[derive(Debug)]
struct AlwaysEqual;

#[derive(Debug)]
struct Square(u32,u32);


fn main() {
    println!("Hello, world!");

    let mut user =  build_user("dong33@163.com","dong33");

    println!("user is {:?}",user);

    let mut user1 = User{
        active: true,
        username: user.username,
        email: user.email,
        sign_in_count: 1,
    };


    println!("user1 is {:?}",user1);
    dbg!(user1);

    let black = Color(0,0,0);


    println!("black is {:?}",black);
    dbg!(black);

    let origin = Point(0,0,0);

    println!("origin is {:?}",origin);
    dbg!(origin);

    let subject = AlwaysEqual;
    println!("subject is {:?}",subject);
    dbg!(subject);


    let width = 30;
    let height = 50;

    println!(" area is {}",area(width, height));


    let rect = Square(30,50);
    println!("rect is {:?}",rect);
    dbg!(&rect);


    println!("square area is {}",area_square(&rect));

}


fn build_user(email: &str,username: &str) -> User {
    User {
        active: true,
        username: String::from(username),
        email: String::from(email),
        sign_in_count: 1,
    }
}


fn area(width: u32,height: u32) -> u32{
    width * height
}


fn area_square(square: &Square) -> u32{
    square.0 * square.1
}

Cargo是什么？

Cargo是rust的构建工具、包管理器；

crate是什么？

  crate类似npm package或ruby gem，类似依赖包的意思；

rust和动态语言对比

rust库

std io标准库

let声明变量

let apples = 5; // 不可变
let mut bananas = 5; // 可变

整型

浮点型

Rust的浮点数类型是 f32和f64,分别占32位和64位，默认类型是f64

浮点数采用 IEEE-754 标准表示。f32 是单精度浮点数，f64 是双精度浮点数。

布尔型

Rust的布尔类型有两个值: true和false,使用 bool表示；

字符类型

Rust的 char类型是语言中原生的字符类型；使用 ''声明字符类型，字符串使用 ""声明；

复合类型

Rust有两个原生复合类型: 元组（tuple）和数组 （array）

元组 Tuple

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

数组 Array

let a: [i32; 5] = [1, 2, 3, 4, 5];

let first = a[0];
let end = a[4];

fn、main

fn用于声明函数，main函数为程序入口；

在函数声明中，必须声明每个参数的类型。

fn main(){
print_labeled_measurement(5,'h');
}

fn print_labeled_measurement(value: i32,unit_label: char){
  println!("The measurement is: {value}{unit_label}")
}

fn five() -> i32{
  5
}

语句和表达式的区别,语句需要;修饰，表达式不需要。

fn main() {
    let x = plus_one(5); //语句

    println!("The value of x is: {x}"); //语句
}

fn plus_one(x: i32) -> i32 {
    x + 1 //表达式
}

练习-斐波那契数列

fn main() {
    fibonacci(22);
}

fn fibonacci(n: i32) -> i32 {
    match n {
        0 => 0,
        1 =>1,
        2 => 1,
        _ => fibonacci(n-1) + fibonacci(n-2),
    }
}

注释

//这是第一行注释
//这是第二行注释
//这是第三行注释

文档注释

///这是第一行注释
///这是第二行注释
///这是第三行注释


//! #这是第一行注释
//!
//! ###这是第三行注释

if表达式

fn main(){
  let number = 3;
  if number < 3 {
    printlin!("Number is less than 3 ")
  }else{
     printlin!("Number is greater than or equal to 3 ")
  }
}

在let语句中使用if else

提示: if else的分支类型要匹配，否则会提示编译错误

fn main(){
let number = 3;
let result = if number >= 3 { 10 } else {0};
println!("The value of number is: {result}")
}

loop循环

fn main() {
    let mut  count = 0;

    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;

        loop{
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }

            if count == 2{
                break 'counting_up;
            }
            remaining -= 1;
        }
        count += 1;
    }

    println!("End count = {count}")

}

while循环

fn main(){
let mut number = 3;

    while number != 0 {
        println!("{number}");
        number -= 1;
    }

    println!("End");
}

for循环

fn main(){
let a = [10,20,30,40,50];

    for element in a {
        println!("the value is: {element}");
    }
}

match 分支

用于分支判断，类似其他语言的switch(condition){}

let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

const 常量

常量和其他语言类似，约定大写+_命名

所有权(ownership)

• 堆: 先进先出；

• 栈: 先进后出；

所有权规则

• rust 中的每一个值都有一个 owner；

• 值在任一时刻有且只有一个owner；

• 当owner离开作用域，这个值将被丢弃；

变量作用域

{                      // s 在这里无效，它尚未声明
        let s = "hello";   // 从此处起，s 是有效的
        // 使用 s
 }                      // 此作用域已结束，s 不再有效

String 类型

如果你在其他语言中听说过术语 浅拷贝（shallow copy）和 深拷贝（deep copy），那么拷贝指针、长度和容量而不拷贝数据可能听起来像浅拷贝。不过因为 Rust 同时使第一个变量无效了，这个操作被称为 移动（move），而不是叫做浅拷贝。上面的例子可以解读为 s1 被 移动 到了 s2 中。

let s1 = String::from("hello");
let s2 = s1;
  //-- value moved here
println!("{s1}");
//^^^^ value borrowed here after move

Copy类型

• 所有整数类型，比如 u32。

• 布尔类型，bool，它的值是 true 和 false。

• 所有浮点数类型，比如 f64。

• 字符类型，char。

• 元组，当且仅当其包含的类型也都实现 Copy 的时候。比如，(i32, i32) 实现了 Copy，但 (i32, String) 就没有。

引用（References）与借用

&语法让我们创建一个指向的引用，但并不拥有。

fn main() {
    let s1 = String::from("hello");

    let len = calculate_length(&s1);

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

& mut 可变引用，可修改应用的值；

限制:

• 在任意给定时间，要么 只能有一个可变引用，要么 只能有多个不可变引用。

• 引用必须总是有效的。

数据竞争（data race）类似于竞态条件，它可由这三个行为造成：

• 两个或更多指针同时访问同一数据。

• 至少有一个指针被用来写入数据。

• 没有同步数据访问的机制。

fn main() {
    let mut s1 = String::from("hello");
    change(&mut s1);

    println!("The length of '{}' is {}.", s1, s1.len());
}

fn change(s: &mut String){
    s.push_str(", world!!!!");
}

Slice类型

slice 允许你引用集合中一段连续的元素序列，而不用引用整个集合。slice 是一种引用，所以它没有所有权。

  Transformer模型最早是由Google的研究团队在2017年提出的，并在论文《Attention is All You Need》^[1] 中进行了详细的介绍。这个模型是为了解决自然语言处理（NLP）任务中的一些问题而设计的，特别是为了克服传统循环神经网络（RNN）和长短期记忆网络（LSTM）在处理长序列时的局限性，如梯度消失或梯度爆炸问题。

  Transformer模型的核心思想是使用自注意力机制（Self-Attention Mechanism）来捕捉输入序列中的依赖关系。这种机制允许模型在处理每个输入元素时，都能够关注到输入序列中的所有其他元素，从而能够捕捉到更长的依赖关系。此外，Transformer模型还采用了位置编码（Positional Encoding）来弥补模型本身不具备处理序列顺序的能力。

  Transformer模型由两部分组成：编码器（Encoder）和解码器（Decoder）。编码器负责将输入序列转换为一系列向量表示，而解码器则负责根据这些向量表示生成输出序列。这两部分都由多个相同的层堆叠而成，每一层都包含一个多头自注意力子层和一个简单的全连接前馈神经网络。

  由于Transformer模型不依赖RNN的顺序结构，因此它可以实现高效的并行化训练，这使得它在处理大规模数据集时具有显著的优势。此外，Transformer模型的强大表示能力和灵活性使得它在多个NLP任务上都取得了显著的效果，成为了自然语言处理领域的一种主流模型。

  总的来说，Transformer模型是Google研究团队在2017年提出的一种基于自注意力机制的深度学习模型，它的出现为自然语言处理领域的发展带来了革命性的突破。

引用:

• Text-to-SQL小白入门（一）

• Text-to-SQL小白入门（二）

原论文:

查看示例

如何安装

1. 安装revealjs-animated插件

npm install revealjs-animated

2. 在Reveal.js中初始化安装路径

//index.html
Reveal.initialize({
    dependencies: [
        // Other plugins
        {src: 'node_modules/revealjs-animated/dist/revealjs-animated.js', async: true}
    ]
});

如何使用？

居中移动动画

<!--html-->
<h1 id="titulo" class="fragment animated move-to-middle-top">居中</h1>

<!--md-->
# 居中<!-- .element: class="fragment animated move-to-middle-top" -->

属性

此动画不允许使用任何属性。

自定义位置移动动画

<!--html-->    
<p class="fragment animated move-to">默认参数</p>

<!--md-->
默认参数<!-- .element: class="fragment animated move-to" -->

属性

放大动画

<!--html-->    
<p class="fragment animated scale-up">放大</p>
<!--md-->
放大<!-- .element: class="fragment animated scale-up" -->

属性

缩小动画

<!--html-->    
<p class="fragment animated scale-down">缩小</p>
<!--md-->
缩小<!-- .element: class="fragment animated scale-down" -->

属性

旋转动画

<!--html-->    
<p class="fragment animated rotate">旋转</p>
<!--md-->
旋转<!-- .element: class="fragment animated rotate" -->

属性

时间属性

duration, iteration 和 fill 动画属性可以通过以下属性进行控制：

属性

组合动画

从1.2.0版本开始，可以将多个动画组合在一起以创建动画。只需要添加多个CSS类。

<!--html-->
<p class="fragment animated move-to-middle-top rotate">移动并旋转</p>
<!--md-->
移动并旋转<!-- .element: class="fragment animated  move-to-middle-top rotate" -->

时间属性 只能用于组合动画，不能单独用于每个动画；