深度学习资源专题

Deep Learning Resources

---

🧭 学习路径

基础网络  →  CNN  →  RNN/LSTM  →  Transformer  →  前沿
  (入门)      (视觉)   (序列)       (现代NLP)      (探索)

阶段	核心内容	时间	前置
🟢 入门	感知机、MLP、反向传播、梯度下降	2-3 周	线代 + 微积分
🟡 视觉	CNN、ResNet、迁移学习、目标检测	3-4 周	MLP 基础
🟠 序列	RNN、LSTM、GRU、Attention	3-4 周	CNN 基础
🔴 现代	Transformer、BERT、GPT、ViT	4-6 周	Attention
⚫ 前沿	Diffusion、GNN、RLHF、多模态	持续	上述全部

动手实践推荐 预测建模实战指南

---

📚 概述

深度学习是机器学习的一个子领域，基于多层神经网络学习数据的层次化表示。自 2012 年 AlexNet 在 ImageNet 竞赛中取得突破性成果以来，深度学习已成为人工智能的核心驱动力。

核心应用领域: - 计算机视觉（图像分类、目标检测、分割） - 自然语言处理（机器翻译、文本生成、问答） - 语音识别与合成 - 强化学习（游戏、机器人控制） - 生成模型（GAN、Diffusion、VAE） - 推荐系统

---

🗺️ 知识地图

graph TB
    A[深度学习] --> B[基础理论]
    A --> C[神经网络架构]
    A --> D[训练技术]
    A --> E[应用领域]

    B --> B1[反向传播]
    B --> B2[优化算法]
    B --> B3[正则化]
    B --> B4[损失函数]

    C --> C1[MLP]
    C --> C2[CNN]
    C --> C3[RNN/LSTM]
    C --> C4[Transformer]
    C --> C5[Autoencoder]

    D --> D1[Batch Norm]
    D --> D2[Learning Rate 调度]
    D --> D3[迁移学习]
    D --> D4[模型压缩]

    E --> E1[计算机视觉]
    E --> E2[NLP]
    E --> E3[语音]
    E --> E4[强化学习]

---

📖 经典书籍

入门级

书名	作者	年份	难度	特点
《Deep Learning with Python》	François Chollet	2021	⭐⭐⭐	Keras 作者亲笔，实战友好
《动手学深度学习》	李沐等	2023	⭐⭐⭐	免费开源，PyTorch 代码
《神经网络与深度学习》	Michael Nielsen	2019	⭐⭐⭐	理论基础清晰

进阶级

书名	作者	年份	难度	特点
《Deep Learning》	Goodfellow et al.	2016	⭐⭐⭐⭐	花书，理论圣经，免费在线
《Dive into Deep Learning》	Aston Zhang et al.	2023	⭐⭐⭐⭐	交互式学习，代码丰富
《Understanding Deep Learning》	Prince	2023	⭐⭐⭐⭐	图文并茂，讲解清晰

高级级

书名	作者	年份	难度	特点
《Pattern Recognition and Machine Learning》	Bishop	2006	⭐⭐⭐⭐⭐	贝叶斯视角，数学严谨
《Probabilistic Deep Learning》	Beel et al.	2020	⭐⭐⭐⭐⭐	概率深度学习
《Generative Deep Learning》	David Foster	2021	⭐⭐⭐⭐	GAN、VAE、Diffusion

---

🎓 在线课程

免费课程

课程	平台	讲师	时长	链接
Deep Learning Specialization	Coursera	Andrew Ng	5 门课	链接
CS231n	YouTube/Stanford	Fei-Fei Li	16 讲	链接
CS224n	YouTube/Stanford	Christopher Manning	20 讲	链接
深度学习	B 站	李宏毅	45 讲	链接
Practical Deep Learning	fast.ai	Jeremy Howard	7 周	链接

实战课程

课程	平台	特点	链接
Deep Learning with PyTorch	Udacity	Facebook 合作	链接
Tensorflow Developer Certificate	Coursera	Google 认证	链接
Deep Learning Nanodegree	Udacity	项目驱动	链接

---

🔧 框架与工具

主流框架

框架	特点	Stars	链接
PyTorch	动态图、研究首选	70k+	GitHub
TensorFlow	工业部署、生态完善	170k+	GitHub
JAX	函数式、高性能	25k+	GitHub
PaddlePaddle	百度出品、中文友好	20k+	GitHub

高级库

库	功能	Stars	链接
Lightning	PyTorch 训练框架	25k+	GitHub
Hugging Face	预训练模型库	100k+	GitHub
Detectron2	目标检测与分割	25k+	GitHub
MMDetection	商汤检测工具箱	25k+	GitHub

---

📊 核心概念详解

1. 神经网络基础

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleMLP(nn.Module):
    """多层感知机示例"""

    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size // 2)
        self.fc3 = nn.Linear(hidden_size // 2, output_size)
        self.dropout = nn.Dropout(0.5)

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

# 实例化模型
model = SimpleMLP(input_size=784, hidden_size=512, output_size=10)

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

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

---

2. 卷积神经网络 (CNN)

class CNNForImageClassification(nn.Module):
    """图像分类 CNN"""

    def __init__(self, num_classes=10):
        super().__init__()

        # 卷积层
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)

        # 池化层
        self.pool = nn.MaxPool2d(2, 2)

        # 批归一化
        self.bn1 = nn.BatchNorm2d(32)
        self.bn2 = nn.BatchNorm2d(64)
        self.bn3 = nn.BatchNorm2d(128)

        # 全连接层
        self.fc1 = nn.Linear(128 * 4 * 4, 256)
        self.fc2 = nn.Linear(256, num_classes)

        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        # Conv Block 1
        x = self.pool(F.relu(self.bn1(self.conv1(x))))

        # Conv Block 2
        x = self.pool(F.relu(self.bn2(self.conv2(x))))

        # Conv Block 3
        x = self.pool(F.relu(self.bn3(self.conv3(x))))

        # 展平
        x = x.view(-1, 128 * 4 * 4)

        # 全连接
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)

        return x

# 经典 CNN 架构
# - LeNet-5 (1998): 手写数字识别
# - AlexNet (2012): ImageNet 突破
# - VGG (2014): 深度与简洁
# - ResNet (2015): 残差连接
# - EfficientNet (2019): 复合缩放

---

3. 循环神经网络 (RNN/LSTM)

class LSTMForSequenceClassification(nn.Module):
    """LSTM 序列分类"""

    def __init__(self, vocab_size, embedding_dim, hidden_size, num_classes, num_layers=2):
        super().__init__()

        self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=0)
        self.lstm = nn.LSTM(
            embedding_dim,
            hidden_size,
            num_layers=num_layers,
            batch_first=True,
            bidirectional=True,
            dropout=0.3 if num_layers > 1 else 0
        )
        self.fc = nn.Linear(hidden_size * 2, num_classes)

    def forward(self, x, lengths=None):
        # x: (batch_size, seq_len)
        embedded = self.embedding(x)  # (batch, seq, embed)

        # LSTM
        lstm_out, (hidden, cell) = self.lstm(embedded)

        # 连接双向隐状态
        hidden_cat = torch.cat((hidden[-2,:,:], hidden[-1,:,:]), dim=1)

        # 分类
        output = self.fc(hidden_cat)

        return output

# 变体
# - GRU: 简化版 LSTM
# - Bi-LSTM: 双向 LSTM
# - Attention-based LSTM: 带注意力机制

---

4. Transformer 架构

class TransformerBlock(nn.Module):
    """Transformer 编码器块"""

    def __init__(self, embed_dim, num_heads, ff_dim, dropout=0.1):
        super().__init__()

        self.attention = nn.MultiheadAttention(embed_dim, num_heads, dropout=dropout)
        self.feed_forward = nn.Sequential(
            nn.Linear(embed_dim, ff_dim),
            nn.ReLU(),
            nn.Linear(ff_dim, embed_dim)
        )

        self.norm1 = nn.LayerNorm(embed_dim)
        self.norm2 = nn.LayerNorm(embed_dim)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, mask=None):
        # 自注意力（带残差连接和 LayerNorm）
        attn_output, _ = self.attention(x, x, x, attn_mask=mask)
        x = self.norm1(x + self.dropout(attn_output))

        # 前馈网络
        ff_output = self.feed_forward(x)
        x = self.norm2(x + self.dropout(ff_output))

        return x

class TransformerEncoder(nn.Module):
    """完整 Transformer 编码器"""

    def __init__(self, vocab_size, max_seq_len, embed_dim, num_heads, 
                 num_layers, ff_dim, num_classes):
        super().__init__()

        self.token_embedding = nn.Embedding(vocab_size, embed_dim)
        self.position_embedding = nn.Embedding(max_seq_len, embed_dim)

        self.transformer_blocks = nn.ModuleList([
            TransformerBlock(embed_dim, num_heads, ff_dim)
            for _ in range(num_layers)
        ])

        self.fc = nn.Linear(embed_dim, num_classes)

    def forward(self, x):
        batch_size, seq_len = x.shape
        positions = torch.arange(seq_len).unsqueeze(0).expand(batch_size, -1)

        # 词嵌入 + 位置嵌入
        embedded = self.token_embedding(x) + self.position_embedding(positions)

        # Transformer 块
        for block in self.transformer_blocks:
            embedded = block(embedded.transpose(0, 1)).transpose(0, 1)

        # 全局平均池化
        pooled = embedded.mean(dim=1)

        # 分类
        output = self.fc(pooled)

        return output

---

5. 训练技巧

# 1. 学习率调度器
from torch.optim.lr_scheduler import CosineAnnealingLR, ReduceLROnPlateau

scheduler = CosineAnnealingLR(optimizer, T_max=10, eta_min=1e-6)
# 或
scheduler = ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=3)

# 2. 梯度裁剪
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# 3. 混合精度训练
from torch.cuda.amp import autocast, GradScaler

scaler = GradScaler()

with autocast():
    output = model(input)
    loss = criterion(output, target)

scaler.scale(loss).backward()
scaler.step(optimizer)
scaler.update()

# 4. 早停机制
class EarlyStopping:
    def __init__(self, patience=5, min_delta=0.001):
        self.patience = patience
        self.min_delta = min_delta
        self.counter = 0
        self.best_loss = None
        self.should_stop = False

    def __call__(self, val_loss):
        if self.best_loss is None:
            self.best_loss = val_loss
        elif val_loss > self.best_loss - self.min_delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.should_stop = True
        else:
            self.best_loss = val_loss
            self.counter = 0

early_stopper = EarlyStopping(patience=5)

# 训练循环中
for epoch in range(max_epochs):
    train_loss = train_one_epoch()
    val_loss = validate()

    early_stopper(val_loss)
    if early_stopper.should_stop:
        print(f"Early stopping at epoch {epoch}")
        break

---

6. 迁移学习

from torchvision import models

def setup_transfer_learning(num_classes, pretrained=True, freeze_backbone=True):
    """设置迁移学习模型"""

    # 加载预训练模型
    model = models.resnet50(pretrained=pretrained)

    if freeze_backbone:
        # 冻结骨干网络
        for param in model.parameters():
            param.requires_grad = False

    # 替换最后的全连接层
    num_features = model.fc.in_features
    model.fc = nn.Sequential(
        nn.Dropout(0.5),
        nn.Linear(num_features, num_classes)
    )

    return model

# 使用示例
model = setup_transfer_learning(num_classes=10, freeze_backbone=True)

# 只训练新层
optimizer = torch.optim.Adam(filter(p: p.requires_grad, model.parameters()), lr=0.001)

# 训练几个 epoch 后，解冻骨干网络进行微调
def fine_tune(model, unfreeze_from_layer=None):
    """微调策略"""
    # 解冻所有层
    for param in model.parameters():
        param.requires_grad = True

    # 使用更小的学习率
    optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)

    return optimizer

---

7. 数据增强

from torchvision import transforms

# 图像数据增强
train_transform = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomVerticalFlip(p=0.2),
    transforms.RandomRotation(30),
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1), scale=(0.9, 1.1)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                         std=[0.229, 0.224, 0.225]),
    transforms.RandomErasing(p=0.2)
])

test_transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                         std=[0.229, 0.224, 0.225])
])

# 高级增强 (CutMix, Mixup)
def cutmix(x, y, alpha=1.0):
    """CutMix 数据增强"""
    lam = np.random.beta(alpha, alpha)
    batch_size = x.size(0)
    index = torch.randperm(batch_size)

    bbx1, bby1, bbx2, bby2 = rand_bbox(x.size(), lam)
    x[:, :, bbx1:bbx2, bby1:bby2] = x[index, :, bbx1:bbx2, bby1:bby2]

    # 调整标签
    lam = 1 - ((bbx2 - bbx1) * (bby2 - bby1) / (x.size(-1) * x.size(-2)))
    y = y * lam + y[index] * (1. - lam)

    return x, y

---

8. 模型评估与可视化

from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

def evaluate_model(model, dataloader, device, class_names=None):
    """全面评估模型"""
    model.eval()

    all_preds = []
    all_labels = []
    all_probs = []

    with torch.no_grad():
        for inputs, labels in dataloader:
            inputs, labels = inputs.to(device), labels.to(device)

            outputs = model(inputs)
            probs = F.softmax(outputs, dim=1)
            _, preds = torch.max(outputs, 1)

            all_preds.extend(preds.cpu().numpy())
            all_labels.extend(labels.cpu().numpy())
            all_probs.extend(probs.cpu().numpy())

    # 分类报告
    print("分类报告:")
    print(classification_report(all_labels, all_preds, target_names=class_names))

    # 混淆矩阵
    cm = confusion_matrix(all_labels, all_preds)
    plt.figure(figsize=(10, 8))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
    plt.title('Confusion Matrix')
    plt.ylabel('True Label')
    plt.xlabel('Predicted Label')
    plt.show()

    # 计算各类别指标
    from sklearn.metrics import precision_recall_fscore_support
    precision, recall, f1, _ = precision_recall_fscore_support(
        all_labels, all_preds, average=None
    )

    metrics_df = pd.DataFrame({
        'Precision': precision,
        'Recall': recall,
        'F1-Score': f1,
        'Support': np.bincount(all_labels)
    }, index=class_names)

    print("\n各类别指标:")
    print(metrics_df)

    return {
        'predictions': all_preds,
        'labels': all_labels,
        'probabilities': all_probs,
        'metrics': metrics_df
    }

---

📝 实战项目

项目 1: 图像分类完整流程

class ImageClassificationPipeline:
    """图像分类完整流程"""

    def __init__(self, model_name='resnet50', num_classes=10, pretrained=True):
        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
        self.model = self.setup_model(model_name, num_classes, pretrained)
        self.criterion = nn.CrossEntropyLoss()
        self.optimizer = None
        self.scheduler = None
        self.history = {'train_loss': [], 'val_loss': [], 'train_acc': [], 'val_acc': []}

    def setup_model(self, model_name, num_classes, pretrained):
        """设置模型"""
        if model_name == 'resnet50':
            model = models.resnet50(pretrained=pretrained)
            num_features = model.fc.in_features
            model.fc = nn.Linear(num_features, num_classes)
        elif model_name == 'efficientnet':
            model = models.efficientnet_b0(pretrained=pretrained)
            num_features = model.classifier[1].in_features
            model.classifier[1] = nn.Linear(num_features, num_classes)

        return model.to(self.device)

    def train(self, train_loader, val_loader, epochs=10, lr=0.001):
        """训练模型"""
        self.optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
        self.scheduler = CosineAnnealingLR(self.optimizer, T_max=epochs)

        for epoch in range(epochs):
            # 训练
            train_loss, train_acc = self.train_one_epoch(train_loader)

            # 验证
            val_loss, val_acc = self.validate(val_loader)

            # 记录历史
            self.history['train_loss'].append(train_loss)
            self.history['val_loss'].append(val_loss)
            self.history['train_acc'].append(train_acc)
            self.history['val_acc'].append(val_acc)

            print(f"Epoch {epoch+1}/{epochs}")
            print(f"  Train Loss: {train_loss:.4f}, Acc: {train_acc:.4f}")
            print(f"  Val Loss: {val_loss:.4f}, Acc: {val_acc:.4f}")

            self.scheduler.step()

        return self.history

    def train_one_epoch(self, loader):
        """单个 epoch 训练"""
        self.model.train()
        running_loss = 0.0
        correct = 0
        total = 0

        for inputs, labels in loader:
            inputs, labels = inputs.to(self.device), labels.to(self.device)

            self.optimizer.zero_grad()
            outputs = self.model(inputs)
            loss = self.criterion(outputs, labels)
            loss.backward()
            self.optimizer.step()

            running_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

        return running_loss / len(loader), correct / total

    def validate(self, loader):
        """验证"""
        self.model.eval()
        running_loss = 0.0
        correct = 0
        total = 0

        with torch.no_grad():
            for inputs, labels in loader:
                inputs, labels = inputs.to(self.device), labels.to(self.device)
                outputs = self.model(inputs)
                loss = self.criterion(outputs, labels)

                running_loss += loss.item()
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()

        return running_loss / len(loader), correct / total

    def predict(self, image_path):
        """单张图像预测"""
        from PIL import Image

        transform = test_transform
        image = Image.open(image_path).convert('RGB')
        image_tensor = transform(image).unsqueeze(0).to(self.device)

        self.model.eval()
        with torch.no_grad():
            outputs = self.model(image_tensor)
            probs = F.softmax(outputs, dim=1)
            _, predicted = torch.max(outputs, 1)

        return predicted.item(), probs[0].cpu().numpy()

# 使用示例
pipeline = ImageClassificationPipeline(num_classes=10)
history = pipeline.train(train_loader, val_loader, epochs=20)

---

📚 前沿研究方向

生成模型

模型类型	代表模型	应用	链接
GAN	StyleGAN, CycleGAN	图像生成、风格迁移	Paper
VAE	VQ-VAE	图像压缩、生成	Paper
Diffusion	Stable Diffusion, DALL-E 2	文生图	Paper
Flow	Glow, RealNVP	密度估计	Paper

大模型

模型	参数量	特点
GPT-4	未知	最强通用模型
LLaMA	7B-70B	开源 SOTA
CLIP	400M	图文对比学习
SAM	1B+	图像分割大模型

---

最后更新: 2026-06-01

相关文档: - machine-learning-resources.md - 机器学习资源 - nlp-resources.md - 自然语言处理资源 - visualization-resources.md - 数据可视化资源

---

**深度学习资源专题 | 从 CNN 到 Transformer** [返回顶部](#深度学习资源专题)