矩阵乘法：规则、直觉与高效实现

可视化演示

展示矩阵乘法A×B=C的行列点积计算过程，以及结合律、分配律等核心运算性质和维度匹配规则。

行列相乘规则

物流老板面对两张表：左边 A 表记着每家工厂给每个中转仓发多少货，右边 B 表记着每个中转仓往每家门店送多少货。要回答“工厂 i 最终到门店 j 有多少货”，不能只看某一行某一列，而要走遍所有中转仓：先看工厂 i 给中转仓 k 发了几件（A 表里的数），再看中转仓 k 每发一件能变成送到门店 j 的几件（B 表里的数），两者相乘就是这条路的贡献；把每条中转线路的贡献全部加起来，才是最终答案。这就是矩阵乘法的全部直觉。

翻译成数学语言：A 是 m×n 的“工厂—中转仓”表，B 是 n×p 的“中转仓—门店”表。它们能相乘的前提是 A 的列数等于 B 的行数——因为中转仓的编号必须前后对得上，这个相等的维度叫“内维”。结果 AB 就是一张 m×p 的“工厂—门店”直达表，行数来自 A 的行数，列数来自 B 的列数。

$$\displaystyle (AB)_{ij} = \sum_{k=1}^{n} A_{ik}B_{kj}$$

1. 结果矩阵的元素：$(AB)_{ij}$ 表示直达表中第 i 行、第 j 列的那一个数字，回答“工厂 i 到门店 j 总共有多少货”。

$$\displaystyle (AB)_{ij}$$

2. 对中转仓求和：$\sum_{k=1}^{n}$ 的意思是让中转仓编号 k 从 1 数到 n，把每条中转线路的贡献都加进来，一条都不能漏。

$$\displaystyle \sum_{k=1}^{n}$$

3. A 表里的数：$A_{ik}$ 是 A 矩阵第 i 行第 k 列的元素，即工厂 i 发给中转仓 k 的件数。

$$\displaystyle A_{ik}$$

4. B 表里的数：$B_{kj}$ 是 B 矩阵第 k 行第 j 列的元素，即中转仓 k 配送到门店 j 的件数；两者相乘再求和就是最终到达量。

$$\displaystyle A_{ik}B_{kj}$$

例如 A 是 2×3、B 是 3×2：先算左上角 C[0][0] = 1×7 + 2×9 + 3×11 = 58，再算右上角 C[0][1] = 1×8 + 2×10 + 3×12 = 64，下半行同理得 139、154，最终结果是 [[58, 64], [139, 154]]。只要记住“工厂 → 中转仓 → 门店”这条链路，任何矩阵乘法都能手算出来，一行一行、一列一列慢慢磨即可。

定义的动机

有人会问：为什么不把两个矩阵对应位置的数直接相乘呢？那样简单多了。但物流公司要的不是两张表的“账目对碰”，而是一条完整的运输链路。矩阵 A 是一台“搬运机器”：输入仓库需求，输出工厂计划；矩阵 B 是另一台“搬运机器”：输入门店订单，输出仓库需求。把两台机器串起来使用，正是先 B 后 A 的层层汇总——矩阵乘法天生就是为“复合搬运”而生的。

从另一角度看，AB 的第 j 列只依赖 B 的第 j 列。B 的第 j 列里的每个数 B[k][j] 就像是“中转仓 k 的重要程度”，用它当权重去加权混合 A 的各列，就得到了结果的第 j 列。这就是“线性组合”视角：矩阵乘法不是在算一堆孤立的乘积，而是在按权重把整列货物重新混装。

$$\displaystyle (AB)_{:j} = \sum_{k=1}^{n} B_{kj}\, A_{:k}$$

1. 结果的第 j 列：$(AB)_{:j}$ 表示 AB 这个新矩阵的整列第 j 列，它是一组数而不是一个数。

$$\displaystyle (AB)_{:j}$$

2. 权重来自 B：$B_{kj}$ 是 B 第 j 列的各个元素，它们扮演“配方比例”的角色，决定每列货物放多少。

$$\displaystyle \sum_{k=1}^{n} B_{kj}$$

3. A 的第 k 列：$A_{:k}$ 表示 A 矩阵的第 k 列，它是一整批原始货物。

$$\displaystyle A_{:k}$$

4. 加权混合：把 A 的每一列按对应权重加起来，就得到结果的一列——这正是“分列汇总”的数学表达。

$$\displaystyle \sum_{k=1}^{n} B_{kj} A_{:k}$$

为什么一定要这样定义？因为如果有 y = Ax 和 x = Bz，那么把 x 代进 y 的表达式就得到 y = A(Bz) = (AB)z。换句话说，两次搬运可以合并成一次，而矩阵乘法恰好定义成满足这种“换元复合”的运算。逐元素相乘做不到这一点——这就是矩阵乘法与逐元素积之间最本质的区别。

几何意义

把矩阵想象成一台“变形机器”：平面上每个点都是一件货物，矩阵接到这个点后，按固定规则把它搬到新位置。规则是“新坐标的每个分量都是旧坐标的加权混合”，这正是线性变换。旋转、拉伸、翻转、错切，全是这种变形机器的工作模式。用物流的话说：矩阵就是“全场货物重新摆放”的说明书。

两台变形机器串联会发生什么？先让 B 机器变形，再让 A 机器接着变形，效果等价于一台更复杂的“合成机器”，它的说明书就是矩阵 AB。注意顺序要从右往左读：先乘在右的 B，再乘在左的 A。为什么 AB 和 BA 不同？先旋转再拉伸，和先拉伸再旋转，得到的形状当然不一样——方向感变了，几何上非常直观。

$$\displaystyle \begin{pmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{pmatrix} \begin{pmatrix} x \\ y \end{pmatrix} = \begin{pmatrix} x\cos\theta - y\sin\theta \\ x\sin\theta + y\cos\theta \end{pmatrix}$$

1. 旋转矩阵：第一行 $(\cos\theta, -\sin\theta)$ 和第二行 $(\sin\theta, \cos\theta)$ 共同定义了“逆时针转 θ 度”的搬运规则。

$$\displaystyle \begin{pmatrix} \cos\theta & -\sin\theta \\ \sin\theta & \cos\theta \end{pmatrix}$$

2. 被移动的点：$\begin{pmatrix} x \\ y \end{pmatrix}$ 是平面上等待变形的点坐标，相当于一件待搬运的货物。

$$\displaystyle \begin{pmatrix} x \\ y \end{pmatrix}$$

3. 新坐标的 x 分量：$x\cos\theta - y\sin\theta$ 是旧坐标按规则混合出来的新横坐标。

$$\displaystyle x\cos\theta - y\sin\theta$$

4. 新坐标的 y 分量：$x\sin\theta + y\cos\theta$ 是新的纵坐标。把 θ 换成 90°，代入 (1, 0) 就能验证它确实被转到了 (0, 1)。

$$\displaystyle x\sin\theta + y\cos\theta$$

回到送货比喻：几何意义其实是“质量再分配”的另一种语言。每一行的混合系数，就是“把旧位置的货按比例挪到新位置”的搬运指令。深度学习里的权重矩阵也因此不再神秘——它们就是一台台把数据摆来摆去的变形机器。

运算性质

物流公司有三条交通规则。第一条是结合律：先让“工厂→中转仓→门店”跑一趟，再统一把货物送到总仓；或者先把“中转仓→门店→总仓”合成一条直达线，再让工厂按新线路发货。两种方案最终每家门店收到的货量完全一致——括号放在哪里，不影响结果。

第二条是分配律：两家供应商先各自到货再合起来盘点，和先把两家到货量加在一起再统一配送，结果一模一样。第三条也是最容易踩坑的：没有交换律。工厂发货给门店，和门店发货给工厂，是两套方向完全相反的物流网络，绝不能倒过来算。就算两个矩阵同尺寸，交换后通常也不相等。

$$\displaystyle (AB)C = A(BC), \qquad A(B+C) = AB + AC, \qquad AB \ne BA$$

1. 结合律：$(AB)C = A(BC)$ 表示乘法结果与“先算哪两个”无关，括号可以自由移动而不改变最终矩阵。

$$\displaystyle (AB)C = A(BC)$$

2. 分配律：$A(B+C) = AB + AC$ 表示先把 B 和 C 并表相加，等于分别乘完再相加，账目对得上。

$$\displaystyle A(B+C) = AB + AC$$

3. 无交换律：$AB \ne BA$ 说明矩阵乘法一般不满足交换律。例如 $A=\begin{pmatrix}0&1\\0&0\end{pmatrix}$、$B=\begin{pmatrix}0&0\\1&0\end{pmatrix}$ 时，左右两边结果完全不同。

$$\displaystyle AB = \begin{pmatrix}1&0\\0&0\end{pmatrix}, \quad BA = \begin{pmatrix}0&0\\0&1\end{pmatrix}$$

三条规则里，结合律最“值钱”：它保证了无论怎么加括号，最终答案都一样。但注意——答案一样，不等于成本一样。不同括号方案下中间仓库需要的存储和运输量可能天差地别，这正是后面“高效实现”与“计算复杂度”两章的钥匙。

分块矩阵乘法

当物流网络太庞大时，公司会按区域划分管理：华东仓、华南仓各自核算，互不干扰。矩阵也一样，可以用横竖切割线把一个大矩阵切成若干小块，每一块本身仍是一个小矩阵。切完以后，把每个小块当成一个“数字”参与乘法运算——块内部再用普通矩阵乘法处理。

关键前提是切割线要对齐：A 的横向分块列数必须等于 B 的横向分块行数，就像中转仓数量必须前后一致。只要对齐了，分块乘法的结果与整体直接相乘完全一致——这不是近似近似，而是严格的数学定理。它告诉我们：表格怎么切不改变真实账目。

$$\displaystyle \begin{pmatrix} A_{11} & A_{12} \\ A_{21} & A_{22} \end{pmatrix} \begin{pmatrix} B_{11} & B_{12} \\ B_{21} & B_{22} \end{pmatrix} = \begin{pmatrix} A_{11}B_{11} + A_{12}B_{21} & A_{11}B_{12} + A_{12}B_{22} \\ A_{21}B_{11} + A_{22}B_{21} & A_{21}B_{12} + A_{22}B_{22} \end{pmatrix}$$

1. 把 A 切四块：$A_{11}, A_{12}, A_{21}, A_{22}$ 是把 A 按横竖各切一刀得到的四块子矩阵。

$$\displaystyle \begin{pmatrix} A_{11} & A_{12} \\ A_{21} & A_{22} \end{pmatrix}$$

2. 块当元素相乘：$A_{11}B_{11} + A_{12}B_{21}$ 表示左上角结果块由两块子矩阵乘积相加得到。

$$\displaystyle A_{11}B_{11} + A_{12}B_{21}$$

3. 对齐条件：要求 A 的分块列数与 B 的分块行数一致，即 $A_{11}$ 的列数等于 $B_{11}$ 的行数。

$$\displaystyle A_{11}B_{11}, \quad A_{12}B_{21}$$

4. 拼回大矩阵：右下角结果块 $A_{21}B_{12} + A_{22}B_{22}$ 同理得到，四块拼回去就是完整乘积。

$$\displaystyle C_{21} = A_{21}B_{11} + A_{22}B_{21}$$

分块的意义在工程上极其巨大：GPU 可以把不同块分给不同计算核心同时处理，互不等待；深度学习里的 batch 操作本质上就是按批分块。物流分区管理，数学上完全等价，效率上却快出几个量级——这正是分块矩阵乘法的价值所在。

高效实现

结合律告诉我们“结果都一样”，那到底选哪种括号方案？答案是看成本。A 是 m×n、B 是 n×p 时，要算完整个乘积需要 m×n×p 次标量乘法——这是一个固定的“运输总里程”，由三个维度共同决定。n 越大（中转仓越多），成本涨得越凶。

对三个矩阵的链式乘法，选择更关键：X 是 100×10、Y 是 10×50、Z 是 50×5。先算 (XY)，中间结果是 100×50，总成本 100×10×50 + 100×50×5 = 75000；先算 (YZ)，中间结果是 10×5，总成本 10×50×5 + 100×10×5 = 7500。同样是三个矩阵相乘，成本差 10 倍——括号位置决定了中间结果的大小，也就决定了总运量。

$$\displaystyle \text{cost}(A_{m\times n} B_{n\times p}) = m \cdot n \cdot p$$

1. 外层行循环：$m$ 是结果矩阵的行数，每一行都要独立算一遍。

$$\displaystyle m$$

2. 内层累加项：$n$ 是求和号里的项数，也就是内维的长度，每个结果元素都要累加 n 项。

$$\displaystyle n$$

3. 外层列循环：$p$ 是结果矩阵的列数，每一列也都要独立算一遍。

$$\displaystyle p$$

4. 总次数：$m \cdot n \cdot p$ 三者相乘就是标量乘法总次数，复杂度写作 $O(mnp)$。

$$\displaystyle m \cdot n \cdot p$$

除了选括号，实现层面还有两个常用优化：循环顺序调整成 i→k→j 能保证内层访问连续内存，提高缓存命中率；GPU 上每个线程独立计算一个输出元素，天然可以大规模并行。回到物流比喻：挑对配送路线、装好货箱顺序，运输成本可能差 10 倍甚至更多——算法优化的精髓就在于此。

计算复杂度

两个 n×n 的方阵相乘，朴素算法要做 n³ 次标量乘法。n 每翻一倍，耗时涨 8 倍——这就是深度学习训练慢的根源之一：大模型的权重矩阵乘来乘去，底层全是 n³ 级别的成本。所以“怎么让矩阵乘法更快”一直是计算机科学的重要课题。

数学家们想尽办法降低指数。Strassen 算法是第一个大突破：把 2×2 分块乘法的 8 次乘法降为 7 次，用额外的加法换取乘法次数减少。每次递归都少一次乘法，规模越大省得越多，最终把指数从 3 压到约 2.807。

$$\displaystyle T(n) = 7\,T\!\left(\frac{n}{2}\right) + O(n^2) \;\Longrightarrow\; T(n) = O\!\left(n^{\log_2 7}\right) \approx O\!\left(n^{2.807}\right)$$

1. 递归关系：$T(n) = 7T(n/2) + O(n^2)$ 表示把 n 阶问题切成若干个 n/2 阶子问题，7 次子乘法加一次合并。

$$\displaystyle T(n) = 7\,T\!\left(\frac{n}{2}\right) + O(n^2)$$

2. 7 次子问题：$7T(n/2)$ 里的 7 来自 Strassen 精心构造的 7 个中间矩阵，比普通分块的 8 次少一次。

$$\displaystyle 7\,T\!\left(\frac{n}{2}\right)$$

3. 加法换乘法：$O(n^2)$ 是拼出这 7 个中间矩阵所需的加法成本，加法比乘法便宜得多。

$$\displaystyle O(n^2)$$

4. 解出复杂度：$O(n^{\log_2 7}) \approx O(n^{2.807})$，因为 $\log_2 7 \approx 2.807$，小于 3，n 越大优势越明显。

$$\displaystyle O\!\left(n^{\log_2 7}\right) \approx O\!\left(n^{2.807}\right)$$

不过 Strassen 在工程上并不总是最优：常数因子偏大、数值稳定性略差，只有超大矩阵才划算。现代 BLAS 库（深度学习的底层引擎）会混合使用朴素循环、分块并行与 Strassen 变体。回到比喻：与其纠结每辆车的装法，不如在“分段运输”的整体结构上动刀——这就是计算复杂度分析的真正意义。

AI 应用场景

Python 演示

def matrix_mult(A, B):    rows_a = len(A)    cols_a = len(A[0])    rows_b = len(B)    cols_b = len(B[0])    if cols_a != rows_b:        raise ValueError('A 的列数必须等于 B 的行数')    C = [[0] * cols_b for _ in range(rows_a)]    for i in range(rows_a):        for j in range(cols_b):            for k in range(cols_a):                C[i][j] += A[i][k] * B[k][j]    return C  def mul_cost(m, n, p):    return m * n * p  def main():    A = [[1, 0, 2], [3, 1, 0], [0, 2, 1]]    B = [[2, 1, 0], [1, 0, 3], [1, 2, 1]]    C = matrix_mult(A, B)    print('A × B =')    for row in C:        print(row)    assert C[0] == [4, 5, 2]    assert C[1] == [7, 3, 3]    assert C[2] == [3, 2, 7]     X = [[1, 2], [3, 4]]    Y = [[0, 1], [1, 0]]    Z = [[2, 0], [0, 2]]    left = matrix_mult(matrix_mult(X, Y), Z)    right = matrix_mult(X, matrix_mult(Y, Z))    assert left == right    print('结合律验证通过：(XY)Z == X(YZ)')     print('链式乘法成本对比（标量乘法次数）：')    print('  (XY)Z 成本 =', mul_cost(100, 10, 50) + mul_cost(100, 50, 5))    print('  X(YZ) 成本 =', mul_cost(10, 50, 5) + mul_cost(100, 10, 5))  if __name__ == '__main__':    main()

1. if cols_a != rows_b:内维匹配检查，对应“中转仓数量必须对得上”，不匹配直接报错。
2. C = [[0] * cols_b for _ in range(rows_a)]预分配结果矩阵，避免动态扩容开销。
3. C[i][j] += A[i][k] * B[k][j]核心累加语句，逐项相乘再求和，就是整篇文章反复强调的动作。
4. assert C[0] == [4, 5, 2]拿手算结果做单元测试，确保实现与数学定义一致。
5. left = matrix_mult(matrix_mult(X, Y), Z)按 (XY)Z 的括号顺序计算。
6. right = matrix_mult(X, matrix_mult(Y, Z))按 X(YZ) 的括号顺序计算。
7. assert left == right验证结合律：结果相同，验证“括号不影响答案”。
8. mul_cost(100, 10, 50) + mul_cost(100, 50, 5)计算 (XY)Z 的总成本，对比可看出成本差 10 倍。

常见误区

面试题