时间可能不存在

本页面只读。您可以查看源文件，但不能更改它。如果您觉得这是系统错误，请联系管理员。
# 1. 向量到底是什么？

先忘掉学校里“向量是既有大小又有方向的量”这句话。

这个定义没错，但对于 AI 入门来说不够好用。

现在先把向量理解成：

> **一组按照顺序排列的数字。**

例如：

```text
[1, 2, 3]
```

这就是一个向量。

再比如：

```text
[10, 20, 30, 40]
```

也是向量。

甚至：

```text
[0.123, -0.827, 1.234, 0.001]
```

也是向量。

---

# 2. 为什么强调“顺序”？

例如：

```text
A = [CPU, Memory, GPU]
```

假设：

```text
A = [80, 60, 90]
```

我们约定：

```text
第1个数字 = CPU
第2个数字 = Memory
第3个数字 = GPU
```

那么：

```text
[80, 60, 90]
```

和：

```text
[60, 80, 90]
```

虽然数字一样，但**不是同一个向量**。

因为它们代表的数据不同。

所以：

```text
[1, 2, 3]
```

和：

```text
[3, 2, 1]
```

不是一回事。

---

# 3. 向量的“维度”

这个概念非常重要。

例如：

```text
[1, 2]
```

有两个数字。

我们说它是：

> **2 维向量**

```text
[1, 2, 3]
```

是：

> **3 维向量**

```text
[1, 2, 3, 4, 5]
```

是：

> **5 维向量**

所以：

```text
向量维度 = 向量中元素的数量
```

例如：

```text
x = [10, 20, 30, 40]
```

那么：

```text
dim(x) = 4
```

---

# 4. 用测试工程来理解

假设你测试服务器，每秒采集：

```text
CPU利用率
内存利用率
GPU利用率
GPU温度
功耗
```

某一时刻：

```text
CPU = 80%
Memory = 65%
GPU = 95%
Temperature = 72℃
Power = 350W
```

可以表示成：

```text
X = [80, 65, 95, 72, 350]
```

这就是一个：

> **5 维向量**

所以你完全可以把向量理解成：

> **描述某一个对象的一组数字。**

这已经非常接近 AI 中的实际用法了。

---

# 5. 向量为什么能表示现实世界？

这是 AI 很重要的思想。

比如我们想描述一辆汽车：

```text
重量
马力
价格
最高速度
油耗
```

可以：

```text
Car A = [1500, 200, 200000, 220, 8]
```

另一辆：

```text
Car B = [1800, 250, 300000, 240, 10]
```

于是：

```text
现实对象
   ↓
提取特征
   ↓
数字
   ↓
向量
```

这就是机器学习非常核心的思想：

> **把现实世界的信息转换成计算机可以计算的数字。**

---

# 6. 向量也可以表示位置

现在进入数学里的另一种理解。

假设有一个二维坐标系：

```text
        y
        ↑
        │
        │       ● (3,2)
        │      /
        │     /
        │    /
        │   /
        └────────────→ x
```

点：

```text
(3, 2)
```

也可以写成向量：

```text
[3, 2]
```

表示：

> 从原点 `(0,0)` 出发，向右 3，向上 2。

所以二维向量：

```text
[3,2]
```

既可以理解成：

> 一组数字

也可以理解成：

> 一个方向 + 一个长度

这就是学校里“有大小和方向”的来源。

---

# 7. 向量的长度

假设：

```text
v = [3, 4]
```

画出来：

```text
      ● (3,4)
     /
    /
   /
  /
 ●
(0,0)
```

根据勾股定理：

```text
长度 = √(3² + 4²)
```

所以：

```text
= √25
= 5
```

向量的长度通常叫：

> **模（Norm）**

写成：

```text
||v||
```

所以：

```text
v = [3,4]

||v|| = 5
```

---

# 8. 为什么 AI 要关心向量长度？

因为以后你会遇到：

```text
Normalization
L2 Norm
Vector Similarity
Cosine Similarity
```

这些都和向量长度有关。

比如：

```text
A = [3,4]
```

长度：

```text
5
```

我们可以把它“缩短”成长度为 1 的向量。

```text
A' = [3/5, 4/5]

   = [0.6, 0.8]
```

它的长度：

```text
√(0.6² + 0.8²)
= 1
```

这叫：

> **单位向量**

---

# 9. 向量可以相加

这个很简单。

假设：

```text
A = [1,2]
B = [3,4]
```

那么：

```text
A + B
```

就是对应位置相加：

```text
[1+3, 2+4]
```

得到：

```text
[4,6]
```

所以：

```text
[1,2] + [3,4]
= [4,6]
```

注意：

> **对应位置相加。**

---

# 10. 向量可以减

同样：

```text
A = [5,7]
B = [2,3]
```

那么：

```text
A - B
```

就是：

```text
[5-2, 7-3]
```

得到：

```text
[3,4]
```

这件事情在 AI 中非常重要。

例如：

```text
A = 一个模型的特征
B = 另一个模型的特征
```

那么：

```text
A - B
```

可以表示两者之间的差异。

---

# 11. 向量可以乘一个数字

例如：

```text
A = [2,3]
```

乘以：

```text
2
```

得到：

```text
2A = [4,6]
```

乘以：

```text
0.5
```

得到：

```text
0.5A = [1,1.5]
```

这叫：

> **标量乘法**

其中：

```text
2
```

这种单独的数字叫：

> **标量 Scalar**

所以：

```text
标量 × 向量
```

非常常见。

---

# 12. 到这里，你已经掌握了向量的基本运算

假设：

```text
A = [1,2,3]
B = [4,5,6]
```

那么：

### 加法

```text
A+B

= [5,7,9]
```

### 减法

```text
A-B

= [-3,-3,-3]
```

### 乘 2

```text
2A

= [2,4,6]
```

### 长度

```text
||A||

= √(1²+2²+3²)
```

```text
= √14
```

这些你现在不需要死记公式。

先形成感觉：

> **向量就是一组数字，可以进行各种数学运算。**

---

# 13. 最重要的来了：点积

这是今天最值得搞懂的东西。

假设：

```text
A = [1,2,3]

B = [4,5,6]
```

点积：

```text
A · B
```

计算：

```text
1×4 + 2×5 + 3×6
```

也就是：

```text
4 + 10 + 18
```

最终：

```text
32
```

所以：

```text
[1,2,3] · [4,5,6] = 32
```

---

# 14. 点积和普通乘法有什么区别？

注意：

```text
A = [1,2,3]
B = [4,5,6]
```

如果逐元素乘：

```text
[1×4, 2×5, 3×6]
```

得到：

```text
[4,10,18]
```

这还是一个向量。

但是点积：

```text
1×4 + 2×5 + 3×6
```

得到：

```text
32
```

是一个**数字**。

所以：

```text
逐元素乘法
[1,2,3] × [4,5,6]
↓
[4,10,18]
```

而：

```text
点积
[1,2,3] · [4,5,6]
↓
32
```

这个区别以后一定要记住。

---

# 15. 点积为什么这么重要？

因为点积可以用来衡量两个向量的“方向相似程度”。

例如：

```text
A = [1,0]
B = [1,0]
```

两个向量完全同方向：

```text
A · B = 1
```

如果：

```text
A = [1,0]
B = [0,1]
```

两个方向垂直：

```text
A · B = 0
```

如果：

```text
A = [1,0]
B = [-1,0]
```

方向完全相反：

```text
A · B = -1
```

所以点积包含了一个非常有意思的信息：

```text
正数 → 大体同方向
0    → 垂直
负数 → 大体反方向
```

当然，严格判断相似程度通常还要考虑向量长度。

这就引出了：

# Cosine Similarity

以后 RAG、Embedding、向量数据库都会遇到。

---

# 16. Cosine Similarity

公式：

```text
cos(θ) = (A · B) / (||A|| ||B||)
```

先不要被公式吓到。

它实际上就是：

> **两个向量的点积 ÷ 两个向量长度的乘积。**

它主要关注：

> **两个向量的方向是不是相似。**

例如：

```text
A = [1,1]
B = [2,2]
```

虽然：

```text
B
```

比：

```text
A
```

长很多。

但是它们方向完全一样。

所以：

```text
Cosine Similarity = 1
```

这也是为什么 Embedding 搜索经常使用余弦相似度。

---

# 17. 现在把它和 LLM 联系起来

假设：

```text
"苹果"
```

经过 Embedding：

```text
A = [0.2, 0.8, -0.1, 0.5, ...]
```

而：

```text
"香蕉"
```

得到：

```text
B = [0.3, 0.7, -0.2, 0.4, ...]
```

然后计算：

```text
Cosine Similarity(A,B)
```

如果结果比较高：

```text
0.92
```

说明：

> 两个向量在语义空间里比较接近。

这就是：

```text
文字
 ↓
Embedding
 ↓
向量
 ↓
数学运算
 ↓
相似度
```

这条链是以后学 RAG 必须理解的。

---

# 18. 更重要的一件事：向量为什么能表示“语义”？

这是 AI 最有意思的地方之一。

例如模型训练之后，可能得到这样的结果：

```text
国王
 ↓
[0.81, 0.22, 0.71, ...]
```

```text
王后
 ↓
[0.78, 0.25, 0.73, ...]
```

它们的向量比较接近。

而：

```text
汽车
 ↓
[-0.32, 0.91, -0.17, ...]
```

可能距离比较远。

于是：

```text
语义
 ↓
高维空间中的位置
```

这就是所谓：

> **Embedding Space**

你后面学 LLM、RAG、向量数据库都会一直遇到。

---

# 19. 你现在先不要纠结“为什么模型能学出这种空间”

这是后面：

```text
Neural Network
 ↓
Training
 ↓
Loss
 ↓
Gradient
```

的内容。

现在只需要记住：

> **AI 会通过训练，让具有相似特征/语义的东西在向量空间中呈现某种结构。**

---

# 20. 最后讲一个和你职业特别相关的例子

假设我们测试一个 GPU：

```text
GPU A：

性能：100
功耗：300
温度：70
显存：80
```

表示成：

```text
A = [100,300,70,80]
```

GPU B：

```text
B = [95,280,68,75]
```

我们可以：

### 比较差异

```text
A-B
```

### 计算距离

```text
||A-B||
```

### 比较方向

```text
Cosine Similarity(A,B)
```

于是：

> **测试数据本身就可以变成向量，然后用数学方法进行比较。**

这就是为什么机器学习特别适合做：

* 异常检测
* 聚类
* 性能分析
* 故障分类
* 指标关联分析

---

# 21. 今天真正需要记住的东西

不用背一大堆公式，只记住下面这些：

### ① 向量

```text
[1,2,3]
```

就是一组有顺序的数字。

### ② 维度

```text
[1,2,3]
```

是 3 维向量。

### ③ 向量长度

```text
||A||
```

表示向量有多长。

### ④ 向量加减

```text
[1,2] + [3,4]
= [4,6]
```

### ⑤ 标量乘法

```text
2 × [1,2]
= [2,4]
```

### ⑥ 点积

```text
[1,2,3] · [4,5,6]
= 32
```

### ⑦ Cosine Similarity

用来衡量：

> **两个向量方向有多相似。**