当前位置：首页 > news >正文

Pytorch 第九回：卷积神经网络——ResNet模型

news 来源：原创 2025/5/16 13:46:27

Pytorch 第九回：卷积神经网络——ResNet模型

本次开启深度学习第九回，基于Pytorch的ResNet卷积神经网络模型。这是分享的第四个卷积神经网络模型。该模型是基于解决因网络加深而出现的梯度消失和网络退化而进行设计的。接下来给大家分享具体思路。
本次学习，借助的平台是PyCharm 2024.1.3，python版本3.11 numpy版本是1.26.4，pytorch版本2.0.0+cu118，d2l的版本是1.0.3

文章目录

Pytorch 第九回：卷积神经网络——ResNet模型
前言
- 1、残差块
- 2、ResNet模型
一、数据准备
二、模型准备
- 1、残差块定义
- 2、ResNet模型定义
模型训练
- 1、实例化ResNet模型
- 2、迭代训练模型
- 3、输出展示
总结

前言

讲述模型前，先讲述两个概念，统一下思路：

1、残差块

残差块是ResNet模型的基础架构，该架构允许输入特征跨层作用到块的输出端，从而加强了浅层特征的输出。其结构如下图所示：
在这里插入图片描述
如上图所示，这里的1*1卷积层，可以将输入特征直接作用到输出端，从而避免了浅层的梯度到达输出端时过小的问题。

2、ResNet模型

2015年，ResNet模型由微软研究院提出，并在ImageNet大规模视觉挑战赛中一举夺得了冠军。之前设计的神经网络，随着网络层的增多，并没有达到训练误差不断减少的预期，反而出现训练误差逐渐加大的现象，人们也称之为“网络退化”。ResNet模型通过加入了残差块的框架，使训练的深层神经网络更加有效。

闲言少叙，直接展示逻辑，先上引用：

import numpy as np
import torch
from torch import nn
from torchvision.datasets import CIFAR10
import time
from torch.utils.data import DataLoader
from d2l import torch as d2l
import torch.nn.functional as F

一、数据准备

如前几回一样，本次仍然采用CIFAR10数据集，因此不做重点解释（有兴趣的可以查看第六回内容），本回只展示代码：

def data_treating(x):
    x = x.resize((96, 96), 2)  #
    x = np.array(x, dtype='float32') / 255
    x = (x - 0.5) / 0.5  #
    x = x.transpose((2, 0, 1))  #
    x = torch.from_numpy(x)
    return x


train_set = CIFAR10('./data', train=True, transform=data_treating)
train_data = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
test_set = CIFAR10('./data', train=False, transform=data_treating)
test_data = torch.utils.data.DataLoader(test_set, batch_size=128, shuffle=False)

注:
在本回设计的模型中，数据最小为96 * 96。有兴趣的可以参考第八回小记自己进行计算。

二、模型准备

1、残差块定义

残差块的定义分为两部分，一部分是初始化函数，一部分是前向传播函数。需要注意的是add_conv1_1这个参数，用于控制是否有输入特征直接作用于输出端。代码如下所示：

class residual(nn.Module):
    def __init__(self, channel_in, channel_out, add_conv1_1=False, stride=1):
        super(residual, self).__init__()
        self.add_conv1_1 = add_conv1_1
        
        self.conv1 = nn.Conv2d(channel_in, channel_out, 3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(channel_out)
        self.conv2 = nn.Conv2d(channel_out, channel_out, 3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(channel_out)
        
        if self.add_conv1_1:
            self.conv3 = nn.Conv2d(channel_in, channel_out, 1, stride=stride)
        else:
            self.conv3 = None

    def forward(self, x):
        y = self.conv1(x)
        y = F.relu(self.bn1(y), True)
        y = self.conv2(y)
        y = F.relu(self.bn2(y), True)

        if self.add_conv1_1:
            x = self.conv3(x)
        y = y + x
        return F.relu(y, True)

如代所示，码残差块中定义了两个33的卷积，每个卷积层后面接了一个规范化层和一个Relu激活函数（体现在传播函数中）。self.conv3中定义了一个11的卷积层，当add_conv1_1=True时，输入会经过self.conv3卷积层直接反馈到输出端（y = y + x）。

2、ResNet模型定义

本回中的ResNet模型，定义了五个网络块。第一个网络块单独定义，后四个网络块结构相似（有兴趣的可以建立一个标准模块，方便设计深层网络）。

class resnet(nn.Module):
    def __init__(self, in_channel, num_classes):
        super(resnet, self).__init__()
        self.block1 = nn.Sequential(
            nn.Conv2d(in_channel, 64, 7, 2),
            nn.BatchNorm2d(64, eps=1e-3),
            nn.ReLU(True),
            nn.MaxPool2d(3, 2, 1))

        self.block2 = nn.Sequential(
            residual(64, 64),
            residual(64, 64)
        )

        self.block3 = nn.Sequential(
            residual(64, 128, True, stride=2),
            residual(128, 128)
        )

        self.block4 = nn.Sequential(
            residual(128, 256, True, stride=2),
            residual(256, 256)
        )

        self.block5 = nn.Sequential(
            residual(256, 512, True, stride=2),
            residual(512, 512),
            nn.AvgPool2d(3),
            nn.Flatten()
        )

        self.classifier = nn.Linear(512, num_classes)

    def forward(self, x):
        x = self.block1(x)
        x = self.block2(x)
        x = self.block3(x)
        x = self.block4(x)
        x = self.block5(x)
        x = self.classifier(x)
        return x

注：
由于本回采用d2l.train_ch6()进行数据训练，里面集成了损失函数和优化器，因此不需要单独定义（在第八回小记中介绍了如何安装d2l库）。

模型训练

1、实例化ResNet模型

这里输入为3个通道，因为彩色图片有三个数据通道。输出为10，因为数据集有10个类别（数据集的介绍，在第六回中）。

classify_ResNet = resnet(3, 10)

2、迭代训练模型

本次训练采用d2l.train_ch6()函数，其参数有六个：第一个是模型，第二个是训练集，第三个是测试集，第四个是迭代次数（设定为20次），第五个是学习率（设定为0.01），第六个是进行训练的设备（设定为GPU训练）。

d2l.train_ch6(classify_ResNet, train_data, test_data, 20, 0.01, d2l.try_gpu())

3、输出展示

输出含有训练集精度、测试集精度和消耗的时间等（这里我进对源码进行了修改，可以查看第八回小记）。

epoch0, loss 1.472, train acc 0.466, test acc 0.526,consume time 228.0
epoch4, loss 0.424, train acc 0.857, test acc 0.678,consume time 1139.3
epoch8, loss 0.047, train acc 0.989, test acc 0.680,consume time 2050.4
epoch12, loss 0.006, train acc 0.999, test acc 0.741,consume time 2961.4
epoch16, loss 0.002, train acc 1.000, test acc 0.746,consume time 3872.2
epoch19, loss 0.002, train acc 1.000, test acc 0.744,consume time 4555.5