把一张图顺时针旋转 90 度,代码里写 R @ v,结果落在 y 轴的正方向,方向对了。同事把同一行改成 v @ R,程序不报错,形状也对,结果却落在 y 轴的负方向,正好转反了。同一个矩阵、同一个向量,只换了乘法的左右顺序,得到一个相反的旋转。

更麻烦的是「旋转加平移」:图形绕原点转完,还想整体向右移动十个像素。拿 2×2 矩阵怎么调都做不到,因为矩阵乘法里原点必须映射到原点,平移会把原点挪走。要在二维里同时表达旋转和平移,得把坐标升到三维,用 3×3 矩阵和齐次坐标,这是图形学里绕不开的一步。

这两个现象指向同一个事实:矩阵乘法不是一组随意的数字规则,它对应一次空间变换。这篇先把乘法规则写清楚,再解释为什么矩阵的每一列就是基向量的新位置,然后用四种基本变换、复合顺序、行列式和非方阵,把「矩阵在旋转和缩放什么」这个问题拆开。

矩阵乘法的规则:内维对齐

矩阵乘法只有一条硬规则:内维相等。形状 (m, n) 的矩阵乘以 (n, p) 的矩阵,左边列数等于右边行数,配对成功,结果是 (m, p)。结果的行数来自左边,列数来自右边;内维 n 在计算过程中被消掉,不出现在结果里。

取两个 2×2 矩阵,手算一遍。A 为 [[1, 2], [3, 4]],B 为 [[5, 6], [7, 8]],乘积 C 的四个元素逐个算:

C11 = 1×5 + 2×7 = 5 + 14 = 19
C12 = 1×6 + 2×8 = 6 + 16 = 22
C21 = 3×5 + 4×7 = 15 + 28 = 43
C22 = 3×6 + 4×8 = 18 + 32 = 50

所以 AB 是 [[19, 22], [43, 50]]。用纯 Python 验证,同时把 BA 也算出来:

A = [[1, 2], [3, 4]]
B = [[5, 6], [7, 8]]

def mm(P, Q):
    return [[sum(P[i][k] * Q[k][j] for k in range(len(Q))) for j in range(len(Q[0]))] for i in range(len(P))]

print("A@B:", mm(A, B))
print("B@A:", mm(B, A))
A@B: [[19, 22], [43, 50]]
B@A: [[23, 34], [31, 46]]

BA 是另一组数,和 AB 不相等。这说明矩阵乘法不满足交换律,但满足结合律:(AB)C = A(BC)。结合律的用处很直接,一串变换可以先乘成一个矩阵,再作用到向量上,计算量从「每个向量乘好几次」变成「矩阵乘一次、向量乘一次」。

每个元素的算法是「左行点右列」。C 的第 i 行第 j 列,等于 A 的第 i 行与 B 的第 j 列逐项相乘再相加,和上一篇文章里的点积是同一个动作。2×2 乘 2×2 一共 8 次乘法,一般 (m, n) 乘 (n, p) 是 mnp 次乘法、mp(n−1) 次加法。

从形状看,内维 n 像一个中间计数器:A 的每一行有 n 个数,B 的每一列也有 n 个数,两边逐项配对完,n 就没有了,所以结果的形状只剩 m 和 p。若把 B 按列切成 p 个向量,乘法就是对每一列做一次矩阵乘向量,再把结果拼起来;batch 的写法也是同一件事,只是把多个向量堆成了矩阵。

线性变换的核心:每一列就是基向量的去向

线性变换(linear transformation)是保持加法与数乘的映射:T(u+v) = T(u)+T(v),T(cu) = cT(u)。在二维里,只要一个映射满足这两条,它一定可以写成一个 2×2 矩阵。反过来,每个 2×2 矩阵也都定义了一个线性变换。

理解矩阵的钥匙是基向量。取 e1 = (1, 0) 和 e2 = (0, 1),它们是二维空间的标准基。对矩阵 M = [[a, b], [c, d]],算一下 M 乘 e1:

M·e1 = [ a×1 + b×0 ]   = [ a ]
       [ c×1 + d×0 ]     [ c ]

结果正好是 M 的第一列 (a, c)。同理 M 乘 e2 得到 (b, d),正好是第二列。所以读一个矩阵不要只看数字本身,要看两列分别指向哪里:第一列是原来的 x 轴单位向量被送到的新位置,第二列是原来的 y 轴单位向量被送到的新位置。整个平面上的其他点,由这两个去向线性组合出来。

为什么两列就能决定整个变换?因为任意向量 x 都能写成 x1·e1 + x2·e2,线性性质要求 T(x) = x1·T(e1) + x2·T(e2)。第一列给出 T(e1),第二列给出 T(e2),两个去向定了,所有点的去向就都定了。矩阵乘法只是把这个线性组合写成了紧凑的形式。

旋转矩阵是 R = [[cosθ, −sinθ], [sinθ, cosθ]]。θ 取 90 度,也就是弧度 π/2,cos 是 0、sin 是 1,矩阵变成 [[0, −1], [1, 0]]。按列读,e1 被送到 (0, 1),e2 被送到 (−1, 0),这正是逆时针转 90 度。用 Python 真跑:

import math
t = math.pi / 2
R = [[math.cos(t), -math.sin(t)], [math.sin(t), math.cos(t)]]

def mv(P, u):
    return [sum(P[i][k] * u[k] for k in range(len(u))) for i in range(len(P))]

def vv(u, P):
    return [sum(u[k] * P[k][j] for k in range(len(u))) for j in range(len(P[0]))]

print("cos", math.cos(t), "sin", math.sin(t))
print("R @ e1:", mv(R, [1, 0]))
print("R @ e2:", mv(R, [0, 1]))
print("v @ R :", vv([1, 0], R))
cos 6.123233995736766e-17 sin 1.0
R @ e1: [6.123233995736766e-17, 1.0]
R @ e2: [-1.0, 6.123233995736766e-17]
v @ R : [6.123233995736766e-17, -1.0]

cos 不是精确的 0,而是 6.12e-17,这是浮点表示 pi 带来的误差。判断「是不是 0」要用一个很小的容差,不能直接拿等号比较。结果的第一项接近 0,第二项是 1,所以 e1 确实落在 y 轴正方向。

最后一行给出了开篇那个现象的原因。把同一个向量写成行向量再右乘 R,等价于用 R 的转置去乘列向量,也就是反向旋转。列向量右乘矩阵才是「矩阵作用在向量上」的标准写法,行向量左乘会得到另一个结果。旋转方向反了,先分清当前向量是行还是列,再检查 sin 的符号。

四种基本变换:缩放、旋转、剪切、投影

二维里最常用的四种变换,都能用 2×2 矩阵写出来,按它们对单位正方形做什么来记最省事。

缩放 S[[sx, 0], [0, sy]]:x 方向拉 sx 倍,y 方向拉 sy 倍。sx=sy 是等比缩放,两个方向一起变;不等比会把圆压成椭圆。
旋转 R[[cosθ, −sinθ], [sinθ, cosθ]]:长度不变,夹角不变,面积不变,det 恒等于 1。θ 为正时方向取决于坐标轴怎么画。
剪切 H[[1, k], [0, 1]]:x 坐标加上 k 倍的 y,底边不动,上边横向平移。正方形变成平行四边形,面积不变,det 等于 1。
投影 P[[1, 0], [0, 0]]:只保留 x 分量,把整个平面压到 x 轴上。面积变成 0,det 等于 0,两个不同的点可能落到同一个位置。

以剪切 k=1 为例,单位正方形的四个顶点 (0,0)、(1,0)、(1,1)、(0,1) 被送到 (0,0)、(1,0)、(2,1)、(1,1),成为一个平行四边形。底边没有动,上边向右移了一个单位,高度不变,所以面积仍然是 1:

单位正方形被剪切矩阵变成平行四边形
原正方形 剪切后 底边不动

这四种变换的共同点是:原点不动,直线还是直线,平行线还是平行线,网格的等距关系在同一个方向上保持不变。二维里,满足这些条件的映射就是线性变换,可以写成 2×2 矩阵。投影是其中最特殊的一个,它把二维压成一维,虽然仍然是线性的,但已经不可逆了。

这四种变换还能组合出更多效果。先剪切再旋转,会得到一个倾斜的旋转结果;先缩放再投影,投影到轴上的长度会跟着缩放变化。组合时每一步都作用在上一步的结果上,所以顺序不能随便换,这正是下一节要展开的内容。

缩放和旋转的顺序也会影响结果。先沿 x 拉两倍再旋转,和先旋转再沿 x 拉两倍,得到的图形不一样,因为第二次变换作用在已经被改过的坐标上。这不是实现细节,是矩阵乘法不可交换的直接后果。

复合变换就是矩阵相乘,顺序从右往左

先做 B 再做 A,对向量 x 的结果是 A(Bx)。因为矩阵乘法满足结合律,A(Bx) = (AB)x,所以可以把两个矩阵先乘成一个,再作用到向量。写成 AB 时,B 在右边,先作用;A 在左边,后作用。读表达式要从右往左。

用旋转 90 度和沿 x 方向缩放两倍来比较两种顺序。R 是上面的旋转矩阵,S 是 [[2, 0], [0, 1]],初始向量取 (1, 0):

import math
t = math.pi / 2
R = [[math.cos(t), -math.sin(t)], [math.sin(t), math.cos(t)]]
S = [[2, 0], [0, 1]]
v = [1, 0]

def mm(P, Q):
    return [[sum(P[i][k] * Q[k][j] for k in range(len(Q))) for j in range(len(Q[0]))] for i in range(len(P))]

def mv(P, u):
    return [sum(P[i][k] * u[k] for k in range(len(u))) for i in range(len(P))]

print("先旋转再缩放:", mv(mm(S, R), v))
print("先缩放再旋转:", mv(mm(R, S), v))
print("S@R", [["%.3g" % x for x in row] for row in mm(S, R)])
print("R@S", [["%.3g" % x for x in row] for row in mm(R, S)])
先旋转再缩放: [1.2246467991473532e-16, 1.0]
先缩放再旋转: [1.2246467991473532e-16, 2.0]
S@R [['1.22e-16', '-2'], ['1', '6.12e-17']]
R@S [['1.22e-16', '-1'], ['2', '6.12e-17']]

同一个起点 (1, 0),先转再缩落在 (0, 1),先缩再转落在 (0, 2)。两者不是差一点,是差一倍。原因也清楚:先缩放时,x 方向已经被拉成 2,再旋转就把这个长度带了过去;先旋转时,向量已经落到 y 轴,沿 x 的缩放对它没有作用。

把两个矩阵交换位置,得到的是两个不同的矩阵,S@R 和 R@S 的右上、左下元素明显不同。这也解释了为什么图形管线里的变换顺序不能随手调换,为什么数据增强里「先裁剪再旋转」和「先旋转再裁剪」结果不同。顺序是语义的一部分,不是代码风格。

写代码时可以用括号把顺序写死,比如 (S @ R) @ v,比一串没有括号的乘法更容易读。结合律保证先合并哪两个都一样,但不保证交换任意两个都一样。把「先做什么」写进变量名或注释,能省掉很多排查时间。

行列式是面积缩放倍数

行列式(determinant)是方阵对应的一个数,二维里直接算 det = ad − bc,其中矩阵是 [[a, b], [c, d]]。它的几何含义是面积缩放倍数:原来面积为 1 的单位正方形,经过变换后面积变成 |det|。

用三个矩阵真跑一遍:

def det(M):
    return M[0][0] * M[1][1] - M[0][1] * M[1][0]

print(det([[2, 0], [0, 1]]))
print(det([[1, 2], [2, 4]]))
print(det([[1, 1], [0, 1]]))
2
0
1

第一个矩阵 [[2, 0], [0, 1]] 把单位正方形拉成宽 2、高 1 的矩形,面积从 1 变成 2,det 也正好是 2。第三个是剪切,正方形变成平行四边形,底和高都没变,面积保持 1,det 也是 1。

第二个矩阵 [[1, 2], [2, 4]] 的两列是 (1, 2) 和 (2, 4),后者正好是前者的两倍,两个方向共线。正方形被压成一条线段,面积变成 0,det 也是 0。这时候不同的输入会落到同一个输出上,比如 (2, −1) 和 (0, 0) 都满足 Mx = 0,信息被合并,变换没有逆。

det 为负时面积大小不变,但方向翻转,相当于照了一次镜子。二维里这表示原来的左右手关系被交换了。判断「图形是不是被翻面」,看 det 的符号;判断「面积缩了多少倍」,看 det 的绝对值。det 接近 0 但还没到 0 时,逆变换会把误差放大很多倍,数值上已经开始不稳定,这一点下一篇还会遇到。

行列式还有一个好用的性质:复合变换的行列式等于两个矩阵行列式的乘积,det(AB) = det(A)·det(B)。面积先乘一次再乘一次,正好对应两个缩放倍数的相乘。旋转的 det 是 1,所以旋转不改变面积;投影的 det 是 0,所以只要复合里有一次投影,整体 det 就是 0,信息一定丢了。

非方阵:升维和降维

方阵把 n 维空间映到 n 维,维数不变。非方阵改变维数:2×3 矩阵接收 3 维输入、输出 2 维,是做降维;3×2 矩阵接收 2 维、输出 3 维,是把低维空间嵌到高维空间。

降维最直白的例子是丢掉一个坐标。取 P = [[1, 0, 0], [0, 1, 0]],它把 (3, 4, 5) 变成 (3, 4),第三个分量被直接扔掉。这个变换是线性的,但显然不可逆:只看 (3, 4),无法判断原来的第三个分量是 5、是 0、还是 −100。

升维的例子是 Q = [[1, 0], [0, 1], [0, 0]],它把 (3, 4) 变成 (3, 4, 0),把一个平面放进三维空间,第三个分量固定为 0。这个变换不丢信息,因为从结果里能读回原来的两个分量,但它把二维对象放到了一个更大的空间里。用代码把两者和它们的复合都跑出来:

P = [[1, 0, 0], [0, 1, 0]]
Q = [[1, 0], [0, 1], [0, 0]]

def mm(P, Q):
    return [[sum(P[i][k] * Q[k][j] for k in range(len(Q))) for j in range(len(Q[0]))] for i in range(len(P))]

def mv(P, u):
    return [sum(P[i][k] * u[k] for k in range(len(u))) for i in range(len(P))]

print("P is", len(P), "x", len(P[0]))
print("Q is", len(Q), "x", len(Q[0]))
print("P@Q", mm(P, Q))
print("Q@P", mm(Q, P))
print("P@(3,4,5)", mv(P, [3, 4, 5]))
print("Q@(3,4)", mv(Q, [3, 4]))
P is 2 x 3
Q is 3 x 2
P@Q [[1, 0], [0, 1]]
Q@P [[1, 0, 0], [0, 1, 0], [0, 0, 0]]
P@(3,4,5) [3, 4]
Q@(3,4) [3, 4, 0]

P 乘 Q 得到 2×2 的单位矩阵,说明「先升维再降维」在结果上等于什么都没做。但反过来,Q 乘 P 得到 3×3 的矩阵,它的第三行和第三列全是 0,作用在任何向量上都会把第三个分量抹掉,包括原本就有的第三个分量。所以「先降维再升维」不是恒等变换,而是把信息压扁后再也补不回来。

这也是非方阵不能有通常意义的逆的原因。P 是 2×3,Q 是 3×2,两者维度不同,P 的逆必须是一个 3×2 矩阵,但 3×2 乘 2×3 只能得到 3×3,凑不出 2×2 的单位矩阵。最多只能在某一侧有左逆或右逆,而且需要额外的秩条件。

从秩的角度看,P 的两行线性无关,秩是 2,但它作用在三维空间里,仍然有一个方向被压成 0;Q 的两列线性无关,秩也是 2,它把二维嵌进三维,但没有填满三维。非方阵的秩最多等于行数和列数中较小的那个,所以 2×3 和 3×2 的秩都不会超过 2。这个数字下一篇会正式定义,这里先建立直觉:秩是变换后还剩下几个独立方向。

一张现象对照表

下面这些现象,几乎都能用「列是基向量的去向」和「乘法不可交换」这两条来解释。

现象真实原因第一步查什么
旋转方向反了sin 的符号写反,或坐标轴 y 向下导致视觉方向相反检查 sin 符号和坐标系方向,再看向量是行还是列
两次变换顺序不对矩阵乘法不可交换,复合要从右往左读确认代码里 A@B 实际是先 B 后 A
图形被压扁矩阵接近奇异,或用了投影这类 det 为 0 的变换先算 det,再看两列是否近似共线
det 为 0 后无法还原不同输入被合并到同一输出,变换不可逆解 Mx=0,看是否有非零解
非方阵乘法形状错内维不相等,或升维降维的方向反了打印形状,确认 2×3 和 3×2 谁在左谁在右
平移怎么都做不出来2×2 矩阵只能表达固定原点的线性变换改用 3×3 齐次坐标,或把平移单独加在矩阵外
旋转后位置不对旋转中心不是原点,矩阵只绕原点转先平移到原点,转完再平移回去

边界与代价

第一,矩阵只能表达线性变换。它固定原点,保持直线和平行关系,不能把一条直线弯成曲线。现实里的透视、鱼眼、非线性形变,都超出 2×2 矩阵的范围。要包含平移,得升到齐次坐标;要包含弯曲,得引入非线性函数或者分片近似。

第二,非方阵不可逆。降维会丢信息,投影会把不同点合并,一旦丢了就补不回来。工程上常说的「压缩到低维再还原」,还原出来的只是投影,不是原始数据;能还原的前提是原始数据本来就落在那个低维子空间里。

第三,复合顺序敏感。矩阵乘法不可交换,旋转、缩放、剪切的先后会改变结果。三维里更复杂,绕不同轴的旋转组合通常不能交换,所以图形和机器人领域会用四元数或旋转向量来避免顺序带来的歧义。

第四,接近 det=0 时数值不稳定。det 很小意味着至少一个方向被压得很扁,求逆会把输入里的微小误差放大到 1/det 倍。det=1e-8 时,误差可能被放大一亿倍,计算结果看起来有值,实际已经不可信。判断矩阵是否「病态」,不能只看 det,还要看条件数。

第五,二维直觉不能直接搬到高维。三维旋转不是「绕一个点转」,而是「绕一条轴转」,四个参数描述一个旋转但有冗余;四维空间的旋转可以同时绕两个平面转。矩阵乘法的规则仍然成立,但几何解释需要重新建立。

第六,计算成本随维数上升。二维矩阵很小,三维图形管线用 4×4 齐次矩阵,深度学习里的矩阵动辄几千维。两个 n×n 矩阵相乘是 n 的三次方级,n 翻一倍,计算量变成八倍;显存和带宽也会跟着吃紧。几何直觉帮你看懂变换,但不能替代对成本的估算。

当天可以验证的练习

这五条都能用标准库完成,重点是把代码结果和手算结果对上。

  1. 手算 [[1, 2], [3, 4]] 乘 [[5, 6], [7, 8]] 的四个元素,再用嵌套循环验证,最后算一遍反过来的顺序,确认两个结果不同。
  2. 构造旋转 90 度的矩阵,分别作用在 (1, 0) 和 (0, 1) 上,验证它们落在 (0, 1) 和 (−1, 0),并用 1e-9 的容差判断 cos 的误差。
  3. 用同一个向量比较「先旋转再缩放」和「先缩放再旋转」,打印两组结果和两个复合矩阵,说明差在哪一步。
  4. 算 [[2, 0], [0, 1]] 和 [[1, 2], [2, 4]] 的行列式,解释单位正方形变换后的面积,再说明第二个为什么不可逆。
  5. 用 3×2 矩阵把 (3, 4) 升到三维,再用 2×3 矩阵降回二维,打印中间和最终结果,指出哪一步丢了信息、丢的是哪个分量。

小结

这篇的主线可以压成四句。矩阵乘法的内维必须对齐;矩阵的每一列记录一个基向量的去向;复合变换按从右往左的顺序作用,交换顺序结果就变;行列式是面积缩放倍数,非方阵负责升维和降维,降维会丢信息。

下一篇讲秩与可逆。行列式为 0 意味着变换把平面压成了一条线,多个输入挤到同一个输出,这时方程组要么无解,要么有无穷多解。秩就是用来量化「还剩几个独立方向」的,可逆则是「一个方向都没丢」的另一种说法。把这一篇的几何图像带过去,秩和逆会从公式变成看得见的东西。