基于MindSpore高效完成图像分割，实现Dice！

Dice 系数的介绍及实现

Dice系数原理

Dice是医学图像比赛中使用频率最高的度量指标，它是一种集合相似度度量指标，通常用于计算两个样本的相似度，值阈为[0, 1]。在医学图像中经常用于图像分割，分割的最好结果是1，最差时候结果为0.

Dice系数计算公式如下：

当然Dice也有另一个表达方式，是利用混淆矩阵中的TP，FP，FN来表达：

该公式原理如下图：

MindSpore代码实现

先简单介绍一下MindSpore——新一代AI开源计算框架。创新编程范式，AI科学家和工程师更易使用，便于开放式创新；该计算框架可满足终端、边缘计算、云全场景需求，能更好保护数据隐私；可开源，形成广阔应用生态。

2020年3月28日，华为在开发者大会2020上宣布，全场景AI计算框架MindSpore在码云正式开源。MindSpore着重提升易用性并降低AI开发者的开发门槛，MindSpore原生适应每个场景包括端、边缘和云，并能够在按需协同的基础上，通过实现AI算法即代码，使开发态变得更加友好，显著减少模型开发时间，降低模型开发门槛。

通过MindSpore自身的技术创新及MindSpore与华为昇腾AI处理器的协同优化，实现了运行态的高效，大大提高了计算性能；MindSpore也支持GPU、CPU等其它处理器。

"""Dice"""
import numpy as np
from mindspore._checkparam import Validator as validator
from .metric import Metricclass Dice(Metric):def __init__(self, smooth=1e-5):super(Dice, self).__init__()self.smooth = validator.check_positive_float(smooth, "smooth")self._dice_coeff_sum = 0self._samples_num = 0self.clear()def clear(self):# 是来清除历史数据self._dice_coeff_sum = 0self._samples_num = 0def update(self, *inputs):# 更新输入数据，y_pred和y，数据输入类型可以是Tensor，lisy或numpy，维度必须相等if len(inputs) != 2:raise ValueError('Dice need 2 inputs (y_pred, y), but got {}'.format(len(inputs)))# 将数据进行转换，统一转换为numpyy_pred = self._convert_data(inputs[0])y = self._convert_data(inputs[1])self._samples_num += y.shape[0]if y_pred.shape != y.shape:raise RuntimeError('y_pred and y should have same the dimension, but the shape of y_pred is{}, ''the shape of y is {}.'.format(y_pred.shape, y.shape))# 先求交集，利用dot对应点相乘再相加intersection = np.dot(y_pred.flatten(), y.flatten())# 求并集，先将输入shape都拉到一维，然后分别进行点乘，再将两个输入进行相加  unionset = np.dot(y_pred.flatten(), y_pred.flatten()) + np.dot(y.flatten(), y.flatten())# 利用公式进行计算，加smooth是为了防止分母为0，避免当pred和true都为0时，分子被0除的问题，同时减少过拟合single_dice_coeff = 2 * float(intersection) / float(unionset + self.smooth)# 对每一批次的系数进行累加self._dice_coeff_sum += single_dice_coeffdef eval(self):# 进行计算if self._samples_num == 0:raise RuntimeError('Total samples num must not be 0.')return self._dice_coeff_sum / float(self._samples_num)

使用方法如下：

import numpy as np
from mindspore import Tensor
from mindspore.nn.metrics Dicemetric = Dice(smooth=1e-5)
metric.clear()
x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
y = Tensor(np.array([[0, 1], [1, 0], [0, 1]]))
metric.update(x, y)
dice = metric.eval()
print(dice)0.20467791371802546

每个batch（两组数据）进行计算的时候如下：

import numpy as np
from mindspore import Tensor
from mindspore.nn.metrics Dicemetric = Dice(smooth=1e-5)
metric.clear()
x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
y = Tensor(np.array([[0, 1], [1, 0], [0, 1]]))
metric.update(x, y)x1= Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
y1 = Tensor(np.array([[1, 0], [1, 1], [1, 0]]))
metric.update(x1, y1)
avg_dice = metric.eval()
print(dice)

Dice Loss 介绍及实现

Dice Loss原理

Dice Loss 原理是在 Dice 系数的基础上进行计算，用1去减Dice系数

这种是在二分类一个批次只有一张图的情况，当一个批次有N张图片时，可以将图片压缩为一维向量，如下图：

对应的label也会相应变化，最后一起计算N张图片的Dice系数和Dice Loss。

MindSpore 二分类 DiceLoss 代码实现

class DiceLoss(_Loss):def __init__(self, smooth=1e-5):super(DiceLoss, self).__init__()self.smooth = validator.check_positive_float(smooth, "smooth")self.reshape = P.Reshape()def construct(self, logits, label):# 进行维度校验，维度必须相等。（输入必须是tensor）_check_shape(logits.shape, label.shape)# 求交集，和dice系数一样的方式intersection = self.reduce_sum(self.mul(logits.view(-1), label.view(-1)))# 求并集，和dice系数一样的方式unionset = self.reduce_sum(self.mul(logits.view(-1), logits.view(-1))) + \self.reduce_sum(self.mul(label.view(-1), label.view(-1)))# 利用公式进行计算single_dice_coeff = (2 * intersection) / (unionset + self.smooth)dice_loss = 1 - single_dice_coeff / label.shape[0]return dice_loss.mean()@constexpr
def _check_shape(logits_shape, label_shape):validator.check('logits_shape', logits_shape, 'label_shape', label_shape)

使用方法如下：

import numpy as np
import mindspore.common.dtype as mstype
import mindspore.nn as nn
from mindspore import Tensorloss = nn.DiceLoss(smooth=1e-5)
y_pred = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mstype.float32)
y = Tensor(np.array([[0, 1], [1, 0], [0, 1]]), mstype.float32)
output = loss(y_pred, y)
print(output)[0.7953220862819745]

MindSpore 多分类 MultiClassDiceLoss 代码实现

在MindSpore中支持在语义分割中有多种损失函数可以选择，不过最常用的还是用交叉熵来做损失函数。

class MultiClassDiceLoss(_Loss):def __init__(self, weights=None, ignore_indiex=None, activation=A.Softmax(axis=1)):super(MultiClassDiceLoss, self).__init__()# 利用Dice系数self.binarydiceloss = DiceLoss(smooth=1e-5)# 权重是一个Tensor，应该和分类数的维度一样：Tensor of shape `[num_classes, dim]`。self.weights = weights if weights is None else validator.check_value_type("weights", weights, [Tensor])# 要忽略的类别序号self.ignore_indiex = ignore_indiex if ignore_indiex is None else \validator.check_value_type("ignore_indiex", ignore_indiex, [int])# 使用激活函数self.activation = A.get_activation(activation) if isinstance(activation, str) else activationif activation is not None and not isinstance(self.activation, Cell):raise TypeError("The activation must be str or Cell, but got {}.".format(activation))self.activation_flag = self.activation is not Noneself.reshape = P.Reshape()def construct(self, logits, label):# 进行维度校验，维度必须相等。（输入必须是tensor）_check_shape(logits.shape, label.shape)# 先定义一个loss，初始值为0total_loss = 0# 如果使用激活函数if self.activation_flag:logits = self.activation(logits)# 按照标签的维度的第一个数进行遍历for i in range(label.shape[1]):if i != self.ignore_indiex:dice_loss = self.binarydiceloss(logits[:, i], label[:, i])if self.weights is not None:_check_weights(self.weights, label)dice_loss *= self.weights[i]total_loss += dice_lossreturn total_loss/label.shape[1]

使用方法如下：

import numpy as np
import mindspore.common.dtype as mstype
import mindspore.nn as nn
from mindspore import Tensorloss = nn.MultiClassDiceLoss(weights=None, ignore_indiex=None, activation="softmax")
y_pred = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]), mstype.float32)
y = Tensor(np.array([[0, 1], [1, 0], [0, 1]]), mstype.float32)
output = loss(y_pred, y)
print(output)[0.7761003]

Dice Loss 存在的问题

训练误差曲线非常混乱，很难看出关于收敛的信息。尽管可以检查在验证集上的误差来避开此问题。