基于ResNet50的十二生肖分类

最新推荐文章于 2023-12-29 18:00:52 发布

Hook_daidai

最新推荐文章于 2023-12-29 18:00:52 发布

阅读量225

点赞数 3

文章标签： python 计算机视觉多分类

本文链接：https://blog.csdn.net/weixin_74182458/article/details/134536695

版权

5.1定义一个ZodiacDataset class类进行对照片集的处理

本篇仅为个人学习总结，有兴趣的朋友可以参考下面链接，fork其项目

#项目来源#

【深度学习项目三】ResNet50多分类任务【十二生肖分类】 - 飞桨AI Studio星河社区

1、ResNet50介绍

残差结构解决梯度消失问题，多个路径前向传播。
层数改变如图左下角，主要是为了减少计算开销，既减少参数。

2、数据集介绍

一共12种动物照片

训练样本量| 7,096张

验证样本量| 639张

测试样本量| 656张

加载使用方式|自定义数据集

├── test|train|valid │

├── dog │

├── dragon │

├── goat │

├── horse │

├── monkey │

├── ox │

├── pig │

├── rabbit │

├── ratt │

├── rooster │

├── snake │

└── tiger

处理后为十二类文件夹，各个文件夹对应各自的数据集

3、导入必要的库

import io
import os
import paddle
import numpy as np
from PIL import Image
from config import get
from dataset import ZodiacDataset
import matplotlib.pyplot as plt
from paddle.static import InputSpec
import paddle.vision.transforms as T

4、索引字典

__all__ = ['CONFIG', 'get']

CONFIG = {
    'model_save_dir': r"....\ResNet50\work\output\zodiac",  # 模型保存的目录路径
    'num_classes': 12,  # 分类问题中的类别数量
    'total_images': 7096,  # 总共的图像数量
    'epochs': 20,  # 训练的轮次数量
    'batch_size': 32,  # 批处理大小
    'image_shape': [3, 224, 224],  # 图像的形状（通道数、高度、宽度）
    'LEARNING_RATE': {
        'params': {
            'lr': 0.00375
        }
    },  # 学习率设置
    'OPTIMIZER': {
        'params': {
            'momentum': 0.9
        },
        'regularizer': {
            'function': 'L2',
            'factor': 0.000001
        }
    },  # 优化器设置，包括动量和正则化
    'LABEL_MAP': [
        "ratt",
        "ox",
        "tiger",
        "rabbit",
        "dragon",
        "snake",
        "horse",
        "goat",
        "monkey",
        "rooster",
        "dog",
        "pig",
    ]
}  # 标签映射，用于将类别索引映射到类别名称

CONFIG为总字典，其中：

model_save_dir 为 模型保存的目录路径 （此处用目标路径的绝对路径）

num_classes 为 分类问题的类别数量

total_images 为 图像的总数

epochs 为 训练的次数 （可自定义）

batch-size 为 批处理大小

1、小批量（Mini-Batch）: 小批量训练使用相对较小的批处理大小，例如 32、64、128 等。这种方法通常在训练过程中能够提供一定程度的随机性，有助于模型收敛到较好的局部最小值。同时，小批量训练可以利用硬件加速（如GPU）来并行处理多个样本，从而提高训练效率。

2、批量梯度下降（Batch Gradient Descent）: 批量梯度下降使用整个训练数据集来计算每个梯度更新，批处理大小等于训练集的大小。这意味着每个训练迭代都使用了全部数据，通常会导致更稳定的收敛，但计算成本也更高，特别是对于大型数据集。

3、随机梯度下降（Stochastic Gradient Descent）: 随机梯度下降使用批处理大小为 1，每次只使用一个样本来计算梯度更新。这种方法具有很高的随机性，但也更快地收敛到局部最小值。然而，它可能会导致训练过程中的抖动。

选择合适的批处理大小通常取决于数据集的大小、可用的计算资源以及模型的架构。较大的批处理大小可以加速训练，但可能需要更多的内存和计算能力。较小的批处理大小可以增加训练的随机性，有助于避免局部最小值，但可能需要更多的训练迭代来达到收敛。

image_shape 为图像的形状（通道数，高度，宽度）一般为[3,224,224]

LEARNING_RATE 为学习率

学习率是一个控制模型在每次训练迭代中更新权重的步长或幅度的超参数。具体来说，学习率决定了模型在每次迭代中沿着梯度方向更新权重的幅度。较小的学习率会导致权重更新缓慢，但通常会更稳定；较大的学习率会导致权重更新快速，但可能会不稳定。

OPTIMIZER 为优化器其中 momentum 为动量

动量（momentum）是一种优化算法的参数，用于加速模型的训练过程，通常设置在0到1之间。较大的动量值使模型在更新权重时更具惯性，有助于克服局部极小值问题，从而加速收敛。

regularizer 是正则化的设置

用来指定正则化的设置。正则化是一种用于控制模型复杂度和防止过拟合的技术。

正则化的类型被设置为 'L2'，表示使用L2正则化（也称为权重衰减）。

'factor' 参数被设置为 0.000001，这是正则化的超参数，控制正则化的强度。

L2正则化会在损失函数中添加一个惩罚项，使权重趋向于较小的值，从而降低模型的复杂度，有助于防止过拟合。

LABEL_MAP 为总标签

4.1、字典索引函数

def get(full_path):
    for id, name in enumerate(full_path.split('.')):
        if id == 0:
            config = CONFIG

        config = config[name]

    return config

通过对路径的处理，读取full_path的 id 和后缀，并返回读取字典中对应的值

5、图像处理

__all__ = ['ZodiacDataset']

# 定义图像的大小
image_shape = get('image_shape')
IMAGE_SIZE = (image_shape[1], image_shape[2])


class ZodiacDataset(paddle.io.Dataset):
    """
    十二生肖数据集类的定义
    """

    def __init__(self, mode='train'):
        """
        初始化函数
        """
        # 具体来说，这行代码的作用是检查变量 mode 是否包含在列表 ['train', 'test', 'valid'] 中。
        # 如果 mode 的值不是这三个字符串之一，就会引发 AssertionError 异常，
        # 其中包含指定的错误消息 'mode is one of train, test, valid.'。
        assert mode in ['train', 'test', 'valid'], 'mode is one of train, test, valid.'

        self.data = []

        with open(r'E:\paddle_LeNet\ResNet50_try\data_animal\signs\{}.txt'.format(mode)) as f:
            for line in f.readlines():
                info = line.strip().split('\t')

                if len(info) > 0:
                    self.data.append([info[0].strip(), info[1].strip()])

        if mode == 'train':
            self.transforms = T.Compose([
                T.RandomResizedCrop(IMAGE_SIZE),    # 随机裁剪大小
                T.RandomHorizontalFlip(0.5),        # 随机水平翻转
                T.ToTensor(),                       # 数据的格式转换和标准化 HWC => CHW  
                T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # 图像归一化
            ])
        else:
            self.transforms = T.Compose([
                T.Resize(256),                 # 图像大小修改
                T.RandomCrop(IMAGE_SIZE),      # 随机裁剪
                T.ToTensor(),                  # 数据的格式转换和标准化 HWC => CHW
                T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])   # 图像归一化
            ])
        
    def __getitem__(self, index):
        """
        根据索引获取单个样本
        """
        image_file, label = self.data[index]
        image = Image.open(image_file)

        if image.mode != 'RGB':
            image = image.convert('RGB')

        image = self.transforms(image)

        return image, np.array(label, dtype='int64')

    def __len__(self):
        """
        获取样本总数
        """
        return len(self.data)

5.1定义一个ZodiacDataset class类进行对照片集的处理

区分train和test、valid的照片处理

if mode == 'train':
    self.transforms = T.Compose([
        T.RandomResizedCrop(IMAGE_SIZE),    # 随机裁剪大小
        T.RandomHorizontalFlip(0.5),        # 随机水平翻转
        T.ToTensor(),                       # 数据的格式转换和标准化 HWC => CHW  
        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # 图像归一化
    ])
else:
    self.transforms = T.Compose([
        T.Resize(256),                 # 图像大小修改
        T.RandomCrop(IMAGE_SIZE),      # 随机裁剪
        T.ToTensor(),                  # 数据的格式转换和标准化 HWC => CHW
        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])   # 图像归一化
    ])

如果 mode 是 'train'，表示当前处于训练模式，将执行以下数据预处理操作：

T.RandomResizedCrop(IMAGE_SIZE): 随机裁剪图像到指定的尺寸 IMAGE_SIZE，以增加数据的多样性。
T.RandomHorizontalFlip(0.5): 以50%的概率随机水平翻转图像，也是为了增加数据的多样性。
T.ToTensor(): 将图像数据转换为张量（tensor）格式，通常深度学习模型需要输入张量格式的数据。
T.Normalize(): 对图像进行标准化，即对图像的每个通道进行归一化，以使均值为 [0.485, 0.456, 0.406]，标准差为 [0.229, 0.224, 0.225]。

如果 mode 不是 'train'，表示当前处于测试模式，将执行以下数据预处理操作：

T.Resize(256): 调整图像大小到指定的尺寸，这里是将图像的较短边调整为256像素，保持纵横比不变。
T.RandomCrop(IMAGE_SIZE): 对图像进行随机裁剪到指定的尺寸 IMAGE_SIZE，也是为了增加数据的多样性。
T.ToTensor(): 同样将图像数据转换为张量格式。
T.Normalize(): 对图像进行标准化，与训练模式下相同。

对每一个照片以及标签相应处理

标签变成NumPy数组，数据类型为 'int64'，通常表示整数类型。


def __getitem__(self, index):
    """
    根据索引获取单个样本
    """
    image_file, label = self.data[index]
    image = Image.open(image_file)

    if image.mode != 'RGB':
        image = image.convert('RGB')

    image = self.transforms(image)

    return image, np.array(label, dtype='int64')

从数据集的 self.data 中根据索引 index 获取单个样本的文件路径 image_file 和标签 label。

使用Pillow库中的 Image.open(image_file) 打开图像文件，将图像加载到内存中。

检查图像的模式是否为 'RGB'，如果不是 'RGB' 模式，则使用 image.convert('RGB') 将图像转换为 'RGB' 模式。这是因为深度学习模型通常要求输入图像为 'RGB' 彩色模式。

接下来，将图像传递给之前在构造函数中定义的数据预处理变换 self.transforms，以进行图像的预处理。根据不同的模式（训练模式或测试模式），self.transforms 可以是不同的预处理操作，如调整大小、裁剪、归一化等。

最后，将经过预处理的图像 image 和标签 label 返回。图像通常被转换为张量格式，而标签通常被转换为NumPy数组，并指定数据类型为 'int64'，以适应深度学习模型的要求。