网络调试

网络调试的基本流程

（1）网络流程调试成功，网络执行整体不报错，正确输出loss值，且正常完成参数更新。

• 打印Checkpoint文件中的权重值，查看两个step的权重是否发生改变，并完成更新。

（2）网络多轮迭代执行输出loss值，且loss值具有基本的收敛趋势。

（3）网络精度调试，超参调优。

用PyNative模式进行流程调试

• PyNative模式支持执行单算子、普通函数和网络，以及单独求梯度的操作。在PyNative模式下，可以方便地设置断点，获取网络执行的中间结果，也可以通过pdb的方式对网络进行调试。
• 在默认情况下，MindSpore处于Graph模式，可以通过set_context(mode=PYNATIVE_MODE)设置为PyNative模式

精度调试工具

• Callback 功能：ModelCheckpoint、LossMonitor、SummaryCollector等Callback类用于保存模型参数、监控loss值、保存训练过程信息等功能
• Metrics 功能：评估训练结果的好坏，accuracy、loss、precision、recall、F1等。
• 自定义训练、学习率、优化函数
• 使用MindOptimizer进行超参调优

案例

• 设置动态图

import numpy as np
import mindspore.ops as ops
import mindspore.nn as nn
from mindspore import Tensor, set_context, PYNATIVE_MODE, dtype as mstype

# 设置运行模式为动态图模式
set_context(mode=PYNATIVE_MODE)

• 定义加法算子

add = ops.Add()
x = Tensor(np.array([1, 2]).astype(np.float32))
y = Tensor(np.array([3, 5]).astype(np.float32))
z = add(x, y)
print("x:", x.asnumpy(), "\ny:", y.asnumpy(), "\nz:", z.asnumpy())

• 自定义函数

add = ops.Add()

def add_func(x, y):
    z = add(x, y)
    z = add(z, x)
    return z

x = Tensor(np.array([1, 2]).astype(np.float32))
y = Tensor(np.array([3, 5]).astype(np.float32))
z = add_func(x, y)
print("x:", x.asnumpy(), "\ny:", y.asnumpy(), "\nz:", z.asnumpy())

• 自定义网络

class Net(nn.Cell):
    def __init__(self):
        super(Net, self).__init__()
        self.mul = ops.Mul()

    def construct(self, x, y):
        return self.mul(x, y)

net = Net()
x = Tensor(np.array([1.0, 2.0, 3.0]).astype(np.float32))
y = Tensor(np.array([4.0, 5.0, 6.0]).astype(np.float32))
z = net(x, y)

print("x:", x.asnumpy(), "\ny:", y.asnumpy(), "\nz:", z.asnumpy())

• 自定义反向传播

# 自定义nn.Cell对象的反向传播（计算）函数，从而控制nn.Cell对象梯度计算的过程，定位梯度问题。

set_context(mode=PYNATIVE_MODE)

class Net(nn.Cell):
    def construct(self, x, y):
        z = x * y
        z = z * y
        return z

    def bprop(self, x, y, out, dout):
        x_dout = x + y
        y_dout = x * y
        return x_dout, y_dout

grad_all = ops.GradOperation(get_all=True)
output = grad_all(Net())(Tensor(1, mstype.float32), Tensor(2, mstype.float32))
print(output)

• 自定义同步执行
  • 为了提升性能，算子在device上使用了异步执行方式，因此在算子执行错误的时候，错误信息可能会在程序执行到最后才显示。针对这种情况，MindSpore增加了一个pynative_synchronize的设置来控制算子device上是否使用异步执行。
  • 当算子执行失败时，可以方便地通过调用栈看到出错的代码位置。

from mindspore import dtype as mstype

# 通过设置pynative_synchronize来使算子同步执行
set_context(mode=PYNATIVE_MODE, pynative_synchronize=True)

class Net(nn.Cell):
    def __init__(self):
        super(Net, self).__init__()
        self.get_next = ops.GetNext([mstype.float32], [(1, 1)], 1, "test")

    def construct(self, x1,):
        x = self.get_next()
        x = x + x1
        return x

set_context()
x1 = np.random.randn(1, 1).astype(np.float32)
net = Net()
output = net(Tensor(x1))
print(output.asnumpy())

loss值对比检查

• 对比对标脚本跑出的loss值与MindSpore脚本跑出的loss值，以验证整体网络结构和算子精度的正确性。
• (1) 保证输入相同: 使用相同数据集进行计算
• (2)去除网络中随机性因素的影响: 设置相同的随机性种子，关掉数据shuffle，修改代码去除dropout、initializer等网络中具有随机性的算子的影响等
• (3) 保证相关超参数的设置相同
• (4) 运行网络，比较输出的loss值，一般loss值误差在1‰左右，因为算子本身存在一定精度误差，随着step数增大，误差会有一定累加。