深度学习入门

深度学习入门

深度学习 = 多层神经网络。核心思想：层层抽象，自动学习特征。

flowchart LR
    A[输入层<br/>784 像素] --> B[隐藏层1<br/>256 神经元]
    B --> C[隐藏层2<br/>128 神经元]
    C --> D[输出层<br/>10 类别]

感知机：起点

单个神经元完成”加权求和 + 激活”：

$$y = f\left(\sum_{i=1}^n w_i x_i + b\right)$$

import numpy as np

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

class Perceptron:
    def __init__(self, n_inputs):
        self.w = np.random.randn(n_inputs) * 0.01
        self.b = 0.0

    def forward(self, x):
        return sigmoid(np.dot(x, self.w) + self.b)

p = Perceptron(3)
print(f"输出: {p.forward(np.array([1.0, 0.5, -0.3])):.4f}")

多层感知机 (MLP)

import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(784, 256),   # 输入 → 隐藏层1
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(256, 128),   # 隐藏层1 → 隐藏层2
            nn.ReLU(),
            nn.Linear(128, 10),    # 隐藏层2 → 输出
        )

    def forward(self, x):
        return self.model(x)

model = MLP()
print(f"参数量: {sum(p.numel() for p in model.parameters()):,}")

激活函数

函数	公式	特点
Sigmoid	$\sigma(x) = \frac{1}{1+e^{-x}}$	输出 (0,1)，有梯度消失
ReLU	$f(x) = \max(0, x)$	简单高效，最常用
GELU	$f(x) = x \cdot \Phi(x)$	Transformer 标配

反向传播

链式法则逐层计算梯度：

flowchart LR
    A[前向传播] --> B[计算损失]
    B --> C[反向传播<br/>链式法则]
    C --> D[更新参数]
    D --> A

x = torch.tensor([2.0], requires_grad=True)
y = x ** 3 + 2 * x
y.backward()  # 自动计算 dy/dx
print(f"dy/dx at x=2: {x.grad.item()}")  # 3×4 + 2 = 14

训练循环

def train_one_epoch(model, dataloader, optimizer, loss_fn):
    model.train()
    total_loss = 0
    for x_batch, y_batch in dataloader:
        optimizer.zero_grad()          # 清零梯度
        y_pred = model(x_batch)        # 前向传播
        loss = loss_fn(y_pred, y_batch) # 计算损失
        loss.backward()                # 反向传播
        optimizer.step()               # 更新参数
        total_loss += loss.item()
    return total_loss / len(dataloader)

训练技巧

技巧	作用	实现
学习率调度	逐步降低学习率	CosineAnnealingLR
梯度裁剪	防止梯度爆炸	clip_grad_norm_
Early Stopping	防止过拟合	监控验证损失
混合精度	加速训练	torch.cuda.amp

# 混合精度训练示例
scaler = torch.cuda.amp.GradScaler()
with torch.cuda.amp.autocast():
    loss = loss_fn(model(x), y)
scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

下一步

• CNN — 图像处理的利器
• RNN — 序列模型
• Transformer — 现代架构