昇思25天学习打卡营第24天|基于MobileNetv2的垃圾分类案例：从数据准备到导出模型文件

最新推荐文章于 2024-07-31 00:21:16 发布

前端基地

最新推荐文章于 2024-07-31 00:21:16 发布

阅读量636

点赞数 17

分类专栏： AI实验室文章标签：深度学习 python 人工智能 MobileNetv2 MobileNetv2案例模型训练模型推理

本文链接：https://blog.csdn.net/chinayun_6401/article/details/140799551

版权

AI实验室专栏收录该内容

25 篇文章 0 订阅

订阅专栏

MindSpore 版本配置及相关数据集与预训练权重文件下载

基于 MindSpore 的垃圾分类数据集创建与配置

MobileNetV2 模型的构建与相关类定义

基于 MindSpore 的 MobileNetV2 模型训练与测试代码分析

基于 MobileNetV2 模型的图像推理代码分析

MobileNetV2 模型的构建、加载与导出代码分析

MindSpore 版本配置及相关数据集与预训练权重文件下载

首先使用 %%capture captured_output 捕获后续代码的输出。接着，如果需要更改 MindSpore 版本，会先卸载已安装的版本，然后从指定源安装特定版本 2.3.0rc1 的 MindSpore ，并查看当前安装的 MindSpore 版本。随后，从 download 模块导入 download 函数，分别用于下载两个数据集：data_en 数据集和预训练权重文件。指定了每个数据集的 url 地址，并将它们下载到当前目录（./），采用 zip 格式，若已存在则进行替换。

代码如下：

%%capture captured_output
# 实验环境已经预装了mindspore==2.3.0rc1，如需更换mindspore版本，可更改下面mindspore的版本号
!pip uninstall mindspore -y
!pip install -i https://pypi.mirrors.ustc.edu.cn/simple mindspore==2.3.0rc1
# 查看当前 mindspore 版本
!pip show mindspore
from download import download

# 下载data_en数据集
url = "https://ascend-professional-construction-dataset.obs.cn-north-4.myhuaweicloud.com:443/MindStudio-pc/data_en.zip" 
path = download(url, "./", kind="zip", replace=True)
from download import download

# 下载预训练权重文件
url = "https://ascend-professional-construction-dataset.obs.cn-north-4.myhuaweicloud.com:443/ComputerVision/mobilenetV2-200_1067.zip" 
path = download(url, "./", kind="zip", replace=True)

基于 MindSpore 的垃圾分类数据集创建与配置

首先进行了一系列的库导入，并设置了一些环境变量用于日志记录。然后定义了垃圾分类的相关类别和标签映射字典。接下来，设置了训练的超参数，包括类别数量、图像尺寸、批量大小、训练轮数等。之后定义了一个名为 create_dataset 的函数，用于根据给定的数据集路径和配置参数创建训练或评估数据集。在函数内部，根据训练或评估的不同需求，对数据进行了不同的预处理操作，如随机裁剪、水平翻转、颜色调整、归一化、数据类型转换等，并进行了数据的混洗和批量处理。

代码如下：

import math
import numpy as np
import os
import random

from matplotlib import pyplot as plt
from easydict import EasyDict
from PIL import Image
import numpy as np
import mindspore.nn as nn
from mindspore import ops as P
from mindspore.ops import add
from mindspore import Tensor
import mindspore.common.dtype as mstype
import mindspore.dataset as de
import mindspore.dataset.vision as C
import mindspore.dataset.transforms as C2
import mindspore as ms
from mindspore import set_context, nn, Tensor, load_checkpoint, save_checkpoint, export
from mindspore.train import Model
from mindspore.train import Callback, LossMonitor, ModelCheckpoint, CheckpointConfig

os.environ['GLOG_v'] = '3' # Log level includes 3(ERROR), 2(WARNING), 1(INFO), 0(DEBUG).
os.environ['GLOG_logtostderr'] = '0' # 0：输出到文件，1：输出到屏幕
os.environ['GLOG_log_dir'] = '../../log' # 日志目录
os.environ['GLOG_stderrthreshold'] = '2' # 输出到目录也输出到屏幕：3(ERROR), 2(WARNING), 1(INFO), 0(DEBUG).
set_context(mode=ms.GRAPH_MODE, device_target="CPU", device_id=0) # 设置采用图模式执行，设备为Ascend#
# 垃圾分类数据集标签，以及用于标签映射的字典。
garbage_classes = {
    '干垃圾': ['贝壳', '打火机', '旧镜子', '扫把', '陶瓷碗', '牙刷', '一次性筷子', '脏污衣服'],
    '可回收物': ['报纸', '玻璃制品', '篮球', '塑料瓶', '硬纸板', '玻璃瓶', '金属制品', '帽子', '易拉罐', '纸张'],
    '湿垃圾': ['菜叶', '橙皮', '蛋壳', '香蕉皮'],
    '有害垃圾': ['电池', '药片胶囊', '荧光灯', '油漆桶']
}

class_cn = ['贝壳', '打火机', '旧镜子', '扫把', '陶瓷碗', '牙刷', '一次性筷子', '脏污衣服',
            '报纸', '玻璃制品', '篮球', '塑料瓶', '硬纸板', '玻璃瓶', '金属制品', '帽子', '易拉罐', '纸张',
            '菜叶', '橙皮', '蛋壳', '香蕉皮',
            '电池', '药片胶囊', '荧光灯', '油漆桶']
class_en = ['Seashell', 'Lighter','Old Mirror', 'Broom','Ceramic Bowl', 'Toothbrush','Disposable Chopsticks','Dirty Cloth',
            'Newspaper', 'Glassware', 'Basketball', 'Plastic Bottle', 'Cardboard','Glass Bottle', 'Metalware', 'Hats', 'Cans', 'Paper',
            'Vegetable Leaf','Orange Peel', 'Eggshell','Banana Peel',
            'Battery', 'Tablet capsules','Fluorescent lamp', 'Paint bucket']

index_en = {'Seashell': 0, 'Lighter': 1, 'Old Mirror': 2, 'Broom': 3, 'Ceramic Bowl': 4, 'Toothbrush': 5, 'Disposable Chopsticks': 6, 'Dirty Cloth': 7,
            'Newspaper': 8, 'Glassware': 9, 'Basketball': 10, 'Plastic Bottle': 11, 'Cardboard': 12, 'Glass Bottle': 13, 'Metalware': 14, 'Hats': 15, 'Cans': 16, 'Paper': 17,
            'Vegetable Leaf': 18, 'Orange Peel': 19, 'Eggshell': 20, 'Banana Peel': 21,
            'Battery': 22, 'Tablet capsules': 23, 'Fluorescent lamp': 24, 'Paint bucket': 25}

# 训练超参
config = EasyDict({
    "num_classes": 26,
    "image_height": 224,
    "image_width": 224,
    #"data_split": [0.9, 0.1],
    "backbone_out_channels":1280,
    "batch_size": 16,
    "eval_batch_size": 8,
    "epochs": 10,
    "lr_max": 0.05,
    "momentum": 0.9,
    "weight_decay": 1e-4,
    "save_ckpt_epochs": 1,
    "dataset_path": "./data_en",
    "class_index": index_en,
    "pretrained_ckpt": "./mobilenetV2-200_1067.ckpt" # mobilenetV2-200_1067.ckpt 
})
def create_dataset(dataset_path, config, training=True, buffer_size=1000):
    """
    create a train or eval dataset

    Args:
        dataset_path(string): the path of dataset.
        config(struct): the config of train and eval in diffirent platform.

    Returns:
        train_dataset, val_dataset
    """
    data_path = os.path.join(dataset_path, 'train' if training else 'test')
    ds = de.ImageFolderDataset(data_path, num_parallel_workers=4, class_indexing=config.class_index)
    resize_height = config.image_height
    resize_width = config.image_width
    
    normalize_op = C.Normalize(mean=[0.485*255, 0.456*255, 0.406*255], std=[0.229*255, 0.224*255, 0.225*255])
    change_swap_op = C.HWC2CHW()
    type_cast_op = C2.TypeCast(mstype.int32)

    if training:
        crop_decode_resize = C.RandomCropDecodeResize(resize_height, scale=(0.08, 1.0), ratio=(0.75, 1.333))
        horizontal_flip_op = C.RandomHorizontalFlip(prob=0.5)
        color_adjust = C.RandomColorAdjust(brightness=0.4, contrast=0.4, saturation=0.4)
    
        train_trans = [crop_decode_resize, horizontal_flip_op, color_adjust, normalize_op, change_swap_op]
        train_ds = ds.map(input_columns="image", operations=train_trans, num_parallel_workers=4)
        train_ds = train_ds.map(input_columns="label", operations=type_cast_op, num_parallel_workers=4)
        
        train_ds = train_ds.shuffle(buffer_size=buffer_size)
        ds = train_ds.batch(config.batch_size, drop_remainder=True)
    else:
        decode_op = C.Decode()
        resize_op = C.Resize((int(resize_width/0.875), int(resize_width/0.875)))
        center_crop = C.CenterCrop(resize_width)
        
        eval_trans = [decode_op, resize_op, center_crop, normalize_op, change_swap_op]
        eval_ds = ds.map(input_columns="image", operations=eval_trans, num_parallel_workers=4)
        eval_ds = eval_ds.map(input_columns="label", operations=type_cast_op, num_parallel_workers=4)
        ds = eval_ds.batch(config.eval_batch_size, drop_remainder=True)

    return ds

垃圾分类评估数据集的获取与图像可视化

首先调用之前定义的 create_dataset 函数创建了一个评估数据集 ds ，并打印出数据集的大小。然后，通过创建字典迭代器获取数据，将数据中的图像和标签分别存储在 images 和 labels 中。接下来，使用 for 循环绘制 4 个子图，每个子图展示一张图像，并在标题中显示对应的标签。最后，使用 plt.show 显示图形。

代码如下：

ds = create_dataset(dataset_path=config.dataset_path, config=config, training=False)
print(ds.get_dataset_size())
data = ds.create_dict_iterator(output_numpy=True)._get_next()
images = data['image']
labels = data['label']

for i in range(1, 5):
    plt.subplot(2, 2, i)
    plt.imshow(np.transpose(images[i], (1,2,0)))
    plt.title('label: %s' % class_en[labels[i]])
    plt.xticks([])
plt.show()

运行结果：

MobileNetV2 模型的构建与相关类定义

定义了一系列与 MobileNetV2 相关的类和函数。首先定义了一些辅助函数，如 _make_divisible 用于对数值进行调整。然后创建了几个类：GlobalAvgPooling 用于全局平均池化操作，ConvBNReLU 用于卷积、批量归一化和 ReLU 激活的组合操作，InvertedResidual 定义了 MobileNetV2 中的残差块。接着定义了 MobileNetV2Backbone 用于构建 MobileNetV2 的骨干架构，包括对不同层的配置和初始化权重的方法。MobileNetV2Head 定义了网络的头部结构，包括全连接层和可能的激活函数，同样包含了初始化权重的方法。MobileNetV2 则将骨干和头部组合起来构建完整的网络。最后，mobilenet_v2 函数用于创建 MobileNetV2Combine 对象。

代码如下：

__all__ = ['MobileNetV2', 'MobileNetV2Backbone', 'MobileNetV2Head', 'mobilenet_v2']

def _make_divisible(v, divisor, min_value=None):
    if min_value is None:
        min_value = divisor
    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
    if new_v < 0.9 * v:
        new_v += divisor
    return new_v

class GlobalAvgPooling(nn.Cell):
    """
    Global avg pooling definition.

    Args:

    Returns:
        Tensor, output tensor.

    Examples:
        >>> GlobalAvgPooling()
    """

    def __init__(self):
        super(GlobalAvgPooling, self).__init__()

    def construct(self, x):
        x = P.mean(x, (2, 3))
        return x

class ConvBNReLU(nn.Cell):
    """
    Convolution/Depthwise fused with Batchnorm and ReLU block definition.

    Args:
        in_planes (int): Input channel.
        out_planes (int): Output channel.
        kernel_size (int): Input kernel size.
        stride (int): Stride size for the first convolutional layer. Default: 1.
        groups (int): channel group. Convolution is 1 while Depthiwse is input channel. Default: 1.

    Returns:
        Tensor, output tensor.

    Examples:
        >>> ConvBNReLU(16, 256, kernel_size=1, stride=1, groups=1)
    """

    def __init__(self, in_planes, out_planes, kernel_size=3, stride=1, groups=1):
        super(ConvBNReLU, self).__init__()
        padding = (kernel_size - 1) // 2
        in_channels = in_planes
        out_channels = out_planes
        if groups == 1:
            conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, pad_mode='pad', padding=padding)
        else:
            out_channels = in_planes
            conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, pad_mode='pad',
                             padding=padding, group=in_channels)

        layers = [conv, nn.BatchNorm2d(out_planes), nn.ReLU6()]
        self.features = nn.SequentialCell(layers)

    def construct(self, x):
        output = self.features(x)
        return output

class InvertedResidual(nn.Cell):
    """
    Mobilenetv2 residual block definition.

    Args:
        inp (int): Input channel.
        oup (int): Output channel.
        stride (int): Stride size for the first convolutional layer. Default: 1.
        expand_ratio (int): expand ration of input channel

    Returns:
        Tensor, output tensor.

    Examples:
        >>> ResidualBlock(3, 256, 1, 1)
    """

    def __init__(self, inp, oup, stride, expand_ratio):
        super(InvertedResidual, self).__init__()
        assert stride in [1, 2]

        hidden_dim = int(round(inp * expand_ratio))
        self.use_res_connect = stride == 1 and inp == oup

        layers = []
        if expand_ratio != 1:
            layers.append(ConvBNReLU(inp, hidden_dim, kernel_size=1))
        layers.extend([
            ConvBNReLU(hidden_dim, hidden_dim,
                       stride=stride, groups=hidden_dim),
            nn.Conv2d(hidden_dim, oup, kernel_size=1,
                      stride=1, has_bias=False),
            nn.BatchNorm2d(oup),
        ])
        self.conv = nn.SequentialCell(layers)
        self.cast = P.Cast()

    def construct(self, x):
        identity = x
        x = self.conv(x)
        if self.use_res_connect:
            return P.add(identity, x)
        return x

class MobileNetV2Backbone(nn.Cell):
    """
    MobileNetV2 architecture.

    Args:
        class_num (int): number of classes.
        width_mult (int): Channels multiplier for round to 8/16 and others. Default is 1.
        has_dropout (bool): Is dropout used. Default is false
        inverted_residual_setting (list): Inverted residual settings. Default is None
        round_nearest (list): Channel round to . Default is 8
    Returns:
        Tensor, output tensor.

    Examples:
        >>> MobileNetV2(num_classes=1000)
    """

    def __init__(self, width_mult=1., inverted_residual_setting=None, round_nearest=8,
                 input_channel=32, last_channel=1280):
        super(MobileNetV2Backbone, self).__init__()
        block = InvertedResidual
        # setting of inverted residual blocks
        self.cfgs = inverted_residual_setting
        if inverted_residual_setting is None:
            self.cfgs = [
                # t, c, n, s
                [1, 16, 1, 1],
                [6, 24, 2, 2],
                [6, 32, 3, 2],
                [6, 64, 4, 2],
                [6, 96, 3, 1],
                [6, 160, 3, 2],
                [6, 320, 1, 1],
            ]

        # building first layer
        input_channel = _make_divisible(input_channel * width_mult, round_nearest)
        self.out_channels = _make_divisible(last_channel * max(1.0, width_mult), round_nearest)
        features = [ConvBNReLU(3, input_channel, stride=2)]
        # building inverted residual blocks
        for t, c, n, s in self.cfgs:
            output_channel = _make_divisible(c * width_mult, round_nearest)
            for i in range(n):
                stride = s if i == 0 else 1
                features.append(block(input_channel, output_channel, stride, expand_ratio=t))
                input_channel = output_channel
        features.append(ConvBNReLU(input_channel, self.out_channels, kernel_size=1))
        self.features = nn.SequentialCell(features)
        self._initialize_weights()

    def construct(self, x):
        x = self.features(x)
        return x

    def _initialize_weights(self):
        """
        Initialize weights.

        Args:

        Returns:
            None.

        Examples:
            >>> _initialize_weights()
        """
        self.init_parameters_data()
        for _, m in self.cells_and_names():
            if isinstance(m, nn.Conv2d):
                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
                m.weight.set_data(Tensor(np.random.normal(0, np.sqrt(2. / n),
                                                          m.weight.data.shape).astype("float32")))
                if m.bias is not None:
                    m.bias.set_data(
                        Tensor(np.zeros(m.bias.data.shape, dtype="float32")))
            elif isinstance(m, nn.BatchNorm2d):
                m.gamma.set_data(
                    Tensor(np.ones(m.gamma.data.shape, dtype="float32")))
                m.beta.set_data(
                    Tensor(np.zeros(m.beta.data.shape, dtype="float32")))

    @property
    def get_features(self):
        return self.features

class MobileNetV2Head(nn.Cell):
    """
    MobileNetV2 architecture.

    Args:
        class_num (int): Number of classes. Default is 1000.
        has_dropout (bool): Is dropout used. Default is false
    Returns:
        Tensor, output tensor.

    Examples:
        >>> MobileNetV2(num_classes=1000)
    """

    def __init__(self, input_channel=1280, num_classes=1000, has_dropout=False, activation="None"):
        super(MobileNetV2Head, self).__init__()
        # mobilenet head
        head = ([GlobalAvgPooling(), nn.Dense(input_channel, num_classes, has_bias=True)] if not has_dropout else
                [GlobalAvgPooling(), nn.Dropout(0.2), nn.Dense(input_channel, num_classes, has_bias=True)])
        self.head = nn.SequentialCell(head)
        self.need_activation = True
        if activation == "Sigmoid":
            self.activation = nn.Sigmoid()
        elif activation == "Softmax":
            self.activation = nn.Softmax()
        else:
            self.need_activation = False
        self._initialize_weights()

    def construct(self, x):
        x = self.head(x)
        if self.need_activation:
            x = self.activation(x)
        return x

    def _initialize_weights(self):
        """
        Initialize weights.

        Args:

        Returns:
            None.

        Examples:
            >>> _initialize_weights()
        """
        self.init_parameters_data()
        for _, m in self.cells_and_names():
            if isinstance(m, nn.Dense):
                m.weight.set_data(Tensor(np.random.normal(
                    0, 0.01, m.weight.data.shape).astype("float32")))
                if m.bias is not None:
                    m.bias.set_data(
                        Tensor(np.zeros(m.bias.data.shape, dtype="float32")))
    @property
    def get_head(self):
        return self.head

class MobileNetV2(nn.Cell):
    """
    MobileNetV2 architecture.

    Args:
        class_num (int): number of classes.
        width_mult (int): Channels multiplier for round to 8/16 and others. Default is 1.
        has_dropout (bool): Is dropout used. Default is false
        inverted_residual_setting (list): Inverted residual settings. Default is None
        round_nearest (list): Channel round to . Default is 8
    Returns:
        Tensor, output tensor.

    Examples:
        >>> MobileNetV2(backbone, head)
    """

    def __init__(self, num_classes=1000, width_mult=1., has_dropout=False, inverted_residual_setting=None, \
        round_nearest=8, input_channel=32, last_channel=1280):
        super(MobileNetV2, self).__init__()
        self.backbone = MobileNetV2Backbone(width_mult=width_mult, \
            inverted_residual_setting=inverted_residual_setting, \
            round_nearest=round_nearest, input_channel=input_channel, last_channel=last_channel).get_features
        self.head = MobileNetV2Head(input_channel=self.backbone.out_channel, num_classes=num_classes, \
            has_dropout=has_dropout).get_head

    def construct(self, x):
        x = self.backbone(x)
        x = self.head(x)
        return x

class MobileNetV2Combine(nn.Cell):
    """
    MobileNetV2Combine architecture.

    Args:
        backbone (Cell): the features extract layers.
        head (Cell):  the fully connected layers.
    Returns:
        Tensor, output tensor.

    Examples:
        >>> MobileNetV2(num_classes=1000)
    """

    def __init__(self, backbone, head):
        super(MobileNetV2Combine, self).__init__(auto_prefix=False)
        self.backbone = backbone
        self.head = head

    def construct(self, x):
        x = self.backbone(x)
        x = self.head(x)
        return x

def mobilenet_v2(backbone, head):
return MobileNetV2Combine(backbone, head)

基于 MindSpore 的 MobileNetV2 模型训练与测试代码分析

实现了基于 MindSpore 框架的 MobileNetV2 模型的训练和测试过程。

首先，定义了 cosine_decay 函数用于生成学习率的变化数组。根据给定的总训练步数、初始学习率、结束学习率、最大学习率以及预热步数，通过不同的计算方式在预热阶段和余弦衰减阶段分别确定学习率的值。

接着，switch_precision 函数用于在特定设备目标为 Ascend 时，对网络进行数据类型的转换。

然后，通过 create_dataset 函数创建了训练数据集和评估数据集，并获取了训练数据集的大小。

之后，定义了 MobileNetV2 的骨干网络 backbone，并对其参数进行了一些处理，如冻结参数和加载预训练模型的参数。同时定义了头部网络 head，并组合成完整的网络 network。

再之后，定义了损失函数 loss、损失缩放管理器 loss_scale、学习率数组 lrs 和优化器 opt。

接下来，分别定义了 train_loop 函数用于训练模型，其中包含正向计算、梯度计算和参数更新的过程，并在每 10 个批次打印一次损失值；test_loop 函数用于测试模型，计算测试集的平均损失和准确率。

最后，进行了 2 个 epoch 的训练和测试循环，在每个 epoch 中先进行训练，保存模型的检查点，然后进行测试。

代码如下：

def cosine_decay(total_steps, lr_init=0.0, lr_end=0.0, lr_max=0.1, warmup_steps=0):
    """
    Applies cosine decay to generate learning rate array.

    Args:
       total_steps(int): all steps in training.
       lr_init(float): init learning rate.
       lr_end(float): end learning rate
       lr_max(float): max learning rate.
       warmup_steps(int): all steps in warmup epochs.

    Returns:
       list, learning rate array.
    """
    lr_init, lr_end, lr_max = float(lr_init), float(lr_end), float(lr_max)
    decay_steps = total_steps - warmup_steps
    lr_all_steps = []
    inc_per_step = (lr_max - lr_init) / warmup_steps if warmup_steps else 0
    for i in range(total_steps):
        if i < warmup_steps:
            lr = lr_init + inc_per_step * (i + 1)
        else:
            cosine_decay = 0.5 * (1 + math.cos(math.pi * (i - warmup_steps) / decay_steps))
            lr = (lr_max - lr_end) * cosine_decay + lr_end
        lr_all_steps.append(lr)

    return lr_all_steps
def switch_precision(net, data_type):
    if ms.get_context('device_target') == "Ascend":
        net.to_float(data_type)
        for _, cell in net.cells_and_names():
            if isinstance(cell, nn.Dense):
                cell.to_float(ms.float32)
from mindspore.amp import FixedLossScaleManager
LOSS_SCALE = 1024

train_dataset = create_dataset(dataset_path=config.dataset_path, config=config)
eval_dataset = create_dataset(dataset_path=config.dataset_path, config=config)
step_size = train_dataset.get_dataset_size()
    
backbone = MobileNetV2Backbone() #last_channel=config.backbone_out_channels
# Freeze parameters of backbone. You can comment these two lines.
for param in backbone.get_parameters():
    param.requires_grad = False
# load parameters from pretrained model
load_checkpoint(config.pretrained_ckpt, backbone)

head = MobileNetV2Head(input_channel=backbone.out_channels, num_classes=config.num_classes)
network = mobilenet_v2(backbone, head)

# define loss, optimizer, and model
loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
loss_scale = FixedLossScaleManager(LOSS_SCALE, drop_overflow_update=False)
lrs = cosine_decay(config.epochs * step_size, lr_max=config.lr_max)
opt = nn.Momentum(network.trainable_params(), lrs, config.momentum, config.weight_decay, loss_scale=LOSS_SCALE)

# 定义用于训练的train_loop函数。
def train_loop(model, dataset, loss_fn, optimizer):
    # 定义正向计算函数
    def forward_fn(data, label):
        logits = model(data)
        loss = loss_fn(logits, label)
        return loss

    # 定义微分函数，使用mindspore.value_and_grad获得微分函数grad_fn,输出loss和梯度。
    # 由于是对模型参数求导,grad_position 配置为None，传入可训练参数。
    grad_fn = ms.value_and_grad(forward_fn, None, optimizer.parameters)

    # 定义 one-step training函数
    def train_step(data, label):
        loss, grads = grad_fn(data, label)
        optimizer(grads)
        return loss

    size = dataset.get_dataset_size()
    model.set_train()
    for batch, (data, label) in enumerate(dataset.create_tuple_iterator()):
        loss = train_step(data, label)

        if batch % 10 == 0:
            loss, current = loss.asnumpy(), batch
            print(f"loss: {loss:>7f}  [{current:>3d}/{size:>3d}]")

# 定义用于测试的test_loop函数。
def test_loop(model, dataset, loss_fn):
    num_batches = dataset.get_dataset_size()
    model.set_train(False)
    total, test_loss, correct = 0, 0, 0
    for data, label in dataset.create_tuple_iterator():
        pred = model(data)
        total += len(data)
        test_loss += loss_fn(pred, label).asnumpy()
        correct += (pred.argmax(1) == label).asnumpy().sum()
    test_loss /= num_batches
    correct /= total
    print(f"Test: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
print("============== Starting Training ==============")
# 由于时间问题，训练过程只进行了2个epoch ，可以根据需求调整。建议在Ascend / GPU 环境下进行训练。
epochs = 2
for t in range(epochs):
    print(f"Epoch {t+1}\n-------------------------------")
    train_loop(network, train_dataset, loss, opt)
    ms.save_checkpoint(network, "save_mobilenetV2_model.ckpt")
    test_loop(network, eval_dataset, loss)
print("Done!")

运行结果：

============== Starting Training ==============
Epoch 1
-------------------------------
[ERROR] CORE(788,7f664f098740,python):2024-07-30-07:58:47.276.141 [mindspore/core/utils/file_utils.cc:253] GetRealPath] Get realpath failed, path[/tmp/ipykernel_788/2349218205.py]
[ERROR] CORE(788,7f664f098740,python):2024-07-30-07:58:47.276.185 [mindspore/core/utils/file_utils.cc:253] GetRealPath] Get realpath failed, path[/tmp/ipykernel_788/2349218205.py]
[ERROR] CORE(788,7f664f098740,python):2024-07-30-07:58:47.276.201 [mindspore/core/utils/file_utils.cc:253] GetRealPath] Get realpath failed, path[/tmp/ipykernel_788/2349218205.py]
loss: 3.287117  [  0/162]
loss: 3.197833  [ 10/162]
loss: 3.298612  [ 20/162]
loss: 3.224156  [ 30/162]
loss: 3.174496  [ 40/162]
loss: 3.192225  [ 50/162]
loss: 3.223677  [ 60/162]
loss: 3.245857  [ 70/162]
loss: 3.136196  [ 80/162]
loss: 3.209753  [ 90/162]
loss: 3.173197  [100/162]
loss: 3.230978  [110/162]
loss: 3.148482  [120/162]
loss: 3.201745  [130/162]
loss: 3.179046  [140/162]
loss: 3.178990  [150/162]
loss: 3.271595  [160/162]
[ERROR] CORE(788,7f664f098740,python):2024-07-30-07:59:45.032.918 [mindspore/core/utils/file_utils.cc:253] GetRealPath] Get realpath failed, path[/tmp/ipykernel_788/3136751602.py]
[ERROR] CORE(788,7f664f098740,python):2024-07-30-07:59:45.032.974 [mindspore/core/utils/file_utils.cc:253] GetRealPath] Get realpath failed, path[/tmp/ipykernel_788/3136751602.py]
Test: 
 Accuracy: 8.8%, Avg loss: 3.176884 

Epoch 2
-------------------------------
[ERROR] CORE(788,7f664f098740,python):2024-07-30-08:00:36.675.764 [mindspore/core/utils/file_utils.cc:253] GetRealPath] Get realpath failed, path[/tmp/ipykernel_788/2349218205.py]
[ERROR] CORE(788,7f664f098740,python):2024-07-30-08:00:36.675.806 [mindspore/core/utils/file_utils.cc:253] GetRealPath] Get realpath failed, path[/tmp/ipykernel_788/2349218205.py]
[ERROR] CORE(788,7f664f098740,python):2024-07-30-08:00:36.675.820 [mindspore/core/utils/file_utils.cc:253] GetRealPath] Get realpath failed, path[/tmp/ipykernel_788/2349218205.py]
loss: 3.232986  [  0/162]
loss: 3.228610  [ 10/162]
loss: 3.161849  [ 20/162]
loss: 3.160692  [ 30/162]
loss: 3.202355  [ 40/162]
loss: 3.128389  [ 50/162]
loss: 3.101801  [ 60/162]
loss: 3.155088  [ 70/162]
loss: 3.176835  [ 80/162]
loss: 3.210523  [ 90/162]
loss: 3.140944  [100/162]
loss: 3.178103  [110/162]
loss: 3.185791  [120/162]
loss: 3.136397  [130/162]
loss: 3.190870  [140/162]
loss: 3.134854  [150/162]
loss: 3.158881  [160/162]
Test: 
 Accuracy: 21.5%, Avg loss: 3.097873 

Done!

基于 MobileNetV2 模型的图像推理代码分析

主要实现了使用已训练的 MobileNetV2 模型对一系列图像进行推理预测的功能。

首先，定义了一个名为 image_process 的函数，用于对输入的图像进行预处理。预处理包括减去均值、除以标准差以及调整图像通道的顺序，并将处理后的图像转换为张量格式。

然后，定义了 infer_one 函数，该函数打开指定路径的图像，经过预处理后，使用传入的网络模型进行预测，得到预测的逻辑值，并通过 np.argmax 函数获取预测结果的类别索引，最后打印出图像路径和对应的预测类别。

接下来，定义了 infer 函数。在这个函数中，重新构建了 MobileNetV2 的骨干网络和头部网络，并组合成完整的网络模型。然后加载指定的检查点文件来初始化模型的参数。通过一个循环，对从 91 到 100 的图像路径进行推理预测。

总的来说，这段代码的目的是利用已保存的模型参数对一系列特定的图像进行类别预测。

代码如下：

CKPT="save_mobilenetV2_model.ckpt"
def image_process(image):
    """Precess one image per time.
    
    Args:
        image: shape (H, W, C)
    """
    mean=[0.485*255, 0.456*255, 0.406*255]
    std=[0.229*255, 0.224*255, 0.225*255]
    image = (np.array(image) - mean) / std
    image = image.transpose((2,0,1))
    img_tensor = Tensor(np.array([image], np.float32))
    return img_tensor

def infer_one(network, image_path):
    image = Image.open(image_path).resize((config.image_height, config.image_width))
    logits = network(image_process(image))
    pred = np.argmax(logits.asnumpy(), axis=1)[0]
    print(image_path, class_en[pred])

def infer():
    backbone = MobileNetV2Backbone(last_channel=config.backbone_out_channels)
    head = MobileNetV2Head(input_channel=backbone.out_channels, num_classes=config.num_classes)
    network = mobilenet_v2(backbone, head)
    load_checkpoint(CKPT, network)
    for i in range(91, 100):
        infer_one(network, f'data_en/test/Cardboard/000{i}.jpg')
infer()

运行结果：

[ERROR] CORE(788,7f664f098740,python):2024-07-30-08:02:41.257.311 [mindspore/core/utils/file_utils.cc:253] GetRealPath] Get realpath failed, path[/tmp/ipykernel_788/3136751602.py]
[ERROR] CORE(788,7f664f098740,python):2024-07-30-08:02:41.257.361 [mindspore/core/utils/file_utils.cc:253] GetRealPath] Get realpath failed, path[/tmp/ipykernel_788/3136751602.py]
data_en/test/Cardboard/00091.jpg Hats
data_en/test/Cardboard/00092.jpg Disposable Chopsticks
data_en/test/Cardboard/00093.jpg Glass Bottle
data_en/test/Cardboard/00094.jpg Lighter
data_en/test/Cardboard/00095.jpg Basketball
data_en/test/Cardboard/00096.jpg Hats
data_en/test/Cardboard/00097.jpg Orange Peel
data_en/test/Cardboard/00098.jpg Hats
data_en/test/Cardboard/00099.jpg Metalware

MobileNetV2 模型的构建、加载与导出代码分析

主要进行了 MobileNetV2 模型的相关操作。

首先，构建了 MobileNetV2 的骨干网络 backbone 和头部网络 head，并将它们组合成完整的网络 network。然后，使用 load_checkpoint 函数加载了指定的检查点文件来初始化 network 的参数。

接着，生成了一个随机的输入数据 input，其数据类型为 np.float32，形状为 [1, 3, 224, 224]。

最后，使用 export 函数将已加载参数的 network 模型与生成的输入数据 input 一起导出为不同的格式。在这段代码中，实际执行的是导出为 ONNX 格式，文件名为 mobilenetv2.onnx。

总的来说，这段代码完成了模型的构建、参数加载，并将模型以特定格式进行导出，以便在不同的环境或框架中使用。

代码如下：

backbone = MobileNetV2Backbone(last_channel=config.backbone_out_channels)
head = MobileNetV2Head(input_channel=backbone.out_channels, num_classes=config.num_classes)
network = mobilenet_v2(backbone, head)
load_checkpoint(CKPT, network)

input = np.random.uniform(0.0, 1.0, size=[1, 3, 224, 224]).astype(np.float32)
# export(network, Tensor(input), file_name='mobilenetv2.air', file_format='AIR')
# export(network, Tensor(input), file_name='mobilenetv2.pb', file_format='GEIR')
export(network, Tensor(input), file_name='mobilenetv2.onnx', file_format='ONNX')

打印时间：

前端基地

关注

17
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
昇思25天学习打卡营第24天|基于MobileNetv2的垃圾分类案例：从数据准备到导出模型文件

这篇文章阐述了：基于 MobileNetv2 的垃圾分类实例，涵盖了从数据准备到导出模型文件的全过程，其中包含了 MindSpore 版本的配置以及相关数据集与预训练权重文件的下载操作，基于 MindSpore 的垃圾分类数据集的创建与配置流程，MobileNetV2 模型的构建及相关类的定义情况，基于 MindSpore 的 MobileNetV2 模型训练与测试的代码剖析，基于 MobileNetV2 模型的图像推理代码分析，以及 MobileNetV2 模型的构建、加载与导出的代码解析。
复制链接

扫一扫

专栏目录