AI数学基础（一）：线性代数——让机器学会”看”向量

300年前那个改变世界的夜晚

1691年的一个秋夜，法国小镇上，一个17岁的少年在昏暗的烛光下写日记。他的名字叫亚伯拉罕·棣莫弗（Abraham de Moivre）。

这个少年可能不会想到，他那天晚上在日记里随手画的一个坐标系——用两条垂直的直线来表示平面上的点的位置——会在300多年后，成为让人工智能”看见”这个世界的基础工具。

你想想看，当你用手机拍照时，照片在电脑眼里是什么？

就是一堆数字。

一张1920×1080的图片，在AI眼里就是一个1920×1080的数字矩阵。每个数字代表一个像素的亮度或颜色值。AI要”看懂”这张图，就得对这些数字进行运算——而这些运算，全都是线性代数。

所以今天，咱们就来聊聊：线性代数到底是什么？为什么AI离不开它？

一、标量、向量、矩阵：从地图坐标到Excel表格

1. 标量：就是一个数字

最简单的开始。标量（scalar）就是一个单独的数字。

1
5、3.14、-2、100

比如：”今天气温23度”——这个”23”就是标量。它只有一个数值，没有方向。

2. 向量：有方向的数组

向量（vector）是一串按顺序排列的数字，而且每个数字都有意义。

生活比喻：地图坐标

你打开手机地图，搜索”故宫”。地图上会显示一个坐标：(39.9163, 116.3972)。

这两个数放在一起，就构成了一个二维向量：

1
[39.9163, 116.3972]

第一个数是纬度，第二个是经度。顺序不能乱！[116.3972, 39.9163]就跑到非洲去了。

再举个例子：你的个人特征

假设AI要描述你这个人，可能会用这样一个向量：

1
2
[年龄, 身高, 体重, 月收入, 购物频率]
= [28, 175, 70, 15000, 12]

这就是一个五维向量。虽然我们画不出五维空间（谁也画不出），但数学上完全没问题！

3. 矩阵：向量的集合

矩阵（matrix）就是多行多列的数字表格。

生活比喻：Excel表格

你打开Excel，看到的就是矩阵。比如一个班级的成绩表：

姓名 数学 语文 英语
小明 95 87 92
小红 88 92 96
小刚 76 85 80

用矩阵表示就是：

1
2
3
4
5
[
  [95, 87, 92],
  [88, 92, 96],
  [76, 85, 80]
]

这是一个3×3矩阵（3行3列）。

AI中的应用：图片就是矩阵

一张黑白照片，每个像素的灰度值（0-255）放在一个矩阵里：

1
2
3
4
5
6
[
  [255, 200, 150, ...],
  [200, 180, 120, ...],
  [150, 120, 100, ...],
  ...
]

彩色照片？那就是三个矩阵（红、绿、蓝三个通道各一个）。

二、向量加减法：从”你家走到学校”

故事：两个向量的”位移”

假设你家在地图上的坐标是 A = [2, 3]，学校在 B = [5, 7]。

向量减法：B - A = [5-2, 7-3] = [3, 4]

这个 [3, 4] 就是从你家走到学校的”位移向量”——往东走3公里，往北走4公里。

向量加法：如果你先走到学校（[3, 4]），再走到网吧（[1, 2]），那从家到网吧的总位移是：

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

NumPy实战

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

# 定义两个向量
home = np.array([2, 3])
school = np.array([5, 7])

# 向量减法：从家到学校的位移
displacement = school - home
print("从家到学校的位移:", displacement)  # 输出: [3 4]

# 向量加法：从家到网吧的总位移
internet_cafe = np.array([1, 2])
total_displacement = displacement + internet_cafe
print("从家到网吧的总位移:", total_displacement)  # 输出: [4 6]

# 验证：直接从家到网吧
home_to_cafe = np.array([4, 6])
print("验证相等:", np.array_equal(total_displacement, home_to_cafe))  # 输出: True

三、向量点乘：两个人”合不合拍”

直觉：点乘衡量”相似度”

向量点乘（dot product）的定义：

1
A · B = a₁×b₁ + a₂×b₂ + ... + aₙ×bₙ

但这公式啥意思？点乘的结果越大，说明两个向量越”相似”（方向越一致）。

生活比喻：两个人的兴趣相似度

假设用向量表示两个人的兴趣：

1
2
你:   [看电影, 打游戏, 听音乐, 运动] = [5, 3, 4, 2]
朋友: [看电影, 打游戏, 听音乐, 运动] = [4, 5, 3, 1]

数字表示喜欢程度（1-5分）。

点乘计算：

1
2
3
你 · 朋友 = 5×4 + 3×5 + 4×3 + 2×1
          = 20 + 15 + 12 + 2
          = 49

如果另一个人的向量是 [1, 1, 1, 5]（只喜欢运动），点乘结果会小很多——说明你们”合不来”。

AI中的应用：推荐系统

Netflix推荐电影，就是用你的观影历史和电影的特征向量做点乘，点乘越大，越推荐给你！

NumPy实战

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

# 两个人的兴趣向量
you = np.array([5, 3, 4, 2])  # [看电影, 打游戏, 听音乐, 运动]
friend = np.array([4, 5, 3, 1])

# 点乘计算相似度
similarity = np.dot(you, friend)
print("你和两个朋友的相似度:", similarity)  # 输出: 49

# 另一个人（只喜欢运动）
another = np.array([1, 1, 1, 5])
similarity_another = np.dot(you, another)
print("你和另一个人的相似度:", similarity_another)  # 输出: 23

# 结论：朋友更合拍！
print("朋友更合拍吗？", similarity > similarity_another)  # 输出: True

四、矩阵乘法：工厂的”原料-产品”关系

直觉：矩阵乘法就是”信息的流动”

矩阵乘法（matrix multiplication）可能是线性代数里最让人头大的概念。但用一个比喻就清楚了：

工厂比喻

假设有个工厂：

  • 原料：钢铁、塑料、电子元件（3种原料）
  • 产品：手机、电脑、平板（3种产品）

第一个矩阵（原料消耗矩阵）：生产每个产品需要多少原料

1
2
3
4
        手机  电脑  平板
钢铁  [  2,   5,   3  ]
塑料  [  1,   2,   2  ]
电子  [  4,   6,   5  ]

意思是：生产1台手机需要2单位钢铁、1单位塑料、4单位电子元件。

第二个矩阵（利润矩阵）：每个产品卖多少钱

1
2
3
4
        利润
手机  [ 1000 ]
电脑  [ 3000 ]
平板  [ 1500 ]

矩阵乘法：计算每个原料”贡献”了多少利润

1
2
3
4
5
结果 = 原料消耗矩阵 × 利润矩阵

钢铁贡献 = 2×1000 + 5×3000 + 3×1500 = 20,500
塑料贡献 = 1×1000 + 2×3000 + 2×1500 = 11,000
电子贡献 = 4×1000 + 6×3000 + 5×1500 = 32,500

AI中的应用：神经网络的一层

神经网络的每一层，本质上就是一次矩阵乘法！

输入向量 × 权重矩阵 = 输出向量

NumPy实战

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

# 原料消耗矩阵（3种原料 × 3种产品）
consumption = np.array([
    [2, 5, 3],   # 钢铁
    [1, 2, 2],   # 塑料
    [4, 6, 5]    # 电子
])

# 利润矩阵（3种产品 × 1个利润值）
profit = np.array([
    [1000],  # 手机
    [3000],  # 电脑
    [1500]   # 平板
])

# 矩阵乘法
contribution = np.dot(consumption, profit)
print("每种原料贡献的利润:")
print(f"钢铁: {contribution[0][0]} 元")
print(f"塑料: {contribution[1][0]} 元")
print(f"电子: {contribution[2][0]} 元")

五、真实场景：用向量计算用户兴趣相似度

场景：给用户推荐商品

假设有个电商网站，要给用户推荐商品。我们用向量表示用户的兴趣和历史行为：

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
import numpy as np

# 用户A的兴趣向量（浏览次数）
# [电子产品, 服装, 食品, 家居, 运动]
user_a = np.array([10, 5, 2, 8, 3])

# 用户B的兴趣向量
user_b = np.array([8, 6, 1, 9, 4])

# 用户C的兴趣向量（和用户A差异较大）
user_c = np.array([1, 10, 15, 2, 8])

# 计算相似度（点乘）
similarity_ab = np.dot(user_a, user_b)
similarity_ac = np.dot(user_a, user_c)

print(f"用户A和B的相似度: {similarity_ab}")   # 输出: 189
print(f"用户A和C的相似度: {similarity_ac}")   # 输出: 141

# 归一化（用余弦相似度，更准确）
def cosine_similarity(v1, v2):
    dot_product = np.dot(v1, v2)
    norm1 = np.linalg.norm(v1)
    norm2 = np.linalg.norm(v2)
    return dot_product / (norm1 * norm2)

print(f"用户A和B的余弦相似度: {cosine_similarity(user_a, user_b):.3f}")  # 输出: ~0.97
print(f"用户A和C的余弦相似度: {cosine_similarity(user_a, user_c):.3f}")  # 输出: ~0.64

# 结论：用户A和B兴趣更相似，可以给A推荐B喜欢的商品！

这就是推荐系统的核心原理！

Amazon、淘宝、Netflix的推荐算法，本质上都在做这件事——计算向量之间的相似度。

六、总结：线性代数让AI”看见”世界

回过头看，我们从300年前少年的日记出发，走到了今天AI的核心：

  1. 标量：一个数字（气温23度）
  2. 向量：一串数字（地图坐标、个人特征）
  3. 矩阵：数字表格（Excel、图片）
  4. 向量加减：位移、变化
  5. 向量点乘：相似度（推荐系统）
  6. 矩阵乘法：信息流动（神经网络）

线性代数就是AI的”眼睛”——它把世界变成数字，让机器能”看”懂、能运算、能做决策。

下一篇，咱们聊概率论——教机器做”不确定的决策”。毕竟，现实世界不是非黑即白的。

代码示例汇总

本文所有代码都在这里，复制即可运行：

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
import numpy as np

# 1. 向量加减法
home = np.array([2, 3])
school = np.array([5, 7])
displacement = school - home
print("位移:", displacement)

# 2. 向量点乘（相似度）
you = np.array([5, 3, 4, 2])
friend = np.array([4, 5, 3, 1])
similarity = np.dot(you, friend)
print("相似度:", similarity)

# 3. 矩阵乘法（工厂模型）
consumption = np.array([[2, 5, 3], [1, 2, 2], [4, 6, 5]])
profit = np.array([[1000], [3000], [1500]])
contribution = np.dot(consumption, profit)
print("利润贡献:", contribution)

# 4. 余弦相似度（推荐系统）
def cosine_similarity(v1, v2):
    return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))

user_a = np.array([10, 5, 2, 8, 3])
user_b = np.array([8, 6, 1, 9, 4])
print("余弦相似度:", cosine_similarity(user_a, user_b))

下一篇预告：《AI数学基础（二）：概率论——教机器做”不确定的决策”》

1654年，两个法国贵族在赌桌上吵了一架，却意外催生了概率论…