'''
ResNet in PyTorch.
ResNet(深度残差网络)是由微软研究院的Kaiming He等人提出的深度神经网络架构。
主要创新点是引入了残差学习的概念,通过跳跃连接解决了深层网络的退化问题。
主要特点:
1. 引入残差块(Residual Block),使用跳跃连接
2. 使用Batch Normalization进行归一化
3. 支持更深的网络结构(最深可达152层)
4. 在多个计算机视觉任务上取得了突破性进展
Reference:
[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
Deep Residual Learning for Image Recognition. arXiv:1512.03385
'''
import torch
import torch.nn as nn
class BasicBlock(nn.Module):
"""基础残差块
用于ResNet18/34等浅层网络。结构为:
x -> Conv -> BN -> ReLU -> Conv -> BN -> (+) -> ReLU
|------------------------------------------|
Args:
in_channels: 输入通道数
out_channels: 输出通道数
stride: 步长,用于下采样,默认为1
注意:基础模块没有通道压缩,expansion=1
"""
expansion = 1
def __init__(self, in_channels, out_channels, stride=1):
super(BasicBlock,self).__init__()
self.features = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
nn.BatchNorm2d(out_channels),
nn.ReLU(True),
nn.Conv2d(out_channels,out_channels, kernel_size=3, stride=1, padding=1, bias=False),
nn.BatchNorm2d(out_channels)
)
# 如果输入输出维度不等,则使用1x1卷积层来改变维度
self.shortcut = nn.Sequential()
if stride != 1 or in_channels != self.expansion * out_channels:
self.shortcut = nn.Sequential(
nn.Conv2d(in_channels, self.expansion * out_channels, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(self.expansion * out_channels),
)
def forward(self, x):
out = self.features(x)
out += self.shortcut(x)
out = torch.relu(out)
return out
class Bottleneck(nn.Module):
"""瓶颈残差块
用于ResNet50/101/152等深层网络。结构为:
x -> 1x1Conv -> BN -> ReLU -> 3x3Conv -> BN -> ReLU -> 1x1Conv -> BN -> (+) -> ReLU
|-------------------------------------------------------------------|
Args:
in_channels: 输入通道数
zip_channels: 压缩后的通道数
stride: 步长,用于下采样,默认为1
注意:通过1x1卷积先压缩通道数,再还原,expansion=4
"""
expansion = 4
def __init__(self, in_channels, zip_channels, stride=1):
super(Bottleneck, self).__init__()
out_channels = self.expansion * zip_channels
self.features = nn.Sequential(
# 1x1卷积压缩通道
nn.Conv2d(in_channels, zip_channels, kernel_size=1, bias=False),
nn.BatchNorm2d(zip_channels),
nn.ReLU(inplace=True),
# 3x3卷积提取特征
nn.Conv2d(zip_channels, zip_channels, kernel_size=3, stride=stride, padding=1, bias=False),
nn.BatchNorm2d(zip_channels),
nn.ReLU(inplace=True),
# 1x1卷积还原通道
nn.Conv2d(zip_channels, out_channels, kernel_size=1, bias=False),
nn.BatchNorm2d(out_channels)
)
self.shortcut = nn.Sequential()
if stride != 1 or in_channels != out_channels:
self.shortcut = nn.Sequential(
nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(out_channels)
)
def forward(self, x):
out = self.features(x)
out += self.shortcut(x)
out = torch.relu(out)
return out
class ResNet(nn.Module):
"""ResNet模型
网络结构:
1. 一个卷积层用于特征提取
2. 四个残差层,每层包含多个残差块
3. 平均池化和全连接层进行分类
对于CIFAR10,特征图大小变化为:
(32,32,3) -> [Conv] -> (32,32,64) -> [Layer1] -> (32,32,64) -> [Layer2]
-> (16,16,128) -> [Layer3] -> (8,8,256) -> [Layer4] -> (4,4,512) -> [AvgPool]
-> (1,1,512) -> [FC] -> (num_classes)
Args:
block: 残差块类型(BasicBlock或Bottleneck)
num_blocks: 每层残差块数量的列表
num_classes: 分类数量,默认为10
verbose: 是否打印中间特征图大小
init_weights: 是否初始化权重
"""
def __init__(self, block, num_blocks, num_classes=10, verbose=False, init_weights=True):
super(ResNet, self).__init__()
self.verbose = verbose
self.in_channels = 64
# 第一层卷积
self.features = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False),
nn.BatchNorm2d(64),
nn.ReLU(inplace=True)
)
# 四个残差层
self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
# 分类层
self.avg_pool = nn.AvgPool2d(kernel_size=4)
self.classifier = nn.Linear(512 * block.expansion, num_classes)
if init_weights:
self._initialize_weights()
def _make_layer(self, block, out_channels, num_blocks, stride):
"""构建残差层
Args:
block: 残差块类型
out_channels: 输出通道数
num_blocks: 残差块数量
stride: 第一个残差块的步长(用于下采样)
Returns:
nn.Sequential: 残差层
"""
strides = [stride] + [1] * (num_blocks - 1)
layers = []
for stride in strides:
layers.append(block(self.in_channels, out_channels, stride))
self.in_channels = out_channels * block.expansion
return nn.Sequential(*layers)
def forward(self, x):
"""前向传播
Args:
x: 输入张量,[N,3,32,32]
Returns:
out: 输出张量,[N,num_classes]
"""
out = self.features(x)
if self.verbose:
print('block 1 output: {}'.format(out.shape))
out = self.layer1(out)
if self.verbose:
print('block 2 output: {}'.format(out.shape))
out = self.layer2(out)
if self.verbose:
print('block 3 output: {}'.format(out.shape))
out = self.layer3(out)
if self.verbose:
print('block 4 output: {}'.format(out.shape))
out = self.layer4(out)
if self.verbose:
print('block 5 output: {}'.format(out.shape))
out = self.avg_pool(out)
out = out.view(out.size(0), -1)
out = self.classifier(out)
return out
def _initialize_weights(self):
"""初始化模型权重
采用kaiming初始化方法:
- 卷积层权重采用kaiming_normal_初始化
- BN层参数采用常数初始化
- 线性层采用正态分布初始化
"""
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
if m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
nn.init.normal_(m.weight, 0, 0.01)
nn.init.constant_(m.bias, 0)
def ResNet18(verbose=False):
"""ResNet-18模型"""
return ResNet(BasicBlock, [2,2,2,2], verbose=verbose)
def ResNet34(verbose=False):
"""ResNet-34模型"""
return ResNet(BasicBlock, [3,4,6,3], verbose=verbose)
def ResNet50(verbose=False):
"""ResNet-50模型"""
return ResNet(Bottleneck, [3,4,6,3], verbose=verbose)
def ResNet101(verbose=False):
"""ResNet-101模型"""
return ResNet(Bottleneck, [3,4,23,3], verbose=verbose)
def ResNet152(verbose=False):
"""ResNet-152模型"""
return ResNet(Bottleneck, [3,8,36,3], verbose=verbose)
def test():
"""测试函数"""
net = ResNet34()
x = torch.randn(2,3,32,32)
y = net(x)
print('Output shape:', y.size())
# 打印模型结构
from torchinfo import summary
device = 'cuda' if torch.cuda.is_available() else 'cpu'
net = net.to(device)
summary(net,(2,3,32,32))
if __name__ == '__main__':
test()