架构师AI杜

Appearance

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

学习目标 ​

本节将带领读者深入理解深度学习革命的兴起与发展。读者将理解深度学习的兴起背景，掌握卷积神经网络的原理和应用，了解循环神经网络和长短期记忆网络的原理，理解AlphaGo的突破性意义，并掌握深度学习的核心技术和应用。这些知识将为后续学习Transformer和大语言模型等技术打下坚实基础。

课程内容 ​

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加速是深度学习发展的关键因素，GPU具有强大的并行计算能力，非常适合矩阵运算，NVIDIA CUDA平台为深度学习提供了高效的计算框架。硬件发展也非常迅速，GPU性能持续提升，专用AI芯片如TPU和NPU不断涌现，云计算平台为深度学习提供了强大的算力支持。

1.2.3 算法

算法创新是深度学习发展的核心，激活函数方面有ReLU和Leaky ReLU，优化算法有Adam和RMSprop，正则化技术有Dropout和Batch Normalization，网络架构方面有ResNet、Inception和Transformer。

1.3 深度学习的定义 ​

深度学习是基于人工神经网络的机器学习方法，它使用多层神经网络学习数据的层次化表示，通过反向传播算法训练网络。深度学习中的"深度"体现在网络层数多通常超过三层，能够学习层次化特征，从低级特征如边缘、纹理逐步学习到高级语义如物体、场景。

2. 神经网络基础 ​

2.1 感知机（Perceptron） ​

感知机由Frank Rosenblatt于1957年提出，是第一个神经网络模型。感知机的结构是输入层经过加权求和后通过激活函数得到输出，其数学表达是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)。

激活函数方面，Sigmoid函数的公式是f(x) = 1 / (1 + e^(-x))，输出范围在0到1之间，但存在梯度消失问题。Tanh函数的公式是f(x) = (e^x - e^(-x)) / (e^x + e^(-x))，输出范围在负1到1之间，同样存在梯度消失问题。ReLU即Rectified Linear Unit的公式是f(x) = max(0, x)，输出范围从0到无穷大，优势在于缓解梯度消失问题，但存在神经元死亡问题。Leaky ReLU的公式是f(x) = x if x > 0 else αx其中α是很小的数，解决了神经元死亡问题。

2.3 反向传播（Backpropagation） ​

反向传播的核心思想是使用链式法则计算梯度，从输出层向输入层反向传播误差，更新网络参数。链式法则的公式是∂L/∂w = ∂L/∂y * ∂y/∂z * ∂z/∂w。梯度下降的公式是w = w - η * ∂L/∂w。

优化算法方面，SGD即随机梯度下降的公式是w = w - η * ∂L/∂w。Momentum的公式是v_t = γv_{t-1} + η∇L(w_t)和w_t = w_{t-1} - v_t。Adam即自适应矩估计的公式是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

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

Dropout的效果是减少过拟合，提高泛化能力，类似于集成学习。

2.4.2 Batch Normalization

Batch Normalization的原理是对每个batch的输出进行归一化。其公式是μ_B = (1/m)∑x_i，σ_B² = (1/m)∑(x_i - μ_B)²，x̂_i = (x_i - μ_B) / √(σ_B² + ε)，y_i = γx̂_i + β。Batch Normalization的效果是加速训练，允许更大的学习率，减少对初始化的敏感性。

2.4.3 L1/L2正则化

L1正则化的公式是L = L_original + λ∑|w|，可以产生稀疏解，实现特征选择。L2正则化的公式是L = L_original + λ∑w²，可以防止权重过大，使模型更稳定。

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

3.1 CNN的基本思想 ​

卷积神经网络的核心思想是利用局部连接减少参数数量，共享权重提高特征提取效率，降采样减少计算量同时提高平移不变性。CNN特别适用于图像识别、目标检测、语义分割和视频分析等领域。

3.2 CNN的基本组件 ​

3.2.1 卷积层（Convolutional Layer）

卷积操作的公式是输出等于输入乘以卷积核再加上偏置。卷积层的参数包括卷积核大小通常为3x3、5x5或7x7，步长是卷积核移动的步长，填充是在边缘填充0。输出尺寸的计算公式是H_out = (H_in - K + 2P) / S + 1和W_out = (W_in - K + 2P) / S + 1。

3.2.2 池化层（Pooling Layer）

最大池化是取局部区域的最大值，平均池化是取局部区域的平均值。池化的效果是降维，减少计算量，提高平移不变性。

3.2.3 全连接层（Fully Connected Layer）

全连接层的作用是将特征映射到输出空间，用于分类或回归任务。

3.2.4 激活函数

ReLU的公式是f(x) = max(0, x)，优势在于计算简单，缓解梯度消失，加速收敛。

3.3 经典CNN架构 ​

3.3.1 LeNet-5（1998）

LeNet-5的结构是输入32x32x1经过卷积层6个5x5卷积核，池化层2x2，卷积层16个5x5卷积核，池化层2x2，全连接层120，全连接层84，输出层10。LeNet-5主要用于手写数字识别MNIST数据集。

3.3.2 AlexNet（2012）

AlexNet的突破在于在ImageNet竞赛中大幅领先传统方法，证明了深度学习的潜力。AlexNet的结构是输入227x227x3，经过卷积层96个11x11卷积核步长4，池化层3x3步长2，卷积层256个5x5卷积核，池化层3x3步长2，卷积层384个3x3卷积核，卷积层384个3x3卷积核，卷积层256个3x3卷积核，池化层3x3步长2，全连接层4096，全连接层4096，输出层1000。AlexNet的创新包括使用ReLU激活函数，使用Dropout，使用GPU加速，数据增强。

3.3.3 VGG（2014）

VGG的特点是使用小的卷积核3x3，网络更深达到16到19层，结构规整。VGG-16的结构是输入224x224x3，经过2个卷积层64个3x3卷积核，池化层，2个卷积层128个3x3卷积核，池化层，3个卷积层256个3x3卷积核，池化层，3个卷积层512个3x3卷积核，池化层，3个卷积层512个3x3卷积核，池化层，全连接层4096，全连接层4096，输出层1000。VGG的优势是简单规整，易于理解和复现，特征提取能力强。劣势是参数量大，计算量大，训练时间长。

3.3.4 GoogLeNet（Inception）（2014）

GoogLeNet的创新是Inception模块，它包含1x1卷积，1x1卷积后接3x3卷积，1x1卷积后接5x5卷积，3x3最大池化后接1x1卷积，最后拼接。GoogLeNet的优势是多尺度特征提取，减少参数量，提高网络宽度。

3.3.5 ResNet（2015）

ResNet的突破是残差连接。残差块的数学表达是y = F(x) + x。ResNet的优势是解决梯度消失，允许训练非常深的网络达到152层，提高训练速度。ResNet-50的结构是输入224x224x3，经过卷积层7x7步长2，池化层3x3步长2，3个残差块64通道，4个残差块128通道，6个残差块256通道，3个残差块512通道，全局平均池化，输出层1000。

3.4 CNN的应用 ​

CNN的应用领域包括图像分类如ImageNet、CIFAR-10、MNIST，目标检测如R-CNN、Fast R-CNN、Faster R-CNN、YOLO、SSD，语义分割如FCN、U-Net、DeepLab，人脸识别如FaceNet、DeepFace、ArcFace。

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

4.1 RNN的基本思想 ​

循环神经网络的核心思想是处理序列数据，具有记忆能力，当前输出依赖于当前输入和之前的状态。RNN特别适用于自然语言处理、语音识别、时间序列预测和机器翻译等领域。

4.2 RNN的结构 ​

RNN的基本结构的数学表达是h_t = f(W_hh * h_{t-1} + W_xh * x_t + b_h)和y_t = g(W_hy * h_t + b_y)。

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）

梯度爆炸的问题是梯度在反向传播时逐渐增大，导致数值不稳定。解决方法是梯度裁剪。

4.4 LSTM（Long Short-Term Memory） ​

4.4.1 LSTM的基本思想

LSTM的核心思想是引入门控机制，控制信息的流动，解决长期依赖问题。

4.4.2 LSTM的结构

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的优势

LSTM的优势是解决长期依赖问题，可以学习长序列，门控机制灵活。应用场景包括机器翻译、语音识别、文本生成、时间序列预测。

4.5 GRU（Gated Recurrent Unit） ​

GRU是LSTM的简化版本，将遗忘门和输入门合并为更新门。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。GRU的优势是参数更少，训练更快，性能与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的启示 ​

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。

要求：

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

代码框架：

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。

要求：

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

代码框架：

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进行图像分类。

要求：

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

代码框架：

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架构的性能。

要求：

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

作业2：RNN vs LSTM vs GRU ​

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

要求：

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

作业3：迁移学习 ​

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

要求：

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

参考资料 ​

必读文献 ​

  1. Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). "ImageNet Classification with Deep Convolutional Neural Networks". NeurIPS.

    • AlexNet原始论文

  2. Simonyan, K., & Zisserman, A. (2014). "Very Deep Convolutional Networks for Large-Scale Image Recognition". arXiv.

    • VGG原始论文

  3. He, K., Zhang, X., Ren, S., & Sun, J. (2016). "Deep Residual Learning for Image Recognition". CVPR.

    • ResNet原始论文

  4. Hochreiter, S., & Schmidhuber, J. (1997). "Long Short-Term Memory". Neural Computation, 9(8), 1735-1780.

    • LSTM原始论文

  5. Silver, D., et al. (2016). "Mastering the Game of Go with Deep Neural Networks and Tree Search". Nature, 529(7587), 484-489.

    • AlphaGo原始论文

推荐阅读 ​

  1. Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press.

    • 深度学习经典教材

  2. LeCun, Y., Bengio, Y., & Hinton, G. (2015). "Deep learning". Nature, 521(7553), 436-444.

    • 深度学习综述

  3. Schmidhuber, J. (2015). "Deep Learning in Neural Networks: An Overview". Neural Networks, 61, 85-117.

    • 深度学习历史回顾

在线资源 ​

  1. PyTorch Documentation: https://pytorch.org/docs/

    • PyTorch官方文档

  2. TensorFlow Documentation: https://www.tensorflow.org/docs

    • TensorFlow官方文档

  3. CS231n: Convolutional Neural Networks: http://cs231n.stanford.edu/

    • 斯坦福CNN课程

  4. 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杜公众号二维码

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