Welcome file

Ch3.深度学习基础

3.1.线性回归

3.1.1 线性回归的基本要素

模型：weight,bias

模型训练

训练数据；sample,label,feature

损失函数：loss function, square loss

优化算法：analytical solution, numerical solution, mini-batch stochastic gradient descent, learning rate, hyperparameter

模型预测

3.1.2 线性回归的表示方法

1.神经网络图：fully-connected layer, dense layer

2.矢量计算表达式：

广义上讲，当样本数据数为 $n$ 时，特征数为 $d$ 时，线性回归的矢量计算表达式为 $\hat{y}=Xw+b$
设模型参数 $\theta=[w_1,w_2,b]^T$ ，我们将损失函数重写为：
$\mathcal{l}(\theta)=\frac{1}{2n}(\hat{y}-y)^T(\hat{y}-y)$
小批量随机梯度下降的迭代步骤相应的改写为：
$\theta \leftarrow \theta-\frac{\eta}{|\mathcal{B}|}\sum\limits_{i\in \mathcal{B}}\nabla_{\theta}\mathcal{l}^{(i)}(\theta)$

3.2.softmax回归

考虑如下问题：
$o_1=x_1w_{11}+x_2w_{21}+x_3w_{31}+x_4w_{41}+b_1$
$o_2=x_1w_{12}+x_2w_{22}+x_3w_{32}+x_4w_{42}+b_2$
$o_3=x_1w_{13}+x_2w_{23}+x_3w_{33}+x_4w_{43}+b_3$

softmax运算通过以下运算将输出值换成值为正且和为1的概率分布：
$\hat{y_1},\hat{y_2},\hat{y_3}=\text{softmax}(o_1,o_2,o_3)$
其中
$\hat{y_1}=\frac{\text{exp}(o_1)}{\sum\limits_{i=1}^3 \text{exp}(o_i)},\hat{y_2}=\frac{\text{exp}(o_2)}{\sum\limits_{i=1}^3 \text{exp}(o_i)},\hat{y_3}=\frac{\text{exp}(o_3)}{\sum\limits_{i=1}^3 \text{exp}(o_i)}$
我们注意到
$\text{argmin}_i o_i=\text{argmin}_i \hat{y_i}$

交叉熵(cross entropy)损失函数:

假设训练数据集的样本数为 $n$ ，交叉熵损失函数定义为
$\mathcal{l}(\Theta)=\frac{1}{n}\sum\limits_{i=1}^n H(y^{(i)},\hat{y}^{}(i)$
其中 $\Theta$ 代表模型参数，同样的，如果每个样本只有一个标签，那么交叉熵损失可以简写成 $\mathcal{l}(\Theta)=-\frac{1}{n}\sum\limits_{i=1}^n \log \hat{y}^{(i)}_{y^{(i)}}$

3.3.多层感知机

3.3.1 hidden layer

概念： hidden layer, hidden unit

给定一个小批量样本 $X\in \mathbf{R}^{n\times d}$ ，其批量大小为 $n$ ，输入个数为 $d$ 。假设多层感知机只有一个hidden layer，其中hidden units的个数为 $h$ ，记hidden layer的输出为 $H\in \mathbf{R}^{1\times h}$ ，因为hidden layer和output layer均是全连接层，可以设hidden layer的权重和偏差参数分别为 $W_h\in \mathbf{R}^{d\times h}$ 和 $b_h\in \mathbf{R}^{1\times h}$ ，output layer的权重和偏差参数分别为 $W_o\in \mathbf{R}^{h\times q}$ 和 $b_o\in \mathbf{R}^{1\times q}$ 。一种含single hidden layer的多层感知机的设计，其输出为 $O\in \mathbf{R}^{n\times q}$
$H=XW_h+b_h,O=HW_o+b_o$
联立得到：
$O=(XW_h+b_h)W_o+b_o=XW_hW_o+b_hW_o+b_o$

3.3.2 activation function

在上述讨论中容易发现，即使再添加更多的隐藏层，以上设计依然只能与仅含输出层的单层神经网络等价。此类问题的根源在于全连接层只是对数据进行仿射变换(affine transformation)，而多个仿射变换的叠加依然是一个放射变化，解决问题的方法是引入非线性变换，这个非线性函数称为activation function。

1.ReLU函数

ReLU(rectified linear unit)定义为
$\text{ReLU}(x)=\max(x,0)$
以下是该函数及其导数的实现的代码（同样我们进行了绘制，下同）：

import torch  
import torch.nn.functional as F  
import matplotlib.pyplot as plt  
from aioitertools.types import Accumulator  
from more_itertools.more import padded  
  
x = torch.linspace(-5, 5, 1000, requires_grad=True)  
  
def relu(x):  
 return F.relu(x)  
def relu_derivative(x):  
 y = relu(x) y.backward(torch.ones_like(x)) return x.grad  
y_relu = relu(x)  
x.grad.zero_()  
dy_dx_relu = relu_derivative(x)  
  
plt.figure(figsize=(10, 6))  
  
plt.subplot(1, 2, 1)  
plt.plot(x.detach().numpy(), y_relu.detach().numpy())  
plt.title("ReLU Function")  
plt.xlabel("x")  
plt.ylabel("y")  
plt.grid(True)  
  
plt.subplot(1, 2, 2)  
plt.plot(x.detach().numpy(), dy_dx_relu.detach().numpy())  
plt.title("ReLU Derivative")  
plt.xlabel("x")  
plt.ylabel("dy/dx")  
plt.grid(True)  
  
plt.tight_layout()  
plt.show()

2.sigmoid函数

sigmoid函数可以将元素的值变换到0和1之间：
$\text{sigmoid}(x)=\frac{1}{1+\text{exp}(-x)}$
sigmoid函数的导数为：
$\text{sigmoid}'(x)=\text{sigmoid}(x)\left(1-\text{sigmoid}(x)\right)$
以下是代码：

import torch  
import matplotlib.pyplot as plt  
  
x = torch.linspace(-5, 5, 1000, requires_grad=True)  
  
# Sigmoid 函数  
def sigmoid(x):  
 return torch.sigmoid(x)  
# 计算 Sigmoid 导数的函数  
def sigmoid_derivative(x):  
 y = sigmoid(x) y.backward(torch.ones_like(x)) return x.grad  
# 计算 Sigmoid 函数值和导数值  
y_sigmoid = sigmoid(x)  
x.grad.zero_() #梯度清零  
dy_dx_sigmoid = sigmoid_derivative(x)  
  
# 绘制 Sigmoid 函数及其导数  
plt.figure(figsize=(10, 6))  
  
plt.subplot(1, 2, 1)  
plt.plot(x.detach().numpy(), y_sigmoid.detach().numpy())  
plt.title("Sigmoid Function")  
plt.xlabel("x")  
plt.ylabel("y")  
plt.grid(True)  
  
plt.subplot(1, 2, 2)  
plt.plot(x.detach().numpy(), dy_dx_sigmoid.detach().numpy())  
plt.title("Sigmoid Derivative")  
plt.xlabel("x")  
plt.ylabel("dy/dx")  
plt.grid(True)  
  
plt.tight_layout()  
plt.show()

3.tanh函数

tanh（双曲正切）函数可以将元素的值变换到-1和1之间：
$\text{tanh}(x)=\frac{1-\text{exp}(-2x)}{1+\text{exp}(-2x)}$

tanh函数的导数为：
$\text{tanh}'(x)=1-\text{tanh}^2(x)$
代码如下：

import torch  
import matplotlib.pyplot as plt  
  
x = torch.linspace(-5, 5, 1000, requires_grad=True)  
  
# Tanh 函数  
def tanh(x):  
 return torch.tanh(x)  
# 计算 Tanh 导数的函数  
def tanh_derivative(x):  
 y = tanh(x) y.backward(torch.ones_like(x)) return x.grad  
# 计算 Tanh 函数值和导数值  
y_tanh = tanh(x)  
x.grad.zero_() #梯度清零  
dy_dx_tanh = tanh_derivative(x)  
  
# 绘制 Tanh 函数及其导数  
plt.figure(figsize=(10, 6))  
  
plt.subplot(1, 2, 1)  
plt.plot(x.detach().numpy(), y_tanh.detach().numpy())  
plt.title("Tanh Function")  
plt.xlabel("x")  
plt.ylabel("y")  
plt.grid(True)  
  
plt.subplot(1, 2, 2)  
plt.plot(x.detach().numpy(), dy_dx_tanh.detach().numpy())  
plt.title("Tanh Derivative")  
plt.xlabel("x")  
plt.ylabel("dy/dx")  
plt.grid(True)  
  
plt.tight_layout()  
plt.show()

3.4.模型选择、欠拟合和过拟合

training error：模型在训练数据集上表现出来的误差

generalization error：模型在任意一个测试数据样本上表现出的误差的期望

一般情况下，由训练数据集学到的模型参数会使模型在训练数据集上的表现优于或等于在测试数据集上的表现，由于无法从训练误差估计泛化误差，一味地降低训练误差并不意味着泛化误差一定会降低。

3.4.1 model selection

validation data set: 从严格意义上讲，测试集只能在所有hyperparameters和model parameters选定后使用一次，不可以使用测试数据选择模型，如调参。由于无法从训练误差估计泛化误差，因此也不应只依赖训练数据选择模型，鉴于此，我们可以预留一部分在训练数据集和测试数据集以外的数据进行模型选择，这部分数据称为validation selection。
$k$ -fold cross validation：我们把训练数据集分割成 $k$ 个不重合的子数据集，然后我们做 $k$ 次模型训练和验证。每一次，我们使用一个子数据集验证模型，并使用其余 $k-1$ 个子数据集来训练模型。最后，我们对这 $k$ 次训练误差和验证误差分别求平均。

3.4.2 underfitting and overfitting

underfitting：模型无法得到较低的训练误差

overfitting:模型的训练误差远小于测试数据集上的误差

给定训练数据集，如果模型的复杂度过低，很容易出现underfitting；复杂度过高，很容易出现overfitting。

在计算资源允许时，我们希望训练数据集大一些。

3.5.权重衰减(weight decay)

（应对overfitting的策略）

weight decay等价于 $L_2$ 范数正则化(regularization)。正则化通过为模型损失函数添加惩罚项使得学出的模型参数值较小，是应对overfitting的常用手段。

$L_2$ 范数正则化在模型原损失函数的基础上添加 $L_2$ 范数惩罚项，从而得到训练所需要最小化的函数。 $L_2$ 范数惩罚项指的是模型权重参数每个元素的平方和与一个正的常数的乘积。以线性回归损失函数
$\mathcal{l}(w_1,w_2,b)=\frac{1}{n}\sum\limits_{i=1}^n \frac{1}{2}\left(x_1^{(i)}w_1+x_2^{(i)}w_2+b-y^{(i)}\right)^2$
为例，将权重参数用向量 $\vec{w}=[w_1,w_2]$ 表示，带有 $L_2$ 范数惩罚项的新损失函数为
$\mathcal{l}(w_1,w_2,b)+\frac{\lambda}{2n}\|\vec{w}\|^2$
其中hyperparameter $\lambda >0$ 。当权重参数均为0时，惩罚项最小，当 $\lambda$ 较大时，惩罚项在loss function中的比重较大，这通常会使得学到的权重参数的元素接近0.当 $\lambda$ 设为0时，惩罚项完全不起作用。上式中 $L_2$ 范数平方 $\|w\|^2=w_1^2+w_2^2$ 。有了 $L_2$ 范数惩罚项后，在小批量随机梯度下降中，将 $w_1,w_2$ 的迭代改为：
$w_1\leftarrow \left(1-\frac{\eta \lambda}{|\mathcal{B}|}\right)w_1-\frac{\eta}{|\mathcal{B}|}\sum\limits_{i\in \mathcal{B}}x_1^{(i)}(x_1^{(i)}w_1+x_2^{(i)}w_2+b-y^{(i)})$
$w_2\leftarrow \left(1-\frac{\eta \lambda}{|\mathcal{B}|}\right)w_2-\frac{\eta}{|\mathcal{B}|}\sum\limits_{i\in \mathcal{B}}x_2^{(i)}(x_1^{(i)}w_1+x_2^{(i)}w_2+b-y^{(i)})$
可见， $L_2$ 范数正则化令权重 $w_1,w_2$ 先自乘小于1的数，再减去不含惩罚项的梯度。因此， $L_2$ 范数正则化又叫weight decay。

3.6.丢弃法（dropout）

这里的丢弃法特指倒置丢弃法（inverted dropout）

含单hidden layer的多层感知机。其中输入个数为4，hidden units为5，且隐藏单元 $h_i(i=1,...,5)$ 的计算表达式为：
$h_i=\phi(x_1w_{1i}+x_2w_{2i}+x_3w_{3i}+x_4w_{4i}+b_i)$
当对该hidden layer使用dropout时，该层的hidden units将有一定的概率被弃掉。设丢弃概率为 $p$ ，那么有 $p$ 的概率 $h_i$ 会被清零，有 $1-p$ 的概率 $h_i$ 会除以 $1-p$ 做拉伸。丢弃概率是丢弃法的hyperparameter。具体来说，设随机变量 $\xi_i$ 为0和1的概率分别为 $p$ 和 $1-p0$ 。使用dropout时我们计算新的hidden units;’
$h_i'=\frac{\xi_i}{1-p}h_i$
由于 $E(\xi_i)=1-p$ ，因此
$E(h_i')=\frac{E(\xi_i)}{1-p}h_i=h_i$
即dropout不改变其输入的期望值。由于在训练中hidden layer神经元的丢弃是随机的，即 $\{h_i\}$ 都有可能被清零，输出层的计算无法过度依赖 $\{h_i\}$ 中的任一个，从而在训练模型时起到正则化的作用，并可以用来应对overfitting。在测试模型时，为了得到更加确定性的结果，一般不使用dropout。

3.7.正向传播、反向传播

3.7.1 forward-propagation

Concept：是指对神经网络沿着从输入层到输出层的顺序，以此计算并存储模型的中间变量（包括输出）。

为了简单起见，假设输入是一个feature为 $\vec{x}\in \mathbf{R}^d$ 的样本且不考虑bias，那么中间变量
$z=W^{(1)}x$
把中间变量输入按元素运算的activation function $\phi$ 后，将得到向量长度为 $h$ 的隐藏层变量：
$h=\phi(z)$
假设输出层参数只有权重 $W^{(2)}\in \mathbf{R}^{q\times h}$ ，得到输出层变量：
$o=W^{(2)}h$
假设损失函数为 $\mathcal{l}$ ，且样本标签为 $y$ ，可以计算出单个数据样本的损失项：
$L=\mathcal{l}(o,y)$
根据 $L_2$ 范数正则化的定义，给定hyperparameter $\lambda$ ，正则化项即
$s=\frac{\lambda}{2}(\|W^{(1)}\|_F^2+\|W^{(2)}\|_F^2)$
其中矩阵的Frobenius范数等价于将矩阵变平为向量后计算 $L_2$ 范数。最终，模型在给定的数据样本上带正则化的损失为：
$J=L+s$
我们将 $J$ 称为有关给定样本数据的目标函数。

3.7.2 back-propagation

Concept：计算神经网络参数的梯度方法。总的来说，backpropagation依据微积分中的链式法则，沿着从输出层到输入层的顺序，依次计算并存储目标函数有关神经网络各层的中间变量以及参数的梯度。

对输入或输出 $X,YZ$ 为任意形状张量的函数 $Y=f(X),Z=g(Y)$ ，有
$\frac{\partial Z}{\partial X}=\text{prod}\left(\frac{\partial Z}{\partial Y},\frac{\partial Y}{\partial X}\right)$

回顾上述模型，首先计算目标函数 $J=L+s$ 有关梯度：
$\frac{\partial J}{\partial L}=1,\frac{\partial L}{\partial s}=1$
其次，注意到：
$\frac{\partial J}{\partial o}=\text{prod}\left(\frac{\partial J}{\partial L},\frac{\partial L}{\partial o}\right)=\frac{\partial L}{\partial o}$
计算正则项得到：
$\frac{\partial s}{\partial W^{(1)}}=\lambda W^{(1)},\frac{\partial s}{\partial W^{(2)}}=\lambda W^{(2)}$
继续计算：
$\frac{\partial J}{\partial W^{(2)}}=\text{prod}\left(\frac{\partial J}{\partial o},\frac{\partial o}{\partial W^{(2)}}\right)+\text{prod}\left(\frac{\partial J}{\partial s},\frac{\partial s}{\partial W^{(2)}}\right)=\frac{\partial J}{\partial o}h^{\top}+\lambda W^{(2)}$
$\frac{\partial J}{\partial h}=\text{prod}\left(\frac{\partial J}{\partial o},\frac{\partial o}{\partial h}\right)=W^{(2)\top}\frac{\partial J}{\partial o}$
最终可以得到：
$\frac{\partial J}{\partial W^{(1)}}=\text{prod}\left(\frac{\partial J}{\partial z},\frac{\partial z}{\partial W^{(1)}}\right)+\text{prod}\left(\frac{\partial J}{\partial s},\frac{\partial s}{\partial W^{(1)}}\right)=\frac{J}{\partial z}x^{\top}+\lambda W^{(1)}$

Ch5.卷积神经网络(CNN)

5.1.二维卷积层

Convolutional neural network是含有convolutional layers的神经网络。

使用更加直接的cross-correlation运算。在二维卷积层中，一个二维输入数组和一个二维kernel（也叫filter）数组通过cross-correlation运算输出一个二维数组。
卷积核窗口的形状取决于卷积核的宽和高。

在二维cross-correlation运算中，卷积窗口从输入数组的最左上方开始，按从左到右、从上往下的顺序，依次在输入数组上滑动。当卷积窗口滑动到某一位置时，窗口中的输入子数组与kernel数组按元素相乘并求和，得到输出数组的相应位置的元素。

二维卷积层将输入和卷积核做cross-correlation运算，并加上一个bias来得到输出。卷积层的模型参数包括了convolutional kernel和bias。

import torch  
from torch import nn  
  
def corr2d(X, K):  
 h, w = K.shape Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1)) for i in range(Y.shape[0]): for j in range(Y.shape[1]): Y[i, j] = (X[i:i + h, j:j+w] * K).sum() return Y  
X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])  
K = torch.tensor([[0.0, 1.0], [2.0, 3.0]])  
corr2d(X, K)

二维卷积层输出的二维数组可以看作输出在空间维度上某一级的表征，也叫特征图（feature map），影响元素 $x$ 的前向计算的所有可能输入区域叫做 $x$ 的感受野（receptive field）。

5.2.填充和步幅

假设输入形状为 $n_h\times n_w$ ，卷积核形状为 $k_h\times k_w$ ，那么输出形状将是 $(n_h-k_h+1)\times (n_w-k_w+1)$ . 因此，卷积的输出形状取决于输入形状和卷积核的形状。

5.2.1 填充（padding）

如上所述，在应用多层卷积时，我们常常丢失边缘像素。由于我们通常使用小卷积核，因此对于任何单个卷积，我们可能只会丢失几个像素。但随着我们应用许多连续卷积层，累积丢失的像素数就多了。解决这个问题的简单方法即为填充（padding）：在输入图像的边界填充元素（通常填充元素是0）.

通常，如果我们添加 $p_h$ 行填充（大约一半在顶部，一半在底部）和 $p_w$ 列填充（左侧大约一半，右侧一半），则输出形状将为: $(n_h-k_h+p_h+1)\times (n_w-k_w+p_w+1)$
这意味着输出的高度和宽度将分别增加 $p_h$ 和 $p_w$ 。

在许多情况下，我们需要设置 $p_h=k_h-1$ 和 $p_w=k_w-1$ ，使输入和输出具有相同的高度和宽度。这样可以在构建网络时更容易地预测每个图层的输出形状。假设 $k_h$ 是奇数，我们将在高度的两侧填充 $p_n/2$ 行。如果 $k_h$ 是偶数，则一种可能性是输入顶部填充 $\lceil p_n/2 \rceil$ 行，在底部填充 $\lfloor p_h/2\rfloor$ 行。同理，我们填充宽度的两侧。
以下是一个例子：我们创建一个高度和宽度为3的二维卷积层，并在所有侧边填充1个像素。给定高度和宽度为8的输入，则输出的高度和宽度也是8。

import torch  
from torch import nn  
  
# 为了方便起见，我们定义了一个计算卷积层的函数。  
# 此函数初始化卷积层权重，并对输入和输出提高和缩减相应的维数  
def comp_conv2d(conv2d, X):  
 # 这里的（1，1）表示批量大小和通道数都是1  
 X = X.reshape((1, 1) + X.shape) Y = conv2d(X) # 省略前两个维度：批量大小和通道  
 return Y.reshape(Y.shape[2:])  
# 请注意，这里每边都填充了1行或1列，因此总共添加了2行或2列  
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)  
X = torch.rand(size=(8, 8))  
comp_conv2d(conv2d, X).shape

5.2.2 步幅（stride）

在计算互相关时，卷积窗口从输入张量的左上角开始，向下、向右滑动。在前面的例子中，我们默认每次滑动一个元素。但是，有时候为了高效计算或是缩减采样次数，卷积窗口可以跳过中间位置，每次滑动多个元素。

我们将每次滑动元素的数量称为步幅（stride）。

通常，当垂直步幅为 $s_h$ 、水平步幅为 $s_w$ 时，输出形状为：
$\lfloor (n_h-k_h+p_h+s_h)/s_h\rfloor \times \lfloor (n_w-k_w+p_w+s_w)/s_w\rfloor$

为了简洁起见，当输入高度和宽度两侧的填充数量分别为 $p_h$ 和 $p_w$ 时，我们称之为 $(p_h,p_w)$ 。当 $p_h=p_w=p$ 时，填充是 $p$ 。同理，当高度和宽度上的步幅分别为 $s_h$ 和 $s_w$ 时，我们称之为步幅 $(s_h,s_w)$ 。特别的，当 $s_h=s_w=s$ 时，我们称步幅为 $s$ 。默认情况下，填充为0，步幅为1.在实践中，我们很少使用不一致的步幅或填充，也就是说，我们通常有 $p_h=p_w$ 和 $s_w=s_h$ 。

5.3.多输入通道和多输出通道

当我们添加通道时，我们的输入和隐藏的表示都变成了三维张量。例如，每个RGB输入图像具有 $3\times h\times w$ 的形状。我们将这个大小为的轴称为通道（channel）维度。

5.3.1 多输入通道

当输入包含多个通道时，需要构造一个与输入数据具有相同输入通道数的卷积核，以便与输入数据进行互相关运算。假设输入的通道数为 $c_i$ ，那么卷积核的输入通道数也需要为 $c_i$ 。如果卷积核的窗口形状是 $k_h\times k_w$ ，那么当 $c_i=1$ 时，我们可以把卷积核看作形状为 $k_h\times k_w$ 的二维张量。

当 $c_i>1$ 时，我们卷积核的每个输入通道将包含形状为 $k_h\times k_w$ 的张量。将这些张量 $c_i$ 连结在一起可以得到形状为 $c_i\times k_h\times kw$ 的卷积核。由于输入和卷积核都有 $c_|i$ 个通道，我们可以对每个通道输入的二维张量和卷积核的二维张量进行cross-correlation运算，再对通道求和（将 $c_i$ 的结果相加）得到二维张量。这是多通道输入和多输入通道卷积核之间进行二维互相关运算的结果。

import torch  
def corr2d_multi_in(X, K):  
 return sum(corr2d(x, k) for x, k in zip(X, K))X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],  
 [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])  
  
corr2d_multi_in(X, K)

5.3.2 多输出通道

在最流行的神经网络架构中，随着神经网络层数的加深，我们常会增加输出通道的维数，通过减少空间分辨率以获得更大的通道深度。直观地说，我们可以将每个通道看作对不同特征的响应。而现实可能更为复杂一些，因为每个通道不是独立学习的，而是为了共同使用而优化的。因此，多输出通道并不仅是学习多个单通道的检测器。

用 $c_i,c_o$ 分别表示输入和输出通道的数目，并让 $k_h$ 和 $k_w$ 为卷积核的高度和宽度。为了获得多个通道的输出，我们可以为每个输出通道创建一个形状为 $c_o\times c_i\times k_h\times k_w$ 。在cross-correlation运算中，每个输出通道首先获得所有输入通道，再以对应该输出通道的卷积核计算出结果。

def corr2d_multi_in_out(X, K):  
 return torch.stack([corr2d_multi_in(X, k) for k in K], 0)K = torch.stack((K, K + 1, K + 2), 0)  
K.shape

5.3.3 $1\times 1$ 卷积层

因为使用了最小窗口， $1\times 1$ 卷积失去了卷积层的特有能力——在高度和宽度维度上，识别相邻元素间相互作用的能力。其实 $1\times 1$ 卷积的唯一计算发生在通道上。

假设输入和输出具有相同的高度和宽度，输出中的每个元素都是从输入图像中同一位置的元素的线性组合。我们可以将 $1\times 1$ 卷积层看作在每个像素位置应用的全连接层，以 $c_i$ 个输入值转换为 $c_o$ 个输出值。因为这仍然是一个卷积层，所以跨像素的权重是一致的。同时， $1\times 1$ 卷积层需要的权重维度为 $c_o\times c_i$ ，再额外加上一个bias。

def corr2d_multi_in_out_1x1(X, K):  
 c_i, h, w = X.shape c_o = K.shape[0] X = X.reshape((c_i, h * w)) K = K.reshape((c_o, c_i))  
 Y = torch.matmul(K, X) return Y.reshape((c_o, h, w))X = torch.normal(0, 1, (3, 3, 3))  
K = torch.normal(0, 1, (2, 3, 1, 1))  
  
Y1 = corr2d_multi_in_out_1x1(X, K)  
Y2 = corr2d_multi_in_out(X, K)  
assert float(torch.abs(Y1 - Y2).sum()) < 1e-6

5.4.池化层/汇聚层（polling）

通常当我们处理图像时，我们希望逐渐降低隐藏表示的空间分辨率、聚集信息，这样随着我们在神经网络中层叠的上升，每个神经元对其敏感的感受野（输入）就越大。

而我们的机器学习任务通常会跟全局图像的问题有关（例如，“图像是否包含一只猫呢？”），所以我们最后一层的神经元应该对整个输入的全局敏感。通过逐渐聚合信息，生成越来越粗糙的映射，最终实现学习全局表示的目标，同时将卷积图层的所有优势保留在中间层。

此外，当检测较底层的特征时，我们通常希望这些特征保持某种程度上的平移不变性。而在现实中，随着拍摄角度的移动，任何物体几乎不可能发生在同一像素上。即使用三脚架拍摄一个静止的物体，由于快门的移动而引起的相机振动，可能会使所有物体左右移动一个像素（除了高端相机配备了特殊功能来解决这个问题）。

汇聚（pooling）层，它具有双重目的：降低卷积层对位置的敏感性，同时降低对空间降采样表示的敏感性。

5.4.1 最大汇聚层（maximum pooling）和平均汇聚层（average pooling）

与卷积层类似，汇聚层运算符由一个固定形状的窗口组成，该窗口根据其步幅大小在输入的所有区域上滑动，为固定形状窗口（有时称为汇聚窗口）遍历的每个位置计算一个输出。然而，不同于卷积层中的输入与卷积核之间的互相关计算，汇聚层不包含参数。相反，池运算是确定性的，我们通常计算汇聚窗口中所有元素的最大值或平均值。这些操作分别称为最大汇聚层（maximum pooling）和平均汇聚层（average pooling）。

在这两种情况下，与互相关运算符一样，汇聚窗口从输入张量的左上角开始，从左往右、从上往下的在输入张量内滑动。在汇聚窗口到达的每个位置，它计算该窗口中输入子张量的最大值或平均值。计算最大值或平均值是取决于使用了最大汇聚层还是平均汇聚层。

pooling窗口形状为 $p\times q$ 的pooling layer称为 $p\times q$ pooling layer，pooling操作称为 $p\times q$ pooling。

考虑边缘检测的例子，现在我们将使用卷积层是输出作为 $2\times 2$ maximum pooling的输入。设卷积层输入为 $X$ ，pooling layer输出为 $Y$ 。无论 $X[i, j]$ 和 $X[i, j+1]$ 的值相同与否，或 $X[i, j+1]$ 和 $X[i ,j+2]$ 的值相同与否，pooling layer始终输出 $Y[i, j]=1$ 。也就是说，使用 $2\times 2$ maximum pooling layer，即使在高度或宽度上移动一个元素，卷积层仍然可以识别到模式。

import torch  
from torch import nn  
  
def pool2d(X, pool_size, mode='max'):  
 p_h, p_w = pool_size Y =torch.zeros((X.shape[0] -p_h +1, X.shape[1] -p_w + 1)) for i in range(Y.shape[0]): for j in range(Y.shape[1]): if mode == 'max': Y[i, j] = X[i: i + p_h, j: j + p_w].max() elif mode == 'avg': Y[i, j] = X[i: i + p_h, j: j + p_w].mean() return YX = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])  
pool2d(X, (2, 2))

5.4.2 填充和步幅

与卷积层一样，汇聚层也可以改变输出形状。和以前一样，我们可以通过填充和步幅以获得所需的输出形状。

5.4.3 多个通道

在处理多通道输入数据时，汇聚层在每个输入通道上单独运算，而不是像卷积层一样在通道上对输入进行汇总。这意味着汇聚层的输出通道数与输入通道数相同。

5.5.卷积神经网络（LeNet）

用卷积层代替全连接层的另一个好处是：模型更简洁、所需的参数更少。

LeNet，它是最早发布的卷积神经网络之一，因其在计算机视觉任务中的高效性能而受到广泛关注。这个模型是由AT&T贝尔实验室的研究员Yann LeCun在1989年提出的（并以其命名），目的是识别图像中的手写数字。当时，Yann LeCun发表了第一篇通过反向传播成功训练卷积神经网络的研究，这项工作代表了十多年来神经网络研究开发的成果。

当时，LeNet取得了与支持向量机（support vector machines）性能相媲美的成果，成为监督学习的主流方法。 LeNet被广泛用于自动取款机（ATM）机中，帮助识别处理支票的数字。时至今日，一些自动取款机仍在运行Yann LeCun和他的同事Leon Bottou在上世纪90年代写的代码呢！

5.5.1 LeNet

LeNet由两部分组成：

卷积编码器：由两个卷积层组成;
全连接层密集块：由三个全连接层组成。

每个卷积块中的基本单元是一个卷积层、一个sigmoid激活函数和平均汇聚层。请注意，虽然ReLU和最大汇聚层更有效，但它们在20世纪90年代还没有出现。每个卷积层使用 $5\times 5$
卷积核和一个sigmoid激活函数。这些层将输入映射到多个二维特征输出，通常同时增加通道的数量。第一卷积层有6个输出通道，而第二个卷积层有16个输出通道。每个 $2\times 2$
池操作（步幅2）通过空间下采样将维数减少4倍。卷积的输出形状由批量大小、通道数、高度、宽度决定。

为了将卷积块的输出传递给稠密块，我们必须在小批量中展平每个样本。换言之，我们将这个四维输入转换成全连接层所期望的二维输入。这里的二维表示的第一个维度索引小批量中的样本，第二个维度给出每个样本的平面向量表示。LeNet的稠密块有三个全连接层，分别有120、84和10个输出。因为我们在执行分类任务，所以输出层的10维对应于最后输出结果的数量。

import torch  
from torch import nn  
  
net = nn.Sequential(  
 nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2), nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2), nn.Flatten(), nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(), nn.Linear(120, 84), nn.Sigmoid(), nn.Linear(84, 10))  
X = torch.rand(size=(1, 1, 28, 28), dtype=torch.float32)  
for layer in net:  
 X = layer(X) print(layer.__class__.__name__,'output shape: \t',X.shape)

5.5.2 模型训练

虽然卷积神经网络的参数较少，但与深度的多层感知机相比，它们的计算成本仍然很高，因为每个参数都参与更多的乘法。通过使用GPU，可以用它加快训练。

为了进行评估，我们需要对evaluate_accuracy函数进行轻微的修改。由于完整的数据集位于内存中，因此在模型使用GPU计算数据集之前，我们需要将其复制到显存中。

为了使用GPU，我们还需要一点小改动。与之前定义的train_epoch_ch3不同，在进行正向和反向传播之前，我们需要将每一小批量数据移动到我们指定的设备（例如GPU）上。

如下所示，训练函数train_ch6也类似于train_ch3。由于我们将实现多层神经网络，因此我们将主要使用高级API。以下训练函数假定从高级API创建的模型作为输入，并进行相应的优化。我们使用之前介绍的Xavier随机初始化模型参数。与全连接层一样，我们使用交叉熵损失函数和小批量随机梯度下降。

from d2l import torch as d2l  
batch_size = 256  
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)  
def evaluate_accuracy_gpu(net, data_iter, device=None):  
 if isinstance(net, nn.Module): net.eval() if not device: device = next(iter(net.parameters())).device metric = Accumulator() with torch.no_grad(): for X, y in data_iter: if isinstance(X, list): X = [x.to(device) for x in X] else: X = X.to(device) y = y.to(device) metric.add(d2l.accuracy(net(X), y), y.numel()) return metric[0] / metric[1]#@save  
def train_ch6(net, train_iter, test_iter, num_epochs, lr, device):  
 """用GPU训练模型(在第六章定义)"""  
 def init_weights(m): if type(m) == nn.Linear or type(m) == nn.Conv2d: nn.init.xavier_uniform_(m.weight) net.apply(init_weights) print('training on', device) net.to(device) optimizer = torch.optim.SGD(net.parameters(), lr=lr) loss = nn.CrossEntropyLoss() animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs], legend=['train loss', 'train acc', 'test acc']) timer, num_batches = d2l.Timer(), len(train_iter) for epoch in range(num_epochs): # 训练损失之和，训练准确率之和，样本数  
 metric = d2l.Accumulator(3) net.train() for i, (X, y) in enumerate(train_iter): timer.start() optimizer.zero_grad() X, y = X.to(device), y.to(device) y_hat = net(X) l = loss(y_hat, y) l.backward() optimizer.step() with torch.no_grad(): metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0]) timer.stop() train_l = metric[0] / metric[2] train_acc = metric[1] / metric[2] if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1: animator.add(epoch + (i + 1) / num_batches, (train_l, train_acc, None)) test_acc = evaluate_accuracy_gpu(net, test_iter) animator.add(epoch + 1, (None, None, test_acc)) print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, ' f'test acc {test_acc:.3f}') print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec ' f'on {str(device)}')lr, num_epochs = 0.9, 10  
train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

5.6.深度卷积神经网络（AlexNet）

5.6.1 学习表征

Yann LeCun、Geoff Hinton、Yoshua Bengio、Andrew Ng、Shun ichi Amari和Juergen Schmidhuber认为特征本身应该被学习。此外，他们还认为，在合理地复杂性前提下，特征应该由多个共同学习的神经网络层组成，每个层都有可学习的参数。在机器视觉中，最底层可能检测边缘、颜色和纹理。事实上，Alex Krizhevsky、Ilya Sutskever和Geoff Hinton提出了一种新的卷积神经网络变体AlexNet。

在网络的最底层，模型学习到了一些类似于传统滤波器的特征抽取器。AlexNet的更高层建立在这些底层表示的基础上，以表示更大的特征，如眼睛、鼻子、草叶等等。而更高的层可以检测整个物体，如人、飞机、狗或飞盘。最终的隐藏神经元可以学习图像的综合表示，从而使属于不同类别的数据易于区分。尽管一直有一群执着的研究者不断钻研，试图学习视觉数据的逐级表征，然而很长一段时间里这些尝试都未有突破。深度卷积神经网络的突破出现在2012年。突破可归因于两个关键因素。

5.6.1.1 缺少的成分：数据

包含许多特征的深度模型需要大量的有标签数据，才能显著优于基于凸优化的传统方法（如线性方法和核方法）。然而，限于早期计算机有限的存储和90年代有限的研究预算，大部分研究只基于小的公开数据集。例如，不少研究论文基于加州大学欧文分校（UCI）提供的若干个公开数据集，其中许多数据集只有几百至几千张在非自然环境下以低分辨率拍摄的图像。这一状况在2010年前后兴起的大数据浪潮中得到改善。2009年，ImageNet数据集发布，并发起ImageNet挑战赛：要求研究人员从100万个样本中训练模型，以区分1000个不同类别的对象。ImageNet数据集由斯坦福教授李飞飞小组的研究人员开发，利用谷歌图像搜索（Google Image Search）对每一类图像进行预筛选，并利用亚马逊众包（Amazon Mechanical Turk）来标注每张图片的相关类别。这种规模是前所未有的。这项被称为ImageNet的挑战赛推动了计算机视觉和机器学习研究的发展，挑战研究人员确定哪些模型能够在更大的数据规模下表现最好。

5.6.1.2 缺少的成分：硬件

深度学习对计算资源要求很高，训练可能需要数百个迭代轮数，每次迭代都需要通过代价高昂的许多线性代数层传递数据。这也是为什么在20世纪90年代至21世纪初，优化凸目标的简单算法是研究人员的首选。然而，用GPU训练神经网络改变了这一格局。图形处理器（Graphics Processing Unit，GPU）早年用来加速图形处理，使电脑游戏玩家受益。GPU可优化高吞吐量的
矩阵和向量乘法，从而服务于基本的图形任务。幸运的是，这些数学运算与卷积层的计算惊人地相似。由此，英伟达（NVIDIA）和ATI已经开始为通用计算操作优化gpu，甚至把它们作为通用GPU（general-purpose GPUs，GPGPU）来销售。

首先，我们深度理解一下中央处理器（Central Processing Unit，CPU）的核心。 CPU的每个核心都拥有高时钟频率的运行能力，和高达数MB的三级缓存（L3Cache）。它们非常适合执行各种指令，具有分支预测器、深层流水线和其他使CPU能够运行各种程序的功能。然而，这种明显的优势也是它的致命弱点：通用核心的制造成本非常高。它们需要大量的芯片面积、复杂的支持结构（内存接口、内核之间的缓存逻辑、高速互连等等），而且它们在任何单个任务上的性能都相对较差。现代笔记本电脑最多有4核，即使是高端服务器也很少超过64核，因为它们的性价比不高。

相比于CPU，GPU由 $100\sim 1000$
个小的处理单元组成（NVIDIA、ATI、ARM和其他芯片供应商之间的细节稍有不同），通常被分成更大的组（NVIDIA称之为warps）。虽然每个GPU核心都相对较弱，有时甚至以低于1GHz的时钟频率运行，但庞大的核心数量使GPU比CPU快几个数量级。例如，NVIDIA最近一代的Ampere GPU架构为每个芯片提供了高达312 TFlops的浮点性能，而CPU的浮点性能到目前为止还没有超过1 TFlops。之所以有如此大的差距，原因其实很简单：首先，功耗往往会随时钟频率呈二次方增长。对于一个CPU核心，假设它的运行速度比GPU快4倍，但可以使用16个GPU核代替，那么GPU的综合性能就是CPU的 $16\times 1/4=4$
倍。其次，GPU内核要简单得多，这使得它们更节能。此外，深度学习中的许多操作需要相对较高的内存带宽，而GPU拥有10倍于CPU的带宽。

回到2012年的重大突破，当Alex Krizhevsky和Ilya Sutskever实现了可以在GPU硬件上运行的深度卷积神经网络时，一个重大突破出现了。他们意识到卷积神经网络中的计算瓶颈：卷积和矩阵乘法，都是可以在硬件上并行化的操作。于是，他们使用两个显存为3GB的NVIDIA GTX580 GPU实现了快速卷积运算。他们的创新cuda-convnet几年来它一直是行业标准，并推动了深度学习热潮。

5.6.2 AlexNet

AlexNet和LeNet的设计理念非常相似，但也存在显著差异:

AlexNet比相对较小的LeNet5要深得多。AlexNet由八层组成：五个卷积层、两个全连接隐藏层和一个全连接输出层
AlexNet使用ReLU而不是sigmoid作为其激活函数。

5.6.2.1 模型设计

在AlexNet的第一层，卷积窗口的形状是 $11\times 11$
。由于ImageNet中大多数图像的宽和高比MNIST图像的多10倍以上，因此，需要一个更大的卷积窗口来捕获目标。第二层中的卷积窗口形状被缩减为 $5\times 5$
，然后是 $3\times 3$
。此外，在第一层、第二层和第五层卷积层之后，加入窗口形状为
、步幅为2的最大汇聚层。而且，AlexNet的卷积通道数目是LeNet的10倍。

在最后一个卷积层后有两个全连接层，分别有4096个输出。这两个巨大的全连接层拥有将近1GB的模型参数。由于早期GPU显存有限，原版的AlexNet采用了双数据流设计，使得每个GPU只负责存储和计算模型的一半参数。幸运的是，现在GPU显存相对充裕，所以现在很少需要跨GPU分解模型（因此，本书的AlexNet模型在这方面与原始论文稍有不同）。

5.6.2.2 激活函数

此外，AlexNet将sigmoid激活函数改为更简单的ReLU激活函数。一方面，ReLU激活函数的计算更简单，它不需要如sigmoid激活函数那般复杂的求幂运算。另一方面，当使用不同的参数初始化方法时，ReLU激活函数使训练模型更加容易。当sigmoid激活函数的输出非常接近于0或1时，这些区域的梯度几乎为0，因此反向传播无法继续更新一些模型参数。相反，ReLU激活函数在正区间的梯度总是1。因此，如果模型参数没有正确初始化，sigmoid函数可能在正区间内得到几乎为0的梯度，从而使模型无法得到有效的训练。

5.6.2.3 容量控制和预处理

AlexNet通过dropout控制全连接层的模型复杂度，而LeNet只使用了weight decay。为了进一步扩充数据，AlexNet在训练时增加了大量的图像增强数据，如翻转、裁切和变色。这使得模型更健壮，更大的样本量有效地减少了overfitting。

import torch  
from torch import nn  
  
net = nn.Sequential(  
 nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2), nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2), nn.Flatten(), nn.Linear(6400, 4096), nn.ReLU(), nn.Dropout(p=0.5), nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(p=0.5), nn.Linear(4096, 10))  
X = torch.randn(1, 1, 224, 224)  
for layer in net:  
 X=layer(X) print(layer.__class__.__name__,'output shape:\t',X.shape)

5.7.使用重复元素的网络（VGG）

5.7.1 VGG块

经典卷积神经网络的基本组成部分是下面的这个序列：

带填充以保持分辨率的卷积层
非线性激活函数，如ReLU
pooling layer，如maximum pooling layer

而一个CGG块与之类似，有一系列卷积层组成，后面再加上用于空间下采样的maximum polling layers。在最初的VGG论文中，作者使用了带有 $3\times 3$ 卷积核、填充为1（保持高度和宽度）的卷积层，和带有 $2\times 2$ pooling Windows，步幅为2（每个块后的分辨率减半）的maximum pooling layers。在下面的代码中，我们定义了一个名为vgg_block的函数来实现一个VGG块。

该函数有三个参数，分别对应于卷积层的数量num_convs、输入通道的数量in_channels和输出通道的数量out_channels。

import torch  
from torch import nn  
  
def vgg_block(num_convs, in_channels, out_channels):  
 layers = [] for _ in range(num_convs): layers.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)) layers.append(nn.ReLU()) in_channels = out_channels layers.append(nn.MaxPool2d(kernel_size=2, stride=2)) return nn.Sequential(*layers)

5.7.2 VGG网络

与AlexNet、LeNet一样，VGG网络可以分为两部分：第一部分主要由卷积层和pooling layers组成，第二部分由全连接层组成。

VGG神经网络连接的几个VGG块（在vgg_block函数中定义）。其中有hyperparameter变量conv_arch，该变量指定了每个VGG块里卷积层个数和输出通道数。全连接模块则与AlexNet中的相同。

原始VGG网络有5个卷积块，其中前两个块各有一个卷积层，后三个块各包含两个卷积层。第一个模块有64个输出通道，每个后续模块将输出通道数量翻倍，直到数字达到512.由于该网络使用8个卷积层和3个全连接层，因此它通常称为VGG-11.

conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))  
def vgg(conv_arch):  
 conv_blks = [] in_channels = 1 for (num_convs, out_channels) in conv_arch: conv_blks.append(vgg_block(num_convs, in_channels, out_channels)) in_channels = out_channels return nn.Sequential( *conv_blks, nn.Flatten(), nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(), nn.Dropout(0.5), nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5), nn.Linear(4096, 10) )net = vgg(conv_arch)  
  
X = torch.randn(size=(1, 1, 224, 224))  
for blk in net:  
 X = blk(X) print(blk.__class__.__name__, 'output shape:\t', X.shape)

5.8.网络中的网络（NiN）

LeNet、AlexNet和VGG都有一个共同的设计模式：通过一系列的卷积层与pooling layer来提取空间结构特征；然后通过全连接层对特征的表征进行处理。AlexNet和VGG对LeNet的改进主要在于如何扩大和加深这两个模块。或者，可以想象在这个过程的早期使用全连接层。然而，如果使用了全连接层，可能会完全丢弃表征的空间结构。NiN提供了一个非常简单的解决方案：在每个像素的通道上分别使用多层感知机。

5.8.1 NiN块

Recall：卷积层的输入和输出由四维张量组成，张量的每个轴分别对应样本、通道、高度和宽度。另外，全连接层的输入和输出通常是分别对应于样本和特征的二维张量。NiN的想法是在每个像素位置（针对每个高度和宽度）应用一个全连接层。如果我们将权重连接到每个空间位置，我们可以将其视作 $1\times 1$ 卷积层，或作为在每个像素位置上独立作用的全连接层。从另一个角度看，即将空间维度中的每个像素视作单个样本，将通道维度视为不同feature。

NiN块以一个普通卷积层开始，后面是两个 $1\times 1$ 的卷积层。这两个 $1\times 1$ 卷积层充当带有ReLU激活函数的逐像素全连接层。第一层的卷积窗口形状通常由用户设置。随后的卷积窗口形状固定为 $1\times 1$ 。

import torch  
from torch import nn  
  
def nin_block(in_channels, out_channels, kernel_size, strides, padding):  
 return nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size, strides, padding), nn.ReLU(), nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU(), nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU() )

5.8.2 NiN Model

最初的NiN网络是在AlexNet后不久提出的，显然从中得到了一些启示。 NiN使用窗口形状为 $11\times 11$ 、 $5\times 5$ 和 $3\times 3$ 的Convolutional layers，输出通道数量与AlexNet中的相同。每个NiN块后有一个最大汇聚层，汇聚窗口形状为 $3\times 3$ ，步幅为2.

NiN和AlexNet之间的一个显著区别是NiN完全取消了全连接层。相反，NiN使用一个NiN块，其输出通道数等于标签类别的数量。最后放一个全局平均汇聚层（global average pooling layer），生成一个对数几率（logits）。NiN设计的一个优点是，它显著减少了模型所需参数的数量。然而，在实践中，这种设计有时会增加训练模型的时间。

net = nn.Sequential(  
 nin_block(1, 96, kernel_size=11, strides=4, padding=0), nn.MaxPool2d(3, stride=2), nin_block(96, 256, kernel_size=5, strides=1, padding=2), nn.MaxPool2d(3, stride=2), nin_block(256, 384, kernel_size=3, strides=1, padding=1), nn.MaxPool2d(3, stride=2), nn.Dropout(0.5), # 标签类别数是10  
 nin_block(384, 10, kernel_size=3, strides=1, padding=1), nn.AdaptiveAvgPool2d((1, 1)), # 将四维的输出转成二维的输出，其形状为(批量大小,10)  
 nn.Flatten())X = torch.rand(size=(1, 1, 224, 224))  
for layer in net:  
 X = layer(X) print(layer.__class__.__name__,'output shape:\t', X.shape)

5.9.含并行连结的网络（GoogLeNet）

Core Idea：有时使用不同大小的卷积核组合是有利的。

5.9.1 Inception Block

在GoogLeNet中，基本的卷积块被称为Inception块（Inception block）。这很可能得名于电影《盗梦空间》（Inception），因为电影中的一句话“我们需要走得更深”（“We need to go deeper”）。

Inception块由四条并行路径组成。前三条路径使用窗口大小为 $1\times 1, 3\times3, 5\times 5$ 的卷积层，从不同空间大小中提取信息。中间的两条路径在输入上执行 $1\times 1$ 卷积，以减少通道数，从而降低模型的复杂性。第四条路径使用 $3\times 3$ maximum pooling layer。然后使用 $1\times 1$ 卷积层来改变通道数。这四条路径都使用合适的填充来使输入和输出的高和宽一致，最后我们将每条线路的输出在通道维度上连结，并构成inception块的输出。在Inception块中，通常调整的hyperparameter是每层输出的通道数。

那么为什么GoogLeNet这个网络如此有效呢？首先我们考虑一下滤波器（filter）的组合，它们可以用各种滤波器尺寸探索图像，这意味着不同大小的滤波器可以有效地识别不同范围的图像细节。同时，我们可以为不同的滤波器分配不同数量的参数。

import torch  
from torch import nn  
from torch.nn import functional as F  
  
class Inception(nn.Module):  
 # c1--c4是每条路径的输出通道数  
 def __init__(self, in_channels, c1, c2, c3, c4, **kwargs): super(Inception, self).__init__(**kwargs) # 线路1， 单1x1卷积层  
 self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1) # 线路2：1x1卷积层后接3x3卷积层  
 self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1) self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1) # 线路3， 1x1卷积层后接5x5卷积层  
 self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1) self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2) # 线路4，3x3最大汇聚层后接1x1卷积层  
 self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1) self.p4_2 = nn.Conv2d(in_channels, c4, kernel_size=1)  
 def forward(self, x): p1 = F.relu(self.p1_1(x)) p2 = F.relu(self.p2_2(F.relu(self.p2_1(x)))) p3 = F.relu(self.p3_2(F.relu(self.p3_1(x)))) p4 = F.relu(self.p4_2(self.p4_1(x))) # 在通道维度上连结输出  
 return torch.cat((p1, p2, p3, p4), dim=1)

5.9.2 GoogLeNet Model

GoogLeNet一共使用了9个inception块和全局平均汇聚层的堆叠来生成其估计值。Inception块之间的最大汇聚层可降低维度。第一个模块类似于AlexNet和LeNet，Inception块的组合从VGG继承，全局平均汇聚层避免了在最后使用全连接层。

现在，我们逐一实现GoogLeNet的每个模块，第一个模块使用64个通道， $7\times 7$ 卷积层。

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),  
 nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

第二个模块使用两个卷积层：第一个卷积层是64个通道、 $1\times 1$ 卷积层；第二个卷积层使用将通道数量增加三倍的 $3\times 3$ 卷积层。这对应于Inception块中的第二条路径。

b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1),  
 nn.ReLU(), nn.Conv2d(64, 192, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

第三个模块串联两个完整的inception块。第一个inception块的输出通道数为 $64+128+32+32=256$ ，四个路径之间的输出通道数数量比为 $64:128:32:32=2:4:1:1$ 。第二个和第三个路径首先将输入通道的数量分别减少到 $96/192=1/2$ 和 $16/192=1/12$ ，然后连结第二个卷积层。第二个Inception块的输出通道数增加到 $128+192+96+64=480$ ，四个路径之间的输出通道数量比为 $128:192:96:64=4:6:3:2$ 。第二条和第三条路径首先将输入通道的数量分别减少到 $128/256=1/2$ 和 $32/256=1/8$ 。

b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),  
 Inception(256, 128, (128, 192), (32, 96), 64), nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

第四模块更加复杂，它串联了5个Inception块，其输出通道数分别是 $192+208+48+64=512,160+224+64+64=512,128+256+64+64=512,112+288+64+64=528,256+320+128+128=832$ 。这些路径的通道数分配和第三模块中的类似，首先是含 $3\times 3$ 卷积层的第二条路经输出最多通道，其次是仅含 $1\times 1$ 卷积层的第一条路经，之后是含 $5\times 5$ 卷积层的第三条路径和含 $3\times 3$ 最大汇聚层的四弟条路经。其中第二、第三条路径都会先按比例减小通道数。这些比例在各个Inception块中都略有不同。

b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),  
 Inception(512, 160, (112, 224), (24, 64), 64), Inception(512, 128, (128, 256), (24, 64), 64), Inception(512, 112, (144, 288), (32, 64), 64), Inception(528, 256, (160, 320), (32, 128), 128), nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

第五模块包含输出通道数为 $256+320+1288+128=832$ 和 $384+384+128+128=1024$ 的两个Inception块。其中每条路径通道数的分配思路和第三、第四模块中的一致，只是在具体数值上有所不同。需要注意的是，第五模块的后面紧跟输出层，该模块同NiN一样使用全局平均汇聚层，将每个通道的高和宽变为1.最后我们将输出变成二位数组，再接上一个输出个数为标签类别数的全连接层。

b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),  
 Inception(832, 384, (192, 384), (48, 128), 128), nn.AdaptiveAvgPool2d(1, 1), nn.Flatten())net = nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))

GoogLeNet模型的计算复杂，而且不如VGG那样便于修改通道数。为了使得训练集短小精悍，我们将输入的高和宽从224降到96，这简化了计算。

X = torch.rand(size=(1, 1, 96, 96))  
for layer in net:  
 X =layer(X) print(layer.__class__.__name__, 'output shape:\t', X.shape)

5.10.批量规范化(batch normalization)

Batch normalization是一种流行且有效的技术，可持续加速深层网络的收敛速度。再结合下一节欸对残差块，批量规范化使得研究人员能够训练100层以上的网络。

5.10.1 训练深层网络

批量规范化应用于单个可选层（也可以应用到所有层），其原理如下：在每次训练迭代中，我们首先规范化输入，即通过减去其均值并除以其标准差，其中两者均基于当前小批量处理。接下来，我们应用比例系数和比例偏移。正是由于这个基于批量统计的标准化，才有了批量规范化的名称。

请注意，如果我们尝试使用大小为1的小批量应用批量规范化，我们将无法学到任何东西。这是因为在减去均值之后，每个hidden unit将变为0.所以，只有使用足够的mini batch，批量规范化这种方法才是effective and stable。请注意，在应用batch normalization时，batch size的选择可能比没有batch normalization时更重要。

从形式上说，用 $x\in \mathcal{B}$ 表示一个来自mini batch $\mathcal{B}$ 的输入，批量规范化BN根据以下表达式转换 $x$ ：
$\text{BN}(x)=\gamma \odot \frac{x-\hat{\mu_{\mathcal{B}}}}{\hat{\sigma_{\mathcal{B}}}}+\beta$
上式中， $\hat{\mu_{\mathcal{B}}}$ 是mini batch $\mathcal{B}$ 的样本均值， $\sigma_{\mathcal{B}}$ 是mini batch $\mathcal{B}$ 的样本标准差。应用标准化后，生成的mini batch的平均值为0和单位方差为1.由于单位方差是一个主观选择，因此我们通常包含拉伸常数（scale） $\gamma$ 和偏移常数（shift） $\beta$ ，他们的形状与 $x$ 相同。请注意， $\gamma$ 和 $\beta$ 是需要与其他模型参数一起学习的参数。

由于在训练过程中，中间层的变化幅度不能过于剧烈，而批量规范化将每一层主动居中，并将它们重新调整为给定的平均值和大小（通过 $\hat{\mu_{\mathcal{B}}}$ 和 $\hat{\sigma_{\mathcal{B}}}$ ）。

从形式上来看，我们计算出两个参数：
$\hat{\mu_{\mathcal{B}}}=\frac{1}{|\mathcal{B}|}\sum\limits_{x\in \mathcal{B}}x$
$\hat{\sigma_{\mathcal{B}}}^2=\frac{1}{|\mathcal{B}|}\sum\limits_{x\in \mathcal{B}}(x-\hat{\mu_{\mathcal{B}}})^2+\epsilon$
请注意，我们在方差估计值中添加一个小的常量 $\epsilon >0$ ，以确保我们永远不会尝试除以零，即使在经验方差估计值可能消失的情况下也是如此。估计值 $\hat{\mu_{\mathcal{B}}}$ 和 $\hat{\sigma_{\mathcal{B}}}$ 通过使用平均值和方差的噪声（noise）估计来抵消缩放问题。乍看起来，这种噪声是一个问题，而事实上它是有益的。

事实证明，这是深度学习中一个反复出现的主题。由于尚未在理论上明确的原因，优化中的各种噪声源通常会导致更快的训练和较少的过拟合：这种变化似乎是正则化的一种形式。在一些初步研究中，将批量规范化的性质与贝叶斯先验相关联。这些理论揭示了为什么批量规范化最适应 $50\sim 100$ 范围中的中等批量大小的难题。

另外，批量规范化层在”训练模式“（通过小批量统计数据规范化）和“预测模式”（通过数据集统计规范化）中的功能不同。在训练过程中，我们无法得知使用整个数据集来估计平均值和方差，所以只能根据每个小批次的平均值和方差不断训练模型。而在预测模式下，可以根据整个数据集精确计算批量规范化所需的平均值和方差。

5.10.2 批量规范化层

回想一下，批量规范化和其他层之间的一个关键区别是，由于批量规范化在完整的小批量上运行，因此我们不能像以前在引入其他层时那样忽略批量大小。我们在下面讨论这两种情况：全连接层和卷积层，他们的批量规范化实现略有不同。

5.10.2.1 全连接层

通常，我们将批量规范化层置于全连接层中的仿射变换和激活函数之间。设全连接层的输入为 $x$ ，权重参数和偏置参数分别为 $W$ 和 $b$ ，激活函数为 $\phi$ ，批量规范化的运算符为 $\text{BN}$ 。那么，使用批量规范化的全连接层的输出的计算详情如下：
$h=\phi(\text{BN}(Wx+b))$
回想一下，均值和方差是在应用变换的“相同”小批量上计算的。

5.10.2.2 卷积层

同样，对于卷积层，我们可以在卷积层之后和非线性激活函数之前应用批量规范化。当卷积有多个输出通道时，我们需要对这些通道的“每个”输出执行批量规范化，每个通道都有自己的拉伸（scale）和偏移（shift）参数，这两个参数都是标量。假设我们的小批量包含 $m$ 个样本，并且对于每个通道，卷积的输出具有高度 $p$ 和宽度 $q$ ，那么对于卷积层，我们在每个输出通道的 $mpq$ 个元素上同时执行每个批量规范化。因此，在计算平均值和方差时，我们会收集所有空间位置的值，然后在给定通道内应用相同的均值和方差，以便在每个空间位置对值进行规范化。

5.10.2.3 预测过程中的批量规范化

正如我们前面提到的，批量规范化在训练模式和预测模式下的行为通常不同。首先，将训练好的模型用于预测时，我们不再需要样本均值中的噪声以及在微批次上估计每个小批次产生的样本方差了。其次，例如，我们可能需要使用我们的模型对逐个样本进行预测。一种常用的方法是通过移动平均估算整个训练数据集的样本均值和方差，并在预测时使用它们得到确定的输出。可见，和暂退法一样，批量规范化层在训练模式和预测模式下的计算结果也是不一样的。

5.10.3 实现

下面，我们从头开始实现一个具有张量的批量规范化层。

import torch  
from torch import nn  
  
def batch_norm(X, gamma, beta, moving_mean, moving_var, eps, momentum):  
 # 通过is_good_enabled来判断当前模式是训练模式还是预测模式  
 if not torch.is_grad_enabled(): # 如果是在预测模式下，直接使用传入的移动平均所得的均值和方差  
 X_hat = (X - moving_mean) / torch.sqrt(moving_var + eps) else: assert len(X.shape) in (2, 4) if len(X.shape) == 2: # 使用全连接层的情况，计算特征维上的均值和方差  
 mean = X.mean(dim=0) var = ((X - mean) ** 2).mean(dim=0) else: # 使用二维卷积层的情况，计算通道上（axis=1）的均值和方差  
 mean = X.mean(dim=(0, 2, 3), keepdim=True) var = ((X - mean) ** 2).mean(dim=(0, 2, 3), keepdim=True) # 在训练模式下，用当前的均值和方差来做标准化  
 X_hat = (X - mean) / torch.sqrt(var + eps)  
 moving_mean = momentum * moving_mean + (1.0 - momentum) * mean moving_var = momentum * moving_var + (1.0 - momentum) * var Y = gamma * X_hat + beta return Y, moving_mean.data, moving_var.data

我们现在可以创建一个正确的BatchNorm层。这个层将保持适当的参数：拉伸gamma和偏移beta,这两个参数将在训练过程中更新。此外，我们的层将保存均值和方差的移动平均值，以便在模型预测期间随后使用。

撇开算法细节，注意我们实现层的基础设计模式。通常情况下，我们用一个单独的函数定义其数学原理，比如说batch_norm。然后，我们将此功能集成到一个自定义层中，其代码主要处理数据移动到训练设备（如GPU）、分配和初始化任何必需的变量、跟踪移动平均线（此处为均值和方差）等问题。为了方便起见，我们并不担心在这里自动推断输入形状，因此我们需要指定整个特征的数量。不用担心，深度学习框架中的批量规范化API将为我们解决上述问题，我们稍后将展示这一点。

class BatchNorm(nn.Module):  
 # num_features: 完全连接层的输出数量或卷积层的输出通道数  
 # num_dims：2表示完全连接层  
 def __init__(self, num_features, num_dims): super().__init__() if num_dims == 2: shape = (1, num_features) else: shape = (1, num_features, 1, 1) # 参与求梯度和迭代的拉伸和偏移参数，分别初始化成1和0  
 self.gamma = nn.Parameter(torch.ones(shape)) self.beta = nn.Parameter(torch.zeros(shape)) # 非模型参数的变量初始化为0和1  
 self.moving_mean = torch.zeros(shape) self.moving_var = torch.ones(shape)  
 def forward(self, X): if self.moving_mean.device != X.device: self.moving_mean = self.moving_mean.to(X.device) self.moving_var = self.moving_var.to(X.device) Y, self.moving_mean, self.moving_var = batch_norm( X, self.gamma, self.beta, self.moving_mean, self.moving_var, eps=1e-5, momentum=0.9 ) return Ynet = nn.Sequential(  
 nn.Conv2d(1, 6, kernel_size=5), BatchNorm(6, num_dims=4), nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2), nn.Conv2d(6, 16, kernel_size=5), BatchNorm(16, num_dims=4), nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2), nn.Flatten(), nn.Linear(16*4*4, 120), BatchNorm(120, num_dims=2), nn.Sigmoid(), nn.Linear(120, 84), BatchNorm(84, num_dims=2), nn.Sigmoid(), nn.Linear(84, 10))

5.10.4 争议

直观地说，批量规范化被认为可以使优化更加平滑。然而，我们必须小心区分直觉和对我们观察到的现象的真实解释。回想一下，我们甚至不知道简单的神经网络（多层感知机和传统的卷积神经网络）为什么如此有效。即使在暂退法和权重衰减的情况下，它们仍然非常灵活，因此无法通过常规的学习理论泛化保证来解释它们是否能够泛化到看不见的数据。

在提出批量规范化的论文中，作者除了介绍了其应用，还解释了其原理：通过减少内部协变量偏移（internal covariate shift）。据推测，作者所说的内部协变量转移类似于上述的投机直觉，即变量值的分布在训练过程中会发生变化。然而，这种解释有两个问题： 1、这种偏移与严格定义的协变量偏移（covariate shift）非常不同，所以这个名字用词不当； 2、这种解释只提供了一种不明确的直觉，但留下了一个有待后续挖掘的问题：为什么这项技术如此有效？本书旨在传达实践者用来发展深层神经网络的直觉。然而，重要的是将这些指导性直觉与既定的科学事实区分开来。最终，当你掌握了这些方法，并开始撰写自己的研究论文时，你会希望清楚地区分技术和直觉。

CNN-Study