摘要：本文将带大家通过几个小实际疾速上手 MindSpore，其中包含 MindSpore 端边云对立格局及华为智慧终端背地的黑科技。

MindSpore 介绍

MindSpore 是一种实用于端边云场景的新型开源深度学习训练 / 推理框架。MindSpore 提供了敌对的设计和高效的执行，旨在晋升数据科学家和算法工程师的开发体验，并为 Ascend AI 处理器提供原生反对，以及软硬件协同优化。

同时，MindSpore 作为寰球 AI 开源社区，致力于进一步开发和丰盛 AI 软硬件利用生态。

接下来我将带大家通过几个小实际疾速上手 MindSpore：

1.MindSpore 端边云对立格局— — MindIR

2. 华为智慧终端背地的黑科技— —超轻量 AI 引擎 MindSpore Lite

一、MindSpore 端边云对立格局

— — MindIR

MindIR • 全称 MindSpore IR，是 MindSpore 的一种基于图示意的函数式 IR，定义了可扩大的图 构造以及算子的 IR 示意。它打消了不同后端的模型差别，个别用于跨硬件平台执行推理工作。

（1）MindSpore 通过对立 IR 定义了网络的逻辑构造和算子的属性，将 MindIR 格局的模型文件 与硬件平台解耦，实现一次训练屡次部署。

（2）MindIR 作为 MindSpore 的对立模型文件，同时存储了网络结构和权重参数值。同时反对 部署到云端 Serving 和端侧 Lite 平台执行推理工作。

（3）同一个 MindIR 文件反对多种硬件状态的部署：

• Serving 部署推理
• 端侧 Lite 推理部署

1- 1 导出 LeNet 网络的 MindIR 格局模型

于是我参照着大佬的简略的写了一个 py 解决了这题

1. 定义网络

LeNet 网络不包含输出层的状况下，共有 7 层：2 个卷积层、2 个下采样层（池化层）、3 个全连贯层。每层都蕴含不同数量的训练参数，如下图所示：

咱们对全连贯层以及卷积层采纳 Normal 进行参数初始化。

MindSpore 反对 TruncatedNormal、Normal、Uniform 等多种参数初始化办法，默认采纳 Normal。具体能够参考 MindSpore API 的mindspore.common.initializer 模块阐明。

应用 MindSpore 定义神经网络须要继承 mindspore.nn.Cell。Cell 是所有神经网络（Conv2d等）的基类。

神经网络的各层须要事后在 __init__ 办法中定义，而后通过定义 construct 办法来实现神经网络的前向结构。依照 LeNet 的网络结构，定义网络各层如下：

import mindspore.nn as nn
from mindspore.common.initializer import Normal

class LeNet5(nn.Cell):
    """Lenet network structure"""
    #define the operator required
    def __init__(self, num_class=10, num_channel=1):
        super(LeNet5, self).__init__()
        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')
        self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')
        self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))
        self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))
        self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))
        self.relu = nn.ReLU()
        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)
        self.flatten = nn.Flatten()

    #use the preceding operators to construct networks
    def construct(self, x):
        x = self.max_pool2d(self.relu(self.conv1(x)))
        x = self.max_pool2d(self.relu(self.conv2(x)))
        x = self.flatten(x)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        return x

MindSpore 官网为咱们提供了 LeNet 的 Checkpoint 文件，提供了不同版本的：https://download.mindspore.cn…

*Checkpoint • 采纳了 Protocol Buffers 格局，存储了网络中所有的参数值。个别用于训练任务中断后复原训练，或训练后的微调（Fine Tune）工作。

在这里我抉择了 CPU，因为题目说能够不必训练，所以定义完网络我就间接应用了

2. 模型转换

import time
import mindspore.nn as nn
from datetime import datetime
from mindspore.common.initializer import Normal

lenet = LeNet5()
`
# 返回模型的参数字典
param_dict = load_checkpoint("./lenet.ckpt")
# 加载参数到网络
load_param_into_net(lenet, param_dict)
input = np.random.uniform(0.0, 1.0, size=[32, 1, 32, 32]).astype(np.float32)
# 以指定的名称和格局导出文件
export(lenet, Tensor(input), file_name='lenet.mindir', file_format='MINDIR',)

t = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
print(" ")
print("============== Model conversion succeeded ==============")
print(t)

1- 2 训练一个 ResNet50 网络。应用训练好的 checkpoint 文件，导出 MindIR 格局模型

训练 ResNet50 网络生成 checkpoint

参照着官网的教程应用 MindSpore 训练了一个 ResNet50 网络图像分类模型，官网的教程里那个文档实用于 CPU、GPU 和 Ascend AI 处理器环境。应用 ResNet-50 网络实现图像分类：https://www.mindspore.cn/tuto…

（1）数据集的筹备，这里应用的是 CIFAR-10 数据集。

（2）构建一个卷积神经网络，这里应用 ResNet-50 网络。

这里放心本人电脑跑不起来，应用了 ModelArts 平台提供的 Notebook 来跑 8vCPU+64G+1 x Tesla V100-PCIE-32G，不得不说性能很强

这里对训练好的 ResNet50 网络导出为 MindIR 格局

`import numpy as np
from resnet import resnet50

from mindspore.train.serialization import export, load_checkpoint, load_param_into_net
from mindspore import Tensor

resnet = resnet50(batch_size=32, num_classes=10)
# return a parameter dict for model
param_dict = load_checkpoint("./models/ckpt/mindspore_vision_application/train_resnet_cifar10-10_1562.ckpt")
# load the parameter into net
load_param_into_net(resnet, param_dict)
input = np.random.uniform(0.0, 1.0, size=[32, 3, 224, 224]).astype(np.float32)
export(resnet, Tensor(input), file_name='resnet_Jack20.mindir', file_format='MINDIR')`

为了保留数据，我把它下载了下来，后果发现原训练好的 Checkpoint 文件文件过大超过了 100MB 不能间接下载，于是找到了另一种解决办法：

在 Notebook 中，新建一个“ipynb”文件，应用 MoXing 先将大文件从 Notebook 上传到 OBS 中，而后我再从我 OBS 桶了下载不就完了嘛

import moxing as mox
mox.file.copy('./train_resnet_cifar10-10_1562.ckpt', 'obs://bucket_name/train_resnet_cifar10-10_1562.ckpt')

注：其中 ”./train_resnet_cifar10-10_1562.ckpt”为文件在 Notebook 中的存储门路，”train_resnet_cifar10-10_1562.ckpt”为该文件上传到 OBS 的存储门路。

二、华为智慧终端背地的黑科技

— —超轻量 AI 引擎 MindSpore Lite

MindSpore Lite 1.1 在端侧模型训练、算子性能优化、模型小型化、减速库主动裁剪工具、语音类模型反对、Java 接口凋谢、模型可视化等方面进行了全面降级，降级后的版本更轻、更快、更易用

大家能够到官网下载对应的 MindSpore Lite：https://www.mindspore.cn/tuto…

一、设计指标

1. 端云一体化

端云 IR 对立，云侧训练模型可间接反对端偏重训云侧混合精度训练与端侧推理协同晋升推理性能

2. 极致性能 / 轻量化

通过 NPU/CPU/GPU 异构并行最大化施展硬件算力，高效内核算法 + 汇编指令优化缩短推理时延不依赖任何第三方库，底层算子库应用 C 语言 + 汇编开发。

3. 快捷部署

反对第三方模型 TensorFlow Lite、Caffe、ONNX 离线转换，使用户可疾速切换后端；提供量化工具、图片数据处理等性能不便用户的部署和应用；

4. 全场景笼罩

笼罩手机、IoT 等各种智能设施；反对 ARM CPU、GPU、NPU 等多种硬件平台、反对 Android/iOS 操作系统；反对端侧推理及训练；

二、要害个性

1. 性能优化

（1）算子交融：反对多达 20+ 常见的交融，缩小内存读写和计算量

（2）算子替换：反对常见的算子替换，通过参数值替换缩小计算量

（3）算子前移：挪动 slice 相干算动到计算图前，缩小冗余计算

2. 算子优化

对于 CPU 硬件，影响算子指令执行速度的关键因素包含了 L1/L2 缓存的命中率以及指令的流水布，MindSpore 端侧 CPU 算子优化伎俩包含:

（1）数据的正当排布：MindSpore CPU 算子采纳 NHWC 的数据排布格局，相比 NC4HW，channel 方向不须要补齐至 4，更省内存；相比 NCHW，卷积单元的点更加紧凑，对缓存更敌对；此外，算子间也不再波及 layout 转换。

（2）寄存器的正当调配：将寄存器依照用处，划分为 feature map 寄存器、权重寄存器和输入寄存器，寄存器的正当调配能够缩小数据加载的次数。

（3）数据的预存取，通过 prefetch/preload 等指令，能够提前将数据读到 cache 中。

（4）指令重排，尽量减少指令的 pipeline stall。

（5）向量化计算，应用 SIMD 指令，如 ARM NEON 指令，X86 SSE/AVX 指令等

3. 训练后量化

丰盛的量化策略，精度靠近无损

MindSpore Lite 训练后量化工具提供权重量化和全量化两种办法，反对 1~16bit 量化，反对分类，检测，NLP 等多种模型

4.Micro for IoT

挪动终端上的推理框架，通过模型解释的形式来进行推理，这样的形式能够反对多个模型以及跨硬件平台，然而须要额定的运行时内存（MCU 中最低廉的资源）来存储元信息（例如模型构造参数）。MindSpore for Micro 的 CodeGen 形式，将模型中的算子序列从运行时卸载到编译时，并且仅生成将模型执行的代码。它不仅防止了运行时解释的工夫，而且还开释了内存使用量，以容许更大的模型运行。这样生成的二进制大小很轻，因而具备很高的存储效率。

5. 异构主动并行

6. 端云对立

MindSpore 在框架的设计上进行了分层设计，将端云共用的数据结构和模块解耦进去，在满足端侧轻量化的同时，放弃了端云架构的一致性

（1）对立 IR：MindSpore core 的对立 lR，保障了端云模型 / 算子定义的一致性，使得云侧训练的模型能够无缝的部署在端侧。同时，对于端侧训练，能够和云侧应用统一的 R 进行模型的重训。

（2）公共 pass：为了晋升性能，训练好的模型在执行推理前，须要提前做一些优化伎俩，这些优化包含了交融、常量折叠、数据排布的调整等等。对于端云共享的优化，同样也是蕴含在 MindSporecore 模块中，只不过对于云侧推理，这些优化是在线推理时去执行的，而对于挪动终端这些优化在执行推理前离线实现。

（3）对立接口：MindSpore 设计了端云对立的 C ++ 接口。对立的 C ++ 接口的用法尽量与 Python 接口放弃了统一, 升高了学习老本。通过对立接口, 用户能够应用一套代码在不同的硬件上进行推理。

7. 端侧训练

（1)反对 30+ 反向算子，提供 SGD、ADAM 等常见优化器及 CrossEntropy/SparsCrossEntropy/MSE 等损失函数；既可从零训练模型，也可指定特定网络层微调，达到迁徙学习目标;

（2)已反对 LeNet/AlexNet/ResNet/MobileNetV1/V2/V3 和 EffectiveNet 等网络训练，提供残缺的模型加载，转换和训练脚本，不便用户应用和调测;

（3)MindSpore 云侧训练和端侧训练实现无缝对接，云侧模型可间接加载到端侧进行训练;

（4)反对 checkpoint 机制，训练过程异常中断后可疾速复原持续训练;

实际一下：

2- 1 在 MindSpore model_zoo 下载模型 mobilenetv2.mindir（https://download.mindspore.cn…）, 应用 MindSpore lite converter 转成.ms 模型，请保留所应用的模型转换命令和模型转换截图

1. 按要求关上链接找到指定的模型文件下载下来备用

2. 把文件放到 MindSpore lite converter 文件夹下

因为我这里是间接把文件夹放到了桌面，在 CMD 中进到这个文件环境目录里

cd c: UsersAdministratorDesktopMindSporePetClassificationconverter

3. 将.mindir 模型转换为.ms 模型

call converter_lite --fmk=MINDIR --modelFile=c:UsersAdministratorDesktopMindSporePetClassificationconvertermobilenetv2.mindir --outputFile=Jack20

留神：其中 c:UsersAdministratorDesktopMindSporePetClassificationconvertermobilenetv2.mindir 代表生成的 mindir 文件，而 –outputFile 定义转换后 MS 文件的名称。

胜利后，会在 converter 文件夹中生成对应的.ms 文件。

三、一键部署在线推理服务

— —MindSpore Serving

MindSpore Serving 就是为实现将深度学习部署到生产环境而产生的

MindSpore Serving 是一个简略易用、高性能的服务模块，旨在帮忙 MindSpore 开发者在生产环境中高效部署在线推理服务

注：MindSpore Serving以后仅反对 Ascend 310 和Ascend 910环境。

大家能够在 MindSpore 官网下载对应版本安装包实际：https://www.mindspore.cn/vers…

特点

（1）简略易用

提供 Python 接口配置和启动 Serving 服务，对客户端提供 gRPC 和 RESTful 拜访接口，提供 Python 客户端接口，通过它，大家能够轻松定制、公布、部署和拜访模型服务。

装置：

pip install mindspore_serving-1.1.0-cp37-cp37m-linux_aarch64.whl

1. 轻量级部署

服务端调用 Python 接口间接启动推理过程（master 和 worker 共过程），客户端间接连贯推理服务后下发推理工作。执行 master_with_worker.py，实现轻量级部署服务：

import os
from mindspore_serving import master
from mindspore_serving import worker

def start():
    servable_dir = os.path.abspath(".")
    worker.start_servable_in_master(servable_dir, "add", device_id=0)
    master.start_grpc_server("127.0.0.1", 5500)
    
if __name__ == "__main__":
    start()

当服务端打印日志 Serving gRPC start success, listening on 0.0.0.0:5500 时，示意 Serving 服务已加载推理模型结束。

2. 集群部署

服务端由 master 过程和 worker 过程组成，master 用来治理集群内所有的 worker 节点，并进行推理工作的散发。

部署 master：

import os
from mindspore_serving import master

def start():
    servable_dir = os.path.abspath(".")
    master.start_grpc_server("127.0.0.1", 5500)
    master.start_master_server("127.0.0.1", 6500)
    
if __name__ == "__main__":
    start()

部署 worker：

import os
from mindspore_serving import worker

def start():
    servable_dir = os.path.abspath(".")
    worker.start_servable(servable_dir, "add", device_id=0,
                          master_ip="127.0.0.1", master_port=6500,
                          worker_ip="127.0.0.1", worker_port=6600)

if __name__ == "__main__":
    start()

轻量级部署和集群部署启动 worker 所应用的接口存在差别，其中，轻量级部署应用 start_servable_in_master 接口启动 worker，集群部署应用 start_servable 接口启动 worker。

（2）提供定制化服务

反对模型供应商打包公布模型、预处理和后处理，围绕模型提供定制化服务，并一键部署，服务使用者不须要感知模型解决细节。

举个栗子：实现导出两个 tensor 相加操作的模型

import os
from shutil import copyfile
import numpy as np

import mindspore.context as context
import mindspore.nn as nn
import mindspore.ops as ops
import mindspore as ms

context.set_context(mode=context.GRAPH_MODE, device_target="Ascend")
class Net(nn.Cell):
    """Define Net of add"""

    def __init__(self):
        super(Net, self).__init__()
        self.add = ops.TensorAdd()

    def construct(self, x_, y_):
        """construct add net"""
        return self.add(x_, y_)
def export_net():
    """Export add net of 2x2 + 2x2, and copy output model `tensor_add.mindir` to directory ../add/1"""
    x = np.ones([2, 2]).astype(np.float32)
    y = np.ones([2, 2]).astype(np.float32)
    add = Net()
    output = add(ms.Tensor(x), ms.Tensor(y))
    ms.export(add, ms.Tensor(x), ms.Tensor(y), file_name='tensor_add', file_format='MINDIR')
    dst_dir = '../add/1'
    try:
        os.mkdir(dst_dir)
    except OSError:
        pass

    dst_file = os.path.join(dst_dir, 'tensor_add.mindir')
    copyfile('tensor_add.mindir', dst_file)
    print("copy tensor_add.mindir to" + dst_dir + "success")

    print(x)
    print(y)
    print(output.asnumpy())
if __name__ == "__main__":
    export_net()

结构一个只有 Add 算子的网络，并导出 MindSpore 推理部署模型，该模型的输出为两个 shape 为 [2,2] 的二维 Tensor，输入后果是两个输出 Tensor 之和。

（3）反对批处理

用户一次申请可发送数量不定样本，Serving 宰割和组合一个或多个申请的样本以匹配模型的理论 batch，不仅仅减速了 Serving 申请解决能力，并且也简化了客户端的应用。

次要针对解决图片、文本等蕴含 batch 维度的模型。假如 batch_size=2，以后申请有 3 个实例，共 3 张图片，会拆分为 2 次模型推理，第 1 次解决 2 张图片返回 2 个后果，第 2 次对残余的 1 张图片进行拷贝做一次推理并返回 1 个后果，最终返回 3 个后果。

对于一个模型，假如其中一个输出是数据输出，包含 batch 维度信息，另一个输出为模型配置信息，没有包含 batch 维度信息，此时在设置 with_batch_dim 为 True 根底上，设置额 ** 数 without_batch_dim_inputs 指定没有包含 batch 维度信息的输出信息。

from mindspore_serving.worker import register
# Input1 indicates the input shape information of the model, without the batch dimension information.
# input0: [N,3,416,416], input1: [2]
register.declare_servable(servable_file="yolov3_darknet53.mindir", model_format="MindIR",
                          with_batch_dim=True, without_batch_dim_inputs=1)

（4）高性能高扩大

反对多模型多卡并发，通过 client/master/worker 的服务体系架构，实现 MindSpore Serving 的高性能和高扩展性。

华为 Ascend 主打芯片低功耗、高算力等个性，MindSpore 提供高效的内核算法、主动交融，主动并行等能力。反对多模型多卡并发，通过 client/master/worker 的服务体系架构，实现 MindSpore Serving 的高性能和高扩展性。

高可靠性设计（某个服务节点宕机，不影响客户端失常服务），负载平衡（如何更正当的应用所有资源信息），弹性扩容缩容（依据业务的顶峰低谷，动静调整资源）

四、AI 数据高速加载直通车

— —单节点数据缓存

Cache 单节点缓存模块可用于缓存预处理后的训练数据，减速数据加载，晋升数据复用率，升高数据预处理所需的 CPU 算力

对于须要反复拜访近程的数据集或须要反复从磁盘中读取数据集的状况，能够应用单节点缓存算子将数据集缓存于本地内存中，以减速数据集的读取。缓存算子依赖于在以后节点启动的缓存服务器，缓存服务器作为守护过程独立于用户的训练脚本而存在，次要用于提供缓存数据的治理，反对包含存储、查找、读取以及产生缓存未命中时对于缓存数据的写入等操作。

比照应用数据缓存和不应用数据缓存的数据加载流程 pipeline，第一个，是不应用数据缓存服务的惯例数据处理流程

1. 缓存加载后的原始数据，用户能够在数据集加载算子中应用缓存。这将把加载实现的数据存到缓存服务器中，后续若需雷同数据则可间接从中读取，防止从磁盘中反复加载。

2. 缓存通过数据加强操作后的数据，用户也可在 Map 算子中应用缓存。这将容许咱们间接缓存数据加强（如图像裁剪、缩放等）解决后的数据，防止数据加强操作反复进行，缩小了不必要的计算量。

1. 以上两种类型的缓存实质上都是为了进步数据复用，以缩小数据处理过程耗时，进步网络训练性能。

Cache 的三个重要组件

（1）缓存算子

1. 对于 mappable 的数据集（如 ImageFolder）的 pipeline，Cache 将创立名为 CacheLookupOp 和 CacheMergeOp 的两个缓存算子，并对 pipeline 做出相应的调整。

2. 见于上图 Mappable 数据集图示，右边的数据处理 pipeline，当用户在 MapOp 后插入缓存算子后，通过 Cache 变换调整过程，将对 pipeline 进行变换并最终将其调整为右图中蕴含 CacheLookupOp 和 CacheMergeOp 两个缓存算子的构造

3. 对于蕴含 non-mappable 的数据集（如 TFRecord）的 pipeline，咱们将创立名为 CacheOp 的缓存算子，并在 pipeline 相应地位插入 CacheOp。见于上图 Non-mappable 数据集图示，右边的数据处理 pipeline，当用户在 MapOp 后插入缓存算子后，通过 Cache 变换调整过程，将对 pipeline 进行变换并最终将其调整为右图中蕴含 CacheOp 缓存算子的构造。

（2）缓存服务器

次要负责响应缓存客户端所发送的申请，提供缓存数据的查找、读取，以及产生缓存未命中时对于缓存数据的写入等性能。缓存服务器领有本人的工作队列，一直循环从工作队列中获取一个申请去执行并将后果返回给客户端。同一个缓存服务器能够为多个缓存客户端提供服务，且缓存服务器通过缓存客户端的 session_id 以及该缓存客户端所对应的数据处理 pipeline 的 crc 码来惟一确定该缓存客户端。因而，两个完全一致的 pipeline 能够通过指定雷同的 session_id 来共享同一个缓存服务，而不同的 pipeline 若试图共享同一个缓存客户端则会报错。

1.Cache_server 如何启动？

Cache Server 的服务由一个内部守护过程提供，在用户应用 Cache 服务之前，须要先在 mindspore 内部启动一个服务器守护过程，来与缓存客户进行交互沟通；

ms_cache_server start|session [–m <mem_size>] [-d <spill_path>] [-nospill] [-h <host>] [-p <port>]

#Command: start | session
#start
#– starts the service
#session
#– creates a new caching session, returning the session_id as output

而后启动

cache_admin --start

2.cache_server 创立时默认的 port 端口号是多少？

默认对 IP 为 127.0.0.1（localhost）且端口号为 50052 的服务器执行操作

（3）缓存客户端

次要负责与缓存服务器建设通信，向缓存服务器发动数据读取、数据写入、状态查问等申请。缓存客户端与服务器之间通过 gRPC 进行通信，如下图所示：当客户端须要发动申请时，仅须要将申请增加到 gRPC 函数库所提供的 gRPC 队列，由 gRPC 线程一直循环从 gRPC 队列中获取一个申请并将该申请发送到缓存服务器的工作队列中。当缓存服务器须要将解决后的响应数据返回给客户端时，也通过相似的形式将响应数据增加到 gRPC 队列中，并依赖 gRPC 理论将数据传输至客户端。

3.cache_client 实体在创立时，其 <session_id> 如何获取?

惟一标识与缓存服务的连贯 session。应该从 ms_cache_service session 命令返回的 session_id。当给出该选项时，缓存的大小和溢出行为取自 session。如果未给出值，则假如这是惟一的通道，没有其余通道将共享此缓存。在这种状况下，将主动生成一个 session_id。

ms_cache_server start|session [–m <mem_size>] [-d <spill_path>] [-nospill] [-h <host>] [-p <port>]

#Command: start | session
#– creates a new caching session, returning the session_id as output

其中 3231564523 为端口 50052 的服务器调配的缓存会话 id，缓存会话 id 由服务器调配。
若缓存服务器中不存在缓存会话，则须要创立一个缓存会话，失去缓存会话 id：

五、疾速定位模型精度问题

–MindSpore 调试器

在图模式下，用户难以从 Python 层获取到计算图两头节点的后果。MindSpore 调试器是为图模式训练提供的调试工具，能够用来查看并剖析计算图节点的两头后果。

应用 MindSpore 调试器，能够：

（1）在 MindInsight 调试器界面联合计算图，查看图节点的输入后果；

（2）设置监测点，监测训练异常情况（比方查看张量溢出），在异样产生时追踪谬误起因；

（3）查看权重等参数的变动状况。

一、常见精度问题和定位思路

（1）常见景象

1. loss：跑飞，不收敛，收敛慢
2. metrics：accuracy、precision 等达不到预期
3. 梯度：梯度隐没、梯度爆炸
4. 权重：权重不更新、权重变动过小、权重变动过大
5. 激活值：激活值饱和、dead relu

（2）常见问题

1. 模型构造问题：算子应用谬误、权重共享谬误、权重解冻谬误、节点连贯谬误、loss 函数谬误、优化器谬误等
2. 超参问题：超参设置不合理等
3. 数据问题：缺失值过多、异样值、未归一化等

（3）罕用定位思路

（1 定位筹备

1. 回顾算法设计，全面相熟模型

•算法设计、超参、loss、优化器、数据处理等

•参考论文、其它实现

2. 相熟可视化工具

•装置 MindInsight https://www.mindspore.com/ins…

•退出 SummaryCollector callback，收集训练信息

•在 summary_dir 的父目录中启动 MindInsight

•mindinsight start

•相熟调试器应用

3. 相熟调试器

•MindSpore 调试器是为图模式训练提供的调试工具

•在 MindInsight 调试器界面联合计算图，查看图节点的输入后果；

•设置监测点，监测训练异常情况（比方查看张量溢出），在异样产生时追踪谬误起因；

•查看权重等参数的变动状况。

使用指南请见 https://www.mindspore.cn/tuto…

•debugger 使用指南请见 https://www.mindspore.cn/tuto…

(2 查看代码、超参、模型构造

1. 走读脚本，查看代码

•小黄鸭调试法

•查看代码同模型设计、论文、参考脚本等是否统一

1. 超参常见问题：

•学习率不合理

•权重初始化参数不合理等

1. MindInsight 辅助查看：训练列表 -> 训练参数详情
2. 模型构造常见问题：

•算子应用谬误（应用的算子不适用于指标场景，如应该应用浮点除，谬误地应用了整数除），

•权重共享谬误（共享了不应共享的权重），

•权重解冻谬误（解冻了不应解冻的权重），

•节点连贯谬误（应该连贯到计算图中的 block 未连贯），

•loss 函数谬误，

•优化器算法谬误（如果自行实现了优化器）等。

1. MindInsight 辅助查看：训练列表 -> 训练看板 -> 计算图

(3 查看输出数据

1. 输出数据常见问题：

•数据缺失值过多

•每个类别中的样本数目不平衡

•数据中存在异样值

•数据标签谬误

•训练样本有余

•未对数据进行标准化，输出模型的数据不在正确的范畴内

•finetune 和 pretrain 的数据处理形式不同

•训练阶段和推理阶段的数据处理形式不同

•数据处理参数不正确等。

1. MindInsight 辅助查看：训练列表 -> 训练看板 -> 数据抽样

(4 查看 loss 曲线

1. 常见景象

•loss 跑飞

回顾脚本、模型构造和数据，

•查看超参是否有不合理的特地大 / 特地小的取值，

•查看模型构造是否实现正确，特地是查看 loss 函数是否实现正确，

•查看输出数据中是否有缺失值、是否有特地大 / 特地小的取值。

应用参数分布图查看参数更新是否有激烈变动

应用调试器性能对训练现场进行查看

•配置“查看张量溢出”监测点，定位 NAN/INF 呈现地位

•配置“查看过大张量”监测点，定位呈现大值的算子

•配置“查看权重变动过大”、“查看梯度隐没”、“查看梯度过大”监测点，定位异样的权重或梯度

•loss 收敛慢

1. MindInsight 辅助查看：训练列表 -> 训练看板 -> 标量曲线 / 参数分布图

1. 调试器定位

(5 查看精度是否达到预期

1. 回顾代码、模型构造、输出数据和 loss 曲线，

•查看超参是否有不合理的值

•查看模型构造是否实现正确

•查看输出数据是否正确

•查看 loss 曲线的收敛后果和收敛趋势是否存在异样

1. 尝试应用“溯源剖析”和调参器优化超参

•mindoptimizer –config ./config.yaml –iter 10

1. 尝试模型解释
2. 尝试优化模型算法

注意事项

1. 场景反对

•调试器暂不反对分布式训练场景。

•调试器暂不反对推断场景。

•调试器暂不反对单机多卡 / 集群场景。

•调试器暂不反对连贯多个训练过程。

•调试器暂不反对 CPU 场景。

2. 性能影响

•应用调试器时，会对训练性能产生肯定影响。

•设置的监测点数目过多时，可能会呈现零碎内存不足（Out-of-Memory）的异样。

3. GPU 场景

•在 GPU 场景下，只有满足条件的参数节点能够与本身的上一轮次后果作比照：应用下一个节点执行过的节点、应用运行到该节点时选中的节点、作为监测点输出的参数节点。其余状况均无奈应用上一轮次比照性能。

•因为 GPU 上一个轮次是一个子图（而非残缺的图），GPU 上多图做从新查看时，只能从新查看以后的子图。

4. 从新查看只查看以后有张量值的监测点。

5. 查看计算过程溢出须要用户开启异步 Dump 的全副溢出检测性能，开启形式请参照异步 Dump 性能介绍

6. 调试器展现的图是优化后的最终执行图。调用的算子可能曾经与其它算子交融，或者在优化后扭转了名称。

参考

[1]www.mindspore.cn

[2]gitee.com/mindspore

[3]github.com/mindspore-ai

本文分享自华为云社区《几个小实际带你两天疾速上手 MindSpore》，原文作者：Jack20。

点击关注，第一工夫理解华为云陈腐技术~