自定义调试信息

概述

本文介绍如何使用MindSpore提供的Callback、metrics、print算子、日志打印等自定义能力，帮助用户快速调试训练网络。

Callback介绍

Callback是回调函数的意思，但它其实不是一个函数而是一个类，用户可以使用回调函数来观察训练过程中网络内部的状态和相关信息，或在特定时期执行特定动作。例如监控loss、保存模型参数、动态调整参数、提前终止训练任务等。

MindSpore的Callback能力

MindSpore提供Callback能力，支持用户在训练/推理的特定阶段，插入自定义的操作。包括：

  • MindSpore框架提供的ModelCheckpoint、LossMonitor、SummaryStep等Callback函数。

  • MindSpore支持用户自定义Callback。

使用方法：在model.train方法中传入Callback对象，它可以是一个Callback列表，例：

  1. Copyckpt_cb = ModelCheckpoint()                                                            
  2. loss_cb = LossMonitor()
  3. summary_cb = SummaryStep()
  4. model.train(epoch, dataset, callbacks=[ckpt_cb, loss_cb, summary_cb])

ModelCheckpoint可以保存模型参数，以便进行再训练或推理。LossMonitor可以在日志中输出loss，方便用户查看，同时它还会监控训练过程中的loss值变化情况，当loss值为Nan或Inf时终止训练。SummaryStep可以把训练过程中的信息存储到文件中，以便后续进行查看或可视化展示。

自定义Callback

用户可以基于Callback基类，根据自身的需求，实现自定义Callback。

Callback基类定义如下所示：

  1. Copyclass Callback():
  2.     """Callback base class""" 
  3.     def begin(self, run_context):
  4.         """Called once before the network executing."""
  5.         pass
  6.  
  7.     def epoch_begin(self, run_context):
  8.         """Called before each epoch beginning."""
  9.         pass
  10.  
  11.     def epoch_end(self, run_context):
  12.         """Called after each epoch finished.""" 
  13.         pass
  14.  
  15.     def step_begin(self, run_context):
  16.         """Called before each epoch beginning.""" 
  17.         pass
  18.  
  19.     def step_end(self, run_context):
  20.         """Called after each step finished."""
  21.         pass
  22.  
  23.     def end(self, run_context):
  24.         """Called once after network training."""
  25.         pass

Callback可以把训练过程中的重要信息记录下来，通过一个字典类型变量cb_params传递给Callback对象，用户可以在各个自定义的Callback中获取到相关属性，执行自定义操作。也可以自定义其他变量传递给cb_params对象。

cb_params中的主要属性包括：

  • loss_fn：损失函数

  • optimizer：优化器

  • train_dataset：训练的数据集

  • cur_epoch_num：当前的epoch数

  • cur_step_num：当前的step数

  • batch_num：一个epoch中step的数量

  • …

用户可以继承Callback基类自定义Callback对象。

下面通过介绍一个例子，更深一步地了解自定义Callback的用法。

  1. Copyclass StopAtTime(Callback):
  2.     def __init__(self, run_time):
  3.         super(StopAtTime, self).__init__()
  4.         self.run_time = run_time*60
  5.  
  6.     def begin(self, run_context):
  7.         cb_params = run_context.original_args()
  8.         cb_params.init_time = time.time()
  9.  
  10.     def step_end(self, run_context):
  11.         cb_params = run_context.original_args()
  12.         epoch_num = cb_params.cur_epoch_num
  13.         step_num = cb_params.cur_step_num
  14.         loss = cb_params.cb_params
  15.     cur_time = time.time()
  16.     if (cur_time - cb_params.init_time) > self.run_time:
  17.             print("epoch: ", epoch_num, " step: ", step_num, " loss: ", loss)
  18.             run_context.request_stop()
  19.  
  20. stop_cb = StopAtTime(run_time=10)
  21. model.train(100, dataset, callbacks=stop_cb)

输出：

  1. Copyepoch: 20 step: 32 loss: 2.298344373703003

此Callback的功能为：在规定时间内终止训练。通过run_context.original_args()方法可以获取到cb_params字典，字典里会包含前文描述的主要属性信息。同时可以对字典内的值进行修改和添加，上述用例中，在begin()中定义一个init_time对象传递给cb_params字典。在每次step_end会做出判断，当训练时间大于设置的时间阈值时，会向run_context传递终止训练的信号，提前终止训练，并打印当前的epoch、step、loss的值。

MindSpore metrics功能介绍

当训练结束后，可以使用metrics评估训练结果的好坏。

MindSpore提供了多种metrics评估指标，如：accuracy、loss、precision、recall、F1。

用户可以定义一个metrics字典对象，里面包含多种指标，传递给model.eval接口用来验证训练精度。

  1. Copymetrics = {
  2.     'accuracy': nn.Accuracy(),
  3.     'loss': nn.Loss(),
  4.     'precision': nn.Precision(),
  5.     'recall': nn.Recall(),
  6.     'f1_score': nn.F1()
  7. }
  8. net = ResNet()
  9. loss = CrossEntropyLoss()
  10. opt = Momentum()
  11. model = Model(net, loss_fn=loss, optimizer=opt, metrics=metrics)
  12. ds_eval = create_dataset()
  13. output = model.eval(ds_eval)

model.eval()方法会返回一个字典，里面是传入metrics的指标和结果。

用户也可以定义自己的metrics类，通过继承Metric基类，并重写clear、update、eval三个方法即可实现。

以accuracy算子举例说明其内部实现原理：

accuracy继承了EvaluationBase基类，重写了上述三个方法。clear()方法会把类中相关计算参数初始化。update()方法接受预测值和标签值，更新accuracy内部变量。eval()方法会计算相关指标，返回计算结果。调用accuracy的eval方法，即可得到计算结果。

通过如下代码可以更清楚了解到accuracy是如何运行的：

  1. Copyx = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
  2. y = Tensor(np.array([1, 0, 1]))
  3. metric = Accuracy()
  4. metric.clear()
  5. metric.update(x, y)
  6. accuracy = metric.eval()
  7. print('Accuracy is ', accuracy)

输出：

  1. CopyAccuracy is 0.6667

print算子功能介绍

MindSpore的自研print算子可以将用户输入的Tensor或字符串信息打印出来，支持多字符串输入，多Tensor输入和字符串与Tensor的混合输入，输入参数以逗号隔开。

print算子使用方法与其他算子相同，在网络中的init()声明算子并在construct()进行调用，具体使用实例及输出结果如下：

  1. Copyimport numpy as np
  2. from mindspore import Tensor
  3. from mindspore.ops import operations as P
  4. import mindspore.nn as nn
  5. import mindspore.context as context
  6.  
  7. context.set_context(mode=context.GRAPH_MODE)
  8.  
  9. class PrintDemo(nn.Cell):
  10.     def __init__(self):
  11.         super(PrintDemo, self).__init__()
  12.         self.print = P.Print()
  13.  
  14.     def construct(self, x, y):
  15.         self.print('print Tensor x and Tensor y:', x, y)
  16.         return x
  17.  
  18. x = Tensor(np.ones([2, 1]).astype(np.int32))
  19. y = Tensor(np.ones([2, 2]).astype(np.int32))
  20. net = PrintDemo()
  21. output = net(x, y)

输出：

  1. Copyprint Tensor x and Tensor y:
  2. Tensor shape:[[const vector][2, 1]]Int32
  3. val:[[1]
  4. [1]]
  5. Tensor shape:[[const vector][2, 2]]Int32
  6. val:[[1 1]
  7. [1 1]]

日志相关的环境变量和配置

MindSpore采用glog来输出日志，常用的几个环境变量如下：

  • GLOG_v 控制日志的级别，默认值为2，即WARNING级别，对应关系如下：0-DEBUG、1-INFO、2-WARNING、3-ERROR。

  • GLOG_logtostderr 值设置为1时，日志输出到屏幕；值设置为0时，日志输出到文件。默认值为1。

  • GLOG_log_dir=YourPath 指定日志输出的路径。若指定了GLOG_log_dir且GLOG_logtostderr的值为1时，则日志输出到屏幕，不输出到文件。