你刚才已经掌握：
A = [1, 2, 3]
这是一个 3 维向量。
可以把它想成：
CPU Memory GPU ↓ ↓ ↓ 80 60 90
也就是：
A = [80, 60, 90]
一个对象的一组特征。
最简单的理解：
**矩阵就是把很多向量按照一定规则排在一起。**
例如：
A = [ 1 2 3 4 5 6 7 8 9 ]
这个矩阵有：
3 行 3 列
所以叫：
**3 × 3 矩阵**
—
假设你测试了 4 台服务器：
| Server | CPU | Memory | GPU |
| ——– | –: | —–: | –: |
| Server A | 80 | 60 | 90 |
| Server B | 70 | 50 | 80 |
| Server C | 90 | 70 | 95 |
| Server D | 50 | 40 | 60 |
可以变成：
X = [ 80 60 90 70 50 80 90 70 95 50 40 60 ]
那么：
X.shape = 4 × 3
意思就是：
4 个对象 3 个特征
这其实已经非常接近机器学习中的真实数据了。
例如：
X = [ 80 60 90 70 50 80 90 70 95 50 40 60 ]
[80,60,90]
代表：
Server A
### 第二行
[70,50,80]
代表：
Server B
而第一列：
80 70 90 50
代表：
CPU
第二列：
60 50 70 40
代表：
Memory
第三列：
90 80 95 60
代表：
GPU
所以可以记：
**行通常代表样本，列通常代表特征。**
当然这不是数学上的硬性规定，实际工程里可以根据数据组织方式不同而变化。
这个概念以后你会天天遇到。
比如：
X = [ 1 2 3 4 5 6 ]
它有：
2 行 3 列
所以：
shape = (2,3)
注意：
(行, 列)
所以：
(2,3)
不是：
3行2列
而是：
**2 行 3 列**
—
假设你有：
10000 个样本
每个样本：
100 个特征
如果每个样本都是一个向量：
x1 x2 x3 ... x10000
就可以把它们组成：
形状：
10000 × 100
于是整个数据集可以一次性交给 GPU：
CPU ↓ Tensor ↓ GPU ↓ 矩阵运算
而不是：
for 每一个样本:
一个一个算
这就是 AI 为什么喜欢批量计算。
这个非常简单。
假设：
A = [ 1 2 3 4 ]
B = [ 5 6 7 8 ]
那么：
A+B
就是对应位置相加：
[ 1+5 2+6 3+7 4+8 ]
得到：
[ 6 8 10 12 ]
注意：
**两个矩阵必须具有相同的形状，才能直接做矩阵加法。**
—
这部分我们慢慢来。
假设：
A = [ 1 2 3 4 ]
B = [ 5 6 7 8 ]
计算：
A × B
很多人第一次会误以为：
[ 1×5 2×6 3×7 4×8 ]
这是：
[ 5 12 21 32 ]
但是这个结果不是矩阵乘法。
记住一句：
**左边矩阵的“行”，乘右边矩阵的“列”。**
还是：
A = [ 1 2 3 4 ]
B = [ 5 6 7 8 ]
先算结果左上角：
A[第一行] · B[第一列]
也就是：
[1,2] · [5,7]
刚才我们已经学过点积：
1×5 + 2×7
所以：
= 19
A 第一行：
[1,2]
B 第二列：
[6,8]
点积：
1×6 + 2×8
得到：
22
所以结果第一行：
[19,22]
A 第二行：
[3,4]
B 第一列：
[5,7]
点积：
3×5 + 4×7
得到：
43
然后：
[3,4] · [6,8]
得到：
3×6 + 4×8 = 50
所以最终：
A × B = [ 19 22 43 50 ]
矩阵乘法：
A × B
其实就是：
**大量的向量点积。**
也就是说：
矩阵乘法
↓
很多次点积
↓
很多次乘法 + 加法
这就开始和 GPU 联系起来了。
刚才一个 2×2 矩阵，计算量很小。
但是如果：
A = 4096 × 4096 B = 4096 × 4096
那么需要做海量的：
乘法 + 加法
而 GPU 可以同时处理大量这些操作。
于是：
神经网络 ↓ 矩阵乘法 ↓ 大量乘加 ↓ GPU ↓ Tensor Core
你作为测试工程师以后会经常看到：
FLOPS TFLOPS Matrix Multiplication GEMM Tensor Core
现在你已经知道它们背后的数学基础是什么了。
假设：
A.shape = (2,3)
也就是：
A = [ 1 2 3 4 5 6 ]
如果：
B.shape = (3,4)
那么：
A × B
是可以计算的。
因为：
(2 × 3) × (3 × 4)
中间两个：
3 3
匹配。
结果：
(2 × 4)
所以：
(2×3) × (3×4) = (2×4)
这个规则非常重要。
矩阵：
(m × n)
乘：
(n × p)
结果：
(m × p)
也就是：
(m × n) × (n × p)
↑
中间必须相同
最终：
(m × p)
你以后看到 PyTorch：
A @ B
如果报：
mat1 and mat2 shapes cannot be multiplied
基本就是：
**矩阵维度对不上。**
—
假设一个神经网络有：
输入层：3 个特征 输出层：2 个神经元
输入：
X = [CPU, Memory, GPU]
比如：
X = [80,60,90]
模型有一个权重矩阵：
W = [ 0.1 0.2 0.3 0.4 0.5 0.6 ]
那么：
X × W
就是：
[80,60,90] × [ 0.1 0.2 0.3 0.4 0.5 0.6 ]
得到两个输出：
Neuron 1 Neuron 2
所以你可以把神经网络的一层粗略理解成：
**输入向量 × 权重矩阵 → 输出向量**
也就是：
XW
这就是你以后会反复看到的：
Y = XW + b
以后你看到：
Model Parameters Weights Parameters
不要觉得玄学。
最简单的理解：
输入 ↓ 乘上一堆数字 ↓ 得到输出
这些“数字”就是：
**模型参数/权重。**
训练过程实际上就是：
**不断调整这些数字，让模型的预测越来越好。**
这就又和我们上一节说的：
Loss ↓ Gradient ↓ 调整参数
连接起来了。
你现在已经可以看到 AI 的一个基本骨架：
现实世界 ↓ 数字 ↓ 向量 ↓ 矩阵 ↓ 矩阵乘法 ↓ 神经网络 ↓ 预测 ↓ Loss ↓ Gradient ↓ 调整矩阵里的参数
这条链非常重要。
最后讲一个以后一定会遇到的概念：
**Transpose，转置。**
例如：
A = [ 1 2 3 4 5 6 ]
这是：
2 × 3
转置之后：
Aᵀ = [ 1 4 2 5 3 6 ]
变成：
3 × 2
简单理解：
**行和列交换。**
所以：
(2×3)
转置：
(3×2)
因为矩阵乘法经常需要调整维度。
例如：
Q × Kᵀ
你以后学 Attention 时一定会看到这个。
现在你已经知道：
Kᵀ
就是：
**把 K 的行列交换。**
所以以后看到：
QKᵀ
至少不会觉得像某种外星文明的符号。
你现在已经掌握了：
向量 ↓ 维度 ↓ 向量加减 ↓ 向量长度 ↓ 点积 ↓ 矩阵 ↓ 矩阵形状 ↓ 矩阵加法 ↓ 矩阵乘法 ↓ 矩阵维度匹配 ↓ 转置
其中最重要的是这三个：
[a,b,c] · [x,y,z] = ax + by + cz
(m×n) × (n×p) = (m×p)