线性代数速成：向量和矩阵为什么重要？

# 上一篇的更新方式
model.w = model.w - lr * dw
model.b = model.b - lr * db

y
↑
4 |         ↗ (3,4)
3 |       ↗
2 |     ↗
1 |   ↗
0 └──────────→ x
  0  1  2  3

不用矩阵（上一篇的写法）：
for i in range(100):
    y[i] = w1*x[i][0] + w2*x[i][1] + w3*x[i][2] + b

循环100次，每次3个乘法 → 300次运算，串行执行

用矩阵：
Y = X @ W + b

一次矩阵乘法 → 300次运算，并行执行

原始空间（线性不可分）：        变换后的空间（线性可分）：

  y                              y'
  ↑  ●○●                        ↑
  |  ○●○       矩阵变换W         |  ○○○
  |  ●○●     ────────→          |  ────── ← 一条线就能分开
  └──────→ x                    |  ●●●
                                └──────→ x'

import numpy as np
import time

# === 向量基本运算 ===

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

print("=== 向量基本运算 ===")
print(f"a = {a}")
print(f"b = {b}")
print(f"a + b = {a + b}")           # 加法
print(f"3 * a = {3 * a}")           # 数乘
print(f"a · b = {np.dot(a, b)}")    # 点积

# 向量的模
print(f"|a| = {np.linalg.norm(a):.4f}")

# 余弦相似度
cos_sim = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
print(f"cos(a, b) = {cos_sim:.4f}")

=== 向量基本运算 ===
a = [1 2 3]
b = [4 5 6]
a + b = [5 7 9]
3 * a = [3 6 9]
a · b = 32
|a| = 3.7417
cos(a, b) = 0.9746

# === 矩阵乘法 ===

A = np.array([[1, 2],
              [3, 4]])
B = np.array([[5, 6],
              [7, 8]])

print("=== 矩阵乘法 ===")
print(f"A:\n{A}")
print(f"B:\n{B}")
print(f"A @ B:\n{A @ B}")  # Python里 @ 就是矩阵乘法

# 手动验证
print(f"\n手动验证：")
print(f"[0,0] = 1*5 + 2*7 = {1*5 + 2*7}")
print(f"[0,1] = 1*6 + 2*8 = {1*6 + 2*8}")
print(f"[1,0] = 3*5 + 4*7 = {3*5 + 4*7}")
print(f"[1,1] = 3*6 + 4*8 = {3*6 + 4*8}")

=== 矩阵乘法 ===
A:
[[1 2]
 [3 4]]
B:
[[5 6]
 [7 8]]
A @ B:
[[19 22]
 [43 50]]

手动验证：
[0,0] = 1*5 + 2*7 = 19
[0,1] = 1*6 + 2*8 = 22
[1,0] = 3*5 + 4*7 = 43
[1,1] = 3*6 + 4*8 = 50

# === 对比：循环 vs 矩阵 ===

np.random.seed(42)

# 数据：1000条，每条5个特征
n_samples = 1000
n_features = 5

X = np.random.randn(n_samples, n_features)  # (1000, 5)
W = np.array([3.0, -1.5, 2.0, 0.5, -0.8])  # 真实权重
b = 4.0                                      # 真实偏置
Y_true = X @ W + b + np.random.randn(n_samples) * 0.5  # 加噪声

# --- 方式1：用循环 ---
def predict_loop(X, w, b):
    """循环方式：一条一条算"""
    n = len(X)
    y_pred = np.zeros(n)
    for i in range(n):
        total = 0
        for j in range(len(w)):
            total += w[j] * X[i][j]
        y_pred[i] = total + b
    return y_pred

# --- 方式2：用矩阵 ---
def predict_matrix(X, w, b):
    """矩阵方式：一次算完"""
    return X @ w + b

# 验证两种方式结果一致
w_init = np.random.randn(n_features)
b_init = 0.0

y1 = predict_loop(X, w_init, b_init)
y2 = predict_matrix(X, w_init, b_init)

print("=== 循环 vs 矩阵 ===")
print(f"结果一致？{np.allclose(y1, y2)}")
print(f"最大差异：{np.max(np.abs(y1 - y2)):.2e}")

# 速度对比
start = time.time()
for _ in range(100):
    predict_loop(X, w_init, b_init)
loop_time = time.time() - start

start = time.time()
for _ in range(100):
    predict_matrix(X, w_init, b_init)
matrix_time = time.time() - start

print(f"\n循环方式：{loop_time:.4f}秒 (100次)")
print(f"矩阵方式：{matrix_time:.4f}秒 (100次)")
print(f"加速比：{loop_time / matrix_time:.0f}x")

=== 循环 vs 矩阵 ===
结果一致？True
最大差异：0.00e+00

循环方式：0.5821秒 (100次)
矩阵方式：0.0008秒 (100次)
加速比：728x

class LinearRegressionMatrix:
    """矩阵版本的线性回归"""

    def __init__(self, n_features):
        self.W = np.random.randn(n_features) * 0.01  # 权重向量
        self.b = 0.0                                   # 偏置

    def predict(self, X):
        """前向传播：Ŷ = XW + b"""
        return X @ self.W + self.b

    def loss(self, X, Y):
        """MSE损失"""
        Y_pred = self.predict(X)
        return np.mean((Y_pred - Y) ** 2)

    def gradients(self, X, Y):
        """
        矩阵形式的梯度

        L = (1/N) * ||XW + b - Y||²

        ∂L/∂W = (2/N) * Xᵀ(XW + b - Y)
        ∂L/∂b = (2/N) * sum(XW + b - Y)
        """
        N = len(X)
        error = self.predict(X) - Y           # (N,)

        dW = (2 / N) * (X.T @ error)          # (n_features,)
        db = (2 / N) * np.sum(error)           # 标量

        return dW, db

    def train(self, X, Y, lr=0.01, epochs=100, print_every=20):
        """梯度下降训练"""
        losses = []
        print(f"初始损失: {self.loss(X, Y):.4f}")
        print(f"目标权重: {W}")
        print("-" * 60)

        for epoch in range(epochs):
            dW, db = self.gradients(X, Y)
            self.W -= lr * dW
            self.b -= lr * db
            current_loss = self.loss(X, Y)
            losses.append(current_loss)

            if (epoch + 1) % print_every == 0:
                print(f"Epoch {epoch+1:4d} | Loss: {current_loss:.6f} | "
                      f"W: [{', '.join(f'{w:.3f}' for w in self.W)}] | "
                      f"b: {self.b:.3f}")

        print("-" * 60)
        print(f"学到的W: [{', '.join(f'{w:.3f}' for w in self.W)}]")
        print(f"真实的W: [{', '.join(f'{w:.3f}' for w in W)}]")
        print(f"学到的b: {self.b:.3f}，真实的b: {b:.3f}")
        return losses

# 训练
model = LinearRegressionMatrix(n_features=5)
losses = model.train(X, Y_true, lr=0.01, epochs=200, print_every=40)

初始损失: 17.8234
目标权重: [ 3.  -1.5  2.   0.5 -0.8]
------------------------------------------------------------
Epoch   40 | Loss: 0.269384 | W: [2.993, -1.497, 1.992, 0.496, -0.795] | b: 3.996
Epoch   80 | Loss: 0.252173 | W: [2.999, -1.501, 1.998, 0.499, -0.799] | b: 3.999
Epoch  120 | Loss: 0.251627 | W: [3.000, -1.501, 1.999, 0.500, -0.800] | b: 4.000
Epoch  160 | Loss: 0.251610 | W: [3.000, -1.501, 1.999, 0.500, -0.800] | b: 4.000
Epoch  200 | Loss: 0.251609 | W: [3.000, -1.501, 1.999, 0.500, -0.800] | b: 4.000
------------------------------------------------------------
学到的W: [3.000, -1.501, 1.999, 0.500, -0.800]
真实的W: [3.000, -1.500, 2.000, 0.500, -0.800]
学到的b: 4.000，真实的b: 4.000

输入: X (batch_size × seq_len × d_model)

1. Q = X @ W_Q    (生成Query)
2. K = X @ W_K    (生成Key)
3. V = X @ W_V    (生成Value)
4. scores = Q @ K.T  (计算注意力分数)
5. output = scores @ V  (加权求和)
6. output = output @ W_O  (输出投影)
7. FFN: output @ W1, 再 @ W2  (前馈网络)

import time
import numpy as np

sizes = [100, 500, 1000, 2000, 4000]

print("=== 矩阵乘法计算时间 ===")
print(f"{'矩阵大小':>12} | {'计算时间':>10} | {'运算次数':>12}")
print("-" * 45)

for n in sizes:
    A = np.random.randn(n, n)
    B = np.random.randn(n, n)

    start = time.time()
    for _ in range(3):
        C = A @ B
    elapsed = (time.time() - start) / 3

    ops = 2 * n * n * n  # 乘法+加法
    print(f"{n:>5}x{n:<5} | {elapsed:>8.4f}秒 | {ops:>12,}")

print(f"\n对比：GPT-2一次前向传播约需要 10^12 次浮点运算")
print(f"对比：GPT-4一次前向传播约需要 10^14 次浮点运算")

=== 矩阵乘法计算时间 ===
  矩阵大小 |     计算时间 |       运算次数
---------------------------------------------
 100x100   |   0.0001秒 |    2,000,000
 500x500   |   0.0042秒 |  250,000,000
1000x1000  |   0.0280秒 |    2,000,000,000
2000x2000  |   0.1950秒 |   16,000,000,000
4000x4000  |   1.4200秒 |  128,000,000,000

对比：GPT-2一次前向传播约需要 10^12 次浮点运算
对比：GPT-4一次前向传播约需要 10^14 次浮点运算

输入层          隐藏层          输出层
(3个特征)      (4个神经元)     (1个输出)

 x₁ ──┐
       ├──→  h₁ ──┐
 x₂ ──┤          ├──→  y
       ├──→  h₂ ──┤
 x₃ ──┤          ├──→
       ├──→  h₃ ──┘
       └──→  h₄

数学表达：

第一层: h = ReLU(X @ W₁ + b₁)
  X: (batch, 3)
  W₁: (3, 4)
  b₁: (4,)
  h: (batch, 4)

第二层: y = h @ W₂ + b₂
  h: (batch, 4)
  W₂: (4, 1)
  b₂: (1,)
  y: (batch, 1)

class TwoLayerNet:
    """一个两层神经网络，纯矩阵运算"""

    def __init__(self, input_dim, hidden_dim, output_dim):
        # 随机初始化权重
        self.W1 = np.random.randn(input_dim, hidden_dim) * 0.1
        self.b1 = np.zeros(hidden_dim)
        self.W2 = np.random.randn(hidden_dim, output_dim) * 0.1
        self.b2 = np.zeros(output_dim)

    def relu(self, x):
        """ReLU激活函数：小于0的变成0"""
        return np.maximum(0, x)

    def forward(self, X):
        """前向传播"""
        # 第一层：线性变换 + ReLU
        self.z1 = X @ self.W1 + self.b1          # 矩阵乘法
        self.a1 = self.relu(self.z1)              # 激活函数

        # 第二层：线性变换（输出层不用激活函数）
        self.z2 = self.a1 @ self.W2 + self.b2     # 矩阵乘法

        return self.z2

    def loss(self, X, Y):
        """MSE损失"""
        Y_pred = self.forward(X)
        return np.mean((Y_pred.flatten() - Y) ** 2)

# 测试
net = TwoLayerNet(input_dim=5, hidden_dim=16, output_dim=1)

# 用之前的数据
Y_pred = net.forward(X)
print(f"输入形状: {X.shape}")              # (1000, 5)
print(f"第一层输出形状: {net.a1.shape}")     # (1000, 16)
print(f"最终输出形状: {Y_pred.shape}")       # (1000, 1)
print(f"参数总量: {5*16 + 16 + 16*1 + 1} = {5*16 + 16 + 16*1 + 1}")

输入形状: (1000, 5)
第一层输出形状: (1000, 16)
最终输出形状: (1000, 1)
参数总量: 5*16 + 16 + 16*1 + 1 = 113

def shape_trace(X, W1, b1, W2, b2):
    """追踪每一步的张量形状"""
    print("=== 形状追踪 ===")
    print(f"输入 X:     {X.shape}")
    print(f"权重 W1:    {W1.shape}")

    z1 = X @ W1
    print(f"X @ W1:     {z1.shape}  ← ({X.shape[0]}×{X.shape[1]}) @ ({W1.shape[0]}×{W1.shape[1]})")

    z1 = z1 + b1
    print(f"+ b1:       {z1.shape}  ← 广播加法")

    a1 = np.maximum(0, z1)
    print(f"ReLU(z1):   {a1.shape}  ← 逐元素操作，形状不变")

    print(f"权重 W2:    {W2.shape}")
    z2 = a1 @ W2
    print(f"a1 @ W2:    {z2.shape}  ← ({a1.shape[0]}×{a1.shape[1]}) @ ({W2.shape[0]}×{W2.shape[1]})")

    z2 = z2 + b2
    print(f"+ b2:       {z2.shape}  ← 最终输出")

shape_trace(X, net.W1, net.b1, net.W2, net.b2)

=== 形状追踪 ===
输入 X:     (1000, 5)
权重 W1:    (5, 16)
X @ W1:     (1000, 16)  ← (1000×5) @ (5×16)
+ b1:       (1000, 16)  ← 广播加法
ReLU(z1):   (1000, 16)  ← 逐元素操作，形状不变
权重 W2:    (16, 1)
a1 @ W2:    (1000, 1)   ← (1000×16) @ (16×1)
+ b2:       (1000, 1)   ← 最终输出

X @ W1 的结果:           b1:              相加结果:
┌─────────────┐       ┌──────┐       ┌─────────────┐
│ z₁₁ z₁₂ ... │       │b₁ b₂│       │z₁₁+b₁ z₁₂+b₂│
│ z₂₁ z₂₂ ... │   +   │b₁ b₂│   =   │z₂₁+b₁ z₂₂+b₂│
│ ... ... ... │       │ ... │       │ ...  ...     │
│ zₙ₁ zₙ₂ ... │       │b₁ b₂│       │zₙ₁+b₁ zₙ₂+b₂│
└─────────────┘       └──────┘       └─────────────┘
  (1000, 16)            (16,)          (1000, 16)
                      ↑ 自动复制1000行

# 合法广播
(1000, 16) + (16,)     → (1000, 16)  # b1加到每一行
(1000, 16) + (1, 16)   → (1000, 16)  # 同上
(1000, 1)  + (1, 16)   → (1000, 16)  # 两边都广播

# 不合法
(1000, 16) + (15,)     → 报错！16 ≠ 15

从前两篇到这一篇，我们已经掌握了AI训练的核心数学工具：

| 篇章 | 工具 | 解决的问题 |
|------|------|-----------|
| 1-1 函数与导数 | 导数、偏导数、梯度 | 知道参数往哪个方向调 |
| 1-2 梯度下降 | 梯度下降、Adam优化器 | 知道怎么一步步调参数 |
| **1-3 线性代数** | **向量、矩阵、矩阵乘法** | **知道怎么高效地算** |

---

## 九、总结

### 三个层次的理解

**第一层：直觉**
> 向量是"一组数字"。矩阵是"一堆向量"。矩阵乘法是"批量做点积"。神经网络每一层就是一次矩阵乘法。

**第二层：数学**
> 矩阵乘法实现了线性变换——对空间的旋转、拉伸、投影。加上激活函数的非线性变换，神经网络可以把数据变换到任意形状的空间。

**第三层：工程实践**
> 矩阵运算可以被GPU并行加速。把循环改成矩阵运算，速度提升几百倍。这就是为什么AI训练需要显卡。

### 关键公式卡片

### 下期预告

下一篇：**《概率论基础：AI的"不确定性"从何而来？》**

到目前为止，我们的模型输出的是一个确定的数字（比如预测房价123万）。但AI经常需要回答的问题是："这张图片是猫的概率是多少？"

概率论给了AI处理"不确定性"的能力。下一篇我们从高中的概率开始，讲到贝叶斯定理、概率分布，最终理解Softmax——Transformer输出层那个把"分数"变成"概率"的函数。

---

*写于2026年2月，"技术解码·数学筑基"系列第3篇。*
*从循环到矩阵，从CPU到GPU，效率提升的秘密藏在线性代数里。*

**系列导航**：
- 上篇：[[博客-技术解码-1.2-梯度下降]] 1-2 梯度下降：AI是怎么"学习"的？
- 本篇：1-3 线性代数速成：向量和矩阵为什么重要？
- 下篇：[[博客-技术解码-1.4-概率论基础]] 1-4 概率论基础：AI的"不确定性"从何而来？