第3天：深度学习革命（2010-2017）

学习目标

理解深度学习的兴起背景
掌握卷积神经网络（CNN）的原理和应用
了解循环神经网络（RNN）和长短期记忆网络（LSTM）
理解AlphaGo的突破性意义
掌握深度学习的核心技术和应用

课程内容

1. 深度学习的兴起

1.1 从机器学习到深度学习

机器学习的局限性：

依赖特征工程
难以处理高维数据
泛化能力有限

深度学习的突破：

自动特征学习
端到端学习
处理高维数据的能力

关键转折点：

2006年：Hinton等人提出深度置信网络（DBN）
2012年：AlexNet在ImageNet竞赛中夺冠
2014年：VGG、GoogLeNet
2015年：ResNet

1.2 深度学习的三大驱动力

1.2.1 数据

大数据时代：

互联网产生海量数据
社交媒体、电子商务、搜索引擎
标注数据的积累

ImageNet数据集：

2010年发布
包含1400万张图像
2万多个类别
为计算机视觉提供标准数据集

1.2.2 算力

GPU加速：

并行计算能力强
适合矩阵运算
NVIDIA CUDA平台

硬件发展：

GPU性能持续提升
专用AI芯片（TPU、NPU）
云计算平台

1.2.3 算法

算法创新：

激活函数（ReLU、Leaky ReLU）
优化算法（Adam、RMSprop）
正则化技术（Dropout、Batch Normalization）
网络架构（ResNet、Inception、Transformer）

1.3 深度学习的定义

深度学习：

基于人工神经网络的机器学习方法
使用多层神经网络学习数据的层次化表示
通过反向传播算法训练网络

"深度"的含义：

网络层数多（通常>3层）
学习层次化特征
从低级特征到高级语义

2. 神经网络基础

2.1 感知机（Perceptron）

历史：

1957年由Frank Rosenblatt提出
第一个神经网络模型

结构：

输入层 → 加权求和 → 激活函数 → 输出

数学表达：

y = f(∑w_i * x_i + b)

激活函数：

阶跃函数：f(x) = 1 if x > 0 else 0

局限性：

只能解决线性可分问题
无法解决XOR问题

2.2 多层感知机（MLP）

结构：

输入层 → 隐藏层 → 输出层

前向传播：

h = f(W1 * x + b1)
y = g(W2 * h + b2)

激活函数：

1. Sigmoid：

f(x) = 1 / (1 + e^(-x))

范围：(0, 1)
问题：梯度消失

2. Tanh：

f(x) = (e^x - e^(-x)) / (e^x + e^(-x))

范围：(-1, 1)
问题：梯度消失

3. ReLU（Rectified Linear Unit）：

f(x) = max(0, x)

范围：[0, ∞)
优势：缓解梯度消失
问题：神经元死亡

4. Leaky ReLU：

f(x) = x if x > 0 else αx (α is small)

解决神经元死亡问题

2.3 反向传播（Backpropagation）

核心思想：

使用链式法则计算梯度
从输出层向输入层反向传播误差
更新网络参数

链式法则：

∂L/∂w = ∂L/∂y * ∂y/∂z * ∂z/∂w

梯度下降：

w = w - η * ∂L/∂w

优化算法：

1. SGD（Stochastic Gradient Descent）：

w = w - η * ∂L/∂w

2. Momentum：

v_t = γv_{t-1} + η∇L(w_t)
w_t = w_{t-1} - v_t

3. Adam（Adaptive Moment Estimation）：

m_t = β1m_{t-1} + (1-β1)∇L(w_t)
v_t = β2v_{t-1} + (1-β2)(∇L(w_t))^2
w_t = w_{t-1} - η * m_t / (√v_t + ε)

2.4 正则化技术

2.4.1 Dropout

原理：随机丢弃部分神经元，防止过拟合。

实现：

python

class Dropout:
    def __init__(self, p=0.5):
        self.p = p
    
    def forward(self, x, training=True):
        if training:
            mask = np.random.binomial(1, 1-self.p, size=x.shape) / (1-self.p)
            return x * mask
        else:
            return x

效果：

减少过拟合
提高泛化能力
类似集成学习

2.4.2 Batch Normalization

原理：对每个batch的输出进行归一化。

公式：

μ_B = (1/m)∑x_i
σ_B² = (1/m)∑(x_i - μ_B)²
x̂_i = (x_i - μ_B) / √(σ_B² + ε)
y_i = γx̂_i + β

效果：

加速训练
允许更大的学习率
减少对初始化的敏感性

2.4.3 L1/L2正则化

L1正则化：

L = L_original + λ∑|w|

产生稀疏解
特征选择

L2正则化：

L = L_original + λ∑w²

防止权重过大
更稳定

3. 卷积神经网络（CNN）

3.1 CNN的基本思想

核心思想：

利用局部连接
共享权重
降采样

适用场景：

图像识别
目标检测
语义分割
视频分析

3.2 CNN的基本组件

3.2.1 卷积层（Convolutional Layer）

卷积操作：

输出 = 输入 * 卷积核 + 偏置

示例：

输入图像（5x5）：
┌─────────┐
│ 1 1 1 0 0 │
│ 0 1 1 1 0 │
│ 0 0 1 1 1 │
│ 0 0 1 1 0 │
│ 0 1 1 0 0 │
└─────────┘

卷积核（3x3）：
┌─────┐
│ 1 0 1 │
│ 0 1 0 │
│ 1 0 1 │
└─────┘

输出特征图（3x3）：
┌─────┐
│ 4 3 4 │
│ 2 4 3 │
│ 2 3 4 │
└─────┘

参数：

卷积核大小：3x3, 5x5, 7x7
步长（Stride）：卷积核移动的步长
填充（Padding）：在边缘填充0

输出尺寸：

H_out = (H_in - K + 2P) / S + 1
W_out = (W_in - K + 2P) / S + 1

3.2.2 池化层（Pooling Layer）

最大池化（Max Pooling）：

取局部区域的最大值

示例：

输入（4x4）：
┌─────────┐
│ 1 1 2 4 │
│ 5 6 7 8 │
│ 3 2 1 0 │
│ 1 2 3 4 │
└─────────┘

最大池化（2x2，步长2）：
┌─────┐
│ 6 8 │
│ 3 4 │
└─────┘

平均池化（Average Pooling）：

取局部区域的平均值

效果：

降维
减少计算量
提高平移不变性

3.2.3 全连接层（Fully Connected Layer）

作用：

将特征映射到输出空间
用于分类或回归

3.2.4 激活函数

ReLU：

f(x) = max(0, x)

优势：

计算简单
缓解梯度消失
加速收敛

3.3 经典CNN架构

3.3.1 LeNet-5（1998）

结构：

输入（32x32x1）
→ 卷积层（6个5x5卷积核）
→ 池化层（2x2）
→ 卷积层（16个5x5卷积核）
→ 池化层（2x2）
→ 全连接层（120）
→ 全连接层（84）
→ 输出层（10）

应用：手写数字识别（MNIST）

3.3.2 AlexNet（2012）

突破：

在ImageNet竞赛中大幅领先传统方法
证明了深度学习的潜力

结构：

输入（227x227x3）
→ 卷积层（96个11x11卷积核，步长4）
→ 池化层（3x3，步长2）
→ 卷积层（256个5x5卷积核）
→ 池化层（3x3，步长2）
→ 卷积层（384个3x3卷积核）
→ 卷积层（384个3x3卷积核）
→ 卷积层（256个3x3卷积核）
→ 池化层（3x3，步长2）
→ 全连接层（4096）
→ 全连接层（4096）
→ 输出层（1000）

创新：

使用ReLU激活函数
使用Dropout
使用GPU加速
数据增强

3.3.3 VGG（2014）

特点：

使用小的卷积核（3x3）
网络更深（16-19层）
结构规整

VGG-16结构：

输入（224x224x3）
→ 2x卷积层（64个3x3卷积核）
→ 池化层
→ 2x卷积层（128个3x3卷积核）
→ 池化层
→ 3x卷积层（256个3x3卷积核）
→ 池化层
→ 3x卷积层（512个3x3卷积核）
→ 池化层
→ 3x卷积层（512个3x3卷积核）
→ 池化层
→ 全连接层（4096）
→ 全连接层（4096）
→ 输出层（1000）

优势：

简单、规整
易于理解和复现
特征提取能力强

劣势：

参数量大
计算量大
训练时间长

3.3.4 GoogLeNet（Inception）（2014）

创新：Inception模块

Inception模块：

输入
├─ 1x1卷积
├─ 1x1卷积 → 3x3卷积
├─ 1x1卷积 → 5x5卷积
└─ 3x3最大池化 → 1x1卷积
→ 拼接

优势：

多尺度特征提取
减少参数量
提高网络宽度

3.3.5 ResNet（2015）

突破：残差连接（Residual Connection）

残差块：

x → 卷积层 → 卷积层 → 拼接(x) → ReLU → 输出

数学表达：

y = F(x) + x

优势：

解决梯度消失
允许训练非常深的网络（152层）
提高训练速度

ResNet-50结构：

输入（224x224x3）
→ 卷积层（7x7，步长2）
→ 池化层（3x3，步长2）
→ 残差块（3个，64通道）
→ 残差块（4个，128通道）
→ 残差块（6个，256通道）
→ 残差块（3个，512通道）
→ 全局平均池化
→ 输出层（1000）

3.4 CNN的应用

3.4.1 图像分类

任务：将图像分类到预定义的类别。

示例：

ImageNet分类（1000类）
CIFAR-10分类（10类）
MNIST分类（10类）

3.4.2 目标检测

任务：检测图像中的目标并定位。

算法：

R-CNN
Fast R-CNN
Faster R-CNN
YOLO（You Only Look Once）
SSD（Single Shot MultiBox Detector）

3.4.3 语义分割

任务：为图像中的每个像素分配类别标签。

算法：

FCN（Fully Convolutional Network）
U-Net
DeepLab

3.4.4 人脸识别

任务：识别图像中的人脸。

应用：

人脸解锁
安防监控
社交媒体

4. 循环神经网络（RNN）

4.1 RNN的基本思想

核心思想：

处理序列数据
具有记忆能力
当前输出依赖于当前输入和之前的状态

适用场景：

自然语言处理
语音识别
时间序列预测
机器翻译

4.2 RNN的结构

基本结构：

h_t = f(W_hh * h_{t-1} + W_xh * x_t + b_h)
y_t = g(W_hy * h_t + b_y)

展开图：

x_1 → [RNN] → h_1 → [输出]
       ↑
x_2 → [RNN] → h_2 → [输出]
       ↑
x_3 → [RNN] → h_3 → [输出]

示例：

python

# 简单的RNN实现
import numpy as np

class RNN:
    def __init__(self, input_size, hidden_size, output_size):
        self.W_xh = np.random.randn(hidden_size, input_size) * 0.01
        self.W_hh = np.random.randn(hidden_size, hidden_size) * 0.01
        self.W_hy = np.random.randn(output_size, hidden_size) * 0.01
        self.b_h = np.zeros((hidden_size, 1))
        self.b_y = np.zeros((output_size, 1))
    
    def forward(self, x):
        h = np.zeros((self.W_hh.shape[0], 1))
        h_list = []
        for t in range(x.shape[1]):
            h = np.tanh(np.dot(self.W_xh, x[:, t:t+1]) + np.dot(self.W_hh, h) + self.b_h)
            h_list.append(h)
        y = np.dot(self.W_hy, h) + self.b_y
        return y, h_list

4.3 RNN的问题

4.3.1 梯度消失（Vanishing Gradient）

问题：

在长序列中，梯度在反向传播时逐渐消失
网络无法学习长期依赖

原因：

激活函数的导数小于1
多次相乘导致梯度趋近于0

影响：

无法学习长期依赖
记忆能力有限

4.3.2 梯度爆炸（Exploding Gradient）

问题：

梯度在反向传播时逐渐增大
导致数值不稳定

解决方法：

梯度裁剪（Gradient Clipping）

4.4 LSTM（Long Short-Term Memory）

4.4.1 LSTM的基本思想

核心思想：

引入门控机制
控制信息的流动
解决长期依赖问题

4.4.2 LSTM的结构

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)

示例：

python

# 简单的LSTM实现
class LSTM:
    def __init__(self, input_size, hidden_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        
        # 遗忘门
        self.W_f = np.random.randn(hidden_size, input_size + hidden_size) * 0.01
        self.b_f = np.zeros((hidden_size, 1))
        
        # 输入门
        self.W_i = np.random.randn(hidden_size, input_size + hidden_size) * 0.01
        self.b_i = np.zeros((hidden_size, 1))
        
        # 候选记忆
        self.W_C = np.random.randn(hidden_size, input_size + hidden_size) * 0.01
        self.b_C = np.zeros((hidden_size, 1))
        
        # 输出门
        self.W_o = np.random.randn(hidden_size, input_size + hidden_size) * 0.01
        self.b_o = np.zeros((hidden_size, 1))
    
    def forward(self, x):
        h = np.zeros((self.hidden_size, 1))
        C = np.zeros((self.hidden_size, 1))
        h_list = []
        C_list = []
        
        for t in range(x.shape[1]):
            # 拼接输入和隐藏状态
            combined = np.concatenate((h, x[:, t:t+1]), axis=0)
            
            # 遗忘门
            f = self.sigmoid(np.dot(self.W_f, combined) + self.b_f)
            
            # 输入门
            i = self.sigmoid(np.dot(self.W_i, combined) + self.b_i)
            
            # 候选记忆
            C_candidate = np.tanh(np.dot(self.W_C, combined) + self.b_C)
            
            # 更新记忆单元
            C = f * C + i * C_candidate
            
            # 输出门
            o = self.sigmoid(np.dot(self.W_o, combined) + self.b_o)
            
            # 更新隐藏状态
            h = o * np.tanh(C)
            
            h_list.append(h)
            C_list.append(C)
        
        return h, h_list, C_list
    
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

4.4.3 LSTM的优势

优势：

解决长期依赖问题
可以学习长序列
门控机制灵活

应用：

机器翻译
语音识别
文本生成
时间序列预测

4.5 GRU（Gated Recurrent Unit）

简化：将遗忘门和输入门合并为更新门。

GRU单元：

更新门：z_t = σ(W_z * [h_{t-1}, x_t])
重置门：r_t = σ(W_r * [h_{t-1}, x_t])
候选隐藏：h̃_t = tanh(W * [r_t * h_{t-1}, x_t])
隐藏状态：h_t = (1 - z_t) * h_{t-1} + z_t * h̃_t

优势：

参数更少
训练更快
性能与LSTM相当

5. AlphaGo的突破

5.1 AlphaGo的背景

围棋：

复杂度极高（10^170种可能）
直觉和模式识别至关重要
人类围棋大师的直觉难以编程

挑战：

搜索空间巨大
评估函数难以设计
需要长期规划

5.2 AlphaGo的技术

5.2.1 蒙特卡洛树搜索（MCTS）

基本思想：

通过随机模拟评估棋局
平衡探索和利用
逐步构建搜索树

四个步骤：

选择：从根节点开始，选择最有希望的子节点
扩展：在叶子节点添加新的子节点
模拟：从新节点开始随机模拟到终局
回溯：将模拟结果反向传播到根节点

5.2.2 策略网络（Policy Network）

作用：

预测下一步走法
减少搜索空间
提高搜索效率

结构：

卷积神经网络
输入：棋盘状态
输出：每个位置的概率分布

5.2.3 价值网络（Value Network）

作用：

评估棋局
减少模拟次数
提高评估准确性

结构：

卷积神经网络
输入：棋盘状态
输出：胜率

5.2.4 强化学习

自我对弈：

AlphaGo与自己对弈
从对弈中学习
不断改进策略

5.3 AlphaGo的成就

2016年3月：

AlphaGo 4:1 战胜李世石（韩国围棋九段）
标志着AI在复杂博弈中超越人类

意义：

证明了深度学习的强大
展示了AI的创造力
推动了AI的发展

后续发展：

AlphaGo Zero（2017）：完全从零学习，不使用人类棋谱
AlphaZero（2017）：通用算法，可以下围棋、国际象棋、日本将棋
AlphaFold（2018）：蛋白质结构预测

5.4 AlphaGo的启示

启示：

深度学习可以解决复杂问题
强化学习可以自主学习
AI可以超越人类专家
计算力和数据至关重要

6. 深度学习的应用

6.1 计算机视觉

图像分类：

ImageNet
CIFAR
MNIST

目标检测：

YOLO
Faster R-CNN
SSD

语义分割：

U-Net
DeepLab
FCN

人脸识别：

FaceNet
DeepFace
ArcFace

6.2 自然语言处理

机器翻译：

Google翻译
百度翻译
有道翻译

文本分类：

情感分析
垃圾邮件检测
主题分类

命名实体识别：

人名识别
地名识别
组织名识别

6.3 语音识别

语音转文字：

Siri
Alexa
Google Assistant

语音合成：

WaveNet
Tacotron
FastSpeech

6.4 推荐系统

推荐算法：

协同过滤
深度学习推荐
混合推荐

应用：

电商推荐
视频推荐
音乐推荐

7. 深度学习的挑战

7.1 数据需求

问题：

需要大量标注数据
数据标注成本高
数据质量影响性能

解决方法：

数据增强
迁移学习
半监督学习

7.2 计算资源

问题：

训练深度网络需要大量算力
训练时间长
能耗高

解决方法：

分布式训练
模型压缩
专用硬件

7.3 可解释性

问题：

深度网络是黑盒
决策过程不透明
难以解释

解决方法：

可解释AI（XAI）
注意力机制
可视化技术

7.4 泛化能力

问题：

在训练集上表现好，在测试集上表现差
对分布外数据敏感
难以适应新场景

解决方法：

正则化
数据增强
元学习

实践任务

任务1：实现简单的CNN

目标：使用PyTorch实现一个简单的CNN。

要求：

实现一个3层的CNN
在CIFAR-10数据集上训练
评估分类性能
可视化训练过程

代码框架：

python

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 定义CNN
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, 3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(128 * 4 * 4, 512)
        self.fc2 = nn.Linear(512, 10)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.5)
    
    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))
        x = self.pool(self.relu(self.conv2(x)))
        x = self.pool(self.relu(self.conv3(x)))
        x = x.view(-1, 128 * 4 * 4)
        x = self.dropout(self.relu(self.fc1(x)))
        x = self.fc2(x)
        return x

# 加载数据
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = DataLoader(trainset, batch_size=32, shuffle=True)

testset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = DataLoader(testset, batch_size=32, shuffle=False)

# 训练
model = SimpleCNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f'Epoch {epoch+1}, Loss: {running_loss/len(trainloader)}')

# 测试
correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy: {100 * correct / total}%')

任务2：实现简单的RNN

目标：使用PyTorch实现一个简单的RNN。

要求：

实现一个LSTM
在IMDB数据集上进行情感分析
评估分类性能
分析训练过程

代码框架：

python

import torch
import torch.nn as nn
from torchtext.datasets import IMDB
from torchtext.data.utils import get_tokenizer
from torchtext.vocab import build_vocab_from_iterator

# 定义LSTM
class SentimentLSTM(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
        super(SentimentLSTM, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, x):
        embedded = self.embedding(x)
        lstm_out, (hidden, _) = self.lstm(embedded)
        output = self.fc(hidden[-1])
        return output

# 加载数据
tokenizer = get_tokenizer('basic_english')
train_iter = IMDB(split='train')

def yield_tokens(data_iter):
    for _, text in data_iter:
        yield tokenizer(text)

vocab = build_vocab_from_iterator(yield_tokens(train_iter), specials=['<unk>'])
vocab.set_default_index(vocab['<unk>'])

# 训练
model = SentimentLSTM(len(vocab), 100, 256, 2)
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练循环
# ...

# 测试
# ...

任务3：使用预训练模型

目标：使用预训练的ResNet进行图像分类。

要求：

加载预训练的ResNet-50
在ImageNet数据集上测试
可视化预测结果
分析模型的性能

代码框架：

python

import torch
import torchvision.models as models
from torchvision import transforms
from PIL import Image

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

# 图像预处理
preprocess = 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]),
])

# 加载图像
image = Image.open('image.jpg')
input_tensor = preprocess(image)
input_batch = input_tensor.unsqueeze(0)

# 预测
with torch.no_grad():
    output = model(input_batch)

# 获取预测结果
probabilities = torch.nn.functional.softmax(output[0], dim=0)

# 加载ImageNet类别标签
with open('imagenet_classes.txt') as f:
    categories = [s.strip() for s in f.readlines()]

# 显示Top-5预测
top5_prob, top5_catid = torch.topk(probabilities, 5)
for i in range(top5_prob.size(0)):
    print(categories[top5_catid[i]], top5_prob[i].item())

课后作业

作业1：CNN架构比较

题目：比较不同CNN架构的性能。

要求：

实现至少3种CNN架构（如LeNet、AlexNet、VGG）
在CIFAR-10数据集上训练和测试
比较准确率、训练时间、参数量
分析不同架构的优缺点

作业2：RNN vs LSTM vs GRU

题目：比较RNN、LSTM、GRU的性能。

要求：

实现RNN、LSTM、GRU
在时间序列数据集上训练和测试
比较预测性能和训练时间
分析不同模型的适用场景

作业3：迁移学习

题目：使用迁移学习解决新问题。

要求：

加载预训练的ResNet
在新的数据集上微调
比较微调前后的性能
分析迁移学习的效果

参考资料

必读文献

Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). "ImageNet Classification with Deep Convolutional Neural Networks". NeurIPS.
- AlexNet原始论文
Simonyan, K., & Zisserman, A. (2014). "Very Deep Convolutional Networks for Large-Scale Image Recognition". arXiv.
- VGG原始论文
He, K., Zhang, X., Ren, S., & Sun, J. (2016). "Deep Residual Learning for Image Recognition". CVPR.
- ResNet原始论文
Hochreiter, S., & Schmidhuber, J. (1997). "Long Short-Term Memory". Neural Computation, 9(8), 1735-1780.
- LSTM原始论文
Silver, D., et al. (2016). "Mastering the Game of Go with Deep Neural Networks and Tree Search". Nature, 529(7587), 484-489.
- AlphaGo原始论文

在线资源

PyTorch Documentation: https://pytorch.org/docs/
- PyTorch官方文档
TensorFlow Documentation: https://www.tensorflow.org/docs
- TensorFlow官方文档
CS231n: Convolutional Neural Networks: http://cs231n.stanford.edu/
- 斯坦福CNN课程
CS224n: Natural Language Processing: http://cs224n.stanford.edu/
- 斯坦福NLP课程

扩展阅读

深度学习前沿

Vaswani, A., et al. (2017). "Attention is All You Need". NeurIPS.
- Transformer原始论文
Devlin, J., et al. (2019). "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding". NAACL.
- BERT原始论文

深度学习应用

Redmon, J., Divvala, S., Girshick, R., & Farhadi, A. (2016). "You Only Look Once: Unified, Real-Time Object Detection". CVPR.
- YOLO原始论文
Long, J., Shelhamer, E., & Darrell, T. (2015). "Fully Convolutional Networks for Semantic Segmentation". CVPR.
- FCN原始论文

下节预告

下一节我们将学习Transformer与大语言模型（2017-2022），了解Transformer架构的诞生、BERT、GPT系列、预训练+微调范式、多模态AI的兴起，以及它们如何开启大语言模型时代。

扫描二维码关注"架构师AI杜"公众号，获取更多技术内容和最新动态

第3天：深度学习革命（2010-2017） ​

学习目标 ​

课程内容 ​

1. 深度学习的兴起 ​

1.1 从机器学习到深度学习 ​

1.2 深度学习的三大驱动力 ​

1.3 深度学习的定义 ​

2. 神经网络基础 ​

2.1 感知机（Perceptron） ​

2.2 多层感知机（MLP） ​

2.3 反向传播（Backpropagation） ​

2.4 正则化技术 ​

3. 卷积神经网络（CNN） ​

3.1 CNN的基本思想 ​

3.2 CNN的基本组件 ​

3.3 经典CNN架构 ​

3.4 CNN的应用 ​

4. 循环神经网络（RNN） ​

4.1 RNN的基本思想 ​

4.2 RNN的结构 ​

4.3 RNN的问题 ​

4.4 LSTM（Long Short-Term Memory） ​

4.5 GRU（Gated Recurrent Unit） ​

5. AlphaGo的突破 ​

5.1 AlphaGo的背景 ​

5.2 AlphaGo的技术 ​

5.3 AlphaGo的成就 ​

5.4 AlphaGo的启示 ​

6. 深度学习的应用 ​

6.1 计算机视觉 ​

6.2 自然语言处理 ​

6.3 语音识别 ​

6.4 推荐系统 ​

7. 深度学习的挑战 ​

7.1 数据需求 ​

7.2 计算资源 ​

7.3 可解释性 ​

7.4 泛化能力 ​

实践任务 ​

任务1：实现简单的CNN ​

任务2：实现简单的RNN ​

任务3：使用预训练模型 ​

课后作业 ​

作业1：CNN架构比较 ​

作业2：RNN vs LSTM vs GRU ​

作业3：迁移学习 ​

参考资料 ​

必读文献 ​

推荐阅读 ​

在线资源 ​

扩展阅读 ​

深度学习前沿 ​

深度学习应用 ​

下节预告 ​

第3天：深度学习革命（2010-2017）

学习目标

课程内容

1. 深度学习的兴起

1.1 从机器学习到深度学习

1.2 深度学习的三大驱动力

1.3 深度学习的定义

2. 神经网络基础

2.1 感知机（Perceptron）

2.2 多层感知机（MLP）

2.3 反向传播（Backpropagation）

2.4 正则化技术

3. 卷积神经网络（CNN）

3.1 CNN的基本思想

3.2 CNN的基本组件

3.3 经典CNN架构

3.4 CNN的应用

4. 循环神经网络（RNN）

4.1 RNN的基本思想

4.2 RNN的结构

4.3 RNN的问题

4.4 LSTM（Long Short-Term Memory）

4.5 GRU（Gated Recurrent Unit）

5. AlphaGo的突破

5.1 AlphaGo的背景

5.2 AlphaGo的技术

5.3 AlphaGo的成就

5.4 AlphaGo的启示

6. 深度学习的应用

6.1 计算机视觉

6.2 自然语言处理

6.3 语音识别

6.4 推荐系统

7. 深度学习的挑战

7.1 数据需求

7.2 计算资源

7.3 可解释性

7.4 泛化能力

实践任务

任务1：实现简单的CNN

任务2：实现简单的RNN

任务3：使用预训练模型

课后作业

作业1：CNN架构比较

作业2：RNN vs LSTM vs GRU

作业3：迁移学习

参考资料

必读文献

推荐阅读

在线资源

扩展阅读

深度学习前沿

深度学习应用

下节预告