第J2周：ResNet50V2算法实战与解析

oufoc

于 2024-09-27 21:49:48 发布

阅读量726

点赞数 15

文章标签：算法神经网络

本文链接：https://blog.csdn.net/weixin_47918905/article/details/142601770

版权

🍨 本文为🔗365天深度学习训练营中的学习记录博客
🍖 原作者：K同学啊

文章目录

一、前期工作
1、ResNetV2结构与ResNet结构对比
2、关于残差结构的不同尝试
3、关于激活的尝试

二、模型复现
1、设置GPU
2、导入数据
3、数据预处理
4、导入模型
1、Residual Block
2、堆叠Residual Block
3、ResNet50V2架构复线
4、训练函数和测试函数
5、模型训练
6、结果可视化

三、总结

电脑环境：
语言环境：Python 3.8.0
编译器：Jupyter Notebook
深度学习环境：tensorflow 2.17.0

一、前期工作

1、ResNetV2结构与ResNet结构对比

在这里插入图片描述
改进点：(a)original表示原始的ResNet的残差结构，(b)proposed表示新的ResNet残差结构。主要差别就是(a)结构先卷积后进行BN和激活函数计算，最后执行addition后再进行ReLU计算；(b)结构先进行BN和激活函数计算后卷积，把addition后的ReLU计算放到了残差结构内部。

改进结果：作者使用这两种不同的结构在CiFAR-10数据集上做测试，模型使用的是1001层的ResNet模型。从图中我们可以看出，(b)proposed的测试集错误率明显更低，达到了4.92%的错误率，(a)original的测试集错误率为7.61%。

2、关于残差结构的不同尝试

在这里插入图片描述
(b-f)中的快捷连接被不同的组件障碍。为了简化插图，我们不显示BN层，这里属所有单位均采用权值层后的BN层。图中(a-f)都是作者对残差结构的shortcut部分进行的不同尝试，作者对不同shortcut结构的尝试结构如下表所示：
在这里插入图片描述
作者用不同的shortcut结构的ResNet-110在CIFAR-10数据集上做测试，发现原始的(a)original结构是最好的，也就是identity mapping 恒等映射是最好的。

3、关于激活的尝试

在这里插入图片描述

可以得出最好的结果是(e)full pre-activation，其次是(a)original。

二、模型复现

1、设置GPU

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device

2、导入数据

import matplotlib.pyplot as plt
import os, PIL, pathlib
import numpy as np

data_dir = './bird_photos'
dat3a_dir = pathlib.Path(data_dir)
data_path = list(data_dir.glob('*'))
classeNames = [str(path).split('/')[1] for path in data_path]
classeNames

3、数据预处理

import torchvision
from torchvision import transforms, datasets
import torchvision.transforms as transforms

train_transforms = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
        )
])

total_data = datasets.ImageFolder('./bird_photos', transform=train_transforms)

# 划分数据集
train_size = int(0.8 * len(total_data))
test_size = len(total_data) - train_size

train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])

batch_size = 8
train_dl = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_dl = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=True)

4、导入模型

注意：Resnet50V2、ResNet101V2与ResNet152V2的搭建方式完全一样，区别在于堆叠residual block的数量不同。

1、Residual Block

import torch
import torch.nn as nn

class Block2(nn.Module):
    def __init__(self, filters, kernel_size=3, stride=1, conv_shortcut=False):
        super(Block2, self).__init__()
        self.conv_shortcut = conv_shortcut

        self.bn1 = nn.BatchNorm2d(filters)
        self.relu = nn.ReLU(inplace=True)

        if conv_shortcut:
            self.shortcut = nn.Conv2d(4 * filters, kernel_size=1, stride=stride, bias=False)
        else:
            if stride > 1:
                self.shortcut = nn.MaxPool2d(kernel_size=1, stride=stride)
            else:
                self.shortcut = nn.Identity()

        self.conv1 = nn.Conv2d(filters, filters, kernel_size=1, stride=1, bias=False)
        self.bn2 = nn.BatchNorm2d(filters)
        self.relu2 = nn.ReLU(inplace=True)

        self.padding = nn.ZeroPad2d(1)  

        self.conv2 = nn.Conv2d(filters, filters, kernel_size=kernel_size, stride=stride, padding=0, bias=False)
        self.bn3 = nn.BatchNorm2d(filters)
        self.relu3 = nn.ReLU(inplace=True)

        self.conv3 = nn.Conv2d(filters, 4 * filters, kernel_size=1, bias=False)

        self.add = nn.Identity() 

    def forward(self, x):
        preact = self.bn1(x)
        preact = self.relu(preact)

        if self.conv_shortcut:
            shortcut = self.shortcut(preact)
        else:
            shortcut = self.shortcut(x)

        out = self.conv1(preact)
        out = self.bn2(out)
        out = self.relu2(out)
        out = self.padding(out)
        out = self.conv2(out)
        out = self.bn3(out)
        out = self.relu3(out)

        out = self.conv3(out)

        out += shortcut

        return out

2、堆叠Residual Block

import torch.nn as nn

class Stack2(nn.Module):
    def __init__(self, block, filters, blocks, stride1=2):
        super(Stack2, self).__init__()
        self.layers = nn.ModuleList()
        self.layers.append(block(filters, stride=stride1, conv_shortcut=True))

        for i in range(2, blocks):
            self.layers.append(block(filters))

        self.layers.append(block(filters, stride=stride1))

    def forward(self, x):
        for layer in self.layers:
            x = layer(x)
        return x

3、ResNet50V2架构复线

在这里插入图片描述

代码如下：

import torch
import torch.nn as nn
import torch.nn.functional as F

class ResNet50V2(nn.Module):
    def __init__(self, num_classes=1000, include_top=True, preact=False, pooling='avg'):
        super(ResNet50V2, self).__init__()
        self.include_top = include_top
        self.preact = preact

        # conv1
        self.conv1_pad = nn.ZeroPad2d((3, 3, 3, 3))
        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)

        # conv2_x
        self.pool1_pad = nn.ZeroPad2d((1, 1, 1, 1))
        self.pool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        # Residual Blocks (stack layers)
        self.layer1 = self._make_stack_layer(64, 64, 3, stride=1, name='conv2')
        self.layer2 = self._make_stack_layer(64*4, 128, 4, stride=2, name='conv3')
        self.layer3 = self._make_stack_layer(128*4, 256, 6, stride=2, name='conv4')
        self.layer4 = self._make_stack_layer(256*4, 512, 3, stride=2, name='conv5')

        # BatchNorm and relu for post-processing
        self.post_bn = nn.BatchNorm2d(512 * 4)
        self.post_relu = nn.ReLU(inplace=True)

        # Pooling and Fully Connected Layer
        if include_top:
            self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
            self.fc = nn.Linear(512 * 4, num_classes)
        else:
            if pooling == 'avg':
                self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
            elif pooling == 'max':
                self.avgpool = nn.AdaptiveMaxPool2d((1, 1))

    def _make_stack_layer(self, in_planes, planes, blocks, stride=1, name=None):
        layers = []
        # First block with shortcut
        layers.append(Bottleneck(in_planes, planes, stride, conv_shortcut=True))

        # Remaining blocks
        for _ in range(1, blocks):
            layers.append(Bottleneck(planes * 4, planes))
        return nn.Sequential(*layers)

    def forward(self, x):
        # Initial layers (conv1)
        x = self.conv1_pad(x)
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)

        # MaxPool layer (conv2_x)
        x = self.pool1_pad(x)
        x = self.pool1(x)

        # Residual blocks (stack layers)
        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        # Optional post-bn and relu if preact is True
        if self.preact:
            x = self.post_bn(x)
            x = self.post_relu(x)

        # Pooling layer
        x = self.avgpool(x)
        x = torch.flatten(x, 1)

        if self.include_top:
            x = self.fc(x)

        return x

# Bottleneck Block used in ResNet
class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, in_planes, planes, stride=1, conv_shortcut=False):
        super(Bottleneck, self).__init__()
        self.conv_shortcut = conv_shortcut

        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(planes)

        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)

        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * 4)

        if self.conv_shortcut:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_planes, planes * 4, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(planes * 4)
            )
        else:
            self.shortcut = nn.Identity()

    def forward(self, x):
        shortcut = self.shortcut(x)

        out = self.conv1(x)
        out = self.bn1(out)
        out = F.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)
        out = F.relu(out)

        out = self.conv3(out)
        out = self.bn3(out)

        out += shortcut
        out = F.relu(out)

        return out

# Instantiate the model
def ResNet50V2_instance(include_top=True, num_classes=1000, preact=False, pooling='avg'):
    return ResNet50V2(num_classes=num_classes, include_top=include_top, preact=preact, pooling=pooling)

model = ResNet50V2_instance()
print(model)

4、训练函数和测试函数

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小
    num_batches = len(dataloader)   # 批次数目, (size/batch_size，向上取整)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率

    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)

        # 计算预测误差
        pred = model(X)          # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失

        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.step()       # 每一步自动更新

        # 记录acc与loss
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc  /= size
    train_loss /= num_batches

    return train_acc, train_loss


def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小
    num_batches = len(dataloader)          # 批次数目, (size/batch_size，向上取整)
    test_loss, test_acc = 0, 0

    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss        = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc  /= size
    test_loss /= num_batches

    return test_acc, test_loss

5、模型训练

import copy

optimizer  = torch.optim.Adam(model.parameters(), lr= 1e-4)
loss_fn    = nn.CrossEntropyLoss() # 创建损失函数

epochs     = 10

train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

for epoch in range(epochs):

    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, optimizer)

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    # 获取当前的学习率
    lr = optimizer.state_dict()['param_groups'][0]['lr']

    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%, Test_loss:{:.3f}, Lr:{:.2E}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss,
                          epoch_test_acc*100, epoch_test_loss, lr))

Epoch: 1, Train_acc:51.1%, Train_loss:1.920, Test_acc:61.9%, Test_loss:0.954, Lr:1.00E-04
Epoch: 2, Train_acc:69.5%, Train_loss:0.829, Test_acc:73.5%, Test_loss:1.099, Lr:1.00E-04
Epoch: 3, Train_acc:75.9%, Train_loss:0.638, Test_acc:62.8%, Test_loss:1.229, Lr:1.00E-04
Epoch: 4, Train_acc:81.2%, Train_loss:0.476, Test_acc:77.9%, Test_loss:0.494, Lr:1.00E-04
Epoch: 5, Train_acc:89.2%, Train_loss:0.363, Test_acc:78.8%, Test_loss:0.605, Lr:1.00E-04
Epoch: 6, Train_acc:87.4%, Train_loss:0.373, Test_acc:84.1%, Test_loss:0.495, Lr:1.00E-04
Epoch: 7, Train_acc:90.0%, Train_loss:0.318, Test_acc:78.8%, Test_loss:0.885, Lr:1.00E-04
Epoch: 8, Train_acc:92.7%, Train_loss:0.215, Test_acc:84.1%, Test_loss:0.475, Lr:1.00E-04
Epoch: 9, Train_acc:91.4%, Train_loss:0.248, Test_acc:87.6%, Test_loss:0.643, Lr:1.00E-04
Epoch:10, Train_acc:89.6%, Train_loss:0.282, Test_acc:78.8%, Test_loss:0.553, Lr:1.00E-04

6、结果可视化

# coding=utf-8
import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['figure.dpi']         = 100        #分辨率

epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()