矩阵即线性变换

上一课我们确立了"万物皆向量"，并用点积衡量两个向量的关系。这一课，我们让整个空间动起来：矩阵不再是一张死板的数表，而是一台变换空间的机器——它把每个向量搬到新位置，让网格被缩放、旋转、剪切、压扁。理解了这一点，你就拿到了打开线性代数（以及神经网络）的钥匙。

一、矩阵的双重身份

一个矩阵 \(A\) 同时是两样东西：

• 静态视角：一张数表。比如 \(A=\begin{bmatrix} 2 & 1 \\ 0 & 3 \end{bmatrix}\)，就是排成方阵的四个数。
• 动态视角：一个线性变换 linear transformation。它是一个函数，吃进一个向量 \(v\)，吐出另一个向量 \(Av\)。它作用在整个平面的每一个点上，把空间"掰弯"成新形状。这里的"线性"是有严格含义的——它指变换保持加法和数乘（精确的三条性质我们第三节就给出）。

二、矩阵的列 = 基向量变换后的落点

这是全课最重要的一句话，值得你停下来反复咀嚼。

回忆平面里的两个基向量 basis vector：

任何向量都是它们的线性组合，例如 \(v=\begin{bmatrix}x\\y\end{bmatrix}=x\,\hat{\imath}+y\,\hat{\jmath}\)。

线性变换有个关键性质：只要知道 \(\hat{\imath}\) 和 \(\hat{\jmath}\) 被搬到哪里，就知道所有向量被搬到哪里。这一步用到下一节会正式讲的两条性质——把和拆开（可加性）、把标量提到前面（齐次性）。我们一步步展开，看清楚它不是黑魔法而是机械的两步：

现在看 \(A=\begin{bmatrix} 2 & 1 \\ 0 & 3 \end{bmatrix}\) 怎么作用在基向量上：

看出来了吗？\(A\hat{\imath}\) 恰好是 \(A\) 的第一列，\(A\hat{\jmath}\) 恰好是 \(A\) 的第二列。这不是巧合——这就是矩阵的定义方式。

三、什么样的变换才算"线性"

上一节我们已经反复用到"线性变换"这个词，现在给它一个精确的定义。不是任何把向量搬来搬去的规则都叫线性变换——线性变换必须满足三条性质：

1. 保持加法（可加性）：\(A(u+v)=Au+Av\)。
2. 保持数乘（齐次性）：\(A(c\,v)=c\,(Av)\)。
3. 原点不动：\(A\,\mathbf{0}=\mathbf{0}\)（这其实是齐次性取 \(c=0\) 的推论）。

回头看第二节那个把 \(Av\) 拆成 \(x(A\hat{\imath})+y(A\hat{\jmath})\) 的等式：第一步"把和拆开"正是性质 1，第二步"把标量提出来"正是性质 2。所以"列视角"不是凭空的魔法，而是这两条性质的直接推论。

四、五种最常见的 2D 变换

下表把几何动作翻译成矩阵。建议你对每个矩阵都心算一下它把 \(\hat{\imath},\hat{\jmath}\)（即两列）搬到了哪里。

旋转矩阵从哪来？

用列视角秒推：逆时针转 \(\theta\) 后，\(\hat{\imath}=(1,0)\) 落到 \((\cos\theta,\sin\theta)\)，\(\hat{\jmath}=(0,1)\) 落到 \((-\sin\theta,\cos\theta)\)。把这两个落点当列拼起来，就是旋转矩阵：

五、行列式：面积的缩放因子

变换把空间拉伸或压缩，那"被放大了多少倍"？答案就是行列式 determinant，记作 \(\det A\) 或 \(|A|\)。对 \(2\times2\)：

六、矩阵乘法 = 变换的复合

如果先做变换 \(B\)、再做变换 \(A\)，整体效果是什么？把它作用在 \(x\) 上就是 \(A(Bx)\)。我们定义矩阵乘积 \(AB\)，使得

也就是说，矩阵乘法 \(AB\) 就是"先 \(B\) 后 \(A\)"这个复合变换对应的那个矩阵。注意书写顺序：靠近 \(x\) 的先作用，所以要从右往左读。（记个口诀：谁挨着 \(x\)，谁先上场。）

为什么一般 \(AB\neq BA\)？

因为"先剪切后旋转"和"先旋转后剪切"在几何上根本是两件事。举例，取旋转 90° 的 \(A=\begin{bmatrix}0&-1\\1&0\end{bmatrix}\) 与缩放 \(B=\begin{bmatrix}2&0\\0&1\end{bmatrix}\)：

两者不等，所以矩阵乘法不满足交换律。（但满足结合律 \((AB)C=A(BC)\)，这正是复合变换天然成立的。）

七、形状契约：维数怎么对上

到这里前六节用的都是 \(2\times2\) 方阵——输入和输出都在同一个平面里。但矩阵不必是方的。一个 \(m\times n\) 矩阵代表一个把 \(n\) 维向量送到 \(m\) 维空间的线性变换（\(n\) 列、每列是 \(m\) 维落点）。这意味着它可以改变维数。

先用一个最小的非方阵建立画面：

它是 \(2\times3\)，把三维向量送到二维。看它怎么作用：\(P\begin{bmatrix}x\\y\\z\end{bmatrix}=\begin{bmatrix}x\\y\end{bmatrix}\)——它丢掉了 \(z\) 坐标，把 3D 空间压扁投影到 \(xy\) 平面上，这正是一次"降维"。反过来，一个 \(3\times2\) 矩阵则把平面"嵌入"到三维空间里（升维）。"\(m\neq n\) 到底在做什么"，答案就是在维数之间搬运。

乘法要能进行，必须满足形状契约：

八、秩与零空间：被压扁到几维

当 \(\det A=0\)（或更一般地，非方阵情形），空间被压扁了。两个概念精确描述"压扁的后果"：

• 秩 rank：变换后的输出实际填满了几维空间——即列向量张成空间的维数。满秩 = 没压扁；秩下降 = 被压扁了。例如投影 \(\begin{bmatrix}1&0\\0&0\end{bmatrix}\) 把整个平面压到一条直线上，秩 = 1。
• 零空间 null space（也叫核 kernel）：所有被变换压到原点 \(\mathbf{0}\) 的向量集合，即满足 \(Av=\mathbf{0}\) 的 \(v\)。它衡量"丢失了哪些信息"。

九、用 numpy 把这一切跑一遍

下面的代码只用 numpy 和 print，几秒跑完。它打印基向量落点、行列式、并验证 \(A(Bx)=(AB)x\) 以及 \(\det(AB)=\det A\det B\)。

import numpy as np

A = np.array([[2., 1.],
              [0., 3.]])

# 1) 矩阵的列 = 基向量变换后的落点
i_hat = np.array([1., 0.])
j_hat = np.array([0., 1.])
print("A @ i_hat =", A @ i_hat, "  <- 应等于 A 的第一列", A[:, 0])
print("A @ j_hat =", A @ j_hat, "  <- 应等于 A 的第二列", A[:, 1])

# 2) 行列式 = 面积缩放因子
print("det(A) =", round(np.linalg.det(A), 6))   # 期望 6.0

# 单位正方形四角 -> 验证面积
square = np.array([[0, 0], [1, 0], [1, 1], [0, 1]]).T  # 每列一个角
print("正方形四角变换后(每行一个角):")
print((A @ square).T)

# 3) 旋转 90 度: (x,y) -> (-y,x)
theta = np.pi / 2
R = np.array([[np.cos(theta), -np.sin(theta)],
              [np.sin(theta),  np.cos(theta)]])
print("R @ [3,2] =", np.round(R @ np.array([3., 2.]), 6))  # 期望 [-2, 3]

# 4) 复合变换 = 矩阵相乘
B = np.array([[1., 1.],
              [0., 1.]])           # 剪切
x = np.array([2., 1.])
print("A @ (B @ x) =", A @ (B @ x))   # 分两步
print("(A @ B) @ x =", (A @ B) @ x)   # 先乘矩阵, 两者应相同

# 5) 乘法不可交换 + 行列式可乘
print("AB =\n", A @ B)
print("BA =\n", B @ A, "  <- 与 AB 不同")
print("det(A)*det(B) =", round(np.linalg.det(A) * np.linalg.det(B), 6),
      " det(AB) =", round(np.linalg.det(A @ B), 6))

运行后你会看到：基向量落点恰是 \(A\) 的两列；\(\det A=6\) 与四角围成的面积一致；\(R[3,2]^\top=[-2,3]^\top\)；两条复合路线都给 \([7,3]^\top\)；而 \(AB\neq BA\)，但 \(\det(AB)=\det A\det B=6\)。

调一调，观察现象

下面三个小实验都只用 numpy 和 print，几秒跑完。每个都先猜结果再运行，重点是把"改一个数 → 几何上发生了什么"对应起来。

import numpy as np
for k in [0., 1., 3.]:
    S = np.array([[1., k],
                  [0., 1.]])
    print("k =", k,
          " j_hat 落点 =", S @ np.array([0., 1.]),
          " det =", round(np.linalg.det(S), 6))

import numpy as np
A = np.array([[2., 1.],
              [0., 3.]])
A_swap = A[[1, 0], :]          # 对调两行
print("det(A)      =", round(np.linalg.det(A), 6))       # 期望 6.0
print("det(行交换) =", round(np.linalg.det(A_swap), 6))   # 期望 -6.0

import numpy as np
th = 0.7
R = np.array([[np.cos(th), -np.sin(th)],
              [np.sin(th),  np.cos(th)]])     # 旋转
D = np.diag([2., 5.])                         # 缩放
P = np.array([[1., 0.],
              [0., 0.]])                      # 投影
print("det(旋转) =", round(np.linalg.det(R), 6))   # 期望 1.0
print("det(缩放) =", round(np.linalg.det(D), 6))   # 期望 10.0
print("det(投影) =", round(np.linalg.det(P), 6))   # 期望 0.0

动手练习

1. 手算 + 列视角。给定 \(M=\begin{bmatrix}3&-1\\2&2\end{bmatrix}\)，(a) 写出它把 \(\hat{\imath},\hat{\jmath}\) 搬到的落点；(b) 用列视角算 \(M\begin{bmatrix}1\\2\end{bmatrix}\)；(c) 算 \(\det M\) 并说出面积放大几倍、有没有翻转。

   import numpy as np
   M = np.array([[3., -1.], [2., 2.]])
   # TODO: 打印 M 的两列、M @ [1,2]、det(M)
   print(M[:, 0], M[:, 1])
   print(M @ np.array([1., 2.]))
   print(round(np.linalg.det(M), 6))
   

2. 旋转复合。构造旋转 30° 与旋转 60° 的矩阵，验证它们相乘等于旋转 90° 的矩阵（提示：转 30° 再转 60° 当然等于转 90°）。

   import numpy as np
   def rot(t):
       return np.array([[np.cos(t), -np.sin(t)],
                        [np.sin(t),  np.cos(t)]])
   # TODO: 比较 rot(60度) @ rot(30度) 与 rot(90度)
   print(np.round(rot(np.pi/3) @ rot(np.pi/6), 6))
   print(np.round(rot(np.pi/2), 6))
   

3. 压扁、零空间与守恒律。对投影矩阵 \(P=\begin{bmatrix}1&0\\0&0\end{bmatrix}\)：(a) 写出它零空间的一个基向量（一个非零 \(v\) 使 \(Pv=\mathbf{0}\)）；(b) 说出它的秩等于几；(c) 验证"秩 + 零空间维 = 2"这条守恒律；(d) 顺手算 \(\det P\) 确认它为 0。

   import numpy as np
   P = np.array([[1., 0.], [0., 0.]])
   # TODO: 找零空间的基, 数秩, 验证守恒律
   v = np.array([0., 1.])             # 零空间的一个基向量?
   print("P @ v =", P @ v)            # 期望 [0, 0]
   print("rank(P) =", np.linalg.matrix_rank(P))   # 期望 1
   print("det(P) =", round(np.linalg.det(P), 6))  # 期望 0.0
   

4. 不可交换的几何（含 det<0）。取剪切 \(S=\begin{bmatrix}1&1\\0&1\end{bmatrix}\) 与反射 \(F=\begin{bmatrix}1&0\\0&-1\end{bmatrix}\)，算 \(SF\) 与 \(FS\)，确认不相等，并各自把 \(\begin{bmatrix}1\\1\end{bmatrix}\) 变换一遍看落点差别；再算 \(\det F\) 确认它是负的（反射翻转了定向）。
5. 形状契约。随机生成一个 \(2\times3\) 矩阵和一个 \(3\times4\) 矩阵相乘，打印结果形状，确认是 \(2\times4\)；再试着把它们反过来乘，观察 numpy 报什么错。

掌握自检

• 看到任意 \(2\times2\) 矩阵，我能立刻说出它把 \(\hat{\imath},\hat{\jmath}\) 搬到哪两个点（即读出两列）。
• 我能用"列的线性组合"和"逐行点积"两种方式算 \(Av\)，并得到相同结果。
• 我能说清线性变换的三条性质，能给出仿射变换的正面定义（\(x\mapsto Ax+b\)），并解释为什么 \(Wx+b\) 严格说是仿射而非线性。
• 给定一个矩阵，我能算 \(\det\) 并解释它的大小、符号、为零各意味着什么几何后果（包括反射的 \(\det=-1\) 为何代表翻转）。
• 我理解 \((AB)x=A(Bx)\)，能举例说明为什么 \(AB\neq BA\)，并知道形状契约 \((m\times n)(n\times p)=(m\times p)\)。
• 我能用"压扁到几维"解释秩，用"哪些向量被压到 0"解释零空间，并能亲手验证"秩 + 零空间维 = 列数"。
• 我能讲出为什么"线性层之间必须插非线性"，以及 \(QK^\top\) 在算什么。

下一课，我们把"点积"升级为内积，用它一次讲透度量、正交、投影、最小二乘——也就是机器学习里"拟合"与"误差最小化"的几何本质。