这是一次真实的对话记录。作为一个 Java 程序员，我在调研"多数据源实体匹配"方案时，一步步追问 AI 底层原理，最终搞明白了大模型到底是怎么回事。没有数学公式，只有大白话。

---

第一章：我只是想合并两个数据库的数据

事情的起因很简单——我有多个数据源的数据，需要判断两条记录是不是同一个东西。

比如数据源 A 写的是"杭州西湖大酒店"，数据源 B 写的是"西湖大饭店（杭州）"。一个人一眼就能看出是同一家，但代码怎么判断？

传统做法是写一堆规则：

# 痛苦的规则匹配
if "酒店" in name or "饭店" in name or "宾馆" in name:
    # 当作同类...
if 去掉空格(地址A) == 去掉空格(地址B):
    # 当作同地址...
# 规则永远写不完...

有人告诉我，用向量数据库可以解决这个问题。把文本变成向量，计算余弦相似度，相似度高就是同一个东西。

听起来很酷，但我的第一个问题是——

---

第二章：“向量化不就是个公式吗？为什么模型文件有 400MB？”

我的直觉是：把文本变成一组数字，能有多复杂？一个哈希函数就行了吧？

# 我以为的"向量化"
向量 = hash("杭州西湖大酒店") % 768   # 几行代码，几 KB

但实际的 Embedding 模型文件动辄 400MB，有的甚至好几 GB。一个"公式"凭什么这么大？

答案让我重新理解了"模型"这个词——

模型文件大，不是因为代码多，而是因为"公式"里有 1 亿多个系数。

打个比方：

一元一次方程：y = 2x + 3
  需要存 2 个数字（2 和 3）→ 8 字节

Embedding 模型：y = W × x + b
  其中 W 是一个 768×768 的矩阵
  这样的矩阵有上百个
  总共需要存 1.02 亿个浮点数
  每个 float32 = 4 字节
  1.02 亿 × 4 = 391 MB

所以模型文件里装的不是代码，是一亿多个精心调校过的数字。代码本身只有几百行，但这些数字占了几百 MB。

就像一本书——目录只有几页（代码），正文有几千页（参数）。

那这一亿个数字是哪来的？这就涉及到模型训练了。

---

第三章：没有人告诉 AI"酒店=饭店"

这是让我最震撼的部分。

在我的认知里，要让程序知道"酒店"和"饭店"意思接近，要么写规则（同义词表），要么人工标注。但 AI 模型不需要。

它从海量文本中自己发现了这个规律。

原理出奇地简单——经常出现在相似上下文中的词，意思就应该相近。

你看中文互联网上的文本：

... 预订了一家 [酒店]，房间很干净 ...
... 预订了一家 [饭店]，房间很干净 ...
... 入住 [酒店] 后办理了登记 ...
... 入住 [饭店] 后办理了登记 ...

"酒店"和"饭店"周围出现的词几乎一模一样：预订、入住、房间、服务、前台…

模型只需要一个训练任务——完形填空：

原句："我 预订 了 一家 [???] 房间 很 干净"
让模型猜 [???] 是什么词

训练过程大概是这样的：

第一步：所有词的向量随机初始化

"酒店" → [0.52, -0.81, 0.13, ...]   随机
"饭店" → [-0.34, 0.67, -0.92, ...]  随机
此时两者的相似度 ≈ 0（毫无关系）

第二步：做完形填空，猜错就调参数

上下文 = ["预订", "一家", "房间", "干净"]
模型猜 = "汽车" ← 猜错了！

调整：让"酒店"的向量靠近这组上下文的向量
      让"汽车"的向量远离这组上下文的向量

第三步：大量重复

又遇到：
  "我 预订 了 一家 [饭店] 房间 很 干净"
  
上下文一模一样！所以 "饭店" 的向量也要向这个方向靠拢。

几十万次之后：
  "酒店" 不断向 ["预订","房间","入住","服务"] 靠拢
  "饭店" 也不断向 ["预订","房间","入住","服务"] 靠拢
  
  → 两者最终被拉到了向量空间中非常接近的位置！

如果你把训练前后的向量空间画出来，大概是这样的：

训练开始（随机位置）：           训练结束（语义位置）：

       汽车·                          酒店·饭店·宾馆
                                           
 酒店·                                         
             饭店·                   预订·入住·房间
                                           
     房间·                                   
         预订·                       汽车·驾驶·公路
               宾馆·                        

没有人写过一行规则说"酒店≈饭店"。模型从上下文的共现规律中，自己学到了这个语义关系。

这也是为什么向量化不是简单的"文本转数字"——它把人类语言的语义关系编码进了数字里。

---

第四章：我在自己的笔记本上微调了一个模型

理解了原理之后，我决定动手试试。

通用模型虽然已经知道"酒店≈饭店"，但它不知道我的业务术语。比如"标间"和"标准间"是酒店行业的说法，"含双早"和"含早餐"也是。我需要用自己的数据教它。

这就是所谓的"微调"（Fine-tuning）。

准备训练数据

格式很简单，就是"两句话 + 相似度打分"：

sentence1,sentence2,score
杭州西湖大酒店,西湖大饭店杭州,0.95
杭州西湖大酒店,上海浦东希尔顿,0.15
标准间,标间,1.0
含早餐,含双早,0.90
大床房,豪华大床房,0.85

我准备了大约 50 条数据。

选择基础模型

模型                     大小       适合场景
─────────────────────────────────────────
bge-small-zh-v1.5       130 MB    内存紧张（8GB）
m3e-base（我选的）       400 MB    新手首选，中文效果好
bge-large-zh-v1.5       1.3 GB    追求效果，需要 16GB+

400MB 的模型，普通笔记本完全能跑。

微调过程

python step3_finetune.py

屏幕上开始滚动日志：

[1/5] 加载 m3e-base 基础模型...
[2/5] 加载训练数据... 训练集: 40 条, 验证集: 5 条
[3/5] 配置训练参数...
[4/5] 开始训练...

Epoch 1/10: loss=0.2341
Epoch 2/10: loss=0.1523
Epoch 3/10: loss=0.0812
...
Epoch 10/10: loss=0.0156

✅ 微调完成！

CPU 上跑了大约 8 分钟。没有 GPU，没有云服务器，就在我的 MacBook 上。

效果对比

文本A          文本B          原始模型    微调后    变化
─────────────────────────────────────────────────────
标准间         标间           0.7823     0.9412    ↑ 提升明显
含早餐         含双早          0.7156     0.9034    ↑ 提升明显
海景房         海景大床房      0.8234     0.8756    ↑ 微调后泛化到没见过的数据
酒店入住       编程语言        0.1523     0.0987    ↓ 不相关的保持低分

50 条数据，8 分钟训练，零成本——就能让模型更懂我的业务。

---

第五章：那 ChatGPT 是怎么会写代码的？

搞明白了 Embedding 模型的原理后，我自然好奇：ChatGPT / Claude 这些大模型能写代码、能推理，又是怎么回事？

答案是——原理完全一样，只是规模大了几千倍。

Embedding 模型（如 m3e-base）         大语言模型（如 ChatGPT）
──────────────────────────           ──────────────────────
参数量：1 亿                          参数量：几千亿
训练数据：几十 GB                     训练数据：几 TB
输出：一组向量                         输出：逐字生成文本

大模型写代码时"脑子里"发生了什么？逐字预测下一个词：

你输入："写一个 Python 函数计算阶乘"

大模型的生成过程：

  已有：""
  → 预测下一个词："def"

  已有："def"
  → 预测下一个词："factorial"

  已有："def factorial"
  → 预测下一个词："("

  已有："def factorial("
  → 预测下一个词："n"

  已有："def factorial(n):\n    "
  → 预测下一个词："if"

  ... 一直到生成完整代码

每一步的"预测"都是基于几千亿个参数做的矩阵运算。它不是"理解"了代码然后"想出"答案——它是从海量代码数据中学到了**“在这个上下文里，下一个词最可能是什么”**。

这和 Embedding 模型从上下文学到"酒店≈饭店"是同一个原理，只是：

• 训练数据从几十 GB 变成了几 TB（包含 GitHub 上几百万个代码仓库）
• 参数从 1 亿变成了几千亿（有足够容量记住各种代码模式）
• 任务从"文本→向量"变成了"前文→下一个词"

---

第六章：AI 有"推理能力"吗？一个严肃的学术争论

在和 AI 对话时，我问了它一个直接的问题：“你说你的推理能力是规模到一定程度后自发出现的，这有可靠依据吗？”

AI 给了我一个诚实的回答：学术界对此存在激烈争论，目前没有定论。

正方观点：涌现能力确实存在

2022 年，Google 研究团队发表了论文 Emergent Abilities of Large Language Models（被引 3000+ 次）。

他们观察到一个现象——某些任务上，小模型完全不会，大到某个临界点后突然就会了：

以"多步算术"为例：

模型参数量       准确率
──────────────────
1 亿            ≈ 0%
10 亿           ≈ 0%
100 亿          ≈ 0%
1000 亿         突然跳到 40%+   ← 从不会到会的突变

他们把这种现象命名为**“涌现能力”（Emergent Abilities）**，暗示大模型可能会出现不可预测的新能力。

反方观点：涌现能力是"测量幻觉"

2023 年，Stanford 团队发表了 Are Emergent Abilities of Large Language Models a Mirage?，直接获得 NeurIPS 2023 杰出论文奖。

他们的反驳简洁有力："涌现"是评估标准造成的假象。

正方的评估方式：
  5 步算术，全部做对 = 1分，有任何一步错 = 0分（非此即彼）

小模型：每步正确率 60%，连续 5 步全对概率 = 0.6^5 = 7.8%  → 接近 0
大模型：每步正确率 95%，连续 5 步全对概率 = 0.95^5 = 77%  → 看起来"突然会了"

但如果换一种评估（按每步单独打分）：
  小模型：60%
  中模型：75%
  大模型：95%
  → 其实是平滑渐进的，根本没有"突变"

用一个比喻：一个学生从 50 分进步到 59 分，“不及格→不及格”，看不出变化。从 59 分进步到 60 分，“不及格→及格！”，看起来"突然就会了"。其实每次都进步了 1 分，"突变"是及格线造成的假象。

所以到底谁对？

目前学术界倾向于一个中间立场：

✓ 广泛接受：模型能力随规模平滑增长，不存在真正的"从无到有"
✓ 广泛接受：评估指标确实会制造"突变"假象
✓ 多数接受：但复杂任务需要多种基础能力组合，存在"组合门槛"
✓ 多数接受："涌现"这个词容易误导，暗示了不必要的神秘性

---

第七章：如何正确认识 AI

经过这次深入探索，我对 AI 形成了几个认知：

1. AI 不神秘

它的核心就是矩阵乘法 + 概率预测。Embedding 模型用 1 亿个参数做完形填空，大语言模型用几千亿个参数预测下一个词。原理并不复杂，复杂的是规模。

2. AI 的"知识"全部来自训练数据

它不会凭空产生知识。知道"酒店≈饭店"是因为训练语料里这两个词总出现在一起。会写 Python 是因为训练数据里有几百万个 Python 项目。它的边界就是训练数据的边界。

3. AI 不是在"思考"，是在"预测"

当 AI 写出一段完美的代码时，它并没有"理解"这段代码要做什么。它做的事情是：根据你的问题（上下文），预测最可能的下一个字，一个字一个字地拼出答案。就像一个对棋谱倒背如流的人，可以下出很好的棋，但他可能并不"理解"每步棋的深层含义。

4. "涌现"没有那么神秘

大模型表现出的"推理能力"，更可能是大量基础模式匹配的组合，而不是什么神秘的智能突变。就像一个人读了 100 万篇代码，自然能写出不错的代码——这不叫"涌现"，这叫"熟能生巧"。

5. AI 是工具，而且是可以定制的工具

最让我兴奋的是——我可以用 50 条数据、8 分钟时间、零成本，让一个模型变得更懂我的业务。 这不是只有大公司才能做的事情。任何一个程序员，在自己的笔记本上，都可以微调一个专属模型。

---

写在最后

这次对话改变了我对 AI 的认知。

之前觉得 AI 是黑盒，是魔法，是只有博士才能理解的东西。现在我知道，它的本质就是：

一个巨大的"公式"，里面有几亿到几千亿个精心调校过的系数。这些系数是从海量数据中，通过反复"完形填空"训练出来的。系数越多、数据越大，"公式"就越准。

仅此而已。

不需要敬畏，不需要恐惧，但值得尊重——毕竟，让一堆矩阵乘法学会人类语言，这件事本身就足够精彩了。

---

如果你也想动手试试微调一个 Embedding 模型，我把完整的可运行代码放在了 embedding-finetune 目录下。四个脚本，按顺序跑就行。