1.ResNet解决什么问题？
网络的层数越多，意味着能够提取到不同level的特征越丰富。并且，越深的网络提取的特征越抽象，越具有语义信息，但并不是深度越深越好，如果简单地增加深度，会导致梯度弥散或梯度爆炸，虽然可通过正则化初始化和中间的正则化层解决，但是又会出现另一个问题，就是退化问题，网络层数增加但是在训练集上的准确率却饱和甚至下降了。这个不能解释为过拟合（overfitting），因为overfit应该表现为在训练集上表现更好才对
退化问题说明了深度网络不能很简单地被很好地优化
这是因为虽然深层网络的解空间虽然包含了浅层网络的解空间，但是我们在训练网络用的是随机梯度下降策略，往往解到的不是全局最优解，而是局部的最优解，显而易见深层网络的解空间更加的复杂，所以导致使用随机梯度下降算法无法解到最优解
为了解决这个问题提出ResNet
随着网络深度的不断增大，所引入的激活函数也越来越多，数据被映射到更加离散的空间，此时已经难以让数据回到原点（恒等变换）。或者说，神经网络将这些数据映射回原点所需要的计算量，已经远远超过我们所能承受。
2.ResNet核心——残差块
残差的思想都是去掉相同的主体部分，从而突出微小的变化，可粗略理解为差分放大器
通过建立前面层与后面层之间的“短路连接”（shortcuts，skip connection）提升训练过程中梯度的反向传播，从而训练出更深的CNN网络
如果深层网络的后面那些层是恒等映射，那么模型就退化为一个浅层网络
通过残差函数去学习恒等映射函数来实现：令F(x) = H(x) - x. 只要F(x)=0，就构成了一个恒等映射H(x) = x
构成：
前向神经网络+shortcut（抄近路）连接
shortcut连接相当于简单执行了同等映射，不会产生额外的参数，也不会增加计算复杂度。 而且，整个网络可以依旧通过端到端的反向传播训练
如果网络已经到达最优，继续加深网络，residual mapping将被push为0，只剩下identity mapping，这样理论上网络一直处于最优状态了，网络的性能也就不会随着深度增加而降低了
引入残差后的映射对输出的变化更敏感，对权重的调整作用更大，所以效果更好
比如把5映射到5.1，那么引入残差前是F’(5)=5.1，引入残差后是H(5)=5.1, H(5)=F(5)+5, F(5)=0.1，s输出从5.1变到5.2，映射F’的输出增加了1/51=2%，而对于残差结构输出从5.1到5.2，映射F是从0.1到0.2，增加了100%
3.设计网络的规则：
- 对于输出feature map大小相同的层，有相同数量的filters，即channel数相同；
- 当feature map大小减半时（池化），filters数量翻倍。
- 对于残差网络，维度匹配的shortcut连接为实线，反之为虚线。维度不匹配时，同等映射有两种可选方案：
- 直接通过zero padding 来增加维度（channel）。
- 投影法（推荐）：乘以W矩阵投影到新的空间。实现是用1x1卷积实现的，直接改变1x1卷积的filters数目。这种会增加参数。
普通的网络与深度残差网络的最大区别在于：
深度残差网络有很多旁路的支线将输入直接连到后面的层，使得后面的层可以直接学习残差，这些支路就叫做shortcut。传统的卷积层或全连接层在信息传递时，或多或少会存在信息丢失、损耗等问题。ResNet 在某种程度上解决了这个问题，通过直接将输入信息绕道传到输出，保护信息的完整性，整个网络则只需要学习输入、输出差别的那一部分，简化学习目标和难度。
4.代码实现resnet18
import torch
from torch import nn, optim
import torchvision
import sys
from time import time
import torch.nn.functional as F
device = torch.device('cuda:1' 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__()
# 3x3搭配1步长，特征图大小不变
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)
# ResNet模型前两层跟GoogLeNet中的一样
net = nn.Sequential(
nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
nn.BatchNorm2d(64), #与GoogLeNet不同之处
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
)
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.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))
class GlobalAvgPool2d(nn.Module):
# 全局平均池化层可通过将池化窗口形状设置成输入的高和宽实现
def __init__(self):
super(GlobalAvgPool2d, self).__init__()
def forward(self, x):
return F.avg_pool2d(x, kernel_size=x.size()[2:])
class GlobalAvgPool2d(nn.Module):
# 全局平均池化层可通过将池化窗口形状设置成输入的高和宽实现
def __init__(self):
super(GlobalAvgPool2d, self).__init__()
def forward(self, x):
return F.avg_pool2d(x, kernel_size=x.size()[2:])
'''对 x 的形状转换 '''
class FlattenLayer(nn.Module):
def __init__(self):
super(FlattenLayer, self).__init__()
def forward(self, x):
return x.view(x.shape[0], -1)
'''加入全局平均池化层和全连接层输出'''
net.add_module('global_avg_pool', GlobalAvgPool2d())
net.add_module('fc', nn.Sequential(FlattenLayer(),nn.Linear(512, 10)))
# 查看模型
X = torch.rand((1, 1, 224, 224))
for name, layer in net.named_children():
X = layer(X)
print(name, ' output shape:\t', X.shape)
定义模型
def resnet18(output=10, in_channels=3):
net = nn.Sequential(
nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
nn.BatchNorm2d(64), #与GoogLeNet不同之处
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
'''为ResNet加入所有残差块'''
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', GlobalAvgPool2d())
net.add_module('fc', nn.Sequential(FlattenLayer(),nn.Linear(512, 10)))
return net读取数据集
'''读取数据集'''
def load_data_fashion_mnist(batch_size, resize=None):
if sys.platform.startswith('win'):
num_workers = 0 # 0表示不用额外的进程来加速读取数据
else:
num_workers = 4
'''定义数据预处理的转换函数列表'''
trans = []
if resize: #判断是否需要进行图像尺寸调整（resize）
trans.append(torchvision.transforms.Resize(size=resize))
#将torchvision.transforms.Resize转换函数添加到转换函数列表trans中，并指定目标尺寸为resize
trans.append(torchvision.transforms.ToTensor())
# 将torchvision.transforms.ToTensor转换函数添加到转换函数列表trans中。这个函数用于将图像数据转换为张量，并且按照通道顺序排列（RGB）
transform = torchvision.transforms.Compose(trans)
#通过torchvision.transforms.Compose函数将转换函数列表trans组合成一个转换操作
mnist_train = torchvision.datasets.FashionMNIST(root='data/FashionMNIST',
train=True,
download=True,
transform=transform)
mnist_test = torchvision.datasets.FashionMNIST(root='data/FashionMNIST',
train=False,
download=True,
transform=transform)
train_iter = torch.utils.data.DataLoader(mnist_train,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers)
test_iter = torch.utils.data.DataLoader(mnist_train,
batch_size=batch_size,
shuffle=False,
num_workers=num_workers)
return train_iter, test_iter定义模型训练函数
'''用于GPU的准确率评估函数'''
def evaluate_accuracy(data_iter, net, device=None):
if device is None and isinstance(net, torch.nn.Module):
device = list(net.parameters())[0].device #如果没指定device就使用net的device
acc_sum, n = 0.0, 0
for X, y in data_iter:
if isinstance(net, torch.nn.Module):
net.eval（) # 评估模式, 这会关闭dropout
acc_sum += (net(X.to(device)).argmax(dim=1) == y.to(device)).float().sum().cpu().item()
net.train() # 改回训练模式
else:
if ('is_training' in net.__code__.co_varnames):
acc_sum += (net(X, is_training=False).argmax(dim=1) == y).float().sum().item()
else:
acc_sum += (net(X).argmax(dim=1) == y).float().sum().item()
n += y.shape[0]
return acc_sum / n
'''确保计算使用的数据和模型同在内存或显存上'''
def train_ch5(net, train_iter, test_iter, batch_size, optimizer , device, num_epochs):
# 将模型加载到指定运算器中
net = net.to(device)
print("training on ", device)
loss = torch.nn.CrossEntropyLoss()
for epoch in range(num_epochs):
# 在每一个迭代周期中，会使用训练集中所有样本一次（假设样本数能够被批量大小整除）
train_l_sum, train_acc_sum, n ,batch_count= 0.0, 0.0, 0,0
# 分别表示训练损失总和、训练准确度总和、样本数
start = time()
for X, y in train_iter:
X = X.to(device)
y = y.to(device)
'''前向传播'''
y_hat = net(X)
#由于变量 l 并不是一个标量，所以我们可以调用 .sum() 将其求和得到一个标量
'''计算损失'''
l = loss(y_hat, y).sum()
'''梯度清零'''
if optimizer is not None:
optimizer.zero_grad()
elif params is not None and params[0].grad is not None:
for param in params:
param.grad.data.zero_()
'''反向传播'''
l.backward() # 运行 l.backward() 得到该变量有关模型参数的梯度
if optimizer is None:
d2l.sgd(params, lr, batch_size)
else:
'''更新参数'''
optimizer.step()
'''计算精度'''
train_l_sum += l.cpu().item()
train_acc_sum += (y_hat.argmax(dim=1) == y).sum().cpu().item()
n += y.shape[0]
batch_count += 1
test_acc = evaluate_accuracy(test_iter, net)
print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f,\
time %.1f sec' %(epoch+1, train_l_sum/batch_count,
train_acc_sum/n, test_acc,
time()-start))训练模型
'''使用fashion_mnist来训练ResNet模型'''
batch_size = 256
train_iter, test_iter = load_data_fashion_mnist(batch_size)
lr, num_epochs = 0.001, 5
optimizer = torch.optim.Adam(net.parameters(), lr=lr)
train_ch5(net, train_iter, test_iter, batch_size, optimizer,device, num_epochs)
完结！昨天差了一篇，今天补上
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
