# 📚 多层感知机（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 --- > **记住**：神经网络的核心是"前向传播 + 反向传播 + 梯度下降"，通过不断调整权重来最小化损失！