01 向量与余弦相似度：AI 如何判断"意思相近"

复习文档 · ADHD友好 · 从零开始

本章学到哪里，不学到哪里#

本章只学习：向量、点积、范数、归一化和余弦相似度之间的关系，并用两个短向量验证公式。

本章暂时不学习：Embedding 模型训练、向量数据库索引、ANN 算法、分块策略和完整 RAG。它们会使用本章的相似度思想，但不是本章的实现目标。

一句话理解#

Embedding 把文本变成固定长度的数字向量，余弦相似度比较两个向量的方向，从而作为语义检索的一个相似度信号。

它在 AI 应用中的位置#

1
文本
2
  -> Embedding 模型
3
  -> 向量
4
  -> 余弦相似度
5
  -> 排序相似文本
6
  -> RAG 检索 / 推荐 / 去重 / 聚类

余弦相似度只负责“比较两个已经存在的向量”，不负责生成向量，也不负责从数据库取出文档。在 RAG 中，向量模型和向量数据库分别是它的前后环节。

最小验证例子#

下面只使用 Python 标准库 math，不需要安装额外依赖：

1
from math import sqrt
2

3

4
def cosine_similarity(a: list[float], b: list[float]) -> float:
5
    if len(a) != len(b):
6
        raise ValueError("两个向量的维度必须一致")
7

8
    dot = sum(x * y for x, y in zip(a, b))
9
    norm_a = sqrt(sum(x * x for x in a))
10
    norm_b = sqrt(sum(y * y for y in b))
11
    if norm_a == 0 or norm_b == 0:
12
        raise ValueError("零向量没有可比较的方向")
13
    return dot / (norm_a * norm_b)
14

15

16
print(cosine_similarity([3, 2], [6, 4]))  # 接近 1：方向相同
17
print(cosine_similarity([1, 0], [0, 1]))  # 0：方向垂直

验证重点不是背出小数，而是观察：同方向的向量即使长度不同，结果仍接近 1；维度不同或出现零向量时，函数应拒绝计算。

🔧 准确术语速查#

术语	准确含义	本章对应
Vector	向量，一组有方向和长度的数字	`[3, 2]`
Component	分量，向量里的每个数字	`3` 和 `2`
Dot product	点积，逐位相乘再求和	`a1b1 + a2b2`
Norm	向量长度，多维勾股定理	`sqrt(x^2 + y^2)`
Cosine similarity	余弦相似度，比较方向接近程度	`dot / (norm_a * norm_b)`
Normalization	归一化，消除尺度影响	除以长度，保留方向

一、先记住这张速查表#

概念	一句话	类比
向量	一根箭，等于一个列表/元组	去超市路线：[向东3步, 向北2步]
分量	列表里每个数字	每个方向各走几步
平方	自己乘自己	3² = 3×3 = 9
开根号	平方的反操作	√9 = 3（因为3×3=9）
勾股定理	横²+竖²=对角线²	房间宽3长4，对角线=5
norm	多维勾股定理，量箭的长度	所有分量平方加起来再开根号
点积	逐位相乘再求和	两根箭在同上方向的”重叠量”
余弦相似度	点积/(长度×长度)，削掉长度比方向	只看口味比例，不看吃多少

二、从零开始：向量是什么#

1
向量 = 一根箭 = 一个列表
2

3
  vec_a = [3, 2]
4

5
  意思是：向右走3步，向上走2步
6
  画出来就是一根从原点出发的箭
7

8
       2 ↑
9
         │ ● ← 箭头
10
         │╱
11
       1 │
12
    ─────┼──────3──→
13
         0    1    2    3

1
类比：
2

3
  去超市的路线 = [3, 2]
4
    第1个分量(3) = 向东走3条街
5
    第2个分量(2) = 向北走2条街
6

7
  去医院的路线 = [1, 4]
8
    第1个分量(1) = 向东走1条街
9
    第2个分量(4) = 向北走4条街
10

11
  两根箭指向不同方向 = 两句话说的是不同内容

1
关键：Embedding模型生成的向量维度永远固定！
2

3
  模型输出 1024 维 → 不管你输入什么句子，输出永远是1024个数字
4
  模型输出 1536 维 → 永远是1536个数字
5

6
  维度多 = 描述更精细 = 足以区分不同语义

三、平方和开根号#

平方 = 自己乘自己#

1
3² = 3 × 3 = 9
2
2² = 2 × 2 = 4
3
0.9² = 0.9 × 0.9 = 0.81
4
(-3)² = (-3) × (-3) = 9    ← 负数平方也变正数！

开根号 = 平方的反操作#

1
√4 = 2      因为 2×2=4
2
√9 = 3      因为 3×3=9
3
√25 = 5     因为 5×5=25
4
√2 ≈ 1.414  因为 1.414×1.414≈2

1
平方 = "放大"：3 → 3×3 → 9
2
开根号 = "还原"：9 → "谁×自己=9" → 3

注意区分！开根号 ≠ 除法#

1
开根号：√9 = 3    （问谁×自己=9）
2
除法：  9÷3 = 3   （把9分成3份）
3

4
数字碰巧一样，但操作完全不同！
5

6
验证：√15 ≈ 3.87，但 15÷3 = 5
7
→ 3.87 ≠ 5，显然不是一回事

四、勾股定理 = 量对角线#

1
一个房间宽3米、长4米
2
从左下角走到右上角的对角线有多远？
3

4
              ● ← 右上角
5
             ╱│
6
        对角线╱ │4米（竖边）
7
           ╱  │
8
   左下角 ●───┘
9
          3米（横边）
10

11
对角线 = √(横边² + 竖边²)
12
       = √(3² + 4²)
13
       = √(9 + 16)
14
       = √25
15
       = 5米

1
一句话记一辈子：
2

3
  横² + 竖² = 对角线²

五、norm = 多维勾股定理 = 量箭的长度#

5.1 先认清”分量”和”分量平方”#

1
向量 A = [3, 2]
2
         ↑  ↑
3
         这两个数字都叫"分量"（Component）
4

5
A[0] = 3  ← 第 0 个分量
6
A[1] = 2  ← 第 1 个分量

分量平方 = 每个分量自己乘自己：

1
向量 A = [3, 2]
2

3
分量平方：
4
  3² = 3×3 = 9
5
  2² = 2×2 = 4

为什么需要分量平方？ 因为分量可能是负数（向左走、向下走），但长度不能是负数。平方让负数变正：

1
向量 [-3, -2]  （向左3，向下2）
2

3
直接加：-3 + (-2) = -5  ❌ 长度不能是负的
4

5
平方后加：(-3)² + (-2)² = 9 + 4 = 13  ✅ 永远是正数

5.2 norm = 分量平方之和再开根号#

1
2维向量：norm = √(分量1² + 分量2²)
2

3
  vec_a = [3, 2]
4
  norm = √(3² + 2²) = √(9+4) = √13 ≈ 3.61
5

6
  横着走了3步，竖着走了2步
7
  箭的长度 = 3.61步

完整三步：

1
第1步：每个分量平方
2
  3² = 9, 2² = 4
3

4
第2步：全部加起来
5
  9 + 4 = 13
6

7
第3步：开平方根
8
  √13 ≈ 3.61   ← 这就是 norm(A)

为什么最后要开根号？ 因为前两步（平方+求和）把数字放大了，开根号把它缩回真正的”箭长”。这是勾股定理：横²+竖²=对角线²，所以对角线 = √(横²+竖²)。

1
5维向量：norm = √(分1² + 分2² + 分3² + 分4² + 分5²)
2

3
  vec = [0.9, 0.8, 0.7, 0.1, 0.2]
4

5
  norm = √(0.81 + 0.64 + 0.49 + 0.01 + 0.04)
6
       = √(1.99)
7
       ≈ 1.41
8

9
  逻辑完全一样！只是加了5个数字而不是2个

1
1024维也一样：√(分1² + 分2² + ... + 分1024²)
2

3
  维度再多，本质不变
4
  就是勾股定理的扩展版

六、点积 = 逐位乘再求和#

1
A = [3, 2]
2
B = [2.8, 1.9]
3

4
点积 = 3 × 2.8  +  2 × 1.9
5
      = 8.4     +  3.8
6
      = 12.2

1
步骤拆解：
2

3
  第1步：同一位置的两个数字相乘
4
    位置0：3 × 2.8 = 8.4
5
    位置1：2 × 1.9 = 3.8
6

7
  第2步：所有乘积加起来
8
    8.4 + 3.8 = 12.2 → 点积
9

10
  乘 = 该方向上两箭的重叠程度（都强→乘积大）
11
  加 = 所有方向的总重叠量

1
5维向量也一样：
2

3
  A = [0.9, 0.8, 0.7, 0.1, 0.2]
4
  B = [0.85, 0.75, 0.65, 0.15, 0.25]
5

6
  点积 = 0.9×0.85 + 0.8×0.75 + 0.7×0.65 + 0.1×0.15 + 0.2×0.25
7
        = 0.765 + 0.6 + 0.455 + 0.015 + 0.05
8
        = 1.885
9

10
  逻辑完全一样！只是乘了5次而不是2次

注意：点积不能单独判断相似性！#

1
A = [3, 2]       长度 ≈ 3.61
2
B = [2.8, 1.9]   长度 ≈ 3.38  方向一致
3
点积 = 12.2
4

5
C = [100, 66.7]  长度 ≈ 121    方向也一致
6
点积 = 433.4
7

8
单看点积：12.2 vs 433.4 → 差很多！
9
但A vs B 和 A vs C 方向其实一样！
10

11
→ 点积混了"长度"信息，必须削掉

七、余弦相似度 = 削掉长度比方向 = 最终答案#

7.1 公式（重要：方向别记反！）#

1
余弦相似度 = 点积 ÷ (norm(A) × norm(B))
2
            ↑               ↑
3
          分子(上面)      分母(下面)
4

5
❌ 错误：norm(A) × norm(B) ÷ 点积
6
✅ 正确：点积 ÷ (norm(A) × norm(B))

为什么是除以而不是乘？ 因为点积里”沾了”长度信息，要除掉它才能还原出”纯方向相似度”。

1
类比：
2
你称体重，但称上沾了泥（多了 2 kg）
3
真实体重 = 称出来的数 - 2    ← 减掉/除掉多余的部分
4
                       不是 + 2

7.2 完整流程三步#

1
余弦相似度 = 点积 / (norm(A) × norm(B))
2

3
           = 逐位乘再求和 / (A长度 × B长度)
4

5
           = 削掉长度，只剩方向

走一个完整例子#

1
A = [3, 2]       ← "代码质量"
2
B = [2.8, 1.9]   ← "程序维护"
3
C = [0.5, 4]     ← "天气"
4

5
步骤1：算长度（norm = 勾股定理）
6
  norm(A) = √(3²+2²)     = √13 ≈ 3.61
7
  norm(B) = √(2.8²+1.9²) = √11.45 ≈ 3.38
8
  norm(C) = √(0.5²+4²)   = √16.25 ≈ 4.03
9

10
步骤2：算重叠（点积 = 逐位乘再求和）
11
  dot(A,B) = 3×2.8 + 2×1.9   = 8.4 + 3.8   = 12.2
12
  dot(A,C) = 3×0.5 + 2×4     = 1.5 + 8     = 9.5
13

14
步骤3：削掉长度得相似度
15
  A vs B = 12.2 / (3.61 × 3.38) = 12.2 / 12.21 ≈ 1.00 ✅
16
  A vs C = 9.5  / (3.61 × 4.03) = 9.5  / 14.49 ≈ 0.66

结果解读#

相似度	含义	例子
~1.0	方向完全一致	”代码质量” vs “程序维护”
0.8-0.9	非常相似
0.6-0.7	比较相似	”代码质量” vs “天气”（不同，但有微弱关联）
0.3-0.5	有点关系
<0.3	基本无关
0	完全无关	垂直方向（手电筒照墙90度）

八、三步完整对比图#

1
                    A向量            B向量
2
                    [3,2]          [2.8,1.9]
3
                      │               │
4
                      ▼               ▼
5
              ┌──────────┐    ┌──────────────┐
6
    步骤1     │ 勾股定理  │    │  勾股定理     │
7
  (量长度)    │norm(A)=   │    │  norm(B)=    │
8
              │√(3²+2²)  │    │ √(2.8²+1.9²)│
9
              │≈ 3.61    │    │ ≈ 3.38       │
10
              └──────────┘    └──────────────┘
11
                      │               │
12
                      └───────┬───────┘
13
                              │
14
                              ▼
15
              ┌───────────────────────────┐
16
    步骤2     │          点积              │
17
  (算重叠)    │   dot = 3×2.8 + 2×1.9     │
18
              │       = 12.2              │
19
              └───────────────────────────┘
20
                              │
21
                              ▼
22
              ┌───────────────────────────┐
23
    步骤3     │   余弦相似度               │
24
  (削长度)    │  12.2 / (3.61 × 3.38)     │
25
              │  = 12.2 / 12.21           │
26
              │  ≈ 1.00  ✅ 非常相似！     │
27
              └───────────────────────────┘

九、Python 代码速查#

1
import numpy as np
2

3
# 两个向量
4
a = np.array([3, 2])
5
b = np.array([2.8, 1.9])
6

7
# 步骤1：算长度（norm）
8
len_a = np.linalg.norm(a)  # √(9+4) ≈ 3.61
9
len_b = np.linalg.norm(b)  # √(7.84+3.61) ≈ 3.38
10

11
# 步骤2：算点积
12
dot = np.dot(a, b)         # 3×2.8 + 2×1.9 = 12.2
13

14
# 步骤3：余弦相似度
15
cosine = dot / (len_a * len_b)  # ≈ 1.0

一句代码版#

1
def cosine_similarity(a, b):
2
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

十、给 Embedding 的类比#

1
"如何提升代码质量"    → Embedding模型 → 向量A → 一根箭（朝"编程"方向）
2
"今天天气真好"        → Embedding模型 → 向量B → 一根箭（朝"天气"方向）
3

4
两根箭方向差很远 → 余弦相似度低 → 语义不同
5
两根箭方向很近   → 余弦相似度高 → 语义相近
6

7
这就是 AI 判断"意思相近"的数学原理！

✅ 检查清单#

向量 = 一根箭 = 一个列表/元组
分量 = 列表里的每个数字
平方 = 自己乘自己；开根号 = 平方的反操作
勾股定理 = 横²+竖²=对角线²（2维特殊版）
norm = 多维勾股定理 = 量箭的长度
点积 = 逐位乘再求和 = 两根箭的重叠量
余弦相似度 = 点积 ÷ (A长度×B长度) = 削掉长度比方向
越接近1 → 越相似；越接近0 → 越无关
同一模型输出的向量维度永远一样，不会出现长度不同

十一、深入理解：为什么除以长度能削掉倍数#

问题的核心#

1
A = [3, 2]
2
B = [100, 66.7] = 33.3 × A   ← B是A放大33.3倍，方向完全相同
3

4
问：如何计算相似度，让结果不受"33.3倍"影响？

第一步：观察点积里的倍数#

1
np.dot(A, B)
2
= 3×100 + 2×66.7
3
= 3×(33.3×3) + 2×(33.3×2)    ← 代入 B = k×A

用乘法交换律提取k：

1
3×(33.3×3)
2
= 3×33.3×3           ← 去括号（结合律）
3
= 33.3×3×3           ← 交换律：3和33.3换位置
4
= 33.3×(3×3)
5
= 33.3×9
6

7
2×(33.3×2)
8
= 2×33.3×2
9
= 33.3×2×2
10
= 33.3×(2×2)
11
= 33.3×4

提取公因数（分配律）：

1
np.dot(A, B)
2
= 33.3×9 + 33.3×4
3
= 33.3 × (9 + 4)     ← 提取公因数33.3
4
= 33.3 × 13
5
= k × np.dot(A, A)   ← 点积里混进了倍数k！

第二步：观察norm里的倍数#

1
norm(B)
2
= √(100² + 66.7²)
3
= √((33.3×3)² + (33.3×2)²)
4
= √(33.3²×9 + 33.3²×4)
5
= √(33.3² × (9+4))
6
= √(33.3² × 13)
7
= 33.3 × √13
8
= 33.3 × norm(A)
9
= k × norm(A)         ← norm里也混进了倍数k！

第三步：相除消掉k#

1
余弦相似度 = dot(A,B) / (norm(A) × norm(B))
2

3
分子：k × np.dot(A,A) = k × (3×3 + 2×2) = k × 13
4
分母：norm(A) × k × norm(A) = k × norm(A)² = k × (√13)² = k × 13
5

6
= (k × 13) / (k × 13)     ← k在分子分母都有！
7
= k/k × 13/13
8
= 1 × 1
9
= 1.0                      ← k被消掉了！
10

11
关键：norm(A)² = dot(A, A)，等式两边严格相等！
12
     norm(A)² = (√(3²+2²))² = 3²+2² = 9+4 = 13 = dot(A, A)
13
     所以不需要用近似值3.61，用精确的13就能完美消掉！

一句话总结#

位置	计算结果	倍数k在哪
分子 dot(A,B)	433.4	`33.3 × 13` ← 这里！
分母 norm(A)	3.61	没有k
分母 norm(B)	120.2	`33.3 × 3.61` ← 这里！
相除结果	1.0	k/k=1，消了！

1
433.4 / (3.61 × 120.2)
2
≈ (33.3×13) / (√13 × 33.3×√13)    ← 不用3.61，用精确的√13
3
= 33.3/33.3 × 13/(√13×√13)         ← k/k 消掉，后面 √13×√13 = 13
4
= 1 × 13/13
5
= 1 × 1
6
≈ 1.0                               ← 用精确值算出来就是严格的1

核心洞察：倍数k同时污染了分子和分母，一除就没了，结果只反映方向！

十二、数学定律速查#

乘法交换律#

1
a × b = b × a
2

3
例子：
4
  3 × 5 = 15
5
  5 × 3 = 15
6
  → 相同！
7

8
在点积中：
9
  3 × (33.3 × 3) = 33.3 × (3 × 3)
10
  把33.3提到前面

乘法结合律#

1
(a × b) × c = a × (b × c)
2

3
例子：
4
  (2 × 3) × 4 = 6 × 4 = 24
5
  2 × (3 × 4) = 2 × 12 = 24
6
  → 相同！
7

8
在norm中：
9
  √((33.3×3)² + (33.3×2)²)
10
  = √(33.3² × (3² + 2²))
11
  = 33.3 × √(3² + 2²)

提取公因数（分配律逆用）#

1
a × b + a × c = a × (b + c)
2

3
例子：
4
  5 × 7 + 5 × 3
5
  = 5 × (7 + 3)
6
  = 5 × 10
7
  = 50
8

9
在点积中：
10
  33.3×9 + 33.3×4
11
  = 33.3 × (9 + 4)
12
  = 33.3 × 13

十三、归一化的数学思想#

什么是归一化#

1
归一化 = 把不同尺度的东西拉到同一标准下再比较
2

3
例子1：打分
4
  小明：85/100分
5
  小红：42/50分
6
  归一化：都转成百分制 → 85% vs 84%
7

8
例子2：房价
9
  北京：800万/100平 = 8万/平
10
  小城市：80万/100平 = 0.8万/平
11
  归一化：每平米价格，公平比较

在向量里#

1
问题：两根箭长度不同，直接比不公平
2
  A = [3, 2]，长度3.61
3
  B = [100, 66.7]，长度120.2（是A的33.3倍）
4

5
  但方向完全相同！
6

7
解决：除以norm，削成单位长度1
8
  削后A = [3/3.61, 2/3.61] = [0.83, 0.55]
9
  削后B = [100/120.2, 66.7/120.2] = [0.83, 0.55]
10

11
  → 削完完全相同！都是[0.83, 0.55]
12

13
结果：余弦相似度 = 1.0，正确反映方向相同！

一句话#

1
归一化 = 削掉长度的影响，只比方向
2

3
在AI中无处不在：
4
  - 距离归一化
5
  - 数据标准化
6
  - 概率归一化（softmax）
7
  - 余弦相似度
8

9
核心思想：只要标准一致，不管尺度大小

十三·补、归一化与余弦相似度的关系（为什么归一化后点积就是余弦相似度）#

1. 先回顾两个公式#

1
余弦相似度公式：
2
  cosine(A, B) = dot(A, B) ÷ (norm(A) × norm(B))
3
                  ↑               ↑
4
               点积(分子)      两个范数相乘(分母)
5

6
归一化定义：
7
  A' = A ÷ norm(A)
8
  B' = B ÷ norm(B)

2. 归一化后范数必然是 1（数学证明）#

1
设 A = [a, b]，norm(A) = √(a² + b²) = N
2

3
归一化后 A' = [a/N, b/N]
4

5
  norm(A') = √((a/N)² + (b/N)²)
6
           = √(a²/N² + b²/N²)        ← 平方后 N² 在分母
7
           = √((a² + b²) / N²)       ← 合并分子
8
           = √(N² / N²)              ← 因为 a² + b² = N²（范数定义）
9
           = √1
10
           = 1  ✅
11

12
→ 任何向量归一化后，范数必然是 1
13
→ 任何数除以自己都等于 1，所以这是数学必然

3. 范数变 1 → 分母变 1 → 余弦相似度 = 点积#

1
归一化后：
2
  norm(A') = 1
3
  norm(B') = 1
4

5
代入余弦相似度公式：
6
  cosine(A', B') = dot(A', B') ÷ (norm(A') × norm(B'))
7
                 = dot(A', B') ÷ (1 × 1)
8
                 = dot(A', B') ÷ 1
9
                 = dot(A', B')   ✅
10

11
→ 归一化后，余弦相似度 = 点积
12
→ 因为分母 (1×1=1)，除以 1 等于没除

4. 关键洞察：除法被”提前”了#

1
不归一化（除法在阶段 2，检索时做）：
2
  阶段 1：无
3
  阶段 2：dot(A, B) ÷ (norm(A) × norm(B))
4
                        ↑
5
                     除法在这（每次检索都要做）
6

7
归一化（除法在阶段 1，灌库时做）：
8
  阶段 1：A' = A ÷ norm(A)，B' = B ÷ norm(B)
9
                     ↑                    ↑
10
                  除法搬到这了（一次性做完，存起来）
11

12
  阶段 2：dot(A', B')
13
          ↑
14
       没有除法，只算点积

除法没消失，只是从阶段 2 搬到阶段 1。

5. 数学等价性证明#

1
归一化后的点积：
2
  dot(A', B')
3
  = dot(A÷norm(A), B÷norm(B))
4
  = (A[0]÷norm(A))×(B[0]÷norm(B)) + (A[1]÷norm(A))×(B[1]÷norm(B))
5
  = (A[0]×B[0])÷(norm(A)×norm(B)) + (A[1]×B[1])÷(norm(A)×norm(B))
6
  = [(A[0]×B[0]) + (A[1]×B[1])] ÷ (norm(A)×norm(B))   ← 分母提取出来
7
  = dot(A, B) ÷ (norm(A) × norm(B))                    ← 跟原公式一样！
8

9
→ 两种做法数学结果完全相同

6. 用具体数字验证#

1
原始向量：
2
  A = [3, 4]      norm(A) = 5
3
  B = [6, 7]      norm(B) = √85 ≈ 9.22
4

5
做法 1：不归一化（阶段 2 做除法）
6
  dot(A, B) = 3×6 + 4×7 = 46
7
  余弦 = 46 ÷ (5 × 9.22) = 46 ÷ 46.1 ≈ 0.998
8

9
做法 2：归一化（阶段 1 做除法）
10
  A' = [3÷5, 4÷5] = [0.6, 0.8]
11
  B' = [6÷9.22, 7÷9.22] ≈ [0.65, 0.76]
12
  dot(A', B') = 0.6×0.65 + 0.8×0.76 = 0.998
13

14
两种做法结果都是 0.998 ✅

7. 为什么要”提前”做除法？（性能优势）#

1
场景：知识库有 1 万个文档，用户问一个问题
2

3
不归一化（每次检索都要算）：
4
  对每个文档：dot(Q, D) ÷ (norm(Q) × norm(D))
5
                          ↑
6
                       1 万次 norm 计算 + 1 万次除法
7

8
归一化（提前算好，检索只算点积）：
9
  灌库时：D' = D ÷ norm(D)    ← 每个文档算 1 次，存起来
10
  查询时：Q' = Q ÷ norm(Q)    ← 算 1 次
11

12
  对每个文档：dot(Q', D')      ← 只算点积，不用算 norm，不用除
13

14
省掉了：1 万次 norm 计算 + 1 万次除法

8. 类比理解#

1
不归一化 = 每次去超市都现量苹果重量，再算总价
2
  顾客1：0.3kg × 10元 = 3元    ← 称重 + 乘法
3
  顾客2：0.5kg × 10元 = 5元    ← 称重 + 乘法
4
  （每次都要称重，慢）
5

6
归一化 = 提前把苹果标成"1斤袋"，单价提前算好
7
  阶段 1：1斤装 × 10元/斤 = 10元/袋   ← 除法（分装）在这
8
  阶段 2：顾客买 3袋 = 30元           ← 只数袋数，不称重，快
9

10
除法（分装）没消失，只是从"每次结账"搬到"提前分装"
11
结账时只算袋数×单价，快很多

9. 在项目里的对应#

1
# 阶段 1 在这里发生（模型内部自动归一化）
2
model.encode(
3
    "test",
4
    convert_to_numpy=True,
5
    normalize_embeddings=True,   # ← 阶段 1：向量 ÷ norm，长度变 1
6
)
7

8
# app/tools/kb_search.py
9
# 阶段 2 在这里发生（ChromaDB 内部算点积）
10
docs = get_vector_store().similarity_search(query, k=safe_limit)
11
#                                       ↑
12
#                   阶段 2：对归一化向量算点积 = 余弦相似度

10. 关键前提：文档和查询必须一致#

1
文档端：normalize_embeddings=True  → 存的向量长度都是 1
2
查询端：normalize_embeddings=True  → 查的向量长度也是 1
3

4
两边一致 → 点积 = 余弦相似度  ✅
5

6
如果一边开一边不开：
7
  文档长度 1，查询长度 3.61
8
  dot(Q, D) ÷ (1 × 3.61) = 点积 / 3.61  ❌ 不是余弦相似度

项目里 get_query_embedding 和 get_document_embedding 都用 normalize_embeddings=True，保持一致。

11. 一句话总结#

1
归一化 = 把余弦相似度的除法"提前"到算点积之前
2

3
数学等价：dot(A÷n_a, B÷n_b) = dot(A,B) ÷ (n_a × n_b)
4
原因：归一化后范数都是 1，分母 (1×1=1)，除以 1 等于没除
5
好处：除法只做一次（灌库时），检索时只算点积，快很多
6
前提：文档和查询必须都开归一化（或都不开），不能一边开一边不开

十四、代码 vs 数学原理#

层面	做了什么	看到k了吗
代码执行	直接乘除	❌ 看不到k
数学原理	提取公因数、消掉k	✅ 能看到k被消

1
# 代码：直接算
2
def cosine_similarity(a, b):
3
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
4

5
# 数学原理：k被消掉了
6
cosine = (k × dot(A,A)) / (norm(A) × k × norm(A))
7
       = k/k × dot(A,A)/norm(A)²
8
       = 1 × dot(A,A)/norm(A)²
9

10
# 结果一样，原理解释了"为什么长度不影响结果"

结论：代码直接乘除，但背后的数学原理就是提取公因数和消掉倍数k。

十五、完整思维导图#

1
对比两句话相似度
2
      │
3
      ▼
4
调用Embedding模型 → 获得两个向量列表
5
      │
6
      ▼
7
┌─────────────────┐
8
│  A = [3, 2]     │
9
│  B = [100, 66.7]│  ← B = k×A，k=33.3
10
└─────────────────┘
11
      │
12
      ├─→ 点积 dot(A,B) = 3×100 + 2×66.7
13
      │              = 3×(k×3) + 2×(k×2)
14
      │              = k×(3×3) + k×(2×2)  ← 交换律
15
      │              = k × (9 + 4)        ← 提取公因数
16
      │              = k × 13             ← 混进k！
17
      │
18
      ├─→ norm(A) = √(3²+2²) = 3.61
19
      │
20
      ├─→ norm(B) = √(100²+66.7²)
21
      │           = √((k×3)² + (k×2)²)
22
      │           = √(k² × (3²+2²))
23
      │           = k × √(3²+2²)
24
      │           = k × 3.61            ← 也混进k！
25
      │
26
      ▼
27
余弦 = dot / (norm(A) × norm(B))
28
     = (k×13) / (3.61 × k×3.61)
29
     = k/k × 13/(3.61×3.61)           ← k消掉了！
30
     = 1 × 1
31
     = 1.0  ✅ 方向相同！

✅ 完整检查清单#

基础概念#

向量 = 一根箭 = 一个列表
分量 = 列表里的每个数字
平方 = 自己乘自己；开根号 = 平方的反操作
勾股定理 = 横²+竖²=对角线²
norm = 多维勾股定理 = 量箭的长度
点积 = 逐位乘再求和
余弦相似度 = 点积÷(长度×长度)

数学定律#

乘法交换律：a×b = b×a，可以换位置
乘法结合律：(a×b)×c = a×(b×c)，可以换括号
提取公因数：a×b + a×c = a×(b+c)，把相同提出来

核心原理#

点积里混进了倍数k（因为B=k×A）
norm(B)里也混进了倍数k
相除时k/k=1，倍数被消掉
结果只反映方向，不受长度影响
这就是归一化的数学思想

✅ 四条理解标准#

思想是什么：把文本变成向量后，用方向是否接近来判断语义是否接近。
干什么：给 RAG 检索、推荐、聚类等任务提供“相似度”计算方法。
为什么这么干：只看点积会被长度影响，余弦相似度通过除以长度消掉倍数。
怎么干：能写出 dot / (norm_a * norm_b)，并能解释点积、norm、归一化各自的作用。

⚠️ 常见坑#

坑	现象	正确做法
把点积当相似度最终答案	长向量天然分数更大	用余弦相似度消掉长度影响
以为开根号是除法	norm 推导卡住	开根号是平方的反操作
忽略分母为 0	空向量计算报错或无意义	真实代码里先检查 norm 是否为 0
把数学公式和代码割裂	会背公式但不会写函数	对照 `dot`、`norm`、`cosine_similarity` 三步实现

下一章预告：用真实 Embedding 模型跑一遍，亲眼看”代码质量”和”天气真好”的相似度到底差多少！