自定义指标

除了使用飞桨框架内置的指标外，飞桨框架还支持用户根据自己的实际场景，完成指标的自定义。

一、自定义Loss

有时你会遇到特定任务的Loss计算方式在框架既有的Loss接口中不存在，或算法不符合自己的需求，那么期望能够自己来进行Loss的自定义。这里介绍如何进行Loss的自定义操作，首先来看下面的代码：

  1. class SelfDefineLoss(paddle.nn.Layer):
  2.    """
  3.    1. 继承paddle.nn.Layer
  4.    """
  5.    def __init__(self):
  6.        """
  7.        2. 构造函数根据自己的实际算法需求和使用需求进行参数定义即可
  8.        """
  9.        super(SelfDefineLoss, self).__init__()
  11.    def forward(self, input, label):
  12.        """
  13.        3. 实现forward函数，forward在调用时会传递两个参数：input和label
  14.            - input：单个或批次训练数据经过模型前向计算输出结果
  15.            - label：单个或批次训练数据对应的标签数据
  16.            接口返回值是一个Tensor，根据自定义的逻辑加和或计算均值后的损失
  17.        """
  18.        # 使用Paddle中相关API自定义的计算逻辑
  19.        # output = xxxxx
  20.        # return output

接下来是一个具体的例子，在图像分割示例代码中写的一个自定义Loss，当时主要是使用自定义的softmax计算维度。

  1. class SoftmaxWithCrossEntropy(paddle.nn.Layer):
  2.     def __init__(self):
  3.        super(SoftmaxWithCrossEntropy, self).__init__()
  5.     def forward(self, input, label):
  6.        loss = F.softmax_with_cross_entropy(input,
  7.                                            label,
  8.                                            return_softmax=False,
  9.                                            axis=1)
  10.        return paddle.mean(loss)

二、自定义Metric

和Loss一样，你也可以来通过框架实现自定义的评估方法，具体的实现如下：

  1. class SelfDefineMetric(paddle.metric.Metric):
  2.     """
  3.     1. 继承paddle.metric.Metric
  4.     """
  5.     def __init__(self):
  6.         """
  7.         2. 构造函数实现，自定义参数即可
  8.         """
  9.         super(SelfDefineMetric, self).__init__()
  11.     def name(self):
  12.         """
  13.         3. 实现name方法，返回定义的评估指标名字
  14.         """
  15.         return '自定义评价指标的名字'
  17.     def compute(self, ...)
  18.         """
  19.         4. 本步骤可以省略，实现compute方法，这个方法主要用于`update`的加速，可以在这个方法中调用一些paddle实现好的Tensor计算API，编译到模型网络中一起使用低层C++ OP计算。
  20.         """
  21.         return 自己想要返回的数据，会做为update的参数传入。
  23.     def update(self, ...):
  24.         """
  25.         5. 实现update方法，用于单个batch训练时进行评估指标计算。
  26.         - 当`compute`类函数未实现时，会将模型的计算输出和标签数据的展平作为`update`的参数传入。
  27.         - 当`compute`类函数做了实现时，会将compute的返回结果作为`update`的参数传入。
  28.         """
  29.         return acc value
  31.     def accumulate(self):
  32.         """
  33.         6. 实现accumulate方法，返回历史batch训练积累后计算得到的评价指标值。
  34.         每次`update`调用时进行数据积累，`accumulate`计算时对积累的所有数据进行计算并返回。
  35.         结算结果会在`fit`接口的训练日志中呈现。
  36.         """
  37.         # 利用update中积累的成员变量数据进行计算后返回
  38.         return accumulated acc value
  40.     def reset(self):
  41.         """
  42.         7. 实现reset方法，每个Epoch结束后进行评估指标的重置，这样下个Epoch可以重新进行计算。
  43.         """
  44.         # do reset action

接下来看一个框架中的具体例子，是框架中已提供的一个评估指标计算接口，这里就是按照上述说明中的方法完成了实现。

  1. from paddle.metric import Metric
  3. class Precision(Metric):
  4.     """
  5.     Precision (also called positive predictive value) is the fraction of
  6.     relevant instances among the retrieved instances. Refer to
  7.     https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers
  8.     Noted that this class manages the precision score only for binary
  9.     classification task.
  11.     ......
  12.     """
  14.     def __init__(self, name='precision', *args, **kwargs):
  15.         super(Precision, self).__init__(*args, **kwargs)
  16.         self.tp = 0  # true positive
  17.         self.fp = 0  # false positive
  18.         self._name = name
  20.     def update(self, preds, labels):
  21.         """
  22.         Update the states based on the current mini-batch prediction results.
  23.         Args:
  24.             preds (numpy.ndarray): The prediction result, usually the output
  25.                of two-class sigmoid function. It should be a vector (column
  26.                vector or row vector) with data type: 'float64' or 'float32'.
  27.            labels (numpy.ndarray): The ground truth (labels),
  28.                the shape should keep the same as preds.
  29.                The data type is 'int32' or 'int64'.
  30.         """
  31.         if isinstance(preds, paddle.Tensor):
  32.             preds = preds.numpy()
  33.         elif not _is_numpy_(preds):
  34.             raise ValueError("The 'preds' must be a numpy ndarray or Tensor.")
  35.         if isinstance(labels, paddle.Tensor):
  36.             labels = labels.numpy()
  37.         elif not _is_numpy_(labels):
  38.             raise ValueError("The 'labels' must be a numpy ndarray or Tensor.")
  40.         sample_num = labels.shape[0]
  41.         preds = np.floor(preds + 0.5).astype("int32")
  43.         for i in range(sample_num):
  44.             pred = preds[i]
  45.             label = labels[i]
  46.             if pred == 1:
  47.                 if pred == label:
  48.                     self.tp += 1
  49.                 else:
  50.                     self.fp += 1
  52.     def reset(self):
  53.         """
  54.         Resets all of the metric state.
  55.         """
  56.         self.tp = 0
  57.         self.fp = 0
  59.     def accumulate(self):
  60.         """
  61.         Calculate the final precision.
  63.         Returns:
  64.            A scaler float: results of the calculated precision.
  65.         """
  66.         ap = self.tp + self.fp
  67.         return float(self.tp) / ap if ap != 0 else .0
  69.     def name(self):
  70.         """
  71.         Returns metric name
  72.         """
  73.         return self._name

三、自定义Callback

fit接口的callback参数支持传入一个Callback类实例，用来在每轮训练和每个batch训练前后进行调用，可以通过callback收集到训练过程中的一些数据和参数，或者实现一些自定义操作。

  1. class SelfDefineCallback(paddle.callbacks.Callback):
  2.     """
  3.     1. 继承paddle.callbacks.Callback
  4.     2. 按照自己的需求实现以下类成员方法：
  5.         def on_train_begin(self, logs=None)                 训练开始前，`Model.fit`接口中调用
  6.         def on_train_end(self, logs=None)                   训练结束后，`Model.fit`接口中调用
  7.         def on_eval_begin(self, logs=None)                  评估开始前，`Model.evaluate`接口调用
  8.         def on_eval_end(self, logs=None)                    评估结束后，`Model.evaluate`接口调用
  9.         def on_predict_begin(self, logs=None)               预测测试开始前，`Model.predict`接口中调用
  10.         def on_predict_end(self, logs=None)                 预测测试结束后，`Model.predict`接口中调用
  11.         def on_epoch_begin(self, epoch, logs=None)          每轮训练开始前，`Model.fit`接口中调用
  12.         def on_epoch_end(self, epoch, logs=None)            每轮训练结束后，`Model.fit`接口中调用
  13.         def on_train_batch_begin(self, step, logs=None)     单个Batch训练开始前，`Model.fit`和`Model.train_batch`接口中调用
  14.         def on_train_batch_end(self, step, logs=None)       单个Batch训练结束后，`Model.fit`和`Model.train_batch`接口中调用
  15.         def on_eval_batch_begin(self, step, logs=None)      单个Batch评估开始前，`Model.evalute`和`Model.eval_batch`接口中调用
  16.         def on_eval_batch_end(self, step, logs=None)        单个Batch评估结束后，`Model.evalute`和`Model.eval_batch`接口中调用
  17.         def on_predict_batch_begin(self, step, logs=None)   单个Batch预测测试开始前，`Model.predict`和`Model.test_batch`接口中调用
  18.         def on_predict_batch_end(self, step, logs=None)     单个Batch预测测试结束后，`Model.predict`和`Model.test_batch`接口中调用
  19.     """
  21.     def __init__(self):
  22.         super(SelfDefineCallback, self).__init__()
  23.     # 按照需求定义自己的类成员方法

看一个框架中的实际例子，这是框架自带的ModelCheckpoint回调函数，可以在fit训练模型时自动存储每轮训练得到的模型。

  1. class ModelCheckpoint(Callback):
  2.     def __init__(self, save_freq=1, save_dir=None):
  3.         self.save_freq = save_freq
  4.         self.save_dir = save_dir
  6.     def on_epoch_begin(self, epoch=None, logs=None):
  7.         self.epoch = epoch
  9.     def _is_save(self):
  10.         return self.model and self.save_dir and ParallelEnv().local_rank == 0
  12.     def on_epoch_end(self, epoch, logs=None):
  13.         if self._is_save() and self.epoch % self.save_freq == 0:
  14.             path = '{}/{}'.format(self.save_dir, epoch)
  15.             print('save checkpoint at {}'.format(os.path.abspath(path)))
  16.             self.model.save(path)
  18.     def on_train_end(self, logs=None):
  19.         if self._is_save():
  20.             path = '{}/final'.format(self.save_dir)
  21.             print('save checkpoint at {}'.format(os.path.abspath(path)))
  22.             self.model.save(path)