''' 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()