1533 lines
35 KiB
Markdown
1533 lines
35 KiB
Markdown
# 📚 多层感知机（MLP）—— 从零理解神经网络（详细版）
|
||
|
||
|
||
|
||
# 🎯 本章学习目标
|
||
|
||
| 目标 | 说明 |
|
||
|------|------|
|
||
| **理解** | 什么是函数——机器学习的核心数学工具 |
|
||
| **理解** | 单层感知机为什么只能解决线性问题（含数学证明） |
|
||
| **理解** | 多层感知机如何解决非线性问题（数学原理） |
|
||
| **掌握** | 前向传播：数据如何在网络中流动（含矩阵维度分析） |
|
||
| **掌握** | 反向传播：网络如何从错误中学习（完整链式法则推导） |
|
||
| **掌握** | 用 NumPy 从零实现一个 MLP（不依赖任何框架） |
|
||
| **理解** | 激活函数、损失函数、学习率等核心概念（含求导过程） |
|
||
|
||
---
|
||
|
||
# 📖 第一部分：数学基础 —— 你必须知道的概念
|
||
|
||
|
||
## 1.1 什么是函数？
|
||
|
||
### 1.1.1 函数的定义
|
||
|
||
**函数**是一种对应规则：输入一个值，经过某种规则，输出一个值。
|
||
|
||
数学定义：
|
||
```
|
||
设 D 是一个非空数集，如果对于 D 中的每一个数 x，按照某种规则 f，
|
||
都能确定唯一一个数 y 与之对应，那么我们就说 f 是定义在 D 上的函数，
|
||
记作：
|
||
|
||
y = f(x)
|
||
|
||
其中：
|
||
- x 称为自变量（输入）
|
||
- y 称为因变量（输出）
|
||
- D 称为定义域（所有可能的输入）
|
||
- f 称为对应规则（函数本身）
|
||
```
|
||
|
||
### 1.1.2 函数的直观理解
|
||
|
||
```
|
||
y = f(x) 可以想象为一个"加工机器"：
|
||
|
||
输入 x --> [ f ] --> 输出 y
|
||
|
||
例子：
|
||
- y = 2x + 1 是一个加工机器：输入 x，输出 2x+1
|
||
- y = x^2 是一个加工机器：输入 x，输出 x^2
|
||
- y = sin(x) 是一个加工机器：输入 x，输出 sin(x)
|
||
```
|
||
|
||
### 1.1.3 神经网络本质上是一个复杂的函数
|
||
|
||
```
|
||
传统函数：
|
||
y = f(x) = 2x + 1
|
||
|
||
神经网络（想象）：
|
||
y = f(x) = ReLU(W2 * ReLU(W1 * x + b1) + b2)
|
||
|
||
这是一个多层嵌套的函数！
|
||
x = 输入（比如一张图片的像素）
|
||
y = 输出（比如图片是数字几的概率）
|
||
```
|
||
|
||
### 1.1.4 多元函数
|
||
|
||
神经网络处理的是多元函数，即有多个输入的函数：
|
||
|
||
```
|
||
z = f(x, y) = x + 2y
|
||
|
||
例子：
|
||
输入：x = 3, y = 5
|
||
输出：z = 3 + 2*5 = 13
|
||
|
||
在神经网络中：
|
||
输入可能是 784 个数（x1, x2, x3, ..., x784）
|
||
输出可能是 10 个数（y1, y2, ..., y10）
|
||
|
||
z1 = f1(x1, x2, ..., x784)
|
||
z2 = f2(x1, x2, ..., x784)
|
||
...
|
||
z10 = f10(x1, x2, ..., x784)
|
||
```
|
||
---
|
||
|
||
## 1.2 导数 —— 变化的度量
|
||
|
||
### 1.2.1 导数的物理意义
|
||
|
||
导数描述的是"变化率"：
|
||
|
||
```
|
||
导数的定义：
|
||
f'(x) = lim(h->0) [f(x+h) - f(x)] / h
|
||
|
||
含义：
|
||
- 当 h 趋近于 0 时，差商 [f(x+h) - f(x)] / h 趋近于一个常数
|
||
- 这个常数就是函数 f 在点 x 处的导数
|
||
- 导数表示：在点 x 处，f 的值随着 x 的增加而变化的快慢
|
||
|
||
几何意义：切线的斜率
|
||
物理意义：瞬时变化率
|
||
```
|
||
|
||
### 1.2.2 常见函数的导数
|
||
|
||
```
|
||
1. 常数函数：f(x) = C
|
||
f'(x) = 0
|
||
|
||
2. 幂函数：f(x) = x^n
|
||
f'(x) = n * x^(n-1)
|
||
|
||
例子：
|
||
f(x) = x^2 -> f'(x) = 2x
|
||
f(x) = x^3 -> f'(x) = 3x^2
|
||
|
||
3. 指数函数：f(x) = e^x
|
||
f'(x) = e^x
|
||
|
||
4. 对数函数：f(x) = ln(x)
|
||
f'(x) = 1/x
|
||
|
||
5. 三角函数：
|
||
f(x) = sin(x) -> f'(x) = cos(x)
|
||
f(x) = cos(x) -> f'(x) = -sin(x)
|
||
```
|
||
|
||
### 1.2.3 导数的运算法则
|
||
|
||
```
|
||
加法法则：[f(x) + g(x)]' = f'(x) + g'(x)
|
||
|
||
乘法法则：[f(x) * g(x)]' = f'(x) * g(x) + f(x) * g'(x)
|
||
|
||
除法法则：[f(x) / g(x)]' = [f'(x) * g(x) - f(x) * g'(x)] / g(x)^2
|
||
|
||
链式法则（最重要）：[f(g(x))]' = f'(g(x)) * g'(x)
|
||
```
|
||
|
||
### 1.2.4 链式法则详解
|
||
|
||
链式法则是理解反向传播的数学基础，必须深入理解！
|
||
|
||
```
|
||
如果 y = f(u)，且 u = g(x)
|
||
那么 y = f(g(x)) 是 x 的复合函数
|
||
|
||
链式法则：
|
||
dy/dx = dy/du * du/dx
|
||
|
||
也可以写成：
|
||
d/dx [f(g(x))] = f'(g(x)) * g'(x)
|
||
|
||
直观理解：
|
||
dy/dx = dy/du * du/dx
|
||
= (y 相对 u 的变化率) * (u 相对 x 的变化率)
|
||
```
|
||
|
||
**例子1**：
|
||
```
|
||
y = (2x + 1)^3
|
||
|
||
令 u = 2x + 1，则 y = u^3
|
||
|
||
dy/du = 3u^2 = 3(2x+1)^2
|
||
du/dx = 2
|
||
|
||
所以 dy/dx = 3u^2 * 2 = 6(2x+1)^2 = 6(2x+1)^2
|
||
```
|
||
|
||
**例子2**：
|
||
```
|
||
y = e^(3x)
|
||
|
||
令 u = 3x，则 y = e^u
|
||
|
||
dy/du = e^u = e^(3x)
|
||
du/dx = 3
|
||
|
||
所以 dy/dx = e^(3x) * 3 = 3e^(3x)
|
||
```
|
||
|
||
### 1.2.5 偏导数
|
||
|
||
当函数有多个自变量时，我们需要偏导数：
|
||
|
||
```
|
||
设 z = f(x, y) = x^2 + 3xy + y^2
|
||
|
||
对 x 的偏导数（把 y 看作常数）：
|
||
∂z/∂x = 2x + 3y
|
||
|
||
对 y 的偏导数（把 x 看作常数）：
|
||
∂z/∂y = 3x + 2y
|
||
|
||
例子：计算 f(1, 2) 的偏导数
|
||
∂z/∂x|(1,2) = 2*1 + 3*2 = 8
|
||
∂z/∂y|(1,2) = 3*1 + 2*2 = 7
|
||
```
|
||
|
||
---
|
||
|
||
## 1.3 线性代数基础
|
||
|
||
### 1.3.1 向量
|
||
|
||
**向量**是一串数字的有序排列：
|
||
|
||
```
|
||
向量 a = [a1, a2, ..., an] 称为 n 维向量
|
||
|
||
例子：
|
||
速度 v = [vx, vy, vz] = [3, 4, 0] 是一个三维向量
|
||
像素 p = [255, 128, 64, ...] 是一个 784 维向量
|
||
|
||
向量的维度：向量中元素的个数
|
||
|
||
向量运算：
|
||
加法：[1,2] + [3,4] = [4,6]
|
||
数乘：2 * [1,2] = [2,4]
|
||
点积：[1,2] · [3,4] = 1*3 + 2*4 = 11
|
||
```
|
||
|
||
**向量的点积（内积）**：
|
||
```
|
||
向量 a = [a1, a2, ..., an]
|
||
向量 b = [b1, b2, ..., bn]
|
||
|
||
点积 a · b = a1*b1 + a2*b2 + ... + an*bn = Σ(ai*bi)
|
||
|
||
几何意义：
|
||
a · b = |a| * |b| * cos(θ)
|
||
|
||
其中 |a| 是向量 a 的长度，θ 是两个向量的夹角
|
||
|
||
当两个向量垂直时（θ = 90°），cos(90°) = 0，点积为 0
|
||
```
|
||
|
||
### 1.3.2 矩阵
|
||
|
||
**矩阵**是一个数字的矩形表格：
|
||
|
||
```
|
||
矩阵 A = [[a11, a12, ..., a1n],
|
||
[a21, a22, ..., a2n],
|
||
...
|
||
[am1, am2, ..., amn]]
|
||
|
||
称为 m 行 n 列的矩阵，记作 A(m x n)
|
||
|
||
例子：
|
||
图片（28x28）是一个 28 行 28 列的矩阵：
|
||
|
||
A = [[0, 128, 255, ..., 0],
|
||
[255, 0, 128, ..., 45],
|
||
...
|
||
[45, 100, 0, ..., 78]]
|
||
```
|
||
|
||
### 1.3.3 矩阵乘法
|
||
|
||
这是神经网络最核心的运算！
|
||
|
||
```
|
||
矩阵 A (m x n) 与矩阵 B (n x k) 的乘积 C (m x k)：
|
||
|
||
C = A @ B
|
||
|
||
其中 C 的每个元素：
|
||
C[i,j] = Σ(A[i,:] * B[:,j]) = A[i,1]*B[1,j] + A[i,2]*B[2,j] + ... + A[i,n]*B[n,j]
|
||
```
|
||
|
||
**例子**：
|
||
```
|
||
A (2x3) = [[1, 2, 3], B (3x2) = [[7, 8],
|
||
[4, 5, 6]] [9, 10],
|
||
[11, 12]]
|
||
|
||
C = A @ B (2x2):
|
||
|
||
C[0,0] = 1*7 + 2*9 + 3*11 = 7 + 18 + 33 = 58
|
||
C[0,1] = 1*8 + 2*10 + 3*12 = 8 + 20 + 36 = 64
|
||
C[1,0] = 4*7 + 5*9 + 6*11 = 28 + 45 + 66 = 139
|
||
C[1,1] = 4*8 + 5*10 + 6*12 = 32 + 50 + 72 = 154
|
||
|
||
C = [[58, 64],
|
||
[139, 154]]
|
||
```
|
||
|
||
### 1.3.4 神经网络中的矩阵运算
|
||
|
||
```
|
||
输入向量 x (784,)
|
||
权重矩阵 W (784 x 128)
|
||
偏置向量 b (128,)
|
||
|
||
计算：z = x @ W + b
|
||
|
||
x 是 1 行 784 列的矩阵 (1 x 784)
|
||
W 是 784 行 128 列的矩阵 (784 x 128)
|
||
x @ W 是 1 行 128 列的矩阵 (1 x 128)
|
||
z 是 1 行 128 列的矩阵 (1 x 128)
|
||
b 是 1 行 128 列的矩阵 (1 x 128)，与 z 相加
|
||
|
||
批量计算时（batch_size = 64）：
|
||
X (64 x 784) @ W (784 x 128) = Z (64 x 128)
|
||
```
|
||
|
||
### 1.3.5 矩阵的转置
|
||
|
||
```
|
||
矩阵 A 的转置 A^T：行列互换
|
||
|
||
A (m x n) -> A^T (n x m)
|
||
|
||
例子：
|
||
A = [[1, 2, 3], A^T = [[1, 4],
|
||
[4, 5, 6]] [2, 5],
|
||
[3, 6]]
|
||
|
||
重要公式：
|
||
(A @ B)^T = B^T @ A^T
|
||
|
||
在反向传播中经常用到！
|
||
```
|
||
|
||
---
|
||
|
||
# 📖 第二部分：生物神经网络与人工神经元
|
||
|
||
## 2.1 生物大脑中的神经元
|
||
|
||
### 2.1.1 神经元的结构
|
||
|
||
```
|
||
树突（接收信号）
|
||
/ | \
|
||
╱ ╱ ╲ ╲
|
||
┌─────────────────────────┐
|
||
│ 细胞体 │
|
||
│ （处理输入，产生输出） │
|
||
└─────────────────────────┘
|
||
│
|
||
│ 轴突
|
||
│
|
||
突触（连接到其他神经元）
|
||
```
|
||
|
||
**各部分功能**：
|
||
- **树突**：接收来自其他神经元的信号
|
||
- **细胞体**：汇总所有输入，如果超过阈值则产生信号
|
||
- **轴突**：传输细胞体产生的信号
|
||
- **突触**：神经元之间的连接点，决定信号传递的"强度"
|
||
|
||
### 2.1.2 神经元的工作原理
|
||
|
||
```
|
||
简化模型：
|
||
1. 多个神经元的信号通过树突传入
|
||
2. 每个输入信号有一个"权重"（突触强度）
|
||
3. 细胞体把所有信号加权求和
|
||
4. 如果总和 > 阈值，神经元激活，输出信号
|
||
5. 信号通过轴突传给其他神经元
|
||
|
||
数学表示：
|
||
y = 激活函数(Σ wi*xi - θ)
|
||
|
||
其中：
|
||
xi = 第 i 个输入信号
|
||
wi = 第 i 个突触的权重（权重越大，该信号越重要）
|
||
θ = 阈值（决定神经元何时激活）
|
||
激活函数 = 把总和转换成输出
|
||
```
|
||
|
||
### 2.1.3 生活中的类比：部门开会投票
|
||
|
||
```
|
||
想象一个部门开会决策：
|
||
|
||
输入（每个人的意见）：
|
||
- 员工 A 的意见（重要性 0.8）
|
||
- 员工 B 的意见（重要性 0.5）
|
||
- 员工 C 的意见（重要性 0.9）
|
||
|
||
汇总计算：
|
||
总分 = 0.8*意见A + 0.5*意见B + 0.9*意见C
|
||
|
||
决策：
|
||
如果 总分 > 阈值（比如 1.5）
|
||
则 部门决定"通过"
|
||
否则 部门决定"不通过"
|
||
|
||
这就是人工神经网络的原理！
|
||
```
|
||
|
||
---
|
||
|
||
## 2.2 人工神经元（感知机）
|
||
|
||
### 2.2.1 感知机的数学模型
|
||
|
||
**感知机（Perceptron）**是最简单的人工神经元模型，由 Frank Rosenblatt 于 1958 年提出。
|
||
|
||
```
|
||
感知机的数学模型：
|
||
|
||
输入：x1, x2, ..., xn（n 个输入）
|
||
权重：w1, w2, ..., wn（每个输入对应一个权重）
|
||
偏置：b（阈值，取负号后称为偏置）
|
||
|
||
计算：
|
||
z = x1*w1 + x2*w2 + ... + xn*wn + b
|
||
|
||
用向量形式：z = x · w + b
|
||
|
||
其中 x = [x1, x2, ..., xn]，w = [w1, w2, ..., wn]
|
||
|
||
激活函数：
|
||
如果 z > 0，则 y = 1（激活）
|
||
如果 z <= 0，则 y = 0（不激活）
|
||
|
||
这叫"阶跃函数"：
|
||
y = { 1, if z > 0
|
||
{ 0, if z <= 0
|
||
```
|
||
|
||
### 2.2.2 感知机的向量形式
|
||
|
||
```
|
||
输入向量：x = [x1, x2, ..., xn] (1 x n)
|
||
权重向量：w = [w1, w2, ..., wn] (1 x n)
|
||
|
||
加权求和：z = x · w + b = Σ(xi * wi) + b
|
||
|
||
这就是两个向量的点积再加上偏置！
|
||
```
|
||
|
||
### 2.2.3 用代码实现感知机
|
||
|
||
```python
|
||
import numpy as np
|
||
|
||
class Perceptron:
|
||
"""单个感知机（人工神经元）"""
|
||
|
||
def __init__(self, input_size):
|
||
"""
|
||
初始化感知机
|
||
input_size: 输入的维度（有多少个输入）
|
||
"""
|
||
# 初始化权重为小的随机数
|
||
self.w = np.random.randn(input_size) * 0.01
|
||
# 初始化偏置为 0
|
||
self.b = 0
|
||
|
||
def forward(self, x):
|
||
"""
|
||
前向传播：计算感知机的输出
|
||
x: 输入向量，比如 (784,)
|
||
"""
|
||
# 计算加权求和：z = x · w + b
|
||
z = np.dot(x, self.w) + self.b
|
||
|
||
# 阶跃激活函数
|
||
if z > 0:
|
||
return 1
|
||
else:
|
||
return 0
|
||
|
||
def __call__(self, x):
|
||
"""让对象可以像函数一样调用"""
|
||
return self.forward(x)
|
||
```
|
||
|
||
### 2.2.4 感知机的几何意义
|
||
|
||
```
|
||
感知机本质上是一个超平面：
|
||
|
||
z = x · w + b = 0
|
||
|
||
这个方程定义了一个 n 维空间中的超平面（n-1 维子空间）
|
||
|
||
对于二维输入（x1, x2）：
|
||
w1*x1 + w2*x2 + b = 0 是一条直线
|
||
|
||
对于三维输入（x1, x2, x3）：
|
||
w1*x1 + w2*x2 + w3*x3 + b = 0 是一个平面
|
||
|
||
感知机的作用：
|
||
- 把输入空间分成两部分
|
||
- 一边输出 1，一边输出 0
|
||
```
|
||
|
||
---
|
||
|
||
# 📖 第三部分：单层感知机的局限——数学证明
|
||
|
||
## 3.1 感知机可以解决什么问题？
|
||
|
||
### 3.1.1 AND 门（与门）
|
||
|
||
```
|
||
AND 门的真值表：
|
||
输入 A 输入 B 输出
|
||
─────────────────
|
||
0 0 0
|
||
0 1 0
|
||
1 0 0
|
||
1 1 1 <- 只有两个都是 1 时才输出 1
|
||
|
||
我们可以用感知机实现 AND 门：
|
||
|
||
设 w1 = 0.5, w2 = 0.5, b = -0.7
|
||
|
||
验证：
|
||
A=0, B=0: z = 0*0.5 + 0*0.5 - 0.7 = -0.7 <= 0 -> y=0 [OK]
|
||
A=0, B=1: z = 0*0.5 + 1*0.5 - 0.7 = -0.2 <= 0 -> y=0 [OK]
|
||
A=1, B=0: z = 1*0.5 + 0*0.5 - 0.7 = -0.2 <= 0 -> y=0 [OK]
|
||
A=1, B=1: z = 1*0.5 + 1*0.5 - 0.7 = 0.3 > 0 -> y=1 [OK]
|
||
|
||
几何解释：
|
||
在二维坐标系中，直线 0.5*x1 + 0.5*x2 - 0.7 = 0
|
||
把 (0,0), (0,1), (1,0) 分到一边（输出 0）
|
||
把 (1,1) 分到另一边（输出 1）
|
||
```
|
||
|
||
### 3.1.2 OR 门（或门）
|
||
|
||
```
|
||
OR 门的真值表：
|
||
输入 A 输入 B 输出
|
||
─────────────────
|
||
0 0 0
|
||
0 1 1
|
||
1 0 1
|
||
1 1 1 <- 至少有一个是 1 时输出 1
|
||
|
||
用感知机实现：w1 = 0.5, w2 = 0.5, b = -0.3
|
||
|
||
验证：
|
||
A=0, B=0: z = 0*0.5 + 0*0.5 - 0.3 = -0.3 <= 0 -> y=0 [OK]
|
||
A=0, B=1: z = 0*0.5 + 1*0.5 - 0.3 = 0.2 > 0 -> y=1 [OK]
|
||
A=1, B=0: z = 1*0.5 + 0*0.5 - 0.3 = 0.2 > 0 -> y=1 [OK]
|
||
A=1, B=1: z = 1*0.5 + 1*0.5 - 0.3 = 0.7 > 0 -> y=1 [OK]
|
||
```
|
||
|
||
### 3.1.3 NOT 门（非门）
|
||
|
||
```
|
||
NOT 门的真值表：
|
||
输入 A 输出
|
||
─────────
|
||
0 1
|
||
1 0
|
||
|
||
用感知机实现：w1 = -0.5, b = 0.3
|
||
|
||
验证：
|
||
A=0: z = 0*(-0.5) + 0.3 = 0.3 > 0 -> y=1 [OK]
|
||
A=1: z = 1*(-0.5) + 0.3 = -0.2 <= 0 -> y=0 [OK]
|
||
```
|
||
|
||
---
|
||
|
||
## 3.2 XOR 门——感知机的致命缺陷
|
||
|
||
### 3.2.1 XOR 的定义
|
||
|
||
```
|
||
XOR（异或）门的真值表：
|
||
输入 A 输入 B 输出
|
||
─────────────────
|
||
0 0 0
|
||
0 1 1
|
||
1 0 1
|
||
1 1 0 <- 两者不一样时输出 1
|
||
|
||
特点：相同输出 0，不同输出 1
|
||
```
|
||
|
||
### 3.2.2 尝试用感知机实现 XOR
|
||
|
||
```
|
||
假设存在感知机使得 XOR 成立，即存在 w1, w2, b 使得：
|
||
|
||
当 (A,B) = (0,0): w1*0 + w2*0 + b <= 0
|
||
当 (A,B) = (0,1): w1*0 + w2*1 + b > 0
|
||
当 (A,B) = (1,0): w1*1 + w2*0 + b > 0
|
||
当 (A,B) = (1,1): w1*1 + w2*1 + b <= 0
|
||
|
||
从第一个条件：b <= 0
|
||
从第二个条件：w2 + b > 0
|
||
从第三个条件：w1 + b > 0
|
||
从第四个条件：w1 + w2 + b <= 0
|
||
|
||
把 b <= 0 代入第二个：w2 + b > 0 -> w2 > -b >= 0 -> w2 > 0
|
||
把 b <= 0 代入第三个：w1 + b > 0 -> w1 > -b >= 0 -> w1 > 0
|
||
|
||
所以 w1 > 0, w2 > 0, b <= 0
|
||
|
||
但第四个条件 w1 + w2 + b <= 0
|
||
由于 w1 > 0, w2 > 0, b <= 0
|
||
如果 b <= 0 但非常接近 0，比如 b = -ε
|
||
那么 w1 + w2 - ε <= 0 -> w1 + w2 <= ε
|
||
|
||
这意味着 w1 和 w2 必须非常小，接近 0
|
||
但根据 w1 > 0, w2 > 0 且 w1 + w2 <= ε
|
||
这不可能同时满足第二个 w1 + b > 0 -> w1 - ε > 0 -> w1 > ε
|
||
和第三个 w2 - ε > 0 -> w2 > ε
|
||
|
||
所以 w1 + w2 > 2ε，与 w1 + w2 <= ε 矛盾！
|
||
|
||
因此：感知机无法实现 XOR！
|
||
```
|
||
|
||
### 3.2.3 XOR 的几何解释
|
||
|
||
```
|
||
AND 门（线性可分）：
|
||
|
||
B
|
||
^ 1 | *
|
||
| |
|
||
| |
|
||
+----------> A
|
||
0 0
|
||
|
||
可以用一条直线（超平面）把 *（输出1）和 。（输出0）分开
|
||
|
||
OR 门（线性可分）：
|
||
|
||
B
|
||
^ 1 | * *
|
||
| |
|
||
| |
|
||
+----------> A
|
||
0 0
|
||
|
||
可以用一条直线把 *（输出1）和 。（输出0）分开
|
||
|
||
XOR 门（线性不可分）：
|
||
|
||
B
|
||
^ 1 | * .
|
||
| . | *
|
||
| |
|
||
+----------> A
|
||
0 0
|
||
|
||
*（输出1）在对角线：(0,1) 和 (1,0)
|
||
.（输出0）在对角线：(0,0) 和 (1,1)
|
||
|
||
无法用一条直线把 * 和 . 分开！
|
||
必须用两条直线（折线）才能分开
|
||
```
|
||
|
||
### 3.2.4 线性可分与线性不可分
|
||
|
||
```
|
||
定义：
|
||
|
||
一组数据点 {x(i)} 被称为线性可分的，如果存在一个超平面
|
||
w · x + b = 0 能够把所有正类点分到一边，所有负类点分到另一边。
|
||
|
||
换句话说：
|
||
如果存在 w, b 使得：
|
||
对于所有正类：w · x + b > 0
|
||
对于所有负类：w · x + b <= 0
|
||
那么这组数据是线性可分的。
|
||
|
||
AND, OR, NOT 都是线性可分的
|
||
XOR 不是线性可分的
|
||
```
|
||
|
||
---
|
||
|
||
# 📖 第四部分：多层感知机（MLP）—— 解决非线性问题
|
||
|
||
## 4.1 多层的思想
|
||
|
||
### 4.1.1 为什么多层可以解决 XOR？
|
||
|
||
```
|
||
单层感知机的局限：
|
||
- 只能画一条直线（一个超平面）
|
||
- 只能解决线性可分问题
|
||
|
||
多层感知机的能力：
|
||
- 第一层：学多条直线（多个超平面）
|
||
- 第二层：综合第一层的结果，画出更复杂的边界
|
||
|
||
XOR 的多层解决方案：
|
||
|
||
输入层 (x1, x2)
|
||
|
|
||
v
|
||
隐藏层：两个感知机 h1, h2
|
||
|
|
||
v
|
||
输出层：综合判断
|
||
|
||
具体：
|
||
h1 = AND(NOT x1, x2) <- 在区域 (0,1) 输出 1
|
||
h2 = AND(x1, NOT x2) <- 在区域 (1,0) 输出 1
|
||
y = OR(h1, h2) <- 任何一个为 1 就输出 1
|
||
```
|
||
|
||
### 4.1.2 多层的几何解释
|
||
|
||
```
|
||
单层：一条直线把空间分成两部分
|
||
|
||
多层：多条直线组合，把空间分成多个区域
|
||
|
||
XOR 的解决过程：
|
||
|
||
第一步：两个隐藏单元各自画一条直线
|
||
h1: w1=[-1,1], b=0.5 -> 识别 (0,1) 区域
|
||
h2: w2=[1,-1], b=0.5 -> 识别 (1,0) 区域
|
||
|
||
第二步：输出层综合
|
||
y = OR(h1, h2)
|
||
|
||
效果：把原本无法用一条直线分开的问题，
|
||
转换成两步：先画两条线，再综合
|
||
```
|
||
|
||
---
|
||
|
||
## 4.2 MLP 的网络结构
|
||
|
||
### 4.2.1 本项目的 MLP 结构
|
||
|
||
```
|
||
网络结构: 784 -> 128 -> 10
|
||
|
||
输入层：
|
||
- 784 个神经元（对应 28x28 图片的 784 个像素值）
|
||
- 输入向量 x：形状 (batch_size, 784)
|
||
|
||
隐藏层：
|
||
- 128 个神经元
|
||
- 每个神经元：z1[i] = x @ W1[:,i] + b1[i]
|
||
- 激活后：a1[i] = ReLU(z1[i])
|
||
|
||
输出层：
|
||
- 10 个神经元（对应数字 0-9）
|
||
- 每个神经元输出一个"分数"
|
||
- 通过 Softmax 转换成概率
|
||
```
|
||
|
||
### 4.2.2 网络的矩阵表示
|
||
|
||
```
|
||
输入：X (batch_size, 784)
|
||
|
||
第一层（输入 -> 隐藏）：
|
||
Z1 = X @ W1 + b1
|
||
W1 形状: (784, 128)
|
||
b1 形状: (128,)
|
||
Z1 形状: (batch_size, 128)
|
||
|
||
A1 = ReLU(Z1)
|
||
|
||
第二层（隐藏 -> 输出）：
|
||
Z2 = A1 @ W2 + b2
|
||
W2 形状: (128, 10)
|
||
b2 形状: (10,)
|
||
Z2 形状: (batch_size, 10)
|
||
|
||
A2 = Softmax(Z2) # 最终概率输出
|
||
```
|
||
|
||
### 4.2.3 参数量计算
|
||
|
||
```
|
||
总参数量：
|
||
|
||
W1: 784 × 128 = 100,352 个
|
||
b1: 128 个
|
||
|
||
W2: 128 × 10 = 1,280 个
|
||
b2: 10 个
|
||
|
||
总计：101,770 个参数
|
||
|
||
这就是为什么深度学习需要大量参数！
|
||
参数量决定了网络能学多复杂的模式。
|
||
```
|
||
|
||
---
|
||
|
||
## 4.3 激活函数
|
||
|
||
### 4.3.1 为什么需要激活函数？
|
||
|
||
```
|
||
如果网络只有线性变换：
|
||
Z1 = X @ W1 + b1
|
||
Z2 = A1 @ W2 + b2
|
||
|
||
那么整个网络仍然是线性的！
|
||
|
||
Z2 = (X @ W1 + b1) @ W2 + b2
|
||
= X @ (W1 @ W2) + (b1 @ W2 + b2)
|
||
= X @ W + b
|
||
|
||
这等价于一个单层网络！
|
||
|
||
所以：必须加入非线性激活函数，才能让多层网络有意义！
|
||
```
|
||
|
||
### 4.3.2 ReLU 激活函数
|
||
|
||
```
|
||
ReLU(x) = max(0, x) = { x, if x > 0
|
||
0, if x <= 0 }
|
||
|
||
函数图像：
|
||
y
|
||
| /
|
||
| /
|
||
| /
|
||
| /
|
||
+----------- x
|
||
0
|
||
|
||
数学性质：
|
||
- 正半轴：导数 = 1
|
||
- 负半轴：导数 = 0
|
||
- 在 x=0 处：不可导（但实际使用中可以任意选择一边）
|
||
|
||
导数（求导过程）：
|
||
当 x > 0 时，ReLU(x) = x，所以 d/dx ReLU(x) = 1
|
||
当 x < 0 时，ReLU(x) = 0，所以 d/dx ReLU(x) = 0
|
||
当 x = 0 时，导数不存在，但在实践中常定义为 0 或 1
|
||
|
||
ReLU'(x) = { 1, if x > 0
|
||
{ 0, if x <= 0
|
||
```
|
||
|
||
### 4.3.3 Softmax 激活函数
|
||
|
||
```
|
||
Softmax 把一个向量转换成概率分布
|
||
|
||
对于向量 z = [z1, z2, ..., zk]：
|
||
|
||
softmax(zi) = exp(zi) / Σj exp(zj)
|
||
|
||
特点：
|
||
1. 每个 softmax(zi) > 0（因为 exp 永远是正数）
|
||
2. Σi softmax(zi) = 1（因为分母是所有分子的和）
|
||
|
||
所以 softmax 的输出是一个合法的概率分布！
|
||
|
||
数值稳定技巧：
|
||
由于 exp 可能溢出，通常用以下技巧：
|
||
|
||
softmax(zi) = exp(zi - C) / Σj exp(zj - C)
|
||
|
||
其中 C = max(z)，这样所有指数都不会太大
|
||
```
|
||
|
||
**Softmax 的求导**：
|
||
|
||
```
|
||
设 y_i = softmax(z_i) = exp(z_i) / Σj exp(z_j)
|
||
|
||
当 i == j 时（对角元素）：
|
||
∂y_i/∂z_i = [exp(z_i) * Σj exp(z_j) - exp(z_i) * exp(z_i)] / (Σj exp(z_j))^2
|
||
= exp(z_i)(Σj exp(z_j) - exp(z_i)) / (Σj exp(z_j))^2
|
||
= exp(z_i) / Σj exp(z_j) * (Σj exp(z_j) - exp(z_i)) / Σj exp(z_j)
|
||
= y_i * (1 - y_i)
|
||
|
||
当 i != j 时（非对角元素）：
|
||
∂y_i/∂z_j = [0 * Σj exp(z_j) - exp(z_i) * exp(z_j)] / (Σj exp(z_j))^2
|
||
= -exp(z_i) * exp(z_j) / (Σj exp(z_j))^2
|
||
= -y_i * y_j
|
||
|
||
总结：
|
||
∂y_i/∂z_j = { y_i * (1 - y_i), if i == j
|
||
{ -y_i * y_j, if i != j
|
||
```
|
||
|
||
---
|
||
|
||
# 📖 第五部分：前向传播 —— 详细数学推导
|
||
|
||
## 5.1 前向传播的完整流程
|
||
|
||
```
|
||
输入：x (784,)
|
||
|
||
第一步：输入层 -> 隐藏层
|
||
z1 = x @ W1 + b1
|
||
a1 = ReLU(z1)
|
||
|
||
第二步：隐藏层 -> 输出层
|
||
z2 = a1 @ W2 + b2
|
||
y = softmax(z2)
|
||
```
|
||
|
||
### 5.1.1 第一步：输入层 -> 隐藏层
|
||
|
||
```
|
||
给定：
|
||
x: (784,) # 一张图片的像素值
|
||
W1: (784, 128) # 权重矩阵
|
||
b1: (128,) # 偏置向量
|
||
|
||
计算 z1：
|
||
z1[i] = Σj x[j] * W1[j,i] + b1[i]
|
||
|
||
z1 的形状: (128,)
|
||
|
||
直观理解：每个隐藏神经元 i 接收所有输入的加权求和
|
||
|
||
计算 a1（ReLU 激活）：
|
||
a1[i] = max(0, z1[i])
|
||
|
||
a1 的形状: (128,)
|
||
|
||
批量计算（batch_size = N）：
|
||
X: (N, 784)
|
||
Z1 = X @ W1 + b1: (N, 128)
|
||
A1 = ReLU(Z1): (N, 128)
|
||
```
|
||
|
||
### 5.1.2 第二步：隐藏层 -> 输出层
|
||
|
||
```
|
||
给定：
|
||
a1: (128,) # 隐藏层激活
|
||
W2: (128, 10) # 权重矩阵
|
||
b2: (10,) # 偏置向量
|
||
|
||
计算 z2：
|
||
z2[i] = Σj a1[j] * W2
|
||
a1[j] * W2[j,i] + b2[i]
|
||
|
||
z2 的形状: (10,)
|
||
|
||
直观理解：每个输出神经元 i 综合所有隐藏层的激活
|
||
|
||
计算 y（Softmax）：
|
||
y[i] = softmax(z2)[i] = exp(z2[i]) / Σj exp(z2[j])
|
||
|
||
y 的形状: (10,) # 10 个数字的概率分布
|
||
|
||
批量计算（batch_size = N）：
|
||
A1: (N, 128)
|
||
Z2 = A1 @ W2 + b2: (N, 10)
|
||
Y = Softmax(Z2): (N, 10)
|
||
```
|
||
|
||
---
|
||
|
||
## 5.2 前向传播的 NumPy 实现
|
||
|
||
```python
|
||
import numpy as np
|
||
|
||
class MLP:
|
||
def __init__(self, input_size=784, hidden_size=128, output_size=10):
|
||
# Xavier 初始化
|
||
self.W1 = np.random.randn(input_size, hidden_size) * np.sqrt(2.0 / input_size)
|
||
self.b1 = np.zeros(hidden_size)
|
||
self.W2 = np.random.randn(hidden_size, output_size) * np.sqrt(2.0 / hidden_size)
|
||
self.b2 = np.zeros(output_size)
|
||
|
||
def relu(self, x):
|
||
return np.maximum(0, x)
|
||
|
||
def softmax(self, x):
|
||
# 数值稳定技巧
|
||
x_shifted = x - np.max(x, axis=1, keepdims=True)
|
||
exp_x = np.exp(x_shifted)
|
||
return exp_x / np.sum(exp_x, axis=1, keepdims=True)
|
||
|
||
def forward(self, X):
|
||
"""
|
||
前向传播
|
||
|
||
X: (batch_size, input_size) 输入图片
|
||
返回: (batch_size, output_size) 每个类的概率
|
||
"""
|
||
# 第一层
|
||
self.z1 = X @ self.W1 + self.b1 # (batch, 784) @ (784, 128) = (batch, 128)
|
||
self.a1 = self.relu(self.z1) # (batch, 128)
|
||
|
||
# 第二层
|
||
self.z2 = self.a1 @ self.W2 + self.b2 # (batch, 128) @ (128, 10) = (batch, 10)
|
||
self.probs = self.softmax(self.z2) # (batch, 10)
|
||
|
||
return self.probs
|
||
```
|
||
|
||
---
|
||
|
||
# 📖 第六部分：反向传播 —— 完整数学推导
|
||
|
||
> 这是神经网络最核心的部分，包含了完整的链式法则推导。
|
||
|
||
## 6.1 损失函数
|
||
|
||
### 6.1.1 交叉熵损失函数
|
||
|
||
```
|
||
对于多分类问题，我们使用交叉熵损失（Cross-Entropy Loss）
|
||
|
||
设：
|
||
y_true: 真实标签的 One-Hot 编码 (10,) # 比如数字 5：[0,0,0,0,0,1,0,0,0,0]
|
||
y_pred: 网络预测的概率分布 (10,) # 比如：[0.1, 0.05, 0.02, 0.03, 0.1, 0.6, 0.02, 0.05, 0.02, 0.01]
|
||
|
||
交叉熵损失：
|
||
L = -Σ y_true[i] * log(y_pred[i])
|
||
|
||
由于 y_true 是 One-Hot 编码，只有一个元素是 1，其他都是 0
|
||
所以 L = -log(y_pred[真实类别])
|
||
|
||
例子：
|
||
真实标签是 5，y_true[5] = 1
|
||
网络预测 y_pred[5] = 0.6
|
||
L = -log(0.6) = 0.51
|
||
|
||
网络预测 y_pred[5] = 0.9
|
||
L = -log(0.9) = 0.11
|
||
|
||
预测越准确，损失越小！
|
||
```
|
||
|
||
### 6.1.2 交叉熵的求导
|
||
|
||
```
|
||
设 L = -Σ y_true[i] * log(y_pred[i])
|
||
|
||
对 y_pred[i] 求偏导：
|
||
∂L/∂y_pred[i] = -y_true[i] / y_pred[i]
|
||
|
||
但是我们实际上是对 z2（Softmax 的输入）求导，而不是对 y_pred。
|
||
|
||
设 y_pred = softmax(z2)
|
||
|
||
我们需要求：∂L/∂z2[i]
|
||
```
|
||
|
||
---
|
||
|
||
## 6.2 反向传播的数学推导
|
||
|
||
### 6.2.1 输出层梯度
|
||
|
||
```
|
||
已知：
|
||
L = -Σ y_true[j] * log(y_pred[j])
|
||
y_pred[j] = softmax(z2)[j] = exp(z2[j]) / Σk exp(z2[k])
|
||
|
||
我们需要求：∂L/∂z2[i]
|
||
|
||
根据链式法则：
|
||
∂L/∂z2[i] = Σj ∂L/∂y_pred[j] * ∂y_pred[j]/∂z2[i]
|
||
= Σj (-y_true[j] / y_pred[j]) * ∂y_pred[j]/∂z2[i]
|
||
|
||
根据 Softmax 的求导结果：
|
||
∂y_i/∂z_j = { y_i * (1 - y_i), if i == j
|
||
{ -y_i * y_j, if i != j
|
||
|
||
所以：
|
||
∂L/∂z2[i] = Σj (-y_true[j] / y_pred[j]) * ∂y_pred[j]/∂z2[i]
|
||
= (-y_true[i] / y_pred[i]) * y_pred[i] * (1 - y_pred[i])
|
||
+ Σ_{j≠i} (-y_true[j] / y_pred[j]) * (-y_pred[i] * y_pred[j])
|
||
|
||
= -y_true[i] * (1 - y_pred[i]) + Σ_{j≠i} y_true[j] * y_pred[i]
|
||
|
||
= -y_true[i] + y_true[i] * y_pred[i] + Σ_{j≠i} y_true[j] * y_pred[i]
|
||
|
||
= -y_true[i] + Σj y_true[j] * y_pred[i]
|
||
|
||
= -y_true[i] + y_pred[i] * Σj y_true[j]
|
||
|
||
= -y_true[i] + y_pred[i] * 1 (因为 y_true 是 One-Hot，和为1)
|
||
|
||
= y_pred[i] - y_true[i]
|
||
|
||
这就是著名的结论：Softmax + Cross-Entropy 的梯度 = y_pred - y_true！
|
||
|
||
d_z2 = y_pred - y_true
|
||
```
|
||
|
||
### 6.2.2 第二层权重梯度
|
||
|
||
```
|
||
现在我们已经知道 d_z2 = y_pred - y_true
|
||
|
||
需要求：
|
||
∂L/∂W2[i,j]
|
||
∂L/∂b2[i]
|
||
|
||
根据链式法则：
|
||
L 是 z2 的函数，z2 是 W2, b2 的函数
|
||
|
||
z2[j] = Σk a1[k] * W2[k,j] + b2[j]
|
||
|
||
∂z2[j]/∂W2[i,j] = a1[i] # 只有 W2[i,j] 影响 z2[j]，系数是 a1[i]
|
||
∂z2[j]/∂b2[j] = 1
|
||
|
||
所以：
|
||
∂L/∂W2[i,j] = Σj ∂L/∂z2[j] * ∂z2[j]/∂W2[i,j]
|
||
= Σj d_z2[j] * a1[i]
|
||
= a1[i] * Σj d_z2[j]
|
||
= a1[i] * d_z2[j]
|
||
|
||
向量形式：
|
||
d_W2 = a1.T @ d_z2 # (128, 10)
|
||
|
||
∂L/∂b2[i] = Σj ∂L/∂z2[j] * ∂z2[j]/∂b2[i]
|
||
= d_z2[i]
|
||
|
||
向量形式：
|
||
d_b2 = d_z2 # (10,)
|
||
```
|
||
|
||
### 6.2.3 隐藏层梯度
|
||
|
||
```
|
||
现在需要把梯度反向传播到隐藏层。
|
||
|
||
我们需要求：
|
||
∂L/∂a1[i] # 损失对隐藏层激活的梯度
|
||
∂L/∂z1[i] # 损失对 ReLU 输入的梯度
|
||
|
||
第一步：求 ∂L/∂a1
|
||
|
||
根据前向传播：
|
||
z2[j] = Σk a1[k] * W2[k,j] + b2[j]
|
||
|
||
所以：
|
||
∂z2[j]/∂a1[k] = W2[k,j]
|
||
|
||
∂L/∂a1[k] = Σj ∂L/∂z2[j] * ∂z2[j]/∂a1[k]
|
||
= Σj d_z2[j] * W2[k,j]
|
||
= Σj W2[k,j] * d_z2[j]
|
||
|
||
向量形式：
|
||
d_a1 = d_z2 @ self.W2.T # (batch, 128)
|
||
|
||
第二步：求 ∂L/∂z1
|
||
|
||
根据前向传播：
|
||
a1[i] = ReLU(z1[i])
|
||
|
||
ReLU 的导数：
|
||
∂a1[i]/∂z1[i] = 1, if z1[i] > 0
|
||
= 0, if z1[i] <= 0
|
||
|
||
所以：
|
||
∂L/∂z1[i] = ∂L/∂a1[i] * ∂a1[i]/∂z1[i]
|
||
= d_a1[i] * ReLU'(z1[i])
|
||
|
||
向量形式：
|
||
d_z1 = d_a1 * (z1 > 0).astype(float)
|
||
```
|
||
|
||
### 6.2.4 第一层权重梯度
|
||
|
||
```
|
||
现在求损失对第一层权重的梯度。
|
||
|
||
我们需要求：
|
||
∂L/∂W1[i,j]
|
||
∂L/∂b1[i]
|
||
|
||
第一步：求 ∂L/∂z1
|
||
|
||
我们已经知道：
|
||
d_z1[i] = ∂L/∂z1[i]
|
||
|
||
第二步：求 ∂L/∂W1[i,j]
|
||
|
||
根据前向传播：
|
||
z1[j] = Σk x[k] * W1[k,j] + b1[j]
|
||
|
||
∂z1[j]/∂W1[i,j] = x[i]
|
||
|
||
∂L/∂W1[i,j] = Σj ∂L/∂z1[j] * ∂z1[j]/∂W1[i,j]
|
||
= Σj d_z1[j] * x[i]
|
||
= x[i] * Σj d_z1[j]
|
||
|
||
向量形式：
|
||
d_W1 = X.T @ d_z1 # (784, 128)
|
||
|
||
第三步：求 ∂L/∂b1
|
||
|
||
∂L/∂b1[i] = Σj ∂L/∂z1[j] * ∂z1[j]/∂b1[i]
|
||
= d_z1[i]
|
||
|
||
向量形式：
|
||
d_b1 = d_z1 # (128,)
|
||
```
|
||
|
||
---
|
||
|
||
## 6.3 梯度更新
|
||
|
||
```
|
||
得到所有梯度后，用梯度下降更新权重：
|
||
|
||
W1 = W1 - learning_rate * d_W1
|
||
b1 = b1 - learning_rate * d_b1
|
||
W2 = W2 - learning_rate * d_W2
|
||
b2 = b2 - learning_rate * d_b2
|
||
|
||
注意：这里梯度已经除以了 batch_size（因为损失是平均的）
|
||
```
|
||
|
||
---
|
||
|
||
## 6.4 完整反向传播代码
|
||
|
||
```python
|
||
def backward(self, X, y_true):
|
||
"""
|
||
反向传播：计算梯度并更新权重
|
||
|
||
参数：
|
||
X: (batch_size, 784) 输入图片
|
||
y_true: (batch_size, 10) One-Hot 真实标签
|
||
"""
|
||
batch_size = X.shape[0]
|
||
|
||
# ===== 第1步：输出层梯度 =====
|
||
# Softmax + CrossEntropy 的组合梯度：d_z2 = y_pred - y_true
|
||
d_z2 = self.probs - y_true # (batch_size, 10)
|
||
|
||
# ===== 第2步：第二层权重梯度 =====
|
||
d_W2 = self.a1.T @ d_z2 # (128, 10)
|
||
d_b2 = np.sum(d_z2, axis=0) # (10,)
|
||
|
||
# ===== 第3步：隐藏层梯度 =====
|
||
d_a1 = d_z2 @ self.W2.T # (batch_size, 128)
|
||
d_z1 = d_a1 * (self.z1 > 0).astype(float) # ReLU 导数
|
||
|
||
# ===== 第4步：第一层权重梯度 =====
|
||
d_W1 = X.T @ d_z1 # (784, 128)
|
||
d_b1 = np.sum(d_z1, axis=0) # (128,)
|
||
|
||
# ===== 第5步：梯度裁剪（防止梯度爆炸） =====
|
||
max_grad = 1.0
|
||
for dW in [d_W1, d_W2]:
|
||
np.clip(dW, -max_grad, max_grad, out=dW)
|
||
for db in [d_b1, d_b2]:
|
||
np.clip(db, -max_grad, max_grad, out=db)
|
||
|
||
# ===== 第6步：梯度下降更新权重 =====
|
||
self.W1 -= self.lr * d_W1 / batch_size
|
||
self.b1 -= self.lr * d_b1 / batch_size
|
||
self.W2 -= self.lr * d_W2 / batch_size
|
||
self.b2 -= self.lr * d_b2 / batch_size
|
||
```
|
||
|
||
---
|
||
|
||
# 📖 第七部分：训练流程
|
||
|
||
## 7.1 完整训练循环
|
||
|
||
```python
|
||
def fit(self, X_train, y_train, epochs=50, batch_size=64):
|
||
"""
|
||
训练 MLP
|
||
|
||
参数：
|
||
X_train: (N, 784) 训练图片
|
||
y_train: (N, 10) 训练标签（One-Hot）
|
||
epochs: 训练轮数
|
||
batch_size: 每批图片数
|
||
"""
|
||
N = len(X_train)
|
||
num_batches = (N + batch_size - 1) // batch_size
|
||
|
||
for epoch in range(epochs):
|
||
# 打乱数据
|
||
indices = np.random.permutation(N)
|
||
X_shuffled = X_train[indices]
|
||
y_shuffled = y_train[indices]
|
||
|
||
epoch_loss = 0
|
||
|
||
# 批训练
|
||
for batch_idx in range(num_batches):
|
||
start = batch_idx * batch_size
|
||
end = min(start + batch_size, N)
|
||
X_batch = X_shuffled[start:end]
|
||
y_batch = y_shuffled[start:end]
|
||
|
||
# 前向传播
|
||
probs = self.forward(X_batch)
|
||
|
||
# 反向传播
|
||
self.backward(X_batch, y_batch)
|
||
|
||
# 计算损失
|
||
loss = self.cross_entropy_loss(probs, y_batch)
|
||
epoch_loss += loss
|
||
|
||
# 打印进度
|
||
if (epoch + 1) % 5 == 0:
|
||
acc = self.accuracy(X_train, y_train)
|
||
print(f"Epoch {epoch+1:3d}/{epochs} | Loss: {epoch_loss/num_batches:.4f} | 准确率: {acc:.4f}")
|
||
|
||
def cross_entropy_loss(self, probs, y_true):
|
||
"""交叉熵损失"""
|
||
# 取真实类别的概率
|
||
correct_probs = probs[np.arange(len(y_true)), y_true.argmax(axis=1)]
|
||
# 避免 log(0)
|
||
loss = -np.mean(np.log(np.clip(correct_probs, 1e-10, 1.0)))
|
||
return loss
|
||
|
||
def accuracy(self, X, y):
|
||
"""计算准确率"""
|
||
if len(y.shape) > 1:
|
||
y = np.argmax(y, axis=1)
|
||
predictions = np.argmax(self.forward(X), axis=1)
|
||
return np.mean(predictions == y)
|
||
```
|
||
|
||
---
|
||
|
||
## 7.2 超参数详解
|
||
|
||
| 超参数 | 默认值 | 说明 | 调参建议 |
|
||
|--------|--------|------|---------|
|
||
| **hidden_size** | 128 | 隐藏层神经元数 | 多→能力强但慢，少→快但弱 |
|
||
| **learning_rate** | 0.1 | 学习率（每步走多远） | 大→震荡，小→太慢 |
|
||
| **epochs** | 50 | 训练轮数 | 多→过拟合，少→欠拟合 |
|
||
| **batch_size** | 64 | 每批图片数 | 大→稳定，小→泛化好 |
|
||
|
||
---
|
||
|
||
# 📖 第八部分：MNIST 数据集
|
||
|
||
## 8.1 MNIST 数据集介绍
|
||
|
||
```
|
||
MNIST = Modified National Institute of Standards and Technology
|
||
美国国家标准与技术研究院改良数据集
|
||
|
||
数据集信息：
|
||
- 70,000 张图片（60,000 训练 + 10,000 测试）
|
||
- 每张图片 28x28 像素，灰度图
|
||
- 10 类（数字 0-9）
|
||
- 来自 250 个不同人的手写样本
|
||
```
|
||
|
||
## 8.2 数据预处理
|
||
|
||
```python
|
||
def load_and_preprocess():
|
||
"""加载并预处理 MNIST 数据"""
|
||
# 1. 加载数据（使用 sklearn）
|
||
from sklearn.datasets import fetch_openml
|
||
mnist = fetch_openml('mnist_784', version=1)
|
||
X, y = mnist.data, mnist.target
|
||
|
||
# 2. 转换为 float32 并归一化到 [0, 1]
|
||
X = X.values.astype(np.float32) / 255.0
|
||
|
||
# 3. 标签转为 One-Hot
|
||
y = y.astype(int)
|
||
num_classes = 10
|
||
y_onehot = np.zeros((len(y), num_classes))
|
||
y_onehot[np.arange(len(y)), y] = 1
|
||
|
||
return X, y_onehot
|
||
```
|
||
|
||
---
|
||
|
||
# 📖 第九部分：梯度消失与梯度爆炸
|
||
|
||
## 9.1 什么是梯度消失？
|
||
|
||
```
|
||
在反向传播过程中，梯度可能会变得非常小（接近 0）
|
||
|
||
原因：
|
||
- 链式法则的乘法效应
|
||
- 深层网络中，梯度逐层相乘
|
||
- 如果每层的梯度都小于 1，深层的梯度会指数衰减
|
||
|
||
例子：
|
||
假设每层的梯度都是 0.5
|
||
第 1 层：梯度 = 0.5
|
||
第 5 层：梯度 = 0.5^5 = 0.03
|
||
第 10 层：梯度 = 0.5^10 = 0.001
|
||
|
||
深层的权重几乎学不到东西！
|
||
```
|
||
|
||
## 9.2 什么是梯度爆炸？
|
||
|
||
```
|
||
与梯度消失相反，梯度可能会变得非常大
|
||
|
||
原因：
|
||
- 每层的梯度大于 1
|
||
- 深层网络中，梯度指数增长
|
||
|
||
例子：
|
||
假设每层的梯度都是 2
|
||
第 1 层：梯度 = 2
|
||
第 5 层：梯度 = 2^5 = 32
|
||
第 10 层：梯度 = 2^10 = 1024
|
||
|
||
权重更新过大，网络不稳定！
|
||
```
|
||
|
||
## 9.3 解决方案
|
||
|
||
```
|
||
梯度裁剪：
|
||
d_W = clip(d_W, -max_grad, max_grad)
|
||
|
||
本项目使用这种方法，效果良好
|
||
|
||
ReLU 激活函数：
|
||
- 正半轴梯度为 1，不会衰减
|
||
- 缓解梯度消失问题
|
||
|
||
Xavier/He 初始化：
|
||
- 让梯度在传播过程中保持合理范围
|
||
- 本项目使用 Xavier 初始化
|
||
```
|
||
|
||
---
|
||
|
||
# 📖 第十部分：总结与公式速查
|
||
|
||
## 10.1 核心公式汇总
|
||
|
||
| 公式 | 说明 |
|
||
|------|------|
|
||
| `z1 = X @ W1 + b1` | 第一层线性变换 |
|
||
| `a1 = ReLU(z1)` | 第一层激活 |
|
||
| `z2 = a1 @ W2 + b2` | 第二层线性变换 |
|
||
| `y = softmax(z2)` | Softmax 概率输出 |
|
||
| `L = -Σ y_true * log(y_pred)` | 交叉熵损失 |
|
||
| `d_z2 = y_pred - y_true` | Softmax+CE 梯度 |
|
||
| `d_W2 = a1.T @ d_z2` | 第二层权重梯度 |
|
||
| `d_z1 = d_a1 * (z1 > 0)` | ReLU 梯度 |
|
||
| `d_W1 = X.T @ d_z1` | 第一层权重梯度 |
|
||
| `W = W - lr * d_W` | 梯度下降更新 |
|
||
|
||
## 10.2 训练流程图
|
||
|
||
```
|
||
输入数据 X
|
||
|
|
||
v
|
||
前向传播 -> 保存中间结果 (z1, a1, z2, probs)
|
||
|
|
||
v
|
||
计算损失 L = -Σ y_true * log(probs)
|
||
|
|
||
v
|
||
反向传播（从后往前）：
|
||
d_z2 = probs - y_true
|
||
d_W2 = a1.T @ d_z2
|
||
d_z1 = (d_z2 @ W2.T) * ReLU'(z1)
|
||
d_W1 = X.T @ d_z1
|
||
|
|
||
v
|
||
梯度下降更新权重
|
||
|
|
||
v
|
||
重复，直到损失足够小
|
||
```
|
||
|
||
---
|
||
|
||
# 📝 课后练习
|
||
|
||
## 练习1：手算前向传播
|
||
|
||
已知：
|
||
```
|
||
x = [1, 0, 1] # 输入
|
||
W1 = [[1, 0], [0, 1], [1, 1]] # (3, 2)
|
||
b1 = [0, 0]
|
||
W2 = [[1, 2], [3, 4]] # (2, 2)
|
||
b2 = [0, 0]
|
||
```
|
||
|
||
计算：
|
||
1. z1 = x @ W1 + b1
|
||
2. a1 = ReLU(z1)
|
||
3. z2 = a1 @ W2 + b2
|
||
4. y = softmax(z2)
|
||
|
||
## 练习2：验证 XOR 的多层解决方案
|
||
|
||
用两层感知机实现 XOR：
|
||
- 隐藏层：h1 = AND(NOT x1, x2), h2 = AND(x1, NOT x2)
|
||
- 输出层：y = OR(h1, h2)
|
||
|
||
验证对所有 4 种输入都正确。
|
||
|
||
## 练习3：理解梯度消失
|
||
|
||
如果每层的 ReLU 输出有一半是 0（因为输入小于 0），那么 10 层之后：
|
||
- 第 10 层的梯度大约是第 1 层的多少？
|
||
- 这说明什么问题？
|
||
|
||
## 练习4：调参实验
|
||
|
||
修改 config.py 中的超参数，记录变化：
|
||
- hidden_size: 64 vs 256
|
||
- learning_rate: 0.01 vs 1.0
|
||
- epochs: 20 vs 100
|
||
|
||
---
|
||
|
||
> **记住**：神经网络的核心是"前向传播 + 反向传播 + 梯度下降"，通过不断调整权重来最小化损失！
|