参考：
- d2l
x.1 AlexNet
研究人员认为：
- 更大更干净的数据集或是稍加改进的特征提取方法，比任何学习算法带来的进步大得多。
- 认为特征本身应该被学习，即卷积核参数应该是可学习的。
- 创新点在于GPU与更深的网络，使用ReLU激活函数，Dropout层。
可参考：
AlexNet https://blog.csdn.net/qq_43369406/article/details/127295070
CODE::AlexNet_model https://blog.csdn.net/qq_43369406/article/details/129171352
x.2 VGG
VGG引入了自定义层，能够更加快速定义层结构。VGG亮点在于，通过堆叠多个3x3卷积核来代替大尺度卷积核，以此达到减少所需参数的目的。虽然减少了参数但是具有相同的感受野。
可参考：
- VGG 网络介绍
https://blog.csdn.net/qq_43369406/article/details/127485929 - CODE::VGG16_model
https://blog.csdn.net/qq_43369406/article/details/129174640
x.3 NiN
最后一层如果使用全连接层会放弃表征的空间结构，所以使用全卷积代替。
x.4 GoogLeNet
GoogLeNet最大的特点在于解决了多大的卷积核最适合的问题，因为以前流行的网络使用小到1x1，大到11x11的卷积核，Inception模块使用了4条并行的路径，这种Inception的输出图中height和width相同而channel不同，最终在channel方向上进行了concat短接，结构如下：
我们注意到在数字图像处理中常常使用各种尺寸的滤波器探索图像，这意味着不同尺寸的滤波器可以有效地识别不同范围的图像细节。还使用了辅助分类器，1x1卷积核降维。
参考：
- GoogLeNet 网络简介
https://blog.csdn.net/qq_43369406/article/details/127608423 - CODE::GoogLeNet_model
https://blog.csdn.net/qq_43369406/article/details/129189694
x.5 ResNet
x.5.1 BatchNormalization
BN作为现代深度学习中浓墨重彩的一笔，它的出现能够可持续加速深层网络的收敛。回顾神经网络碰到的挑战如下：
- 数据预处理方式会对最终结果产生巨大影响。第一步是规范化输入特征，使得全部输入特征 ~ N (0, 1)
- 在中间隐藏层中，如果一个层的可变值是另一层的100倍，这种变量分布中的偏移会阻碍网络的收敛。通过中间隐藏层后的数据难以控制，需要BN归一化。
- 更深层的网络复杂，容易过拟合，意味着正则化更加重要。如L2正则化，在loss中增加weight decay，通过Adam可简易实现。
在BN层中，每一个通道的数据具有四个参数，其中miu和sigma并不是learnable parameters，并不会出现在model.parameters()中；而scale parameter - lambda和shift parameter - beta是learnable parameters可学习参数，会参加梯度计算，如下：
而miu和sigma便是mini-batch小批量样本的均值和方差，
需要注意到的是BN层具有自己的处理顺序，如：Linear-BN-Activation或者Conv-BN-Act
BN同Dropout在model.eval()时候会失去活性，
建议参看BN代码实现如下：
"""
1. BN
"""
def batch_norm(X, gamma, beta, moving_mean, moving_var, eps, momentum):
# Use is_grad_enabled to determine whether we are in training mode
if not torch.is_grad_enabled():
# In prediction mode, use mean and variance obtained by moving average
X_hat = (X - moving_mean) / torch.sqrt(moving_var + eps)
else:
assert len(X.shape) in (2, 4)
if len(X.shape) == 2:
# When using a fully connected layer, calculate the mean and
# variance on the feature dimension
mean = X.mean(dim=0)
var = ((X - mean) ** 2).mean(dim=0)
else:
# When using a two-dimensional convolutional layer, calculate the
# mean and variance on the channel dimension (axis=1). Here we
# need to maintain the shape of X, so that the broadcasting
# operation can be carried out later
mean = X.mean(dim=(0, 2, 3), keepdim=True)
var = ((X - mean) ** 2).mean(dim=(0, 2, 3), keepdim=True)
# In training mode, the current mean and variance are used
X_hat = (X - mean) / torch.sqrt(var + eps)
# Update the mean and variance using moving average
moving_mean = (1.0 - momentum) * moving_mean + momentum * mean
moving_var = (1.0 - momentum) * moving_var + momentum * var
Y = gamma * X_hat + beta # Scale and shift
return Y, moving_mean.data, moving_var.data
class BatchNorm(nn.Module):
# num_features: the number of outputs for a fully connected layer or the
# number of output channels for a convolutional layer. num_dims: 2 for a
# fully connected layer and 4 for a convolutional layer
def __init__(self, num_features, num_dims):
super().__init__()
if num_dims == 2:
shape = (1, num_features)
else:
shape = (1, num_features, 1, 1)
# The scale parameter and the shift parameter (model parameters) are
# initialized to 1 and 0, respectively
self.gamma = nn.Parameter(torch.ones(shape))
self.beta = nn.Parameter(torch.zeros(shape))
# The variables that are not model parameters are initialized to 0 and
# 1
self.moving_mean = torch.zeros(shape)
self.moving_var = torch.ones(shape)
def forward(self, X):
# If X is not on the main memory, copy moving_mean and moving_var to
# the device where X is located
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)
# Save the updated moving_mean and moving_var
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.1)
return Y
# test
temp_builtin = [i for i in torch.nn.BatchNorm2d(4).parameters()]
temp_diy = [i for i in BatchNorm(num_features=4, num_dims=4).parameters()]
# self.moving_mean() and var is not nn.Parameters(), not learnable.
"""
2. LeNet
"""
class BNLeNetScratch(d2l.Classifier):
def __init__(self, lr=0.1, num_classes=10):
super().__init__()
self.save_hyperparameters()
self.net = nn.Sequential(
nn.LazyConv2d(6, kernel_size=5), BatchNorm(6, num_dims=4),
nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2),
nn.LazyConv2d(16, kernel_size=5), BatchNorm(16, num_dims=4),
nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2),
nn.Flatten(), nn.LazyLinear(120),
BatchNorm(120, num_dims=2), nn.Sigmoid(), nn.LazyLinear(84),
BatchNorm(84, num_dims=2), nn.Sigmoid(),
nn.LazyLinear(num_classes))
trainer = d2l.Trainer(max_epochs=10, num_gpus=1)
data = d2l.FashionMNIST(batch_size=128)
model = BNLeNetScratch(lr=0.1)
model.apply_init([next(iter(data.get_dataloader(True)))[0]], d2l.init_cnn) # 因为使用了Lazy init所以要先forward一个Tensor初始化模型
trainer.fit(model, data)
# learnable gamma and beta
print(model.net[1].gamma.reshape((-1,)), model.net[1].beta.reshape((-1,)))
x.5.2 ResNet
随着网络的层数加深，深刻理解新添加的层如何提升神经网络的性能变得至关重要，给定X个特征，y个标签的数据集，我们需要使得f尽量拟合f星，如下：
而为了更接近f星，我们需要尽量使用类似右侧的嵌套函数，复杂度从F1到F6依次增加。
将较复杂的函数类包含较小的函数类这一思想引入，我们得到残差网络核心思想：每个附加层都应该更容易地包含原始函数作为其元素之一。
ResNet的两点在于引入了BN和残差模块，加深了网络深度，如下：
参考：
- ResNet 简介
https://blog.csdn.net/qq_43369406/article/details/127500443 - ResNet 代码实现
https://blog.csdn.net/qq_43369406/article/details/127508108 - CODE::ResNet_model
https://blog.csdn.net/qq_43369406/article/details/129190380
x.6 DenseNet
将ResNet更改为联系前面多层，并使用Concat拼接。
x.7 Designing Convolution Network Architectures
从AlexNet到ResNet，SENet由于加入了位置信息和注意力机制，是Transformers的前身。
NAS的大展身手的诞生了EfficientNets。
手工设计和NAS的结合诞生出了RegNets。
为了设置拟合能力更强的网络，应该使用更深的（channel更大）网络。