第11周：ResNet-50算法实战与解析（Pytorch实现）

目录

• 前言

  一、理论知识储备

  1.1 CNN算法发展

  1.2 残差网络

  1.2.1 为什么要采用残差网络

  1.2.2 ResNet-50介绍

  二、导入数据

  2.1 设置GPU

  2.2 导入数据

  三、数据预处理

  3.1 加载数据

  3.2 划分数据集

  3.3 可视化数据

  四、构建ResNet-50网络模型

  4.1 构建基本残差块

  4.2 ResNet类构建

  4.3 模型实例化

  五、模型训练

  5.1 编写训练函数

  5.2 编写测试函数

  5.3 设置损失函数和学习率

  5.4 正式训练

  六、结果可视化

  总结

---

前言

• 🍨 本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/0dvHCaOoFnW8SCp3JpzKxg) 中的学习记录博客
• 🍖 原作者：[K同学啊](https://mtyjkh.blog.csdn.net/)

说在前面

本周学习目标：了解残差结构，根据原始的Tensorflow代码、编写出响应的Pytorch代码

解决问题：识别小鸟的种类

我的环境：Python3.8、Pycharm2020、torch1.12.1+cu113

数据来源：[K同学啊](https://mtyjkh.blog.csdn.net/)

---

一、理论知识储备

1.1 CNN算法发展

       评估网络的性能，一个维度是识别精度，另一个维度是网络的复杂度(计算量)

（1）开山之作——AlexNet

2012年，AlexNet是由Alex Krizhevsky、llya Sutskever和Geoffrey Hinton在2012年ImageNet图像分类竞赛中提出的一种经典的卷积神经网络。AlexNet是首个深层卷积神经网络，同时还引入ReLu激活函数、局部归一化、数据增强和Dropout处理

（2）越走越深——VGGNets

VGG-Nets是由牛津大学VGG（Visual Geometry Group）提出，是2014年ImageNet竞赛定位任务的第一名和分类任务的第二名的中的基础网络。VGG可以看成是加深版本的AlexNet. 都是conv layer + FC layer，在当时看来这是一个非常深的网络了，因为层数高达十多层，从其论文名字就知道了（《Very Deep Convolutional Networks for Large-Scale Visual Recognition》）

VGG-16将深层网络结构分为几个组，每组堆叠数量不等的Conv-ReLu层并在最后一层使用MaxPool缩减特征尺寸

（3）大浪推手——GoogLeNet

GoogLeNet跟AlexNet,VGG-Nets这种单纯依靠加深网络结构进而改进网络性能的思路不一样，它另辟幽径，在加深网络的同时（22层），也在网络结构上做了创新，引入Inception结构代替了单纯的卷积+激活的传统操作（Inception特点多种尺度卷机核，这思路最早由Network in Network提出）。这是一个提出了使用并联卷积结构，并且在每个通路使用不同卷积核的网络，随后衍生出V2、V3、V4等一系列网络结构，构成一个家族

（4）里程式创新——ResNet

2015年何恺明推出的ResNet在ISLVRC和COCO上横扫所有选手，获得冠军。ResNet在网络结构上做了大创新，而不再是简单的堆积层数。RestNet有V1、V2、NeXt等不同的版本，这是一个提出恒等映射概念、具有短路直接路径、模块化的网络结构可以很方便地扩展位18~1001层

（5）继往开来——DenseNet

DenseNet（Dense Convolutional Network）主要还是和ResNet及Inception网络做对比，思想上有借鉴，但却是全新的结构，网络结构并不复杂，却非常有效，在CIFAR指标上全面超越ResNet。可以说DenseNet吸收了ResNet最精华的部分，并在此上做了更加创新的工作，使得网络性能进一步提升

DenseNet 是一种具有密集连接的卷积神经网络。在该网络中，任何两层之间都有直接的连接，也就是说，网络每一层的输入都是前面所有层输出的并集，而该层所学习的特征图也会被直接传给其后面所有层作为输入

参考自：深度学习算法(二)-CNN发展历程 - 知乎 (zhihu.com)

1.2 残差网络

1.2.1 为什么要采用残差网络

        ResNet主要解决深度卷积网络在深度加深时候的“退化”问题。在一般的卷积神经网络中，增大网络深度后带来的第一个问题就是梯度消失、爆炸，这个问题Szegedy提出BN层后被顺利解决。BN层能对各层的输出做归一化，这样梯度在反向层层传递后仍能保持大小稳定，不会出现过小或过大的情况。但是作者发现加了BN后再加大深度仍然不容易收敛，其提到了第二个问题--准确率下降问题：层级大到一定程度时准确率就会饱和，然后迅速下降，这种下降即不是梯度消失引起的也不是过拟合造成的，而是由于网络过于复杂，以至于光靠不加约束的放养式的训练很难达到理想的错误率。
       准确率下降问题不是网络结构本身的问题，而是现有的训练方式不够理想造成的。当前广泛使用的优化器，无论是SGD，还是RMSProp，或是Adam，都无法在网络深度变大后达到理论上最优的收敛结果。
       作者在文中证明了只要有合适的网络结构，更深的网络肯定会比较浅的网络效果要好。证明过程也很简单:假设在一种网络A的后面添加几层形成新的网络B，如果增加的层级只是对A的输出做了个恒等映射(identity mapping)，即A的输出经过新增的层级变成B的输出后没有发生变化，这样网络A和网络B的错误率就是相等的，也就证明了加深后的网络不会比加深前的网络效果差。

1.2.2 ResNet-50介绍

       何恺明提出了一种残差结构来实现上述恒等映射(图1):整个模块除了正常的卷积层输出外，还有个分支把输入直接连到输出上，该分支输出和卷积的输出做算术相加得到最终的输出，用公式表达就是H(x)= F(x)+x^2，x 是输入， F(X)是卷积分支的输出， H(x)是整个结构的输出。可以证明如果 F(x)分支中所有参数都是0,H(x)就是个恒等映射。残差结构人为制造了恒等映射，就能让整个结构朝着恒等映射的方向去收敛，确保最终的错误率不会因为深度的变大而越来越差。如果一个网络通过简单的手工设置参数值就能达到想要的结果，那这种结构就很容易通过训练来收敛到该结果，这是一条设计复杂的网络时通用的规则。

       图2左边的单元为 ResNet 两层的残差单元，两层的残差单元包含两个相同输出的通道数的 3x3 卷积，只是用于较浅的 ResNet 网络，对较深的网络主要使用三层的残差单元。三层的残差单元又称为 bottleneck 结构，先用一个1x1卷积进行降维，然后3x3卷积，最后用1x1升维恢复原有的维度另外，如果有输入输出维度不同的情况，可以对输入做一个线性映射变换维度，再连接后面的层。三层的残差单元对于相同数量的层又减少了参数量，因此可以拓展更深的模型。通过残差单元的组合有经典的ResNet-50，ResNet101 等网络结构。

二、导入数据

2.1 设置GPU

代码如下：

#导入所需要的包
import torch
import torch.nn as nn
import torchvision.transforms as transforms
import torchvision
from torchvision import transforms, datasets
import os,PIL,pathlib,warnings
import torch.nn.functional as F
import matplotlib.pyplot as plt
import pandas as pd
from torchvision.io import read_image
from torch.utils.data import Dataset
import torch.utils.data as data
from PIL import Image
import copy
import numpy as np


#一、导入数据
'''
1.1 设置GPU
'''
warnings.filterwarnings("ignore")

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

打印输出:cuda

2.2 导入数据

代码如下：

'''
1.2 导入数据
'''
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
data_dir = './bird_photos/'
data_dir = pathlib.Path(data_dir)
data_paths = list(data_dir.glob('*'))
def count_images(folder):
    count = 0
    for item in folder.iterdir():
        if item.is_file():
            count += 1
        if item.is_dir():
            count += count_images(item)
    return count

image_count = count_images(data_dir)
print("图片总数为：", image_count)
classNames = [str(path).split('\\')[1] for path in data_paths]
#利用split()函数对data_paths中的每个文件路径执行分割操作，获取各个文件所属的类别名称并储存在classNames中
# 4类天气，各300张图片
print(classNames)

打印输出：

cuda
图片总数为： 565
['Bananaquit', 'Black Skimmer', 'Black Throated Bushtiti', 'Cockatoo']

三、数据预处理

3.1 加载数据

图片处理：

torchvision.transforms是pytorch中的图像预处理包。一般用Compose把多个步骤整合到一起 
1）Resize：将输入图片resize成统一尺寸
2）ToTensor：将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
3）Normalize：标准化处理-->转换为标准正态分布，使模型更容易收敛；其中mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的
ImageFolder类来创建一个数据集对象，total_data将是一个包含所有图像数据的数据集对象，可以用于训练神经网络模型

代码如下：

#二、数据预处理
'''
2.1 加载数据
'''
train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    # transforms.RandomHorizontalFlip(), # 随机水平翻转
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

test_transform = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor，并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布（高斯分布），使模型更容易收敛
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

total_data = datasets.ImageFolder("./bird_photos/",transform=train_transforms)
print(total_data)
print(total_data.class_to_idx)

打印输出：

Dataset ImageFolder
    Number of datapoints: 565
    Root location: ./bird_photos/
    StandardTransform
Transform: Compose(
               Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=warn)
               ToTensor()
               Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
           )
{'Bananaquit': 0, 'Black Skimmer': 1, 'Black Throated Bushtiti': 2, 'Cockatoo': 3}

3.2 划分数据集

torch.utils.data.random_split(dataset, lengths, generator=<torch._C.Generator object>)

随机将一个数据集分割成给定长度的不重叠的新数据集。可选择固定生成器以获得可复现的结果（效果同设置随机种子）。
dataset (Dataset) – 要划分的数据集。
lengths (sequence) – 要划分的长度。
generator (Generator) – 用于随机排列的生成器。

代码示例

'''
2.2 划分数据集
'''
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])
print(train_dataset, test_dataset)

打印输出：

<torch.utils.data.dataset.Subset object at 0x0000022C503DA6A0> <torch.utils.data.dataset.Subset object at 0x0000022C503DA610>

3.3 可视化数据

代码如下：

'''
2.3 可视化数据
'''
batch_size = 8
train_dl = torch.utils.data.DataLoader(train_dataset,
                                       batch_size=batch_size,
                                       shuffle=True,
                                       num_workers=0)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                      batch_size=batch_size,
                                      shuffle=True,
                                      num_workers=0)
for X, y in test_dl:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break

image_folder = './bird_photos/Cockatoo/'           #指定图像文件夹路径
image_files = [f for f in os.listdir(image_folder) if f.endswith((".jpg", ".png", ".jpeg"))]
fig, axes = plt.subplots(2, 4, figsize=(16, 6))

for ax, img_file in zip(axes.flat, image_files):
    img_path = os.path.join(image_folder, img_file)
    img = Image.open(img_path)
    ax.imshow(img)
    ax.axis('off')
plt.tight_layout()
plt.show()

打印输出：

Shape of X [N, C, H, W]:  torch.Size([8, 3, 224, 224])
Shape of y:  torch.Size([8]) torch.int64

图片输出

四、构建ResNet-50网络模型

4.1 构建基本残差块

实现了 ResNet 的基本残差块，其中包含三层卷积，并通过捷径连接来实现残差学习，从而更有效地训练深度神经网络

代码如下：

# 构造ResNet50模型
class ResNetblock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResNetblock, self).__init__()
        self.blockconv = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(),
            nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(),
            nn.Conv2d(out_channels, out_channels * 4, kernel_size=1, stride=1),
            nn.BatchNorm2d(out_channels * 4)
        )
        if stride != 1 or in_channels != out_channels * 4:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels * 4, kernel_size=1, stride=stride),
                nn.BatchNorm2d(out_channels * 4)
            )

    def forward(self, x):
        residual = x
        out = self.blockconv(x)
        if hasattr(self, 'shortcut'):  # 如果self中含有shortcut属性
            residual = self.shortcut(x)
        out += residual
        out = F.relu(out)
        return out

4.2 ResNet类构建

• 初始化卷积层:包括一个 7x7 的卷积层、批量归一化层、ReLU 激活函数和最大池化层
• 残差层:包含了四个主要的残差层、每层包含了多个残差块，self.layer1 到 self.layer4：使用 make_layer 方法创建四个主要残差层，每层的输出通道数和残差块数量不同——make_layer 首先创建一个步幅列表 strides，第一个元素为输入步幅，剩余元素为 1，然后通过循环创建指定数量的残差块并添加到 layers 列表中，最后返回包含所有残差块的顺序容器 nn.Sequential
• 全局平均池化层
• 全连接层

class ResNet50(nn.Module):
    def __init__(self, block, num_classes=1000):
        super(ResNet50, self).__init__()

        self.conv1 = nn.Sequential(
            nn.ZeroPad2d(3),
            nn.Conv2d(3, 64, kernel_size=7, stride=2),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d((3, 3), stride=2)
        )
        self.in_channels = 64
        # ResNet50中的四大层，每大层都是由ConvBlock与IdentityBlock堆叠而成
        self.layer1 = self.make_layer(ResNetblock, 64, 3, stride=1)
        self.layer2 = self.make_layer(ResNetblock, 128, 4, stride=2)
        self.layer3 = self.make_layer(ResNetblock, 256, 6, stride=2)
        self.layer4 = self.make_layer(ResNetblock, 512, 3, stride=2)

        self.avgpool = nn.AvgPool2d((7, 7))
        self.fc = nn.Linear(512 * 4, num_classes)

    # 每个大层的定义函数
    def make_layer(self, block, channels, num_blocks, stride=1):
        strides = [stride] + [1] * (num_blocks - 1)
        layers = []

        for stride in strides:
            layers.append(block(self.in_channels, channels, stride))
            self.in_channels = channels * 4

        return nn.Sequential(*layers)

    def forward(self, x):
        out = self.conv1(x)
        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

4.3 模型实例化

代码如下：

model = ResNet50(block=ResNetblock, num_classes=len(classNames)).to(device)
print(model)

模型打印输出——部分截图

五、模型训练

5.1 编写训练函数

代码如下：

'''
5.1 编写训练函数
'''
def train(dataloader, model, optimizer, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)

    train_acc, train_loss = 0, 0

    for X, y in dataloader:
        X, y = X.to(device), y.to(device)

        pred = model(X)
        loss = loss_fn(pred, y)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        train_loss += loss.item()
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()

    train_loss /= num_batches
    train_acc /= size

    return train_acc, train_loss

5.2 编写测试函数

代码如下：

'''
5.2 编写测试函数
'''
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.3 设置损失函数和学习率

代码如下：

'''
5.3 设置损失函数和学习率
'''
loss_fn = nn.CrossEntropyLoss()   #交叉熵函数
learn_rate = 1e-3
opt = torch.optim.Adam(model.parameters(), lr=learn_rate)

5.4 正式训练

代码如下：

'''
5.4 正式训练
'''
epochs = 20
train_loss = []
train_acc = []
test_loss = []
test_acc = []
best_acc = 0

# 开始训练
for epoch in range(epochs):

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

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

    if epoch_test_acc > best_acc:
        best_acc = epoch_test_acc
        best_model = copy.deepcopy(model)

    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 = opt.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))

print('Done')

训练过程输出：

六、结果可视化

代码如下：

#六、结果可视化
import warnings
warnings.filterwarnings("ignore")             #忽略警告信息
plt.rcParams['font.sans-serif'] = ['SimHei']  #用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False    #用来正常显示负号
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()

训练过程Loss打印如下：

---

总结

• 由于前面接触较多的是Pytorch框架，现在接触tensorflow的框架相差还是挺大，相同功能的写法不一样；了解了残差结构的应用和基本结构
• 但是模型的训练结果不是很好