华为开源自研AI框架昇思MindSpore应用案例：基于MindSpore框架的UNet-2D案例实现

朱雀 2024-03-23 22:45 77阅读 0赞

#### 目录 ####

*  一、环境准备
 *   *  1.进入ModelArts官网
     *  2.使用CodeLab体验Notebook实例
 *  二、案例实现
 *   *  2.1 环境准备与数据读取
     *  2.2 数据集创建
     *  2.3 模型构建
     *  2.4 自定义评估指标
     *  2.5 模型训练及评估
     *  2.6 模型预测
     *  2.7 可视化预测结果

> Unet模型于2015年在论文《U-Net: Convolutional Networks for Biomedical Image  
> Segmentation》中被提出，最初的提出是为了解决医学图像分割问题，用于细胞层面的图像分割任务。
> 
> Unet模型是在FCN网络的基础上构建的，但由于FCN无法获取上下文信息以及位置信息，导致准确性较低，Unet模型由此引入了U型结构获取上述两种信息，并且模型结构简单高效、容易构建，在较小的数据集上也能实现较高的准确率。  
> ![在这里插入图片描述][870606aaa0924d249ce4deafbddf104d.png]  
> 整个模型结构就是在原始图像输入后，首先进行特征提取，再进行特征融合：
> 
> a)  
> 左半部分负责特征提取的网络结构（即编码器结构）需要利用两个3x3的卷积核与2x2的池化层组成一个“下采样模块”，每一个下采样模块首先会对特征图进行两次valid卷积，再进行一次池化操作。由此经过4个下采样模块后，原始尺寸为572x572大小、通道数为1的原始图像，转换为了大小为28x28、通道数为1024的特征图。
> 
> b)  
> 右半部分负责进行上采样的网络结构（即解码器结构）需要利用1次反卷积操作、特征拼接操作以及两个3x3的卷积核作为一个“上采样模块”，每一个上采样模块首先会对特征图通过反卷积操作使图像尺寸增加1倍，再通过拼接编码器结构中的特征图使得通道数增加，最后经过两次valid卷积。由此经过4个上采样模块后，经过下采样模块的、大小为28x28、通道数为1024的特征图，转换为了大小为388x388、通道数为64的特征图。
> 
> c) 网络结构的最后一部分是通过两个1x1的卷积核将经过上采样得到的通道数为64的特征图，转换为了通道数为2的图像作为预测结果输出。  
> 模型特点
> 
> a) 利用拼接操作将低级特征图与高级特征图进行特征融合
> 
> b) 完全对称的U型结构使得高分辨率信息和低分辨率信息在目标图片中增加，前后特征融合更为彻底。
> 
> c)  
> 结合了下采样时的低分辨率信息（提供物体类别识别依据）和上采样时的高分辨率信息（提供精准分割定位依据），此外还通过融合操作填补底层信息以提高分割精度。

如果你对MindSpore感兴趣，可以关注[**昇思MindSpore社区**][MindSpore]

![在这里插入图片描述][a9571b75523b4cbca146948dbadf8715.png]

![在这里插入图片描述][8e1b9518e76a42838be8cde13c4655c7.png]

## 一、环境准备 ##

### 1.进入ModelArts官网 ###

云平台帮助用户快速创建和部署模型，管理全周期AI工作流，选择下面的云平台以开始使用昇思MindSpore，[获取安装命令][Link 1]，安装MindSpore2.0.0-alpha版本，可以在昇思教程中进入[**ModelArts官网**][ModelArts]

![在这里插入图片描述][661e20e619f840aba899fac2091e96bf.png]

选择下方CodeLab立即体验

![在这里插入图片描述][547900ad31bf4f4386132554fe26dfb9.png]

等待环境搭建完成

![在这里插入图片描述][1466f73e44fa4fe69bd38b0b30661e22.png]

### 2.使用CodeLab体验Notebook实例 ###

下载[**NoteBook样例代码**][NoteBook]，[**基于MindSpore框架的UNet-2D案例实现**][NoteBook] ，`.ipynb`为样例代码

![在这里插入图片描述][cebd6bf723084e4ca91cdf9ece6eca01.png]

打开一个terminal，将项目clone下来

git clone https://github.com/mindspore-courses/applications.git

![在这里插入图片描述][9e800e387fb24dfa8b66f60f15289d1e.png]

找到U-Net.ipynb  
![在这里插入图片描述][efaf6280dd7c4ee2a93a89f899336da1.png]

选择Kernel环境

![在这里插入图片描述][f871d4254e8248cfbc458c0245be9224.png]

切换至GPU环境，切换成第一个限时免费

![在这里插入图片描述][3ee6f6bb23454bbeb5fec682705b3873.png]

进入[**昇思MindSpore官网**][MindSpore 1]，点击上方的安装

![在这里插入图片描述][2dec09846d164105b79d514aa0deed82.png]

获取安装命令

![在这里插入图片描述][084d07e792b64e8e857146e81183ca42.png]

回到Notebook中，在第一块代码前加入命令  
![在这里插入图片描述][d1b5e7f5355b410599f32ed6a59d9000.png]

conda update -n base -c defaults conda

![在这里插入图片描述][805039f1f2df413daf3a797d6ef58b01.png]

安装MindSpore 2.0 GPU版本

conda install mindspore=2.0.0a0 -c mindspore -c conda-forge

![在这里插入图片描述][95a53f7dde714310a336b134e5a51f1d.png]

安装mindvision

pip install mindvision

![在这里插入图片描述][7eec4a2d97634beeae03da93eabf8eb5.png]

安装下载download

pip install download

![在这里插入图片描述][119027ad29034ed9be82b75092515c6c.png]

## 二、案例实现 ##

### 2.1 环境准备与数据读取 ###

本案例基于MindSpore-CPU版本实现，在CPU上完成模型训练。

案例实现所使用的数据即ISBI果蝇电镜图数据集，可以从http://brainiac2.mit.edu/isbi\_challenge/ 中下载，下载好的数据集包括3个tif文件，分别对应测试集样本、训练集标签、训练集样本，文件路径结构如下：

.datasets/
    └── ISBI
        ├── test-volume.tif
        ├── train-labels.tif
        └── train-volume.tif

其中每个tif文件都由30副图片压缩而成，所以接下来需要获取每个tif文件中所存储的所有图片，将其转换为png格式存储，得到训练集样本对应的30张png图片、训练集标签对应的30张png图片以及测试集样本对应的30张png图片。

import sys
    import mindspore
    print(sys.executable)
    print(mindspore.run_check())
    from PIL import Image, ImageSequence
    import math
    import numpy as np
    import matplotlib.pyplot as plt
    #显示下载好的数据
    train_image_path = "data/train-volume.tif"
    train_masks_path = "data/train-labels.tif"
    image = np.array([np.array(p) for p in ImageSequence.Iterator(Image.open(train_image_path))])
    masks = np.array([np.array(p) for p in ImageSequence.Iterator(Image.open(train_masks_path))])
    
    def show_image(image_list,num = 6):
        img_titles = []
        img_draws = []
        for ind,img in enumerate(image_list):
            if ind == num:
                break
            img_titles.append(ind)
            img_draws.append(img)
    
        for i in range(len(img_titles)):
            if len(img_titles) > 6:
                row = 3
            elif 3<len(img_titles)<=6:
                row = 2
            else:
                row = 1
            col = math.ceil(len(img_titles)/row)
            plt.subplot(row,col,i+1),plt.imshow(img_draws[i],'gray')
            plt.title(img_titles[i])
            plt.xticks([]),plt.yticks([])
        plt.show()
        
    show_image(image,num = 12)
    show_image(masks,num = 12)

![在这里插入图片描述][ed74061e916545f0a75da95c0eff9c72.png]

![在这里插入图片描述][e03ded26a1064b779e37f9fd0970460c.png]

具体的实现方式首先是将tif文件转换为数组形式，之后通过io操作将每张图片对应的数组存储为png图像，处理过后的训练集样本及其对应的标签图像如图2所示。将3个tif文件转换为png格式后，针对训练集的样本与标签，将其以2:1的比例，重新划分为了训练集与验证集，划分完成后的文件路径结构如下：

.datasets/
    └── ISBI
        ├── test_imgs
        │   ├── 00000.png
        │   ├── 00001.png
        │   └── . . . . .
        ├── train
        │   ├── image
        │   │   ├── 00001.png
        │   │   ├── 00002.png
        │   │   └── . . . . .
        │   └── mask
        │       ├── 00001.png
        │       ├── 00002.png
        │       └── . . . . .
        └── val
            ├── image
            │   ├── 00000.png
            │   ├── 00003.png
            │   └── . . . . .
            └── mask
                ├── 00000.png
                ├── 00003.png
                └── . . . . .

转换代码如下，请注意，此示例代码仅将第一帧转换为png格式。如果需要转换所有帧，请使用循环并在每次迭代中调用img.seek(i)。

from PIL import Image
    import os
    
    # 创建输出目录
    output_dir = './datasets/ISBI'
    os.makedirs(os.path.join(output_dir, 'train', 'image'), exist_ok=True)
    os.makedirs(os.path.join(output_dir, 'train', 'mask'), exist_ok=True)
    os.makedirs(os.path.join(output_dir, 'val', 'image'), exist_ok=True)
    os.makedirs(os.path.join(output_dir, 'val', 'mask'), exist_ok=True)
    os.makedirs(os.path.join(output_dir, 'test_imgs'), exist_ok=True)
    
    # 将train-volume.tif转换为png格式并保存到train/image目录下
    with Image.open('./data/train-volume.tif') as img:
        img.save(os.path.join(output_dir, 'train', 'image', '00001.png'))
    
    # 将train-labels.tif转换为png格式并保存到train/mask目录下
    with Image.open('./data/train-labels.tif') as img:
        img.save(os.path.join(output_dir, 'train', 'mask', '00001.png'))
    
    # 将test-volume.tif转换为png格式并保存到test_imgs目录下
    with Image.open('./data/test-volume.tif') as img:
        for i in range(img.n_frames):
            img.seek(i)
            img.save(os.path.join(output_dir, 'test_imgs', '{:05d}.png'.format(i)))
    
    # 将train-volume.tif和train-labels.tif分别划分为训练集和验证集，并保存到对应目录下
    with Image.open('./data/train-volume.tif') as img1, Image.open('./data/train-labels.tif') as img2:
        for i in range(img1.n_frames):
            img1.seek(i)
            img2.seek(i)
            if i % 3 == 0:
                img1.save(os.path.join(output_dir, 'val', 'image', '{:05d}.png'.format(i // 3)))
                img2.save(os.path.join(output_dir, 'val', 'mask', '{:05d}.png'.format(i // 3)))
            else:
                img1.save(os.path.join(output_dir, 'train', 'image', '{:05d}.png'.format(i // 3 + 1)))
                img2.save(os.path.join(output_dir, 'train', 'mask', '{:05d}.png'.format(i // 3 + 1)))

![在这里插入图片描述][654b5daf98f8455e849b7b759f437739.png]  
![在这里插入图片描述][da7a5179ef75485b85c10da4486db134.png]

### 2.2 数据集创建 ###

在进行上述tif文件格式转换，以及测试集和验证集的进一步划分后，就完成了数据读取所需的所有工作，接下来就需要利用处理好的图像数据，通过一定的图像变换来进行数据增强，并完成数据集的创建。

import os
    import cv2
    import mindspore.dataset as ds
    import glob
    import mindspore.dataset.vision as vision_C  #.c_transforms
    import mindspore.dataset.transforms as C_transforms #.c_transform
    import random
    import mindspore
    from mindspore.dataset.vision import Inter
    
    def train_transforms(img_size):
        return [
        vision_C.Resize(img_size, interpolation=Inter.NEAREST),
        vision_C.Rescale(1./255., 0.0),
        vision_C.RandomHorizontalFlip(prob=0.5),
        vision_C.RandomVerticalFlip(prob=0.5),
        vision_C.HWC2CHW()
        ]
    
    
    def val_transforms(img_size):
        return [
        vision_C.Resize(img_size, interpolation=Inter.NEAREST),
        vision_C.Rescale(1/255., 0),
        vision_C.HWC2CHW()
        ]
    
    
    
    class Data_Loader:
        def __init__(self, data_path):
            # 初始化函数，读取所有data_path下的图片
            self.data_path = data_path
            self.imgs_path = glob.glob(os.path.join(data_path, 'image/*.png'))
            self.label_path = glob.glob(os.path.join(data_path, 'mask/*.png'))
    
        def __getitem__(self, index):
            # 根据index读取图片
            image = cv2.imread(self.imgs_path[index])
            label = cv2.imread(self.label_path[index], cv2.IMREAD_GRAYSCALE)
            label = label.reshape((label.shape[0], label.shape[1], 1))
        
            return image, label
    
        @property
        def column_names(self):
            column_names = ['image', 'label']
            return column_names
    
        def __len__(self):
            # 返回训练集大小
            return len(self.imgs_path)
    
    
    def create_dataset(data_dir, img_size, batch_size, augment, shuffle):
        mc_dataset = Data_Loader(data_path=data_dir)
        dataset = ds.GeneratorDataset(mc_dataset, mc_dataset.column_names, shuffle=shuffle)
    
        if augment:
            transform_img = train_transforms(img_size)
        else:
            transform_img = val_transforms(img_size)
    
        seed = random.randint(1,1000)
        mindspore.set_seed(seed)
        dataset = dataset.map(input_columns='image', num_parallel_workers=1, operations=transform_img)
        mindspore.set_seed(seed)
        dataset = dataset.map(input_columns="label", num_parallel_workers=1, operations=transform_img)
    
        if shuffle:
            dataset = dataset.shuffle(buffer_size=10000)
        dataset = dataset.batch(batch_size, num_parallel_workers=1)
        if augment == True and shuffle == True:
            print("训练集数据量：", len(mc_dataset))
        elif augment == False and shuffle == False:
            print("验证集数据量：", len(mc_dataset))
        else:
            pass
        return dataset

注意这里要修改datasets对应的路径

if __name__ == '__main__':
        train_dataset = create_dataset('src/datasets/ISBI/val', img_size=224, batch_size=3, augment=False, shuffle=False)
        for item, (image, label) in enumerate(train_dataset):
            if item < 5:
                print(f"Shape of image [N, C, H, W]: {image.shape} {image.dtype}",'---',f"Shape of label [N, C, H, W]: {label.shape} {label.dtype}")

![在这里插入图片描述][e029582731c541f9885ac7bd2e32b5dc.png]

### 2.3 模型构建 ###

本案例实现中所构建的Unet模型结构与2015年论文中提出的Unet结构大致相同，但本案例中Unet网络模型的“下采样模块”与“上采样模块”使用的卷积类型都为Same卷积，而原论文中使用的是Valid卷积。

from mindspore import nn
    import mindspore.numpy as np
    import mindspore.ops as ops
    import mindspore.ops.operations as F
    
    def double_conv(in_ch, out_ch):
        return nn.SequentialCell(nn.Conv2d(in_ch, out_ch, 3),
                                  nn.BatchNorm2d(out_ch), nn.ReLU(),
                                  nn.Conv2d(out_ch, out_ch, 3),
                                  nn.BatchNorm2d(out_ch), nn.ReLU())
    class UNet(nn.Cell):
        def __init__(self, in_ch = 3, n_classes = 1):
            super(UNet, self).__init__()
            self.concat1 = F.Concat(axis=1)
            self.concat2 = F.Concat(axis=1)
            self.concat3 = F.Concat(axis=1)
            self.concat4 = F.Concat(axis=1)
            self.double_conv1 = double_conv(in_ch, 64)
            self.maxpool1 = nn.MaxPool2d(kernel_size=2, stride=2)
            self.double_conv2 = double_conv(64, 128)
            self.maxpool2 = nn.MaxPool2d(kernel_size=2, stride=2)
            self.double_conv3 = double_conv(128, 256)
            self.maxpool3 = nn.MaxPool2d(kernel_size=2, stride=2)
            self.double_conv4 = double_conv(256, 512)
            self.maxpool4 = nn.MaxPool2d(kernel_size=2, stride=2)
            self.double_conv5 = double_conv(512, 1024)
    
            self.upsample1 = nn.ResizeBilinear()
            self.double_conv6 = double_conv(1024 + 512, 512)
            self.upsample2 = nn.ResizeBilinear()
            self.double_conv7 = double_conv(512 + 256, 256)
            self.upsample3 = nn.ResizeBilinear()
            self.double_conv8 = double_conv(256 + 128, 128)
            self.upsample4 = nn.ResizeBilinear()
            self.double_conv9 = double_conv(128 + 64, 64)
    
            self.final = nn.Conv2d(64, n_classes, 1)
            self.sigmoid = ops.Sigmoid()
    
        def construct(self, x):
    
            feature1 = self.double_conv1(x)
            tmp = self.maxpool1(feature1)
            feature2 = self.double_conv2(tmp)
            tmp = self.maxpool2(feature2)
            feature3 = self.double_conv3(tmp)
            tmp = self.maxpool3(feature3)
            feature4 = self.double_conv4(tmp)
            tmp = self.maxpool4(feature4)
            feature5 = self.double_conv5(tmp)
    
            up_feature1 = self.upsample1(feature5, scale_factor=2)
            tmp = self.concat1((feature4, up_feature1))
            tmp = self.double_conv6(tmp)
            up_feature2 = self.upsample2(tmp, scale_factor=2)
            tmp = self.concat2((feature3, up_feature2))
            tmp = self.double_conv7(tmp)
            up_feature3 = self.upsample3(tmp, scale_factor=2)
            tmp = self.concat3((feature2, up_feature3))
            tmp = self.double_conv8(tmp)
            up_feature4 = self.upsample4(tmp, scale_factor=2)
            tmp = self.concat4((feature1, up_feature4))
            tmp = self.double_conv9(tmp)
            output = self.sigmoid(self.final(tmp))
    
            return output

### 2.4 自定义评估指标 ###

为了能够更加全面和直观的观察网络模型训练效果，本案例实现中还使用了MindSpore框架来自定义Metrics，在自定义的metrics类中使用了多种评价函数来评估模型的好坏，分别为准确率Acc、交并比IoU、Dice系数、灵敏度Sens、特异性Spec。

import numpy as np
    from mindspore._checkparam import Validator as validator
    from mindspore.nn import Metric
    from mindspore import Tensor
    
    class metrics_(Metric):
        def __init__(self, metrics, smooth=1e-5):
            super(metrics_, self).__init__()
            self.metrics = metrics
            self.smooth = validator.check_positive_float(smooth, "smooth")
            self.metrics_list = [0. for i in range(len(self.metrics))]
            self._samples_num = 0
            self.clear()
    
        def Acc_metrics(self,y_pred, y):
            tp = np.sum(y_pred.flatten() == y.flatten(), dtype=y_pred.dtype)
            total = len(y_pred.flatten())
            single_acc = float(tp) / float(total)
            return single_acc
    
        def IoU_metrics(self,y_pred, y):
            intersection = np.sum(y_pred.flatten() * y.flatten())
            unionset = np.sum(y_pred.flatten() + y.flatten()) - intersection
            single_iou = float(intersection) / float(unionset + self.smooth)
            return single_iou
    
        def Dice_metrics(self,y_pred, y):
            intersection = np.sum(y_pred.flatten() * y.flatten())
            unionset = np.sum(y_pred.flatten()) + np.sum(y.flatten())
            single_dice = 2*float(intersection) / float(unionset + self.smooth)
            return single_dice
    
        def Sens_metrics(self,y_pred, y):
            tp = np.sum(y_pred.flatten() * y.flatten())
            actual_positives = np.sum(y.flatten())
            single_sens = float(tp) / float(actual_positives + self.smooth)
            return single_sens
    
        def Spec_metrics(self,y_pred, y):
            true_neg = np.sum((1 - y.flatten()) * (1 - y_pred.flatten()))
            total_neg = np.sum((1 - y.flatten()))
            single_spec = float(true_neg) / float(total_neg + self.smooth)
            return single_spec
    
        def clear(self):
            """Clears the internal evaluation result."""
            self.metrics_list = [0. for i in range(len(self.metrics))]
            self._samples_num = 0
    
        def update(self, *inputs):
    
            if len(inputs) != 2:
                raise ValueError("For 'update', it needs 2 inputs (predicted value, true value), ""but got {
        }.".format(len(inputs)))
    
            
            y_pred = Tensor(inputs[0]).asnumpy()  #modelarts,cpu
            # y_pred = np.array(Tensor(inputs[0]))  #cpu
            
            y_pred[y_pred > 0.5] = float(1)
            y_pred[y_pred <= 0.5] = float(0)
            
            y = Tensor(inputs[1]).asnumpy()  #modelarts,cpu
            # y = np.array(Tensor(inputs[1]))  #cpu
            
            self._samples_num += y.shape[0]
    
            if y_pred.shape != y.shape:
                raise ValueError(f"For 'update', predicted value (input[0]) and true value (input[1]) "
                                 f"should have same shape, but got predicted value shape: {
        y_pred.shape}, "
                                 f"true value shape: {
        y.shape}.")
    
            for i in range(y.shape[0]):
                if "acc" in self.metrics:
                    single_acc = self.Acc_metrics(y_pred[i], y[i])
                    self.metrics_list[0] += single_acc
                if "iou" in self.metrics:
                    single_iou = self.IoU_metrics(y_pred[i], y[i])
                    self.metrics_list[1] += single_iou
                if "dice" in self.metrics:
                    single_dice = self.Dice_metrics(y_pred[i], y[i])
                    self.metrics_list[2] += single_dice
                if "sens" in self.metrics:
                    single_sens = self.Sens_metrics(y_pred[i], y[i])
                    self.metrics_list[3] += single_sens
                if "spec" in self.metrics:
                    single_spec = self.Spec_metrics(y_pred[i], y[i])
                    self.metrics_list[4] += single_spec
    
        def eval(self):
            if self._samples_num == 0:
                raise RuntimeError("The 'metrics' can not be calculated, because the number of samples is 0, "
                                   "please check whether your inputs(predicted value, true value) are empty, or has "
                                   "called update method before calling eval method.")
            for i in range(len(self.metrics_list)):
                self.metrics_list[i] = self.metrics_list[i] / float(self._samples_num)
    
            return self.metrics_list

x = Tensor(np.array([[[[0.2, 0.5, 0.7], [0.3, 0.1, 0.2], [0.9, 0.6, 0.8]]]]))
    y = Tensor(np.array([[[[0, 1, 1], [1, 0, 0], [0, 1, 1]]]]))
    metric = metrics_(["acc", "iou", "dice", "sens", "spec"],smooth=1e-5)
    metric.clear()
    metric.update(x, y)
    res = metric.eval()
    print( '丨acc: %.4f丨丨iou: %.4f丨丨dice: %.4f丨丨sens: %.4f丨丨spec: %.4f丨' % (res[0], res[1], res[2], res[3],res[4]), flush=True)

![在这里插入图片描述][1a0acfc9943c4d9e9522a8183feb37f8.png]

### 2.5 模型训练及评估 ###

在模型训练时，首先是设置模型训练的epoch次数为50，再通过2.1节中自定义的create\_dataset方法创建了训练集和验证集，其中训练集batch\_size大小为4，验证集batch\_size大小为2，图像尺寸统一调整为224x224；损失函数使用nn.BCELoss，优化器使用nn.Adam，并设置学习率为0.01。

注意这里要修改对应的路径

import mindspore.nn as nn
    from mindspore import ops
    import mindspore
    from mindspore import ms_function
    os.system("pip install ml_collections" )
    import ml_collections
    
    def get_config():
        """configuration """
        config = ml_collections.ConfigDict()
        config.epochs = 100
        config.train_data_path = "src/datasets/ISBI/train/"
        config.val_data_path = "src/datasets/ISBI/val/"
        config.imgsize = 224
        config.batch_size = 4
        config.pretrained_path = None
        config.in_channel = 3
        config.n_classes = 1
        config.lr = 0.0001
        return config
    
    cfg = get_config()
    
    
    train_dataset = create_dataset(cfg.train_data_path, img_size=cfg.imgsize, batch_size= cfg.batch_size, augment=True, shuffle = True)
    val_dataset = create_dataset(cfg.val_data_path, img_size=cfg.imgsize, batch_size= cfg.batch_size, augment=False, shuffle = False)
    
    
    def train(model, dataset, loss_fn, optimizer, met):
        # Define forward function
        def forward_fn(data, label):
            logits = model(data)
            loss = loss_fn(logits, label)
            return loss, logits
        # Get gradient function
        grad_fn = ops.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)
        # Define function of one-step training
        @ms_function
        def train_step(data, label):
            (loss, logits), grads = grad_fn(data, label)
            loss = ops.depend(loss, optimizer(grads))
            return loss, logits
    
        size = dataset.get_dataset_size()
        model.set_train(True)
        train_loss = 0
        train_pred = []
        train_label = []
        for batch, (data, label) in enumerate(dataset.create_tuple_iterator()):
            loss, logits = train_step(data, label)
            train_loss += loss.asnumpy()
            train_pred.extend(logits.asnumpy())
            train_label.extend(label.asnumpy())
    
        train_loss /= size
        metric = metrics_(met, smooth=1e-5)
        metric.clear()
        metric.update(train_pred, train_label)
        res = metric.eval()
        print(f'Train loss:{train_loss:>4f}','丨acc: %.3f丨丨iou: %.3f丨丨dice: %.3f丨丨sens: %.3f丨丨spec: %.3f丨' % (res[0], res[1], res[2], res[3], res[4]))
    
    
    def val(model, dataset, loss_fn, met):
        size = dataset.get_dataset_size()
        model.set_train(False)
        val_loss = 0
        val_pred = []
        val_label = []
        for batch, (data, label) in enumerate(dataset.create_tuple_iterator()):
            pred = model(data)
            val_loss += loss_fn(pred, label).asnumpy()
            val_pred.extend(pred.asnumpy())
            val_label.extend(label.asnumpy())
    
        val_loss /= size
        metric = metrics_(met, smooth=1e-5)
        metric.clear()
        metric.update(val_pred, val_label)
        res = metric.eval()
    
        print(f'Val loss:{val_loss:>4f}','丨acc: %.3f丨丨iou: %.3f丨丨dice: %.3f丨丨sens: %.3f丨丨spec: %.3f丨' % (res[0], res[1], res[2], res[3], res[4]))
    
        checkpoint = res[1]
        return checkpoint, res[4]
    
    
    net = UNet(cfg.in_channel, cfg.n_classes)
    
    criterion = nn.BCEWithLogitsLoss()
    optimizer = nn.SGD(params=net.trainable_params(), learning_rate=cfg.lr)
    
    iters_per_epoch = train_dataset.get_dataset_size()
    total_train_steps = iters_per_epoch * cfg.epochs
    print('iters_per_epoch: ', iters_per_epoch)
    print('total_train_steps: ', total_train_steps)
    
    metrics_name = ["acc", "iou", "dice", "sens", "spec"]
    
    best_iou = 0
    ckpt_path = 'checkpoint/best_UNet.ckpt'
    for epoch in range(cfg.epochs):
        print(f"Epoch [{epoch+1} / {cfg.epochs}]")
        train(net, train_dataset, criterion, optimizer, metrics_name)
        checkpoint_best, spec = val(net, val_dataset, criterion, metrics_name)
        if epoch > 2 and spec > 0.2:
            if checkpoint_best > best_iou:
                print('IoU improved from %0.4f to %0.4f' % (best_iou, checkpoint_best))
                best_iou = checkpoint_best
                mindspore.save_checkpoint(net, ckpt_path)
                print("saving best checkpoint at: {} ".format(ckpt_path))
            else:
                print('IoU did not improve from %0.4f' % (best_iou),"\n-------------------------------")
    print("Done!")

![在这里插入图片描述][d832725794724d739795d67b719169a6.png]

### 2.6 模型预测 ###

import os
    import cv2
    import mindspore.dataset as ds
    import glob
    import mindspore.dataset.vision as vision_C
    import mindspore.dataset.transforms as C_transforms
    import random
    import mindspore
    from mindspore.dataset.vision import Inter
    import numpy as np
    from tqdm import tqdm
    # import skimage.io as io
    
    
    def val_transforms(img_size):
        return C_transforms.Compose([
        vision_C.Resize(img_size, interpolation=Inter.NEAREST),
        vision_C.Rescale(1/255., 0),
        vision_C.HWC2CHW()
        ])
    
    class Data_Loader:
        def __init__(self, data_path, have_mask):
            # 初始化函数，读取所有data_path下的图片
            self.data_path = data_path
            self.have_mask = have_mask
            self.imgs_path = glob.glob(os.path.join(data_path, 'image/*.png'))
            if self.have_mask:
                self.label_path = glob.glob(os.path.join(data_path, 'mask/*.png'))
    
        def __getitem__(self, index):
            # 根据index读取图片
            image = cv2.imread(self.imgs_path[index])
            if self.have_mask:
                label = cv2.imread(self.label_path[index], cv2.IMREAD_GRAYSCALE)
                label = label.reshape((label.shape[0], label.shape[1], 1))
            else:
                label = image
            return image, label
    
        @property
        def column_names(self):
            column_names = ['image', 'label']
            return column_names
    
        def __len__(self):
            return len(self.imgs_path)
    
    
    def create_dataset(data_dir, img_size, batch_size, shuffle, have_mask = False):
        mc_dataset = Data_Loader(data_path=data_dir, have_mask = have_mask)
        print(len(mc_dataset))
        dataset = ds.GeneratorDataset(mc_dataset, mc_dataset.column_names, shuffle=shuffle)
        transform_img = val_transforms(img_size)
        seed = random.randint(1, 1000)
        mindspore.set_seed(seed)
        dataset = dataset.map(input_columns='image', num_parallel_workers=1, operations=transform_img)
        mindspore.set_seed(seed)
        dataset = dataset.map(input_columns="label", num_parallel_workers=1, operations=transform_img)
        dataset = dataset.batch(batch_size, num_parallel_workers=1)
        return dataset
    
    def model_pred(model, test_loader, result_path, have_mask):
        model.set_train(False)
        test_pred = []
        test_label = []
        for batch, (data, label) in enumerate(test_loader.create_tuple_iterator()):
     
            pred = model(data)
    
            pred[pred > 0.5] = float(1)
            pred[pred <= 0.5] = float(0)
    
            preds = np.squeeze(pred, axis=0)
            img = np.transpose(preds,(1, 2, 0))
    
            if not os.path.exists(result_path):
                os.makedirs(result_path)
            # io.imsave(os.path.join(result_path, "%05d.png" % batch), img.asnumpy())
            cv2.imwrite(os.path.join(result_path, "%05d.png" % batch), img.asnumpy()*255.)
    
            test_pred.extend(pred.asnumpy())
            test_label.extend(label.asnumpy())
    
        if have_mask:
            mtr = ['acc', 'iou', 'dice', 'sens', 'spec']
            metric = metrics_(mtr, smooth=1e-5)
            metric.clear()
            metric.update(test_pred, test_label)
            res = metric.eval()
            print(f'丨acc: %.3f丨丨iou: %.3f丨丨dice: %.3f丨丨sens: %.3f丨丨spec: %.3f丨' % (res[0], res[1], res[2], res[3], res[4]))
        else:
            print("Evaluation metrics cannot be calculated without Mask")
    
    if __name__ == '__main__':
        net = UNet(3, 1)
        mindspore.load_checkpoint("checkpoint/best_UNet.ckpt", net=net)
        result_path = "predict"
        test_dataset = create_dataset("src/datasets/ISBI/test/", 224, 1, shuffle=False, have_mask=False)
        model_pred(net, test_dataset, result_path, have_mask=False)

![在这里插入图片描述][9f1408ed77f54164b6307a704b64a227.png]

### 2.7 可视化预测结果 ###

根据评价指标结构，本案例构建的网络模型具有较好的性能，能够实现对测试集进行较为准确的预测，针对测试集的部分预测结果如图所示。

注意，这里要修改对应的路径

image_path = "src/datasets/ISBI/test/image/"
    pred_path = "predict/"
    
    image_list = os.listdir(image_path)
    pred_list = os.listdir(pred_path)[1:]
    # print(image_list)
    # print(pred_list)
    test_image = np.array([cv2.imread(image_path + image_list[p], -1) for p in range(len(image_list))])
    pred_masks = np.array([cv2.imread(pred_path + pred_list[p], -1) for p in range(len(pred_list))])
    
    show_image(test_image, num = 12)
    show_image(pred_masks, num = 12)

![在这里插入图片描述][ccc534a48f4048488f4cfcc752eff974.png]

[870606aaa0924d249ce4deafbddf104d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8cba29d582ef4f27997af29dcc43ee48.png
[MindSpore]: https://bbs.csdn.net/forums/MindSpore_Official
[a9571b75523b4cbca146948dbadf8715.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/5e4ecd504c4c49d8a606562a569cb5b9.png
[8e1b9518e76a42838be8cde13c4655c7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/23452f0c08bf43af9229fc64f7dfd48a.png
[Link 1]: https://mindspore.cn/install
[ModelArts]: https://console.huaweicloud.com/modelarts/?region=cn-north-4#/dashboard
[661e20e619f840aba899fac2091e96bf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/b0365c511ccc4ef091840433fda4ba2c.png
[547900ad31bf4f4386132554fe26dfb9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/eacce6842a144698b65bc1fa0d44f0dc.png
[1466f73e44fa4fe69bd38b0b30661e22.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4665272fcf504f708ce0c9aa01897f76.png
[NoteBook]: https://github.com/mindspore-courses/applications/blob/master/U-Net/U-Net.ipynb
[cebd6bf723084e4ca91cdf9ece6eca01.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8c68f3a825234128950549d968f11935.png
[9e800e387fb24dfa8b66f60f15289d1e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6a8c0844ca9b49f796d694d8f6b8db93.png
[efaf6280dd7c4ee2a93a89f899336da1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/35497c701bf24a6e9dba65d4c666f9d6.png
[f871d4254e8248cfbc458c0245be9224.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ef06e4bd78704ae9aa0d6025795633a5.png
[3ee6f6bb23454bbeb5fec682705b3873.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/3d4887e5776e463c857bdeeffb074fcf.png
[MindSpore 1]: https://www.mindspore.cn/
[2dec09846d164105b79d514aa0deed82.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/4eea954c0d5d412b85a87a6200d12ef5.png
[084d07e792b64e8e857146e81183ca42.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/340781ac75fe4a4eafd12330c35de831.png
[d1b5e7f5355b410599f32ed6a59d9000.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c0093a2b11b14cf79855e3d9c240aba8.png
[805039f1f2df413daf3a797d6ef58b01.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/70e13aea82404893bc1d348d16a939ac.png
[95a53f7dde714310a336b134e5a51f1d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/dc2e975790eb4bb18b0e82c18d1f8c29.png
[7eec4a2d97634beeae03da93eabf8eb5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/7d44fd89957744e7a0a4daf734c24807.png
[119027ad29034ed9be82b75092515c6c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/de669889bb4a4ef8b8d62cf82147f36c.png
[ed74061e916545f0a75da95c0eff9c72.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/b4821b28479f4415a1d7bc312a481c1b.png
[e03ded26a1064b779e37f9fd0970460c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/fbb61d30a36646848452e7782169c737.png
[654b5daf98f8455e849b7b759f437739.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/cefdd5089521469889568ae61248f10a.png
[da7a5179ef75485b85c10da4486db134.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c658140bbdaa4c43a05c8efa10c99da9.png
[e029582731c541f9885ac7bd2e32b5dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/44574956b1904df88c18433818f58b55.png
[1a0acfc9943c4d9e9522a8183feb37f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/a636fb81b6234e539fb9140758b53099.png
[d832725794724d739795d67b719169a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/7f2077b4ed79499c84da48df6f1b6dd5.png
[9f1408ed77f54164b6307a704b64a227.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9b8afacf4cb9462bba8a46e9ecebb47c.png
[ccc534a48f4048488f4cfcc752eff974.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/141df149793547afb0c388baae4b8cdd.png