模块M01: 深度学习基础理论

阶段: Stage 4 - 深度学习 预计学习时间: 2-3小时（理论）+ 2-3小时（实践） 难度: ⭐⭐⭐ 中等

---

📚 学习目标

完成本模块后，你将能够：

• ✅ 理解神经网络的基本原理（感知机、多层感知机、激活函数）
• ✅ 掌握反向传播算法的数学推导与计算过程
• ✅ 熟悉常用优化器（SGD、Adam、RMSprop）及其适用场景
• ✅ 理解损失函数的选择与正则化技术
• ✅ 能够使用PyTorch从零实现一个简单的神经网络
• ✅ 掌握张量操作、自动微分机制与模型定义方法

---

🎯 核心知识点

1. 神经网络基础

1.1 感知机 (Perceptron)

感知机是最简单的神经网络单元，由美国科学家Frank Rosenblatt在1957年提出。

数学表达式:

y = f(w · x + b)

其中: - x: 输入向量 (特征) - w: 权重向量 - b: 偏置 (bias) - f: 激活函数 - y: 输出

限制: 感知机只能解决线性可分问题（如AND、OR），无法解决XOR问题。

1.2 多层感知机 (Multi-Layer Perceptron, MLP)

通过堆叠多个神经元层，MLP可以解决非线性问题。

网络结构:

输入层 → 隐藏层1 → 隐藏层2 → ... → 输出层

前向传播公式 (Forward Propagation):

h1 = f1(W1 · x + b1)          # 第1层
h2 = f2(W2 · h1 + b2)         # 第2层
y = f_out(W_out · h2 + b_out) # 输出层

1.3 激活函数 (Activation Functions)

激活函数引入非线性，使神经网络能够逼近复杂函数。

激活函数	公式	优点	缺点	适用场景
Sigmoid	σ(x) = 1 / (1 + e^(-x))	输出在(0,1)，适合概率	梯度消失、计算慢	二分类输出层
Tanh	tanh(x) = (e^x - e^(-x)) / (e^x + e^(-x))	输出在(-1,1)，零中心	梯度消失	RNN隐藏层
ReLU	f(x) = max(0, x)	计算快、缓解梯度消失	神经元死亡	CNN隐藏层（最常用）
Leaky ReLU	f(x) = max(0.01x, x)	避免神经元死亡	需调参	深度网络隐藏层
GELU	f(x) = x · Φ(x)	性能优越	计算复杂	Transformer（BERT/GPT）
Softmax	σ(x_i) = e^(x_i) / Σe^(x_j)	输出概率分布	不适合隐藏层	多分类输出层

可视化对比: 参见 notebooks/stage4/01-neural-network.ipynb 第2节

---

2. 反向传播算法 (Backpropagation)

反向传播是训练神经网络的核心算法，通过链式法则计算梯度。

2.1 损失函数 (Loss Function)

衡量模型预测与真实值的差距。

常用损失函数:

任务类型	损失函数	公式	PyTorch实现
二分类	二元交叉熵	BCE = -[y·log(ŷ) + (1-y)·log(1-ŷ)]	nn.BCELoss()
多分类	交叉熵	CE = -Σ y_i · log(ŷ_i)	nn.CrossEntropyLoss()
回归	均方误差	MSE = (1/n) · Σ(y - ŷ)²	nn.MSELoss()
回归	平均绝对误差	MAE = (1/n) · Σ|y - ŷ|	nn.L1Loss()

2.2 梯度计算

链式法则 (Chain Rule):

∂L/∂w = ∂L/∂y · ∂y/∂z · ∂z/∂w

其中: - L: 损失函数 - y: 输出 - z: 线性组合 (z = w·x + b) - w: 权重

手动推导示例 (单层网络):

# 前向传播
z = w * x + b
y_pred = sigmoid(z)
loss = (y_true - y_pred) ** 2

# 反向传播
dL_dy = -2 * (y_true - y_pred)
dy_dz = sigmoid(z) * (1 - sigmoid(z))
dz_dw = x

# 梯度
dL_dw = dL_dy * dy_dz * dz_dw

计算图可视化: 参见 notebooks/stage4/01-neural-network.ipynb 第3节

---

3. 优化器 (Optimizers)

优化器决定如何使用梯度更新参数。

3.1 梯度下降 (Gradient Descent)

公式:

w_new = w_old - learning_rate * ∂L/∂w

三种变体:

类型	每次迭代使用数据量	优点	缺点
批量梯度下降 (BGD)	全部数据	收敛稳定	大数据集很慢
随机梯度下降 (SGD)	1个样本	速度快、可在线学习	收敛不稳定
小批量梯度下降 (Mini-batch GD)	batch_size个样本	平衡速度与稳定性	需调batch_size

3.2 常用优化器对比

优化器	核心思想	优点	缺点	推荐学习率
SGD	基础梯度下降	简单、可复现	需精细调参	0.01-0.1
SGD + Momentum	累积历史梯度	加速收敛、减少震荡	需额外参数	0.01-0.1
RMSprop	自适应学习率	适合RNN	需调衰减率	0.001
Adam	Momentum + RMSprop	自适应、鲁棒性强	可能过拟合	0.001-0.0001
AdamW	Adam + 权重衰减	改进正则化	-	0.001-0.0001

选择建议: - 默认首选: Adam (lr=0.001) - 追求最优性能: SGD + Momentum (lr=0.01, momentum=0.9) + 学习率调度 - Transformer模型: AdamW (lr=5e-5)

公式对比: 参见 notebooks/stage4/01-neural-network.ipynb 第4节

---

4. 正则化技术 (Regularization)

防止过拟合的方法。

4.1 权重衰减 (Weight Decay / L2正则化)

原理: 在损失函数中添加权重的L2范数惩罚项。

公式:

Loss_total = Loss_original + λ · Σw²

PyTorch实现:

optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)

4.2 Dropout

原理: 训练时随机丢弃部分神经元，测试时使用全部神经元。

典型配置: - 全连接层: dropout=0.5 - CNN卷积层: dropout=0.2-0.3 - RNN/Transformer: dropout=0.1

PyTorch实现:

self.dropout = nn.Dropout(p=0.5)
x = self.dropout(x)

4.3 Batch Normalization

原理: 归一化每个batch的激活值，加速训练。

公式:

y = γ · (x - μ) / √(σ² + ε) + β

优点: - 加速收敛（可使用更大学习率） - 减轻梯度消失/爆炸 - 轻微正则化效果

PyTorch实现:

self.bn = nn.BatchNorm1d(num_features)
x = self.bn(x)

---

5. PyTorch基础

5.1 张量操作 (Tensor Operations)

PyTorch中的张量类似于NumPy数组，但支持GPU加速和自动微分。

创建张量:

import torch

# 从Python列表创建
x = torch.tensor([1, 2, 3])

# 创建特殊张量
zeros = torch.zeros(3, 4)       # 全0
ones = torch.ones(2, 3)         # 全1
rand = torch.rand(3, 3)         # 均匀分布[0,1)
randn = torch.randn(3, 3)       # 标准正态分布

常用操作:

# 形状操作
x = torch.randn(2, 3, 4)
print(x.shape)                  # torch.Size([2, 3, 4])
y = x.view(2, -1)              # reshape: (2, 12)
z = x.transpose(1, 2)          # 转置: (2, 4, 3)

# 数学运算
a = torch.tensor([1, 2, 3])
b = torch.tensor([4, 5, 6])
c = a + b                      # 逐元素相加
d = torch.dot(a, b)            # 点积: 32
e = torch.matmul(A, B)         # 矩阵乘法

# GPU加速
if torch.cuda.is_available():
    x_gpu = x.to('cuda')       # 移动到GPU
    y_gpu = x_gpu * 2
    y_cpu = y_gpu.to('cpu')    # 移回CPU

5.2 自动微分 (Autograd)

PyTorch的核心特性，自动计算梯度。

基本用法:

# 需要梯度的张量
x = torch.tensor([2.0], requires_grad=True)
y = x ** 2 + 3 * x + 1

# 反向传播
y.backward()

# 查看梯度
print(x.grad)  # dy/dx = 2x + 3 = 7.0

梯度累积:

x = torch.tensor([1.0], requires_grad=True)

# 第一次前向+反向
y1 = x ** 2
y1.backward()
print(x.grad)  # 2.0

# 第二次（梯度会累积）
y2 = x ** 3
y2.backward()
print(x.grad)  # 2.0 + 3.0 = 5.0

# 清零梯度
x.grad.zero_()

5.3 模型定义

两种方式:

方式1: 使用nn.Module（推荐）:

import torch.nn as nn

class SimpleNN(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_dim, output_dim)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

# 实例化模型
model = SimpleNN(input_dim=10, hidden_dim=20, output_dim=2)

方式2: 使用nn.Sequential（简洁）:

model = nn.Sequential(
    nn.Linear(10, 20),
    nn.ReLU(),
    nn.Linear(20, 2)
)

5.4 训练循环

完整示例:

import torch
import torch.nn as nn
import torch.optim as optim

# 1. 准备数据
X_train = torch.randn(100, 10)
y_train = torch.randint(0, 2, (100,))

# 2. 定义模型
model = SimpleNN(10, 20, 2)

# 3. 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 4. 训练循环
num_epochs = 100
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X_train)
    loss = criterion(outputs, y_train)

    # 反向传播
    optimizer.zero_grad()  # 清零梯度
    loss.backward()        # 计算梯度
    optimizer.step()       # 更新参数

    # 打印进度
    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

# 5. 评估模型
model.eval()
with torch.no_grad():
    test_outputs = model(X_test)
    _, predicted = torch.max(test_outputs, 1)
    accuracy = (predicted == y_test).sum().item() / len(y_test)
    print(f'Accuracy: {accuracy:.2%}')

---

🔬 实践环节

Notebook 1: 手写神经网络 (01-neural-network.ipynb)

内容: 1. 从零实现感知机（不使用PyTorch） 2. 实现MLP并在2D数据集上可视化决策边界 3. 手动推导并实现反向传播 4. 对比不同激活函数的效果 5. 可视化梯度下降过程

数据集: 合成数据（XOR问题、螺旋分类）

预期输出: - 决策边界可视化图 - 损失曲线 - 梯度流可视化

---

Notebook 2: PyTorch基础 (02-pytorch-basics.ipynb)

内容: 1. 张量操作练习（创建、索引、切片、运算） 2. 自动微分机制演示（计算图可视化） 3. 使用nn.Module定义模型 4. 在MNIST数据集上训练手写数字分类器 5. 对比不同优化器的收敛速度 6. 实验正则化技术（Dropout、Weight Decay）

数据集: MNIST（手写数字0-9）

预期输出: - 模型在测试集上达到 >95% 准确率 - 不同优化器的损失曲线对比图 - 正则化效果对比（过拟合vs正常化）

---

📖 推荐阅读

必读

• Neural Networks and Deep Learning - Michael Nielsen (免费在线书)
• Deep Learning Book Chapter 6: Deep Feedforward Networks - Goodfellow et al.
• PyTorch官方教程: 60分钟入门

选读

• CS231n: Convolutional Neural Networks for Visual Recognition - Stanford大学课程（强烈推荐）
• The Matrix Calculus You Need For Deep Learning - 矩阵微积分速查
• An Overview of Gradient Descent Optimization Algorithms - Sebastian Ruder

---

❓ 常见问题

Q1: 为什么使用ReLU而不是Sigmoid？

A: ReLU的优势： 1. 计算快: 只需比较大小，无需指数运算 2. 缓解梯度消失: Sigmoid在输入较大/较小时梯度接近0，ReLU在正区间梯度恒为1 3. 稀疏激活: 约50%的神经元输出为0，提高效率

但ReLU也有**神经元死亡**问题（负区间梯度为0），可用Leaky ReLU缓解。

---

Q2: 如何选择学习率？

A: 学习率选择策略： 1. 经验值: Adam使用0.001，SGD使用0.01-0.1 2. 学习率查找 (Learning Rate Finder): 从很小值开始，逐步增大，绘制loss曲线，选择下降最快的点 3. 学习率调度 (Learning Rate Scheduling): - StepLR: 每N个epoch降低学习率 - CosineAnnealingLR: 余弦退火 - ReduceLROnPlateau: 验证集loss不下降时降低学习率

PyTorch示例:

optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

for epoch in range(100):
    train(...)
    scheduler.step()  # 更新学习率

---

Q3: 过拟合怎么办？

A: 常用方法（按优先级）： 1. 增加数据: 最有效，考虑数据增强 (Data Augmentation) 2. 正则化: - L2正则化 (weight_decay=1e-4) - Dropout (p=0.5) 3. 简化模型: 减少层数或神经元数量 4. Early Stopping: 验证集loss不下降时停止训练 5. Batch Normalization: 轻微正则化效果

诊断方法: - 绘制训练集vs验证集的loss曲线 - 训练loss持续下降但验证loss上升 → 过拟合

---

Q4: GPU加速如何使用？

A: PyTorch中使用GPU的步骤：

# 1. 检查GPU是否可用
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f'Using device: {device}')

# 2. 将模型移到GPU
model = model.to(device)

# 3. 将数据移到GPU
X_train = X_train.to(device)
y_train = y_train.to(device)

# 4. 训练（其他代码不变）
outputs = model(X_train)  # 自动在GPU上计算

注意事项: - CPU张量和GPU张量不能直接运算 - 使用.to('cpu')将GPU张量移回CPU（如绘图时）

---

Q5: 梯度消失/爆炸如何解决？

A:

梯度消失 (Gradient Vanishing): - 症状: 训练很慢，loss几乎不下降 - 原因: Sigmoid/Tanh在深层网络中梯度衰减到接近0 - 解决方案: 1. 使用ReLU激活函数 2. Batch Normalization 3. 残差连接 (Residual Connection, ResNet)

梯度爆炸 (Gradient Exploding): - 症状: loss变为NaN或Inf - 原因: 梯度在反向传播中指数增长 - 解决方案: 1. 梯度裁剪 (Gradient Clipping):

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

2. 降低学习率 3. Batch Normalization

---

🚀 下一步

完成本模块后，你可以:

1. 📘 继续学习 模块M02: 计算机视觉基础 (docs/stage4/02-cv-basics/README.md)
2. 🎯 选择一个深度学习项目开始实践（推荐P02: YOLOv11实时检测）
3. 📚 深入阅读 Deep Learning Book 的其他章节

---

📝 学习检查清单

完成以下任务表示你已掌握本模块内容：

• 能解释感知机与MLP的区别
• 能手写反向传播的梯度推导（至少单层）
• 理解常用激活函数的优缺点及适用场景
• 能使用PyTorch定义一个多层神经网络
• 能选择合适的损失函数和优化器
• 理解正则化技术的原理并能应用
• 能诊断并解决过拟合/欠拟合问题
• 能使用GPU加速训练

---

上一模块: 阶段3模块M04: 机器学习进阶 下一模块: 模块M02: 计算机视觉基础 返回: 阶段4目录