resnet python实现代码

2015年，何恺明等人在《Deep Residual Learning for Image Recognition》中提出了ResNet的新型网络结构，ResNet一经提出便以接连斩获ImageNet目标检测、图像分类，COCO目标检测、图像分割比赛的多项冠军，为深层网络模型的训练开辟了新的思路。

从文章中看

深度卷积神经网络的不断发展为图像分类带来了一系列突破，研究表明，网络深度的增加可以使模型学到更深层的图像特征，而这对于许多视觉任务来说是至关重要的。但随着层数的加深，模型的训练变得愈加困难，甚至出现了深层网络在训练和测试上的效果不如浅层网络的情况，作者在文中给出了20层网络和56层网络的训练和测试误差情况，如下图所示。

面对这一问题，作者对传统的网络架构进行了改进，由此提出了残差网络的设计思想，进而摆脱了深层网络面临的困境。

网络结构

ResNet的整体结构相较于传统的深层网络进入了残差块的结构，作者在文章中以34层网络为例，给出了传统网络与残差网络的设计差异。

从上图中可以看出，与传统网络相比，ResNet最大的特点是，在网络中的某些层的输入前，引入了其前层的输出。这一设计被称为残差块结构。

正是这一巧妙的设计，克服了深层网络的训练难题，作者在文中对残差网络的层数不断探索尝试，甚至提出了1202层的深层网络，均取得了较为良好的效果。

残差块是什么

既然残差块的设计如此巧妙，下面简单说说这一结构究竟是什么。单独将每一个残差块从整体网络中抽出，可以看到其抽象模型如下图所示。

作者将残差块的输出表示为H(x)=F(x)+x，其中F(x)表示残差映射，右侧标有x的曲线表示恒等映射。即：对于前层的输出x，在这一层的学习中，学习在前层中没有学到的F(x)，学习到的F(x)加上前层的输出x，构成了这一层的输出H(x)。

理论上讲，残差块的设计解决了模型训练时的梯度消失问题。同时，当模型达到一定深度后，训练达到最优效果时，将残差映射的权重置为0，残差块的输出将只保留恒等映射，网络的性能便不会随着深度增加而降低。

为了训练更深层的网络，作者提到残差块的设计有以下两种形式。

通过引入1*1的卷积层（bottleneck）改变特征维度，进而减少深层网络训练时间。

PyTorch简易实现

作者在文中给出了不同层数残差网络的结构参数（如下图所示），考虑到现有GPU条件有限，在这里我们尝试实现最简单的ResNet-18，更深的网络实现步骤与ResNet-18类似，通过修改参数不断调试即可。

import torch
from torch import nn
from torch.nn import functional as F
from torch import optim
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
import torchvision.transforms as transforms


class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, strides=1):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=strides, padding=1)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(out_channels)

        self.shortcut = None
        if strides != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=strides, bias=False),
                nn.BatchNorm2d(out_channels)
            )

    def forward(self, x):
        out = self.bn1(self.conv1(x))
        out = F.relu(out)

        out = self.bn2(self.conv2(out))
        if self.shortcut:
            x = self.shortcut(x)
        out += x
        out = F.relu(out)

        return out


class ResNet18(nn.Module):
    def __init__(self):
        super(ResNet18, self).__init__()
        self.conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3)
        self.bn1 = nn.BatchNorm2d(64)
        self.pool1 = nn.MaxPool2d(kernel_size=3, padding=1)

        self.layer1 = self.make_layer(64, 64, 2, strides=1)
        self.layer2 = self.make_layer(64, 128, 2, strides=2)
        self.layer3 = self.make_layer(128, 256, 2, strides=2)
        self.layer4 = self.make_layer(256, 512, 2, strides=2)

        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, 10)

    def make_layer(self, in_channels, out_channels, num_blocks, strides=1):
        layers = []
        layers.append(ResidualBlock(in_channels, out_channels, strides=strides))
        for i in range(num_blocks - 1):
            layers.append(ResidualBlock(out_channels, out_channels, strides=strides))

        return nn.Sequential(*layers)

    def forward(self, x):
        out = self.conv1(x)
        out = self.bn1(out)
        out = nn.ReLU(inplace=True)(out)
        out = self.pool1(out)

        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.layer4(out)

        out = self.avgpool(out)
        out = out.view(out.size(0), -1)
        out = self.fc(out)

        return out


# 定义数据预处理函数
transform = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),

])

# 加载训练集和验证集
train_dataset = MNIST(root='../data/', train=True, transform=transform, download=True)
validation_dataset = MNIST(root='../data/', train=False, transform=transform)

batch_size = 32
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)
validation_loader = DataLoader(dataset=validation_dataset, batch_size=batch_size, shuffle=False)

model = ResNet18()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# 训练模型
num_epochs = 10
for epoch in range(num_epochs):
    for i, (inputs, labels) in enumerate(train_loader):
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        # 打印训练进度
        if (i + 1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch + 1,
                                                                     num_epochs, i + 1,
                                                                     len(train_loader),
                                                                     loss.item()))

    # 在验证集上测试模型
    with torch.no_grad():
        correct = 0
        total = 0
        for inputs, labels in validation_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

        accuracy = 100 * correct / total
        print('Accuracy of the network on the validation images: %d %%' % (accuracy))

参考文献

《Deep Residual Learning for Image Recognition》《Dive Into Deep Learning》