进击J1：ResNet-50算法实战与解析

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

实验目的：

1.根据教程 TensorFlow 代码，编写出相应的 Pytorch 代码
2.了解残差结构
3.尝试将残差模块融入到C3当中，提升准确率（自由探索）

实验环境：

• 语言环境：python 3.8
• 编译器：Google colab
• 深度学习环境：Pytorch
  • torch==2.3.0+cu121
  • torchvision==0.18.0+cu121

理论知识储备

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

2. 残差网络

2.1 残差网络解决了什么

• 残差网络是为了解决神经网络隐藏层过多时，而引起的网络退化问题
• 退化（degradation）问题是指：当网络隐藏层变多时，网络的准确度达到饱和然后急剧退化，而且这个退化不是由于过拟合引起的

拓展： 深度神经网络的“两朵乌云”
● 梯度弥散/爆炸
简单来讲就是网络太深了，会导致模型训练难以收敛。这个问题可以被标准初始化和中间层正规化的方法有效控制。
● 网络退化
随着网络深度增加，网络的表现先是逐渐增加至饱和，然后迅速下降，这个退化不是由于过拟合引起的。

在一般的卷积神经网络中，增大网络深度后带来的第一个问题就是梯度消失、爆炸，这个问题在Szegedy提出BN层后被顺利解决。BN层能对各层的输出做归一化，这样梯度在反向层层传递后仍能保持大小稳定，不会出现过小或过大的情况。但是作者发现加了BN后再加大深度仍然不容易收敛，其提到了第二个问题–准确率下降问题：层级大到一定程度时准确率就会饱和，然后迅速下降，这种下降即不是梯度消失引起的也不是过拟合造成的，而是由于网络过于复杂，以至于光靠不加约束的放养式的训练很难达到理想的错误率。

准确率下降问题不是网络结构本身的问题，而是现有的训练方式不够理想造成的。当前广泛使用的优化器，无论是SGD，还是RMSProp，或是Adam，都无法在网络深度变大后达到理论上最优的收敛结果。

作者在文中证明了只要有合适的网络结构，更深的网络肯定会比较浅的网络效果要好。证明过程也很简单:假设在一种网络A的后面添加几层形成新的网络B，如果增加的层级只是对A的输出做了个恒等映射(identity mapping)，即A的输出经过新增的层级变成B的输出后没有发生变化，这样网络A和网络B的错误率就是相等的，也就证明了加深后的网络不会比加深前的网络效果差。

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 等网络结构。

ResNet-50有两个基本的块，分别名为Conv Block和Identity Block。

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

'''
设置GPU
'''
warnings.filterwarnings("ignore")
 
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(device)

2. 导入数据

'''
导入数据
'''
plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
data_dir = '/content/drive/MyDrive/J1/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中
print(classNames)

3. 加载数据

#数据预处理
'''
加载数据
'''
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("/content/drive/MyDrive/J1/bird_photos",transform=train_transforms)
print(total_data)
print(total_data.class_to_idx)

4. 划分数据集

'''
划分数据集
'''
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)

5. 可视化数据

'''
可视化数据
'''
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 = '/content/drive/MyDrive/J1/bird_photos/Black Skimmer/'           #指定图像文件夹路径
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()

6. 构建ResNet-50网络模型

# 构造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

# ResNet类构建
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

# 模型实例化
model = ResNet50(block=ResNetblock, num_classes=len(classNames)).to(device)
print(model)

模型打印输出，部分截图：

7. 编写训练函数

'''
编写训练函数
'''
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

8. 编写测试函数

'''
编写测试函数
'''
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

9. 设置损失函数和学习率

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

10. 正式训练

'''
正式训练
'''
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')

11. 结果可视化

# 结果可视化
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()

12. 预测

from PIL import Image

classes = list(total_data.class_to_idx)

def predict_one_image(image_path, model, transform, classes):


    test_img = Image.open(image_path).convert('RGB')
    plt.imshow(test_img)  # 展示预测的图片

    test_img = transform(test_img)
    img = test_img.to(device).unsqueeze(0)


    model.eval()
    output = model(img)

    _,pred = torch.max(output,1)
    pred_class = classes[pred]
    print(f'预测结果是：{pred_class}')
    
# 预测训练集中的某张照片
predict_one_image(image_path='/content/drive/MyDrive/J1/bird_photos/Black Skimmer/001.jpg',
                  model=model,
                  transform=train_transforms,
                  classes=classes)

预测结果是：Black Skimmer

13. 总结

在基础营中，我跳过了 TensorFlow 的部分，所以在进阶的第一周，想要自己编写出对应的 PyTorch 代码比较困难。尝试借助大模型辅助但效果差强人意。参考了一些他人的文章，然而复现的结果也不理想，所以最终还是依据前面所学的基础和方法展开练习。此次没有加载预训练的权重模型，预测也仅仅进行了单张图片的预测。

本次实验的重点在于了解 ResNet 的基本结构与应用，后续还需要仔细研读原文《Deep Residual Learning for Image Recognition》，其中尚有诸多值得深入探索的内容。