卷积神经网络（LeNet）

LeNet 的简化版

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)
)

深层卷积神经网络（AlexNet）

从LeNet（左）到AlexNet（右）

net = nn.Sequential(
    # 这里使用一个11*11的更大窗口来捕捉对象。
    # 同时，步幅为4，以减少输出的高度和宽度。
    # 另外，输出通道的数目远大于LeNet
    nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    # 减小卷积窗口，使用填充为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(),
    # 这里，全连接层的输出数量是LeNet中的好几倍。使用dropout层来减轻过拟合
    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, 1000)
)

改进：

1. dropOut层 - 不改变期望但是改变方差
2. ReLU层 - 减缓梯度消失
3. MaxPooling
4. 数据集数据增强

使用块的网络（VGG）

从AlexNet到VGG，它们本质上都是块设计。

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)

网络中的网络（NiN)

对比 VGG 和 NiN 及它们的块之间主要架构差异

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()
        )

减少参数

含并行连结的网络（GoogLeNet）

Inception块的架构

class Inception(nn.Block):
    # c1--c4是每条路径的输出通道数
    def __init__(self, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        # 线路1，单1x1卷积层
        self.p1_1 = nn.Conv2D(c1, kernel_size=1, activation='relu')
        # 线路2，1x1卷积层后接3x3卷积层
        self.p2_1 = nn.Conv2D(c2[0], kernel_size=1, activation='relu')
        self.p2_2 = nn.Conv2D(c2[1], kernel_size=3, padding=1,
                              activation='relu')
        # 线路3，1x1卷积层后接5x5卷积层
        self.p3_1 = nn.Conv2D(c3[0], kernel_size=1, activation='relu')
        self.p3_2 = nn.Conv2D(c3[1], kernel_size=5, padding=2,
                              activation='relu')
        # 线路4，3x3最大汇聚层后接1x1卷积层
        self.p4_1 = nn.MaxPool2D(pool_size=3, strides=1, padding=1)
        self.p4_2 = nn.Conv2D(c4, kernel_size=1, activation='relu')

    def forward(self, x):
        p1 = self.p1_1(x)
        p2 = self.p2_2(self.p2_1(x))
        p3 = self.p3_2(self.p3_1(x))
        p4 = self.p4_2(self.p4_1(x))
        # 在通道维度上连结输出
        return np.concatenate((p1, p2, p3, p4), axis=1)

GoogLeNet架构

	参数（M）	浮点运算（MFlops）
inception	0.16	128
3 * 3 Conv	0.44	346
5 * 5 Conv	1.22	963

模型小 参数少 结构复杂（代码多）

V2 + BN -> V3 换卷积 -> V4 加入残差

批量规范化（BN）

$\mathrm{BN}(\mathbf{x})=\mathbf{\gamma }\odot \frac{\mathbf{x}-{\hat{\mathbf{\mu }}}_{\mathcal{B}}}{{\hat{\mathbf{\sigma }}}_{\mathcal{B}}}+\mathbf{\beta }.$

因此我们通常包含 拉伸参数（scale）$\mathbf{\gamma }$
和偏移参数（shift）$\mathbf{\beta }$，它们的形状与相同。

请注意，$\mathbf{\gamma }$和$\mathbf{\beta }$是需要与其他模型参数一起学习的参数。

我们在方差估计值中添加一个小的常量$ϵ>0$
，以确保我们永远不会尝试除以零，即使在经验方差估计值可能消失的情况下也是如此。

估计值${\hat{\mathbf{\mu }}}_{\mathcal{B}}$和${\hat{\mathbf{\sigma }}}_{\mathcal{B}}$
通过使用平均值和方差的噪声（noise）估计来抵消缩放问题。 乍看起来，这种噪声是一个问题，而事实上它是有益的。

出现背景：backward时深层训练较快（深层语义），而浅层收敛慢（简单纹理）

思想：让每一层尽量服从同一分布，线性变换，使模型比较稳定

	作用	作用在
全连接	特征维	激活函数前	mean = X.mean(axis=0)
卷积层	通道维	激活函数前	mean = X.mean(axis=(0, 2, 3), keepdims=True)

只能加速收敛不能够增强精度

预测过程中的批量规范化

残差网络（ResNet）

对于非嵌套函数类，较复杂（由较大区域表示）的函数类不能保证更接近“真”函数（$f^*$）。这种现象在嵌套函数类中不会发生。 一个正常块（左图）和一个残差块（右图） 防止网络退化

class Residual(nn.Module):
    def __init__(self, input_channels, num_channels,
                 use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels,
                               kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels,
                               kernel_size=3, padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels,
                                   kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)

包含以及不包含1 * 1卷积层的残差块。

稠密连接网络（DenseNet）Dense-全连接

泰勒公式 $f(x)=f(0)+f^{\prime }(0)x+\frac{f^{\prime \prime }(0)}{2!}{x}^2+\frac{f^{\prime \prime \prime }(0)}{3!}{x}^3+\dots .$

ResNet$f(\mathbf{x})=\mathbf{x}+g(\mathbf{x}).$

ResNet（左）与 DenseNet（右）在跨层连接上的主要区别：使用相加和使用连结

$\mathbf{x}\to \left[\mathbf{x},f_1(\mathbf{x}),f_2([\mathbf{x},f_1(\mathbf{x})]),f_3([\mathbf{x},f_1(\mathbf{x}),f_2([\mathbf{x},f_1(\mathbf{x})])]),\dots \right].$

稠密连接