梯度衰减
添加神经网络的隐藏层，模型可以处理更加复杂的分类函数，但是随着网络的层数越深，可能会有梯度衰减等问题使得模型的性能大幅度的下降。
那么什么是梯度衰减呢？
累乘中一个梯度小于1，那么不断累乘，这个值会越来越小，梯度衰减很大，迅速接近0。在神经网络中是离输出层近的参数，梯度越大，远的参数，梯度越接近0。其根本原因是sigmoid函数的缺陷。
残差神经网络
基本思想
对于卷积神经网络来说，每一层在通过卷积核之后都会产生类似有损压缩的效果。但是有损压缩到一定程度之后，分不清楚原本清晰可辨的两张照片。
在工程上我们称之为降采样，就是在向量通过网络的过程中经过一些滤波器（filters）的处理，产生的效果就是让输入向量在通过降采样处理后具有更小的尺寸，在卷积网络中常见的就是卷积层和池化层，这两者都可以充当降采样的功能属性。主要目的是为了避免过拟合，以及有一定的减少运算量的副作用。
为了避免过度的有损压缩，我们将前面层较为“清晰”的向量数据会和后面被进一步“有损压缩”过的数据共同作为后面的数据的输入。
特点
- 网络较瘦，控制了参数数量
- 存在明显层级，特征图个数逐层递进，保证输出特征表达能力
- 使用了较少的池化层，大量使用降采样，提高传播效率
- 没有使用Dropout，利用BN和全局平均池化进行正则化，加快了训练速度
推导
在前向传播中，残差输出表达式是某一层的输入xl和F(x)的累加，而普通神经网络的表达式是一个累乘表达式。
在反向传播中，残差网络的梯度是累加而传统网络的梯度是累乘，也就是累乘造成了不可避免地梯度消失，因此残差网络可以说避免了梯度消失的根源。
代码实现
导入相应的包
import time
import torch
from torch import nn, optim
import torch.nn.functional as F
import sys
# 是否有符合条件的GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')定义残差结构单元
class Residual(nn.Module):
def __init__(self, in_channels, out_channels, use_1x1conv=False, stride=1):
super(Residual, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, stride=stride)
self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
if use_1x1conv:
self.conv3 = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride)
else:
self.conv3 = None
self.bn1 = nn.BatchNorm2d(out_channels)
self.bn2 = nn.BatchNorm2d(out_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)
return F.relu(Y + X)看看输入和输出是否一致
blk = Residual(3, 3)
X = torch.rand((4, 3, 6, 6))
blk(X).shape # torch.Size([4, 3, 6, 6])也可以在增加输出通道数的同时减半输出的高和宽
blk = Residual(3, 6, use_1x1conv=True, stride=2)
blk(X).shape # torch.Size([4, 6, 3, 3])ResNet则使用4个由残差块组成的模块，每个模块使用若干个同样输出通道数的残差块，第一个模块的通道数同输入通道数一致。由于之前已经使用了步幅为2的最大池化层，所以无须减小高和宽。之后的每个模块在第一个残差块里将上一个模块的通道数翻倍，并将高和宽减半。模块实现如下：
def resnet_block(in_channels, out_channels, num_residuals, first_block=False):
if first_block:
assert in_channels == out_channels # 第一个模块的通道数同输入通道数一致
blk = []
for i in range(num_residuals):
if i == 0 and not first_block:
blk.append(Residual(in_channels, out_channels, use_1x1conv=True, stride=2))
else:
blk.append(Residual(out_channels, out_channels))
return nn.Sequential(*blk)搭建ResNet网络
# 主干网络
net = nn.Sequential(
nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
# 添加4个模块，这里每个模块使用两个残差块
net.add_module("resnet_block1", resnet_block(64, 64, 2, first_block=True))
net.add_module("resnet_block2", resnet_block(64, 128, 2))
net.add_module("resnet_block3", resnet_block(128, 256, 2))
net.add_module("resnet_block4", resnet_block(256, 512, 2))
# 加入全局平均池化层后接上全连接层输出
net.add_module("global_avg_pool", d2l.GlobalAvgPool2d()) # GlobalAvgPool2d的输出: (Batch, 512, 1, 1)
net.add_module("fc", nn.Sequential(d2l.FlattenLayer(), nn.Linear(512, 10)))这里每个模块里有4个卷积层（不计算1×11×1卷积层），加上最开始的卷积层和最后的全连接层，共计18层。这个模型通常也被称为ResNet-18。
我们使用数据，观察一下每个层的输出：
X = torch.rand((1, 1, 224, 224))
for name, layer in net.named_children():
X = layer(X)
print(name, ' output shape:\t', X.shape)输出结果：
0 output shape: torch.Size([1, 64, 112, 112])
1 output shape: torch.Size([1, 64, 112, 112])
2 output shape: torch.Size([1, 64, 112, 112])
3 output shape: torch.Size([1, 64, 56, 56])
resnet_block1 output shape: torch.Size([1, 64, 56, 56])
resnet_block2 output shape: torch.Size([1, 128, 28, 28])
resnet_block3 output shape: torch.Size([1, 256, 14, 14])
resnet_block4 output shape: torch.Size([1, 512, 7, 7])
global_avg_pool output shape: torch.Size([1, 512, 1, 1])
fc output shape: torch.Size([1, 10])
