深度学习网络——resnet
- 导入包
- 定义常用卷积
- 两层残差块的实现
- 三层残差块的实现
- 整个网络的实现
- 不同网络层的实现
导入包
导入需要使用的包，并声明可用的网络和预训练好的模型
# -*- coding:UTF-8 -*-
# import torch
# import torchvision
#
# net = torchvision.models.resnet18()
# print(net)
import torch.nn as nn
import torch.utils.model_zoo as model_zoo
# __all__ 用法：
# 1、模块中不使用__all__属性，则导入模块内的所有公有属性，方法和类。
# 2、模块中使用__all__属性，则表示只导入__all__中指定的属性，因此，使用__all__可以隐藏不想被import的默认值。
# 3、__all__变量是一个由string元素组成的list变量。
# 4、它定义了当我们使用 from <module> import * 导入某个模块的时候能导出的符号（这里代表变量，函数，类等）。
# 5、from <module> import * 默认的行为是从给定的命名空间导出所有的符号（当然下划线开头的变量，方法和类除外）。
# 6、需要注意的是 __all__ 只影响到了 from <module> import * 这种导入方式，
# 7、对于 from <module> import <member> 导入方式并没有影响，仍然可以从外部导入。
# 六种不同的网络架构
__all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
'resnet152']
# 每一种架构下都有训练好的可以用的参数文件
model_urls = {
'resnet18': 'https://download.pytorch.org/models/resnet18-5c106cde.pth',
'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
}定义常用卷积
定义要使用到的1x1和3x3的卷积层
# 常见的 3x3 卷积
def conv3x3(in_planes, out_planes, stride=1):
"""3x3 convolution with padding"""
# class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)
# in_channels (int): 输入图片的通道数
# out_channels (int): 卷积产生的通道数
# kernel_size (int or tuple): 卷积内核的大小
# stride (int or tuple, optional): 卷积步长. Default: 1
# padding (int or tuple, optional): 添加到输入两侧的零填充. Default: 0
# dilation (int or tuple, optional): 卷积核元素之间的间距. Default: 1
# groups (int, optional): 从输入通道到输出通道的阻塞连接数. Default: 1
# bias (bool, optional): 如果 bias=True，添加偏置. Default: ``True``
return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
padding=1, bias=False)
# 常见的 1x1 卷积
def conv1x1(in_planes, out_planes, stride=1):
"""1x1 convolution"""
return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)两层残差块的实现
这个实现的是两层的残差块，用于 resnet18/34，比如：
# BasicBlock，基本的 residual block
class BasicBlock(nn.Module):
# 每个 Residual Block 中的输出通道数相对于输入通道数的放大倍数，具体可查看论文中的图和表
expansion = 1
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(BasicBlock, self).__init__()
# 二维卷积层
self.conv1 = conv3x3(inplanes, planes, stride)
# 批正则化，数据归一化处理，使得数据在进行 relu 之前不会因为数据过大而导致网络性能的不稳定
# y = (x - mean[x]) * gamma / (sqrt([x]) + eps) + beta
# class torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True)
# num_features： 来自期望输入的特征数，该期望输入的大小为'batch_size x num_features x height x width'
# eps： 为保证数值稳定性（分母不能趋近或取0）,给分母加上的值。默认为1e-5。
# momentum： 动态均值和动态方差所使用的动量。默认为0.1。
# affine： 一个布尔值，当设为true，给该层添加可学习的仿射变换参数。
# Shape： - 输入：（N, C，H, W) - 输出：（N, C, H, W）（输入输出相同）
self.bn1 = nn.BatchNorm2d(planes)
# inplace 为 True，即为原地操作，将会改变输入的数据，否则不会改变原输入，只会产生新的输出
# 计算结果不会有影响。利用in-place计算可以节省内（显）存，同时还可以省去反复申请和释放内存的时间。但是会对原变量覆盖，只要不带来错误就用。
self.relu = nn.ReLU(inplace=True)
self.conv2 = conv3x3(planes, planes)
self.bn2 = nn.BatchNorm2d(planes)
self.downsample = downsample
self.stride = stride
# 构造前向传播基本残差模块
def forward(self, x):
# 右侧曲线部分，identity mapping 指的就是本身的映射，也就是 x 自身
identity = x
# residual mapping，即残差映射部分
# 第一层卷积
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
# 第二层卷积
out = self.conv2(out)
out = self.bn2(out)
# 下采样
# 若为空，即实线部分，跳跃连接为“实线”，指的是 identity mapping 和 residual mapping 通道数相同。
# 若不为空，即虚线部分，跳跃连接为“虚线”，指的是两者通道数不同，需要使用1x1卷积调整通道维度，使其可以相加。
# 即通道数相同直接相加，不同则需经过下采样后再相加
if self.downsample is not None:
identity = self.downsample(x)
# identity mapping 部分与 residual mapping 相加
out += identity
# 经过 relu 后再输出
out = self.relu(out)
return out三层残差块的实现
这个实现的是三层的残差块，用于 resnet50/101/152，比如：
# Bottleneck，针对深层网络提出的 block
class Bottleneck(nn.Module):
# 输出通道数相对于输入通道数的放大倍数，具体可查看论文中的图和表
expansion = 4
def __init__(self, inplanes, planes, stride=1, downsample=None):
super(Bottleneck, self).__init__()
self.conv1 = conv1x1(inplanes, planes)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = conv3x3(planes, planes, stride)
self.bn2 = nn.BatchNorm2d(planes)
# 第三层卷积输出层扩大了 expansion 倍
self.conv3 = conv1x1(planes, planes * self.expansion)
self.bn3 = nn.BatchNorm2d(planes * self.expansion)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def forward(self, x):
# 右侧曲线部分，identity mapping 指的就是本身的映射，也就是 x 自身
identity = x
# residual mapping，即残差映射部分
# 第一层卷积
out = self.conv1(x)
out = self.bn1(out)
out = self.relu(out)
# 第二层卷积
out = self.conv2(out)
out = self.bn2(out)
out = self.relu(out)
# 第三层卷积
out = self.conv3(out)
out = self.bn3(out)
# 下采样
# 若为空，即实线部分，跳跃连接为“实线”，指的是 identity mapping 和 residual mapping 通道数相同。
# 若不为空，即虚线部分，跳跃连接为“虚线”，指的是两者通道数不同，需要使用1x1卷积调整通道维度，使其可以相加。
# 即通道数相同直接相加，不同则需经过下采样后再相加
if self.downsample is not None:
identity = self.downsample(x)
# identity mapping 部分与 residual mapping 相加
out += identity
# 经过 relu 后再输出
out = self.relu(out)
return out整个网络的实现
# ResNet 类根据列表大小来构建不同深度的 resnet 网络架构
# resnet一共有 5 个阶段
# 第一阶段是一个7x7的卷积，stride=2
# 第二阶段，经过池化层，得到的特征图大小变为原图的1/4。
# 第三阶段，使用_make_layer()函数用来产生 4 个 layer，即 4 个大块，可以根据输入的 layers 列表来创建小块
# 第四阶段，平均池化
# 第五阶段，1000-d 输出分类结果
class ResNet(nn.Module):
# block：指明残差块是两层或三层
# layers：指明每个卷积层需要的残差块数量
# num_classes：指明分类数
# zero_init_residual：是否初始化为0
def __init__(self, block, layers, num_classes=1000, zero_init_residual=False):
super(ResNet, self).__init__()
# 输入层通道数
self.inplanes = 64
self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
# 输入层随层数逐渐翻倍
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(512 * block.expansion, num_classes)
# 各层权重初始化
for m in self.modules():
# 卷积层使用 kaiming 初始化
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
# 批正则化层使用常数初始化
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
# Zero-initialize the last BN in each residual branch,
# so that the residual branch starts with zeros, and each residual block behaves like an identity.
# This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
# 零初始化每个剩余分支中的最后一个 BN
# 以便残差分支以零开头，并且每个残差块的行为类似于标识。
if zero_init_residual:
for m in self.modules():
if isinstance(m, Bottleneck):
nn.init.constant_(m.bn3.weight, 0)
elif isinstance(m, BasicBlock):
nn.init.constant_(m.bn2.weight, 0)
# 生成一个基本的大块，由多个基本的小块组成
# _make_layer()函数用来产生 4 个 layer，可以根据输入的 layers 列表来创建网络。
def _make_layer(self, block, planes, blocks, stride=1):
# 默认不进行下采样
downsample = None
# 步长不为 1，或者虚线部分，需要经过 1x1 的卷积操作，使得 identity mapping 部分与 residual mapping 尺寸大小相同，能够相加
if stride != 1 or self.inplanes != planes * block.expansion:
downsample = nn.Sequential(
conv1x1(self.inplanes, planes * block.expansion, stride),
nn.BatchNorm2d(planes * block.expansion),
)
# 开始生成相同的小块
# 层列表
layers = []
# 每个大块的第一个小块的输入与输出的通道数不同，需要下采样，即图中的虚线部分
# 生成大块的第一块小块，输入为是上一个大块的输出
# 比如 101-layer
# 第一个大块的第一个小块输入为 64，且所有第一个大块都是默认 64 层
layers.append(block(self.inplanes, planes, stride, downsample))
# 根据 layers 列表生成大块的余下小块，此时的小块的输入与输出通道数是相同的，即图中的实线部分，无需进行下采样了
# 接下来剩余要生成的小块的输入为上一个小块的输出
self.inplanes = planes * block.expansion
# 生成剩余相同的小块
for _ in range(1, blocks):
layers.append(block(self.inplanes, planes))
return nn.Sequential(*layers)
def forward(self, x):
# 第一阶段，7x7 卷积
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
# 第二阶段，最大池化
x = self.maxpool(x)
# 第三阶段，构造四个大块
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
# 第四阶段，平均池化
x = self.avgpool(x)
# 第五阶段，类输出
x = x.view(x.size(0), -1)
x = self.fc(x)
return x不同网络层的实现
根据论文中的列表指定大块中的小块数量，从而生成多种不同的 resnet 网络。
# 根据论文中的列表指定大块中的小块数量，从而生成多种不同的 resnet 网络
def resnet18(pretrained=False, **kwargs):
"""Constructs a ResNet-18 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet18']))
return model
def resnet34(pretrained=False, **kwargs):
"""Constructs a ResNet-34 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet34']))
return model
def resnet50(pretrained=False, **kwargs):
"""Constructs a ResNet-50 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet50']))
return model
def resnet101(pretrained=False, **kwargs):
"""Constructs a ResNet-101 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet101']))
return model
def resnet152(pretrained=False, **kwargs):
"""Constructs a ResNet-152 model.
Args:
pretrained (bool): If True, returns a model pre-trained on ImageNet
"""
model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
if pretrained:
model.load_state_dict(model_zoo.load_url(model_urls['resnet152']))
return model
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
