阶段三：深度学习基础

预计时长：6-8周
目标：掌握神经网络原理，熟练使用PyTorch进行模型开发

3.1 神经网络原理（2周）

3.1.1 感知机与多层感知机

核心知识点

主题	内容	重要程度
感知机	单层线性分类器	⭐⭐⭐
多层感知机(MLP)	多层全连接网络	⭐⭐⭐⭐⭐
前向传播	输入→隐藏层→输出	⭐⭐⭐⭐⭐
通用逼近定理	MLP可拟合任意函数	⭐⭐⭐

MLP结构

输入层          隐藏层1         隐藏层2         输出层
  x1  ────┐    ┌──── h1 ────┐   ┌──── h1 ────┐   ┌──── y1
  x2  ────┼────┼──── h2 ────┼───┼──── h2 ────┼───┼──── y2
  x3  ────┼────┼──── h3 ────┼───┼──── h3 ────┘   └──── y3
  ...     │    └──── ... ───┘   └──── ... ───────────────
  xn  ────┘

3.1.2 激活函数

常用激活函数对比

激活函数	公式	优点	缺点	使用场景
Sigmoid	σ(x) = 1/(1+e^(-x))	输出(0,1)	梯度消失、非零中心	二分类输出
Tanh	tanh(x)	零中心	梯度消失	早期RNN
ReLU	max(0,x)	计算快、缓解梯度消失	死神经元	默认选择
LeakyReLU	max(αx,x)	避免死神经元	α需调参	替代ReLU
GELU	x·Φ(x)	平滑、效果好	计算稍慢	Transformer
Swish	x·σ(x)	平滑、效果好	计算稍慢	现代网络

学习目标

理解各激活函数的特点
知道什么时候选择什么激活函数
手写实现各激活函数及其导数

3.1.3 反向传播算法

核心概念

主题	内容	重要程度
计算图	前向计算的图表示	⭐⭐⭐⭐⭐
链式法则	复合函数求导	⭐⭐⭐⭐⭐
梯度反向传播	从输出到输入传播梯度	⭐⭐⭐⭐⭐
梯度消失/爆炸	深层网络的问题	⭐⭐⭐⭐

反向传播核心公式

前向传播:
z = Wx + b
a = σ(z)

反向传播:
∂L/∂W = ∂L/∂a · ∂a/∂z · ∂z/∂W
       = δ · x^T

其中 δ = ∂L/∂z（误差信号）

学习目标

理解计算图和自动微分
手推简单网络的反向传播
理解梯度消失/爆炸的原因

3.1.4 损失函数

常用损失函数

损失函数	公式	使用场景
MSE	mean((y-ŷ)²)	回归问题
MAE	mean(\|y-ŷ\|)	回归（对异常值鲁棒）
交叉熵	-Σy·log(ŷ)	分类问题
二元交叉熵	-[y·log(ŷ)+(1-y)·log(1-ŷ)]	二分类
Focal Loss	-α(1-p)^γ·log(p)	类别不平衡
Hinge Loss	max(0, 1-y·ŷ)	SVM

3.1.5 优化器

优化器演进

SGD → Momentum → NAG → AdaGrad → RMSprop → Adam → AdamW
 │        │              │          │          │
 │    加速收敛        自适应学习率   结合两者   权重衰减解耦

常用优化器

优化器	特点	适用场景	重要程度
SGD	简单，需调学习率	调参充分时效果最好	⭐⭐⭐⭐
SGD+Momentum	加速收敛	通用	⭐⭐⭐⭐
Adam	自适应，收敛快	默认选择	⭐⭐⭐⭐⭐
AdamW	Adam+解耦权重衰减	Transformer	⭐⭐⭐⭐⭐

Adam更新公式

m_t = β1·m_{t-1} + (1-β1)·g_t        # 一阶动量
v_t = β2·v_{t-1} + (1-β2)·g_t²       # 二阶动量
m̂_t = m_t / (1-β1^t)                 # 偏差校正
v̂_t = v_t / (1-β2^t)
θ_t = θ_{t-1} - α·m̂_t / (√v̂_t + ε)

学习目标

理解各优化器的原理
手写实现SGD和Adam
在实验中对比不同优化器

3.2 PyTorch深度学习框架（2周）

3.2.1 张量操作

核心操作

操作类型	常用函数	重要程度
创建张量	torch.tensor, zeros, ones, randn	⭐⭐⭐⭐⭐
形状操作	view, reshape, squeeze, unsqueeze	⭐⭐⭐⭐⭐
索引切片	基本索引, 高级索引	⭐⭐⭐⭐⭐
数学运算	加减乘除, matmul, sum, mean	⭐⭐⭐⭐⭐
设备管理	.to(device), .cuda(), .cpu()	⭐⭐⭐⭐⭐

代码示例

import torch

# 创建张量
x = torch.randn(3, 4)
y = torch.zeros(3, 4)

# 形状操作
x = x.view(2, 6)
x = x.unsqueeze(0)  # 增加维度

# GPU操作
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
x = x.to(device)

# 矩阵运算
z = torch.matmul(x, y.T)

3.2.2 自动微分

核心概念

概念	说明	重要程度
requires_grad	是否需要计算梯度	⭐⭐⭐⭐⭐
backward()	反向传播计算梯度	⭐⭐⭐⭐⭐
grad	存储梯度	⭐⭐⭐⭐⭐
no_grad()	禁用梯度计算	⭐⭐⭐⭐⭐
detach()	从计算图分离	⭐⭐⭐⭐

代码示例

# 自动微分
x = torch.randn(3, requires_grad=True)
y = x ** 2 + 2 * x + 1
loss = y.sum()
loss.backward()
print(x.grad)  # dy/dx = 2x + 2

# 禁用梯度（推理时）
with torch.no_grad():
    output = model(input)

3.2.3 模型构建

nn.Module使用

import torch.nn as nn

class MLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__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

# 使用Sequential
model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Linear(256, 10)
)

3.2.4 数据加载

Dataset与DataLoader

from torch.utils.data import Dataset, DataLoader

class CustomDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

# DataLoader
dataset = CustomDataset(X, y)
dataloader = DataLoader(
    dataset,
    batch_size=32,
    shuffle=True,
    num_workers=4
)

for batch_x, batch_y in dataloader:
    # 训练代码
    pass

3.2.5 训练循环

完整训练模板

import torch
import torch.nn as nn
from torch.optim import Adam

# 模型、损失函数、优化器
model = MLP(784, 256, 10).to(device)
criterion = nn.CrossEntropyLoss()
optimizer = Adam(model.parameters(), lr=0.001)

# 训练循环
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    total_loss = 0
    
    for batch_x, batch_y in train_loader:
        batch_x, batch_y = batch_x.to(device), batch_y.to(device)
        
        # 前向传播
        outputs = model(batch_x)
        loss = criterion(outputs, batch_y)
        
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
    
    # 验证
    model.eval()
    with torch.no_grad():
        val_loss = 0
        correct = 0
        for batch_x, batch_y in val_loader:
            outputs = model(batch_x)
            val_loss += criterion(outputs, batch_y).item()
            pred = outputs.argmax(dim=1)
            correct += (pred == batch_y).sum().item()
        
        accuracy = correct / len(val_loader.dataset)
    
    print(f'Epoch {epoch+1}: Train Loss={total_loss:.4f}, Val Acc={accuracy:.4f}')

3.2.6 模型保存与加载

# 保存模型
torch.save(model.state_dict(), 'model.pth')
torch.save({
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'loss': loss,
}, 'checkpoint.pth')

# 加载模型
model.load_state_dict(torch.load('model.pth'))
checkpoint = torch.load('checkpoint.pth')
model.load_state_dict(checkpoint['model_state_dict'])

3.3 经典网络架构（2-4周）

3.3.1 卷积神经网络（CNN）- 了解

核心组件

组件	作用	重要程度
卷积层	局部特征提取	⭐⭐⭐⭐
池化层	下采样、降维	⭐⭐⭐⭐
BatchNorm	稳定训练	⭐⭐⭐⭐⭐
残差连接	解决梯度消失	⭐⭐⭐⭐⭐

经典架构

网络	年份	特点	了解程度
LeNet	1998	开创性工作	了解
AlexNet	2012	深度学习复兴	了解
VGG	2014	3x3卷积堆叠	了解
ResNet	2015	残差连接	重点理解
EfficientNet	2019	复合缩放	了解

学习目标（了解即可，非LLM方向重点）

理解卷积运算的原理
理解残差连接的作用
能读懂CNN相关代码

3.3.2 循环神经网络（RNN）- 重点

核心概念

主题	内容	重要程度
RNN原理	序列处理、隐状态传递	⭐⭐⭐⭐⭐
梯度问题	梯度消失/爆炸	⭐⭐⭐⭐⭐
LSTM	门控机制解决长期依赖	⭐⭐⭐⭐⭐
GRU	LSTM简化版	⭐⭐⭐⭐
双向RNN	前向+后向信息	⭐⭐⭐⭐

RNN基本公式

h_t = tanh(W_hh · h_{t-1} + W_xh · x_t + b)
y_t = W_hy · h_t + b_y

LSTM门控机制

遗忘门: f_t = σ(W_f · [h_{t-1}, x_t] + b_f)
输入门: i_t = σ(W_i · [h_{t-1}, x_t] + b_i)
候选值: C̃_t = tanh(W_C · [h_{t-1}, x_t] + b_C)
细胞状态: C_t = f_t * C_{t-1} + i_t * C̃_t
输出门: o_t = σ(W_o · [h_{t-1}, x_t] + b_o)
隐状态: h_t = o_t * tanh(C_t)

PyTorch实现

import torch.nn as nn

# LSTM层
lstm = nn.LSTM(
    input_size=128,
    hidden_size=256,
    num_layers=2,
    batch_first=True,
    bidirectional=True,
    dropout=0.2
)

# 前向传播
output, (h_n, c_n) = lstm(input_seq)
# output: (batch, seq_len, hidden_size*2)
# h_n: (num_layers*2, batch, hidden_size)

学习目标

理解RNN处理序列的原理
理解LSTM门控机制
用LSTM实现文本分类

3.3.3 正则化技术

技术	作用	使用场景	重要程度
Dropout	随机丢弃神经元	全连接层	⭐⭐⭐⭐⭐
BatchNorm	批量归一化	CNN	⭐⭐⭐⭐⭐
LayerNorm	层归一化	Transformer/RNN	⭐⭐⭐⭐⭐
Weight Decay	L2正则化	通用	⭐⭐⭐⭐
Early Stopping	提前停止	通用	⭐⭐⭐⭐

LayerNorm vs BatchNorm

BatchNorm: 对batch维度归一化，训练测试行为不同
LayerNorm: 对特征维度归一化，训练测试行为相同

Transformer使用LayerNorm因为:
1. 序列长度可变
2. batch_size可能很小
3. 训练测试一致性

3.4 实践项目

项目1：MNIST手写数字识别

目标：用MLP和CNN实现手写数字分类

要求：

构建简单MLP达到95%+准确率
构建CNN达到99%+准确率
实现完整训练流程

项目2：IMDB情感分类

目标：用LSTM实现电影评论情感分类

要求：

文本预处理和词向量
构建LSTM分类模型
达到85%+准确率

阶段三 Checklist

完成以下任务后，进入阶段四：

下一步

完成本阶段后，进入阶段四：NLP基础

FilesExpand file tree

03-deep-learning.md

Latest commit

History

03-deep-learning.md

File metadata and controls

阶段三：深度学习基础

3.1 神经网络原理（2周）

3.1.1 感知机与多层感知机

核心知识点

MLP结构

3.1.2 激活函数

常用激活函数对比

学习目标

3.1.3 反向传播算法

核心概念

反向传播核心公式

学习目标

3.1.4 损失函数

常用损失函数

3.1.5 优化器

优化器演进

常用优化器

Adam更新公式

学习目标

3.2 PyTorch深度学习框架（2周）

3.2.1 张量操作

核心操作

代码示例

3.2.2 自动微分

核心概念

代码示例

3.2.3 模型构建

nn.Module使用

3.2.4 数据加载

Dataset与DataLoader

3.2.5 训练循环

完整训练模板

3.2.6 模型保存与加载

3.3 经典网络架构（2-4周）

3.3.1 卷积神经网络（CNN）- 了解

核心组件

经典架构

学习目标（了解即可，非LLM方向重点）

3.3.2 循环神经网络（RNN）- 重点

核心概念

RNN基本公式

LSTM门控机制

PyTorch实现

学习目标

3.3.3 正则化技术

LayerNorm vs BatchNorm

3.4 实践项目

项目1：MNIST手写数字识别

项目2：IMDB情感分类

阶段三 Checklist

下一步