From 555b1e5fb559352219c74131f452fec3a394482c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=9E=97=E4=BF=8A=E4=BD=99?= <2167236389@qq.com> Date: Mon, 8 Aug 2022 11:59:05 +0800 Subject: [PATCH] first_dataset --- .../API_dataset/html_api_data_dataset.csv | 16381 ++++++++++++++++ .../API_dataset/html_api_data_generate.py | 205 + .../html_design_data_generate.py | 166 + .../Design_dataset/html_design_dataset.csv | 2850 +++ .../html_grammar_data_generate.py | 152 + .../html_grammar_dataset.csv | 1832 ++ .../html_migration_data_generate.py | 153 + .../html_migration_dataset.csv | 4814 +++++ .../readme.md | 29 + 9 files changed, 26582 insertions(+) create mode 100644 Design_Migration_Grammar_API_dataset/API_dataset/html_api_data_dataset.csv create mode 100644 Design_Migration_Grammar_API_dataset/API_dataset/html_api_data_generate.py create mode 100644 Design_Migration_Grammar_API_dataset/Design_dataset/html_design_data_generate.py create mode 100644 Design_Migration_Grammar_API_dataset/Design_dataset/html_design_dataset.csv create mode 100644 Design_Migration_Grammar_API_dataset/Grammar_Support_dataset/html_grammar_data_generate.py create mode 100644 Design_Migration_Grammar_API_dataset/Grammar_Support_dataset/html_grammar_dataset.csv create mode 100644 Design_Migration_Grammar_API_dataset/Migration_Guide_dataset/html_migration_data_generate.py create mode 100644 Design_Migration_Grammar_API_dataset/Migration_Guide_dataset/html_migration_dataset.csv create mode 100644 Design_Migration_Grammar_API_dataset/readme.md diff --git a/Design_Migration_Grammar_API_dataset/API_dataset/html_api_data_dataset.csv b/Design_Migration_Grammar_API_dataset/API_dataset/html_api_data_dataset.csv new file mode 100644 index 0000000..3e66b82 --- /dev/null +++ b/Design_Migration_Grammar_API_dataset/API_dataset/html_api_data_dataset.csv @@ -0,0 +1,16381 @@ +title,link,content,process,tag +mindspore§张量,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.Tensor +张量，即存储多维数组（n-dimensional array）的数据结构。 + +mindspore.COOTensor +用来表示某一张量在给定索引上非零元素的集合，其中索引(indices)指示了每一个非零元素的位置。 + +mindspore.CSRTensor +用来表示某一张量在给定索引上非零元素的集合，其中行索引由 indptr 表示，列索引由 indices 。 + +mindspore.RowTensor +用来表示一组指定索引的张量切片的稀疏表示。 + +mindspore.SparseTensor +用来表示某一张量在给定索引上非零元素的集合。 + + + +",mindspore,mindspore、mindspore、数据 +mindspore§参数,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.Parameter +Parameter 是 Tensor 的子类，当它们被绑定为Cell的属性时，会自动添加到其参数列表中，并且可以通过Cell的某些方法获取，例如 cell.get_parameters() 。 + +mindspore.ParameterTuple +继承于tuple，用于管理多个Parameter。 + + + +",mindspore,mindspore、mindspore +mindspore§数据类型,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.dtype +创建一个MindSpore数据类型的对象。 + +mindspore.dtype_to_nptype +将MindSpore 数据类型转换成NumPy数据类型。 + +mindspore.issubclass_ +判断 type_ 是否为 dtype 的子类。 + +mindspore.dtype_to_pytype +将MindSpore 数据类型转换为Python数据类型。 + +mindspore.pytype_to_dtype +将Python数据类型转换为MindSpore数据类型。 + +mindspore.get_py_obj_dtype +将Python数据类型转换为MindSpore数据类型。 + + + +",mindspore,mindspore、mindspore、数据类型、数据 +mindspore§随机种子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.set_seed +设置全局种子。 + +mindspore.get_seed +获取随机种子。 + + + +",mindspore,mindspore、mindspore +mindspore§运行环境,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.set_context +设置运行环境的context。 + +mindspore.get_context +根据输入key获取context中的属性值。 + +mindspore.set_auto_parallel_context +配置自动并行，仅在Ascend和GPU上有效。 + +mindspore.get_auto_parallel_context +根据key获取自动并行的配置。 + +mindspore.reset_auto_parallel_context +重置自动并行的配置为默认值。 + +mindspore.ParallelMode +并行模式。 + +mindspore.set_ps_context +设置参数服务器训练模式的上下文。 + +mindspore.get_ps_context +根据key获取参数服务器训练模式上下文中的属性值。 + +mindspore.reset_ps_context +将参数服务器训练模式上下文中的属性重置为默认值。 + +mindspore.set_algo_parameters +设置并行策略搜索算法中的参数。 + +mindspore.get_algo_parameters +获取算法参数配置属性。 + +mindspore.reset_algo_parameters +重置算法参数属性。 + + + +",mindspore,mindspore、mindspore、并行、GPU、Ascend +mindspore§模型,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.Model +模型训练或推理的高阶接口。 + + + +",mindspore,mindspore、mindspore、接口、Model +mindspore§回调函数,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.Callback +用于构建Callback函数的基类。 + +mindspore.CheckpointConfig +保存checkpoint时的配置策略。 + +mindspore.EarlyStopping +当监控的指标停止改进时停止训练。 + +mindspore.History +将网络输出和评估指标的相关信息记录到 History 对象中。 + +mindspore.LambdaCallback +用于自定义简单的callback。 + +mindspore.LearningRateScheduler +用于在训练期间更改学习率。 + +mindspore.LossMonitor +训练场景下，监控训练的loss；边训练边推理场景下，监控训练的loss和推理的metrics。 + +mindspore.ModelCheckpoint +checkpoint的回调函数。 + +mindspore.ReduceLROnPlateau +当 monitor 停止改进时降低学习率。 + +mindspore.RunContext +保存和管理模型的相关信息。 + +mindspore.TimeMonitor +监控训练或推理的时间。 + + + +",mindspore,mindspore、mindspore、Callback、网络、评估、Model、Loss、metric、LR、学习率 +mindspore§数据处理工具,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.DatasetHelper +DatasetHelper是一个处理MindData数据集的类，提供数据集信息。 + +mindspore.connect_network_with_dataset +将 network 与 dataset_helper 中的数据集连接。 + + + +",mindspore,mindspore、mindspore、数据集、数据、MindData、Dataset +mindspore§混合精度,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.LossScaleManager +使用混合精度时，用于管理损失缩放系数（loss scale）的抽象类。 + +mindspore.FixedLossScaleManager +损失缩放系数不变的管理器，继承自 mindspore.LossScaleManager 。 + +mindspore.DynamicLossScaleManager +动态调整损失缩放系数的管理器，继承自 mindspore.LossScaleManager 。 + +mindspore.build_train_network +构建混合精度训练网络。 + + + +",mindspore,mindspore、mindspore、网络、Loss、精度、loss scale、精度 +mindspore§序列化,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.async_ckpt_thread_status +获取异步保存checkpoint文件线程的状态。 + +mindspore.build_searched_strategy +构建网络中每个参数的策略，用于分布式推理。 + +mindspore.convert_model +将MindIR模型转化为其他格式的模型文件。 + +mindspore.export +将MindSpore网络模型导出为指定格式的文件。 + +mindspore.load +加载MindIR文件。 + +mindspore.load_checkpoint +加载checkpoint文件。 + +mindspore.load_distributed_checkpoint +给分布式预测加载checkpoint文件到网络，用于分布式推理。 + +mindspore.load_param_into_net +将参数加载到网络中，返回网络中没有被加载的参数列表。 + +mindspore.merge_sliced_parameter +将参数切片合并为一个完整的参数，用于分布式推理。 + +mindspore.parse_print +解析由 mindspore.ops.Print 生成的数据文件。 + +mindspore.restore_group_info_list +从group_info_file_name指向的文件中提取得到通信域的信息，在该通信域内的所有设备的checkpoint文件均与存储group_info_file_name的设备相同，可以直接进行替换。 + +mindspore.save_checkpoint +将网络权重保存到checkpoint文件中。 + + + +",mindspore,mindspore、mindspore、分布式、MindIR、网络、model、数据、ib +mindspore§调试调优,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.Profiler +MindSpore用户能够通过该类对神经网络的性能进行采集。 + +mindspore.SummaryCollector +SummaryCollector可以收集一些常用信息。 + +mindspore.SummaryLandscape +SummaryLandscape可以帮助您收集loss地形图的信息。 + +mindspore.SummaryRecord +SummaryRecord用于记录summary数据和lineage数据。 + +mindspore.set_dump +启用或者禁用 target 及其子节点的Dump数据功能。 + + + +",mindspore,mindspore、mindspore、网络、loss、调试、数据、性能 +mindspore§即时编译,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.JitConfig +编译时所使用的JitConfig配置项。 + +mindspore.ms_function +将Python函数编译为一张可调用的MindSpore图。 + +mindspore.ms_class +用户自定义类的类装饰器。 + +mindspore.mutable +设置一个常量值为可变的。 + + + +",mindspore,mindspore、mindspore +mindspore§日志,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.get_level +获取日志记录器的级别。 + +mindspore.get_log_config +获取日志配置。 + + + +",mindspore,mindspore、mindspore +mindspore§安装验证,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.run_check +提供了便捷的API用以查询MindSpore的安装是否成功。 + + + +",mindspore,mindspore、mindspore、API +mindspore§内存回收,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.ms_memory_recycle +回收MindSpore使用的内存。 + + + +",mindspore,mindspore、mindspore +mindspore§二阶优化,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html," + + + + + + + +mindspore.ConvertModelUtils +该接口用于增加计算图，提升二阶算法THOR运行时的性能。 + +mindspore.ConvertNetUtils +将网络转换为thor层网络，用于计算并存储二阶信息矩阵。 + + + +",mindspore,mindspore、mindspore、接口、网络、Model、计算图、优化、性能 +mindspore.common.initializer§mindspore.common.initializer,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.common.initializer.html," +初始化神经元参数。 + + +class mindspore.common.initializer.Initializer(**kwargs)[源代码]¶ +初始化器的抽象基类。 +参数： + +kwargs (dict) – Initializer 的关键字参数。 + + + + +mindspore.common.initializer.initializer(init, shape=None, dtype=mstype.float32)[源代码]¶ +创建并初始化一个Tensor。 +参数： + +init (Union[Tensor, str, Initializer, numbers.Number]) – 初始化方式。 + +str - init 是继承自 Initializer 的类的别名，实际使用时会调用相应的类。init 的值可以是”normal”、”ones”或”zeros”等。 +Initializer - init 是继承自 Initializer ，用于初始化Tensor的类。 +numbers.Number - 用于初始化Tensor的常量。 +Tensor - 用于初始化Tensor的Tensor。 + + +shape (Union[tuple, list, int]) - 被初始化的Tensor的shape，默认值为None。 +dtype (mindspore.dtype) – 被初始化的Tensor的数据类型，默认值为 mindspore.float32 。 + +返回： +Tensor。 +异常： + +TypeError - 参数 init 的类型不正确。 +ValueError - 当 init 传入Tensor对象时， init 的shape与形参 shape 内的数值不一致。 + +样例： +>>> import numpy as np +>>> import mindspore +>>> from mindspore import Tensor +>>> from mindspore.common.initializer import initializer, One +>>> data = Tensor(np.zeros([1, 2, 3]), mindspore.float32) +>>> tensor1 = initializer(data, [1, 2, 3], mindspore.float32) +>>> tensor2 = initializer('ones', [1, 2, 3], mindspore.float32) +>>> tensor3 = initializer(One(), [1, 2, 3], mindspore.float32) +>>> tensor4 = initializer(0, [1, 2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.TruncatedNormal(sigma=0.01)[源代码]¶ +生成一个服从截断正态（高斯）分布的随机数组用于初始化Tensor。 +参数： +sigma (float) - 截断正态分布的标准差，默认值为0.01。 +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, TruncatedNormal +>>> tensor1 = initializer(TruncatedNormal(), [1, 2, 3], mindspore.float32) +>>> tensor2 = initializer('truncatedNormal', [1, 2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.Normal(sigma=0.01, mean=0.0)[源代码]¶ +生成一个服从正态分布 \({N}(\text{sigma}, \text{mean})\) 的随机数组用于初始化Tensor。 + +\[f(x) = \frac{1} {\sqrt{2*π} * sigma}exp(-\frac{(x - mean)^2} {2*{sigma}^2})\] +参数： + +sigma (float) - 正态分布的标准差，默认值为0.01。 +mean (float) - 正态分布的均值，默认值为0.0。 + +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, Normal +>>> tensor1 = initializer(Normal(), [1, 2, 3], mindspore.float32) +>>> tensor2 = initializer('normal', [1, 2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.Uniform(scale=0.07)[源代码]¶ +生成一个服从均匀分布 \({U}(-\text{scale}, \text{scale})\) 的随机数组用于初始化Tensor。 +参数： +scale (float) - 均匀分布的边界，默认值为0.07。 +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, Uniform +>>> tensor1 = initializer(Uniform(), [1, 2, 3], mindspore.float32) +>>> tensor2 = initializer('uniform', [1, 2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.HeUniform(negative_slope=0, mode='fan_in', nonlinearity='leaky_relu')[源代码]¶ +生成一个服从HeKaiming均匀分布 \({U}(-\text{boundary}, \text{boundary})\) 的随机数组用于初始化Tensor，其中： + +\[boundary = \text{gain} \times \sqrt{\frac{3}{fan\_mode}}\] +\(gain\) 是一个可选的缩放因子。 \(fan\_mode\) 是权重Tensor中输入或输出单元的数量，取决于 mode 是’fan_in’或是’fan_out’。 +参数： + +negative_slope (int, float, bool) - 本层激活函数的负数区间斜率（仅适用于非线性激活函数’leaky_relu’），默认值为0。 +mode (str) - 可选’fan_in’或’fan_out’，’fan_in’会保留前向传递中权重方差的量级，’fan_out’会保留反向传递的量级，默认为’fan_in’。 +nonlinearity (str) - 非线性激活函数，推荐使用’relu’或’leaky_relu’，默认为’leaky_relu’。 + +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, HeUniform +>>> tensor1 = initializer(HeUniform(), [1, 2, 3], mindspore.float32) +>>> tensor2 = initializer('he_uniform', [1, 2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.HeNormal(negative_slope=0, mode='fan_in', nonlinearity='leaky_relu')[源代码]¶ +生成一个服从HeKaiming正态分布 \({N}(0, \text{sigma}^2)\) 的随机数组用于初始化Tensor，其中： + +\[sigma = \frac{gain} {\sqrt{fan\_mode}}\] +其中， \(gain\) 是一个可选的缩放因子。如果 mode 是’fan_in’，则 \(fan\_mode\) 是权重Tensor中输入单元的数量，如果 mode 是’fan_out’， +\(fan\_mode\) 是权重Tensor中输出单元的数量。 +HeUniform 算法的详细信息，请查看 https://arxiv.org/abs/1502.01852。 +参数： + +negative_slope (int, float, bool) - 本层激活函数的负数区间斜率（仅适用于非线性激活函数’leaky_relu’），默认值为0。 +mode (str) - 可选’fan_in’或’fan_out’，’fan_in’会保留前向传递中权重方差的量级，’fan_out’会保留反向传递的量级，默认为’fan_in’。 +nonlinearity (str) - 非线性激活函数，推荐使用’relu’或’leaky_relu’，默认为’leaky_relu’。 + +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, HeNormal +>>> tensor1 = initializer(HeNormal(), [1, 2, 3], mindspore.float32) +>>> tensor2 = initializer('he_normal', [1, 2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.XavierUniform(gain=1)[源代码]¶ +生成一个服从Xarvier均匀分布U(-boundary, boundary)的随机数组用于初始化Tensor，均匀分布的取值范围为[-boundary, boundary]，其中： + +\[boundary = gain * \sqrt{\frac{6}{n_{in} + n_{out}}}\] +\(gain\) 是一个可选的缩放因子。\(n_{in}\) 为权重Tensor中输入单元的数量。\(n_{out}\) 为权重Tensor中输出单元的数量。 +有关 XavierUniform 算法的详细信息，请查看 http://proceedings.mlr.press/v9/glorot10a.html。 +参数： +gain (float) - 可选的缩放因子，默认值为1。 +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, XavierUniform +>>> tensor1 = initializer(XavierUniform(), [1, 2, 3], mindspore.float32) +>>> tensor2 = initializer('xavier_uniform', [1, 2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.One(**kwargs)[源代码]¶ +生成一个值全为1的常量数组用于初始化Tensor。 +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, One +>>> tensor1 = initializer(One(), [1, 2, 3], mindspore.float32) +>>> tensor2 = initializer('ones', [1, 2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.Zero(**kwargs)[源代码]¶ +生成一个值全为0的常量数组用于初始化Tensor。 +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, Zero +>>> tensor1 = initializer(Zero(), [1, 2, 3], mindspore.float32) +>>> tensor2 = initializer('zeros', [1, 2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.Constant(value)[源代码]¶ +生成一个常量数组用于初始化Tensor。 +参数： +value (Union[int, numpy.ndarray]) - 用于初始化的常数值或者数组。 +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer +>>> tensor1 = initializer(0, [1, 2, 3], mindspore.float32) +>>> tensor2 = initializer(5, [1, 2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.Identity(**kwargs)[源代码]¶ +生成一个2维的单位矩阵用于初始化Tensor。 +异常： + +ValueError - 被初始化的Tensor的维度不等于2。 + +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, Identity +>>> tensor1 = initializer(Identity(), [2, 3], mindspore.float32) +>>> tensor2 = initializer('identity', [2, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.Sparse(sparsity, sigma=0.01)[源代码]¶ +生成一个2维的稀疏矩阵用于初始化Tensor。矩阵非0的位置的值服从正态分布 \(N(0, 0.01)\) 。 +参数： + +sparsity (float) - 矩阵每列中元素被置0的比例。 +sigma (float) - 正态分布的标准差，默认值为0.01。 + +异常： + +ValueError - 被初始化的Tensor的维度不等于2。 + +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, Sparse +>>> tensor1 = initializer(Sparse(sparsity=0.1, sigma=0.01), [5, 8], mindspore.float32) + + + + + +class mindspore.common.initializer.Dirac(groups=1)[源代码]¶ +利用Dirac delta函数生成一个矩阵用于初始化Tensor。这种初始化方式将会保留卷积层的输入。对于group +卷积，通道的每个分组会被分别保留。 +参数： +groups (int) - 卷积层中的分组，默认值为1。 +异常： + +ValueError - 被初始化的Tensor的维度不在[3, 4, 5]的范围内。 +ValueError - 初始化的Tensor的第一个维度不能被groups整除。 + +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, Dirac +>>> tensor1 = initializer(Dirac(groups=2), [6, 4, 3, 3], mindspore.float32) +>>> tensor2 = initializer(""dirac"", [6, 4, 3, 3], mindspore.float32) + + + + + +class mindspore.common.initializer.Orthogonal(gain=1.)[源代码]¶ +生成一个正交或半正交矩阵用于初始化Tensor。被初始化的Tensor的维度至少为2。 +如果维度大于2，多余的维度将会被展平。 +参数： +gain (float) - 可选的比例因子，默认值为1。 +异常： + +ValueError - 被初始化的Tensor的维度小于2。 + +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, Orthogonal +>>> tensor1 = initializer(Orthogonal(gain=2.), [2, 3, 4], mindspore.float32) +>>> tensor2 = initializer('orthogonal', [2, 3, 4], mindspore.float32) + + + + + +class mindspore.common.initializer.VarianceScaling(scale=1.0, mode='fan_in', distribution='truncated_normal')[源代码]¶ +生成一个随机的矩阵用于初始化Tensor。 +当 distribution 是’truncated_normal’或者’untruncated_normal’时，矩阵中的值将服从均值为0，标准差 +为 \(stddev = \sqrt{\frac{scale}{n}}\) 的截断或者非截断正态分布。如果 mode 是’fan_in’， \(n\) 是输入单元的数量； +如果 mode 是’fan_out’， \(n\) 是输出单元的数量；如果 mode 是’fan_avg’， \(n\) 是输入输出单元数量的均值。 +当 distribution 是’uniform’时，矩阵中的值将服从均匀分布 \([-\sqrt{\frac{3*scale}{n}}, \sqrt{\frac{3*scale}{n}}]\)。 +参数： + +scale (float) - 比例因子，默认值为1.0。 +mode (str) - 其值应为’fan_in’，’fan_out’或者’fan_avg’，默认值为’fan_in’。 +distribution (str) - 用于采样的分布类型。它可以是 ‘uniform’，’truncated_normal’或’untruncated_normal’，默认值为’truncated_normal’。 + +异常： + +ValueError - scale 小于等于0。 +ValueError - mode 不是’fan_in’，’fan_out’或者’fan_avg’。 +ValueError - distribution 不是’truncated_normal’，’untruncated_normal’或者’uniform’。 + +样例： +>>> import mindspore +>>> from mindspore.common.initializer import initializer, VarianceScaling +>>> tensor1 = initializer(VarianceScaling(scale=1.0, mode='fan_out', +... distribution='untruncated_normal'), [2, 3], mindspore.float32) +>>> tensor2 = initializer('varianceScaling', [2, 3], mindspore.float32) + + + +",mindspore.common.initializer,mindspore、mindspore、数据 +mindspore.communication§mindspore.communication,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.communication.html," +集合通信接口。 +注意，集合通信接口需要预先设置环境变量。对于Ascend，用户需要配置rank_table，设置rank_id和device_id，相关教程可参考： +Ascend指导文档。 +对于GPU，用户需要预先配置host_file以及mpi，相关教程参考： +GPU指导文档。 +目前尚不支持CPU。 + + +class mindspore.communication.GlobalComm[源代码]¶ +GlobalComm 是一个储存通信信息的全局类。 成员包含：BACKEND、WORLD_COMM_GROUP。 + +BACKEND：使用的通信库，HCCL或者NCCL。 +WORLD_COMM_GROUP：全局通信域。 + + + + +mindspore.communication.init(backend_name=None)[源代码]¶ +初始化通信服务需要的分布式后端，例如 HCCL 或 NCCL 服务。 + +Note +HCCL的全称是华为集合通信库（Huawei Collective Communication Library），NCCL的全称是英伟达集合通信库（NVIDIA Collective Communication Library）。 init 方法应该在 set_context 方法之后使用。 + +参数： + +backend_name (str) – 分布式后端的名称，可选HCCL或NCCL。如果未设置则根据硬件平台类型（device_target）进行推断，默认值为None。 + +异常： + +TypeError – 参数 backend_name 不是字符串。 +RuntimeError – 1）硬件设备类型无效；2）后台服务无效；3）分布式计算初始化失败；4）未设置环境变量 RANK_ID 或 MINDSPORE_HCCL_CONFIG_PATH 的情况下初始化HCCL服务。 + +支持平台： +Ascend GPU +样例： +>>> from mindspore.communication import init +>>> init() + + + + + +mindspore.communication.release()[源代码]¶ +释放分布式资源，例如 HCCL 或 NCCL 服务。 + +Note +release 方法应该在 init 方法之后使用。在运行以下示例之前，用户需要预设通信环境变量，请查看mindspore.communication的文档注释。 + +异常： + +RuntimeError - 在释放分布式资源失败时抛出。 + +支持平台： +Ascend GPU +样例： +>>> from mindspore.communication import init, release +>>> init() +>>> release() + + + + + +mindspore.communication.get_rank(group=GlobalComm.WORLD_COMM_GROUP)[源代码]¶ +在指定通信组中获取当前的设备序号。 + +Note +get_rank 方法应该在 init 方法之后使用。在运行以下示例之前，用户需要预设通信环境变量，请查看mindspore.communication的文档注释。 + +参数： + +group (str) - 通信组名称，通常由 create_group 方法创建，否则将使用默认组。默认值： GlobalComm.WORLD_COMM_GROUP 。 + +返回： +int, 调用该方法的进程对应的组内序号。 +异常： + +TypeError – 在参数 group 不是字符串时抛出。 +ValueError – 在后台不可用时抛出。 +RuntimeError – 在 HCCL 或 NCCL 服务不可用时抛出。 + +支持平台： +Ascend GPU +样例： +>>> from mindspore.communication import init, get_rank +>>> init() +>>> rank_id = get_rank() +>>> print(rank_id) +>>> # the result is the rank_id in world_group + + + + + +mindspore.communication.get_group_size(group=GlobalComm.WORLD_COMM_GROUP)[源代码]¶ +获取指定通信组实例的rank_size。 + +Note +get_group_size 方法应该在 init 方法之后使用。在跑用例之前用户需要预先配置通信相关的环境变量。 + +参数： + +group (str) - 指定工作组实例（由 create_group 方法创建）的名称，支持数据类型为str，默认值为 WORLD_COMM_GROUP 。 + +返回： +指定通信组实例的rank_size，数据类型为int。 +异常： + +TypeError – 在参数 group 不是字符串时抛出。 +ValueError – 在后台不可用时抛出。 +RuntimeError – 在 HCCL 或 NCCL 服务不可用时抛出。 + +支持平台： +Ascend GPU +样例： +>>> import mindspore as ms +>>> from mindspore.communication.management import init, get_group_size +>>> ms.set_auto_parallel_context(device_num=8) +>>> init() +>>> group_size = get_group_size() +>>> print(""group_size is: "", group_size) +group_size is: 8 + + + + + +mindspore.communication.get_world_rank_from_group_rank(group, group_rank_id)[源代码]¶ +由指定通信组中的设备序号获取通信集群中的全局设备序号。 + +Note + +GPU 版本的MindSpore不支持此方法； +参数 group 不能是 hccl_world_group； +get_world_rank_from_group_rank 方法应该在 init 方法之后使用。在运行以下示例之前，用户需要预设通信环境变量，请查看mindspore.communication的文档注释。 + + +参数： + +group (str) - 传入的通信组名称，通常由 create_group 方法创建。 +group_rank_id (int) - 通信组内的设备序号。 + +返回： +int, 通信集群中的全局设备序号。 +异常： + +TypeError – 参数 group 不是字符串或参数 group_rank_id 不是数字。 +ValueError – 参数 group 是 hccl_world_group 或后台不可用。 +RuntimeError – HCCL 或 NCCL 服务不可用，以及使用CPU版本的MindSpore。 + +支持平台： +Ascend +样例： +>>> from mindspore import set_context +>>> from mindspore.communication.management import init, create_group, get_world_rank_from_group_rank +>>> set_context(device_target=""Ascend"") +>>> init() +>>> group = ""0-4"" +>>> rank_ids = [0,4] +>>> create_group(group, rank_ids) +>>> world_rank_id = get_world_rank_from_group_rank(group, 1) +>>> print(""world_rank_id is: "", world_rank_id) +world_rank_id is: 4 + + + + + +mindspore.communication.get_group_rank_from_world_rank(world_rank_id, group)[源代码]¶ +由通信集群中的全局设备序号获取指定用户通信组中的rank ID。 + +Note + +GPU 版本的MindSpore不支持此方法； +参数 group 不能是 hccl_world_group； +get_group_rank_from_world_rank 方法应该在 init 方法之后使用。 + + +参数： + +world_rank_id (int) - 通信集群内的全局rank ID。 +group (str) - 指定通信组实例（由 create_group 方法创建）的名称。 + +返回： +当前通信组内的rank_ID，数据类型为int。 +异常： + +TypeError – 在参数 group_rank_id 不是数字或参数 group 不是字符串时抛出。 +ValueError – 在参数 group 是 hccl_world_group 或后台不可用时抛出。 +RuntimeError – 在 HCCL 或 NCCL 服务不可用，以及使用GPU版本的MindSpore时抛出。 + +支持平台： +Ascend +样例： +>>> from mindspore import set_context +>>> from mindspore.communication.management import init, create_group, get_group_rank_from_world_rank +>>> set_context(device_target=""Ascend"") +>>> init() +>>> group = ""0-4"" +>>> rank_ids = [0,4] +>>> create_group(group, rank_ids) +>>> group_rank_id = get_group_rank_from_world_rank(4, group) +>>> print(""group_rank_id is: "", group_rank_id) +group_rank_id is: 1 + + + + + +mindspore.communication.create_group(group, rank_ids)[源代码]¶ +创建用户自定义的通信组实例。 + +Note + +GPU 版本的MindSpore不支持此方法； +列表rank_ids的长度应大于1； +列表rank_ids内不能有重复数据； +create_group 方法应该在 init 方法之后使用； +PyNative模式下仅支持全局单通信组。 + + +参数： + +group (str) - 输入用户自定义的通信组实例名称，支持数据类型为str。 +rank_ids (list) - 设备编号列表。 + +异常： + +TypeError – 参数 group_rank_id 不是数字或参数 group 不是字符串。 +ValueError – 列表rank_ids的长度小于1，或列表rank_ids内有重复数据，以及后台无效。 +RuntimeError – 在 HCCL 或 NCCL 服务不可用，以及使用CPU版本的MindSpore。 + +支持平台： +Ascend +样例： +>>> from mindspore import set_context +>>> from mindspore.ops import operations as ops +>>> from mindspore.communication.management import init, create_group +>>> set_context(device_target=""Ascend"") +>>> init() +>>> group = ""0-8"" +>>> rank_ids = [0,8] +>>> create_group(group, rank_ids) +>>> allreduce = ops.AllReduce(group) + + + + + +mindspore.communication.get_local_rank(group=GlobalComm.WORLD_COMM_GROUP)[源代码]¶ +获取指定通信组中当前设备的本地设备序号。 + +Note + +GPU 版本的MindSpore不支持此方法； +get_local_rank 方法应该在 init 方法之后使用。在运行以下示例之前，用户需要预设通信环境变量，请查看mindspore.communication的文档注释。 + + +参数： + +group (str) - 通信组名称，通常由 create_group 方法创建，否则将使用默认组名称。默认值： WORLD_COMM_GROUP 。 + +返回： +int, 调用该方法的进程对应的通信组内本地设备序号。 +异常： + +TypeError – 在参数 group 不是字符串时抛出。 +ValueError – 在后台不可用时抛出。 +RuntimeError – 在 HCCL 或 NCCL 服务不可用时抛出。 + +支持平台： +Ascend +样例： +>>> import mindspore as ms +>>> from mindspore.communication.management import init, get_rank, get_local_rank +>>> ms.set_context(device_target=""Ascend"") +>>> ms.set_auto_parallel_context(device_num=16) # 2 server, each server with 8 NPU. +>>> init() +>>> world_rank = get_rank() +>>> local_rank = get_local_rank() +>>> print(""local_rank is: {}, world_rank is {}"".format(local_rank, world_rank)) +local_rank is: 1, world_rank is 9 + + + + + +mindspore.communication.get_local_rank_size(group=GlobalComm.WORLD_COMM_GROUP)[源代码]¶ +获取指定通信组的本地设备总数。 + +Note + +GPU 版本的MindSpore不支持此方法； +get_local_rank_size 方法应该在 init 方法之后使用。 + + +参数： + +group (str) - 传入的通信组名称，通常由 create_group 方法创建，或默认使用 WORLD_COMM_GROUP 。 + +返回： +int, 调用该方法的进程对应的通信组设备总数。 +异常： + +TypeError – 在参数 group 不是字符串时抛出。 +ValueError – 在后台不可用时抛出。 +RuntimeError – 在 HCCL 或 NCCL 服务不可用时抛出。 + +支持平台： +Ascend +样例： +>>> import mindspore as ms +>>> from mindspore.communication.management import init, get_local_rank_size +>>> ms.set_context(device_target=""Ascend"") +>>> ms.set_auto_parallel_context(device_num=16) # 2 server, each server with 8 NPU. +>>> init() +>>> local_rank_size = get_local_rank_size() +>>> print(""local_rank_size is: "", local_rank_size) +local_rank_size is: 8 + + + + + +mindspore.communication.destroy_group(group)[源代码]¶ +注销用户通信组。 + +Note + +GPU 版本的MindSpore不支持此方法； +参数 group 不能是 hccl_world_group； +destroy_group 方法应该在 init 方法之后使用。 + + +参数： + +group (str) - 被注销通信组实例（通常由 create_group 方法创建）的名称。 + +异常： + +TypeError – 在参数 group 不是字符串时抛出。 +ValueError – 在参数 group 是 hccl_world_group 或后台不可用时抛出。 +RuntimeError – 在 HCCL 或 NCCL 服务不可用时抛出。 + +支持平台： +Ascend + + + +mindspore.communication.HCCL_WORLD_COMM_GROUP¶ +“hccl_world_group”字符串，指的是由HCCL创建的默认通信组。 + + + +mindspore.communication.NCCL_WORLD_COMM_GROUP¶ +“nccl_world_group”字符串，指的是由NCCL创建的默认通信组。 + +",mindspore.communication,mindspore、mindspore、数据 +mindspore.dataset§mindspore.dataset,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.html," +该模块提供了加载和处理各种通用数据集的API，如MNIST、CIFAR-10、CIFAR-100、VOC、COCO、ImageNet、CelebA、CLUE等， +也支持加载业界标准格式的数据集，包括MindRecord、TFRecord、Manifest等。此外，用户还可以使用此模块定义和加载自己的数据集。 +该模块还提供了在加载时进行数据采样的API，如SequentialSample、RandomSampler、DistributedSampler等。 +大多数数据集可以通过指定参数 cache 启用缓存服务，以提升整体数据处理效率。 +请注意Windows平台上还不支持缓存服务，因此在Windows上加载和处理数据时，请勿使用。更多介绍和限制， +请参考 Single-Node Tensor Cache。 +在API示例中，常用的模块导入方法如下： +import mindspore.dataset as ds +from mindspore.dataset.transforms import c_transforms + + +常用数据集术语说明如下： + +Dataset，所有数据集的基类，提供了数据处理方法来帮助预处理数据。 +SourceDataset，一个抽象类，表示数据集管道的来源，从文件和数据库等数据源生成数据。 +MappableDataset，一个抽象类，表示支持随机访问的源数据集。 +Iterator，用于枚举元素的数据集迭代器的基类。 + + +",mindspore.dataset,mindspore、mindspore、数据集、MindRecord、API、数据、迭代、dataset、Windows、ib +mindspore.dataset§视觉,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.html," + + + + + + + +mindspore.dataset.Caltech101Dataset +读取和解析Caltech101数据集的源文件构建数据集。 + +mindspore.dataset.Caltech256Dataset +读取和解析Caltech256数据集的源文件构建数据集。 + +mindspore.dataset.CelebADataset +读取和解析CelebA数据集的源文件构建数据集。 + +mindspore.dataset.Cifar10Dataset +读取和解析CIFAR-10数据集的源文件构建数据集。 + +mindspore.dataset.Cifar100Dataset +读取和解析CIFAR-100数据集的源文件构建数据集。 + +mindspore.dataset.CityscapesDataset +读取和解析Cityscapes数据集的源文件构建数据集。 + +mindspore.dataset.CocoDataset +读取和解析COCO数据集的源文件构建数据集。 + +mindspore.dataset.DIV2KDataset +读取和解析DIV2K数据集的源文件构建数据集。 + +mindspore.dataset.EMnistDataset +A source dataset that reads and parses the EMNIST dataset. + +mindspore.dataset.FakeImageDataset +A source dataset for generating fake images. + +mindspore.dataset.FashionMnistDataset +A source dataset that reads and parses the FASHION-MNIST dataset. + +mindspore.dataset.FlickrDataset +A source dataset that reads and parses Flickr8k and Flickr30k dataset. + +mindspore.dataset.Flowers102Dataset +A source dataset that reads and parses Flowers102 dataset. + +mindspore.dataset.ImageFolderDataset +从树状结构的文件目录中读取图片构建源数据集，同一个文件夹中的所有图片将被分配相同的label。 + +mindspore.dataset.KMnistDataset +A source dataset that reads and parses the KMNIST dataset. + +mindspore.dataset.ManifestDataset +读取和解析Manifest数据文件构建数据集。 + +mindspore.dataset.MnistDataset +读取和解析MNIST数据集的源文件构建数据集。 + +mindspore.dataset.PhotoTourDataset +A source dataset that reads and parses the PhotoTour dataset. + +mindspore.dataset.Places365Dataset +A source dataset that reads and parses the Places365 dataset. + +mindspore.dataset.QMnistDataset +A source dataset that reads and parses the QMNIST dataset. + +mindspore.dataset.SBDataset +A source dataset that reads and parses Semantic Boundaries Dataset. + +mindspore.dataset.SBUDataset +A source dataset that reads and parses the SBU dataset. + +mindspore.dataset.SemeionDataset +A source dataset that reads and parses Semeion dataset. + +mindspore.dataset.STL10Dataset +A source dataset that reads and parses STL10 dataset. + +mindspore.dataset.SVHNDataset +A source dataset that reads and parses SVHN dataset. + +mindspore.dataset.USPSDataset +A source dataset that reads and parses the USPS dataset. + +mindspore.dataset.VOCDataset +读取和解析VOC数据集的源文件构建数据集。 + +mindspore.dataset.WIDERFaceDataset +A source dataset that reads and parses WIDERFace dataset. + + + +",mindspore.dataset,mindspore、mindspore、数据集、数据、dataset +mindspore.dataset§文本,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.html," + + + + + + + +mindspore.dataset.AGNewsDataset +A source dataset that reads and parses AG News datasets. + +mindspore.dataset.AmazonReviewDataset +A source dataset that reads and parses Amazon Review Polarity and Amazon Review Full datasets. + +mindspore.dataset.CLUEDataset +读取和解析CLUE数据集的源文件构建数据集。 + +mindspore.dataset.CoNLL2000Dataset +A source dataset that reads and parses CoNLL2000 dataset. + +mindspore.dataset.DBpediaDataset +A source dataset that reads and parses the DBpedia dataset. + +mindspore.dataset.EnWik9Dataset +A source dataset that reads and parses EnWik9 dataset. + +mindspore.dataset.IMDBDataset +A source dataset that reads and parses Internet Movie Database (IMDb). + +mindspore.dataset.IWSLT2016Dataset +A source dataset that reads and parses IWSLT2016 datasets. + +mindspore.dataset.IWSLT2017Dataset +A source dataset that reads and parses IWSLT2017 datasets. + +mindspore.dataset.PennTreebankDataset +A source dataset that reads and parses PennTreebank datasets. + +mindspore.dataset.SogouNewsDataset +A source dataset that reads and parses Sogou News dataset. + +mindspore.dataset.TextFileDataset +读取和解析文本文件构建数据集。 + +mindspore.dataset.UDPOSDataset +A source dataset that reads and parses UDPOS dataset. + +mindspore.dataset.WikiTextDataset +A source dataset that reads and parses WikiText2 and WikiText103 datasets. + +mindspore.dataset.YahooAnswersDataset +A source dataset that reads and parses the YahooAnswers dataset. + +mindspore.dataset.YelpReviewDataset +A source dataset that reads and parses Yelp Review Polarity and Yelp Review Full dataset. + + + +",mindspore.dataset,mindspore、mindspore、数据集、数据、dataset、WSL +mindspore.dataset§音频,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.html," + + + + + + + +mindspore.dataset.LJSpeechDataset +A source dataset that reads and parses LJSpeech dataset. + +mindspore.dataset.SpeechCommandsDataset +A source dataset that reads and parses the SpeechCommands dataset. + +mindspore.dataset.TedliumDataset +A source dataset that reads and parses Tedlium dataset. + +mindspore.dataset.YesNoDataset +A source dataset that reads and parses the YesNo dataset. + + + +",mindspore.dataset,mindspore、mindspore、dataset +mindspore.dataset§标准格式,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.html," + + + + + + + +mindspore.dataset.CSVDataset +读取和解析CSV数据文件构建数据集。 + +mindspore.dataset.MindDataset +读取和解析MindRecord数据文件构建数据集。 + +mindspore.dataset.OBSMindDataset +读取和解析存放在华为云OBS、Minio以及AWS S3等云存储上的MindRecord格式数据集。 + +mindspore.dataset.TFRecordDataset +读取和解析TFData格式的数据文件构建数据集。 + + + +",mindspore.dataset,mindspore、mindspore、数据集、MindRecord、数据、MindData、dataset +mindspore.dataset§用户自定义,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.html," + + + + + + + +mindspore.dataset.GeneratorDataset +自定义Python数据源，通过迭代该数据源构造数据集。 + +mindspore.dataset.NumpySlicesDataset +由Python数据构建数据集。 + +mindspore.dataset.PaddedDataset +由用户提供的填充数据构建数据集。 + +mindspore.dataset.RandomDataset +A source dataset that generates random data. + + + +",mindspore.dataset,mindspore、mindspore、数据集、GeneratorDataset、数据、迭代、dataset +mindspore.dataset§图,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.html," + + + + + + + +mindspore.dataset.ArgoverseDataset +加载argoverse数据集并进行图（Graph）初始化。 + +mindspore.dataset.Graph +主要用于存储图的结构信息和图特征属性，并提供图采样等能力。 + +mindspore.dataset.GraphData +从共享文件或数据库中读取用于GNN训练的图数据集。 + +mindspore.dataset.InMemoryGraphDataset +用于将图数据加载到内存中的Dataset基类。 + + + +",mindspore.dataset,mindspore、mindspore、数据集、数据、dataset、Graph +mindspore.dataset§采样器,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.html," + + + + + + + +mindspore.dataset.DistributedSampler +分布式采样器，将数据集进行分片用于分布式训练。 + +mindspore.dataset.PKSampler +为数据集中每P个类别各采样K个样本。 + +mindspore.dataset.RandomSampler +随机采样器。 + +mindspore.dataset.SequentialSampler +按数据集的读取顺序采样数据集样本，相当于不使用采样器。 + +mindspore.dataset.SubsetRandomSampler +给定样本的索引序列，从序列中随机获取索引对数据集进行采样。 + +mindspore.dataset.SubsetSampler +给定样本的索引序列，对数据集采样指定索引的样本。 + +mindspore.dataset.WeightedRandomSampler +给定样本的权重列表，根据权重决定样本的采样概率，随机采样[0，len(weights) - 1]中的样本。 + + + +",mindspore.dataset,mindspore、mindspore、分布式、数据集、数据、dataset、ib +mindspore.dataset§其他,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.html," + + + + + + + +mindspore.dataset.BatchInfo +此类提供了两种方法获取数据集的批处理数量（batch size）和迭代数（epoch）属性。 + +mindspore.dataset.DatasetCache +创建数据缓存客户端实例。 + +mindspore.dataset.DSCallback +数据处理回调类的抽象基类，用户可以基于此类实现自己的回调操作。 + +mindspore.dataset.SamplingStrategy +指定图数据采样策略的枚举类。 + +mindspore.dataset.Schema +用于解析和存储数据列属性的类。 + +mindspore.dataset.Shuffle +指定混洗模式的枚举类。 + +mindspore.dataset.WaitedDSCallback +阻塞式数据处理回调类的抽象基类，用于与训练回调类 mindspore.Callback 的同步。 + +mindspore.dataset.OutputFormat +通过API get_all_neighbors 获取所有相邻节点时，指定节点的存储格式。 + +mindspore.dataset.compare +比较两个数据处理管道是否相同。 + +mindspore.dataset.deserialize +数据处理管道反序列化，支持输入Python字典或使用 mindspore.dataset.serialize() 接口生成的JSON文件。 + +mindspore.dataset.serialize +将数据处理管道序列化成JSON文件。 + +mindspore.dataset.show +将数据处理管道图写入MindSpore的INFO级别日志文件。 + +mindspore.dataset.sync_wait_for_dataset +等待所有的卡需要的数据集文件下载完成。 + +mindspore.dataset.utils.imshow_det_bbox +使用给定的边界框和类别置信度绘制图像。 + +mindspore.dataset.zip +将多个dataset对象按列进行合并压缩。 + + + +",mindspore.dataset,mindspore、mindspore、接口、数据集、Callback、API、数据、迭代、dataset +mindspore.dataset.audio§mindspore.dataset.audio,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.audio.html," +此模块用于音频数据增强，包括 transforms 和 utils 两个子模块。 +transforms 是一个高性能音频数据增强模块，支持常见的音频数据增强操作。 +utils 提供了一些音频处理的工具方法。 +API样例中常用的导入模块如下： +import mindspore.dataset as ds +import mindspore.dataset.audio as audio + + +常用数据处理术语说明如下： + +TensorOperation，所有C++实现的数据处理操作的基类。 +AudioTensorOperation，所有音频数据处理操作的基类，派生自TensorOperation。 + + +",mindspore.dataset.audio,mindspore、mindspore、API、数据、性能、dataset、C++ +mindspore.dataset.audio§变换,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.audio.html," + + + + + + + +mindspore.dataset.audio.AllpassBiquad +给音频波形施加双极点全通滤波器，其中心频率和带宽由入参指定。 + +mindspore.dataset.audio.AmplitudeToDB +将输入音频从振幅/功率标度转换为分贝标度。 + +mindspore.dataset.audio.Angle +计算复数序列的角度。 + +mindspore.dataset.audio.BandBiquad +给音频波形施加双极点带通滤波器。 + +mindspore.dataset.audio.BandpassBiquad +给音频波形施加双极点巴特沃斯（Butterworth）带通滤波器。 + +mindspore.dataset.audio.BandrejectBiquad +给音频波形施加双极点巴特沃斯（Butterworth）带阻滤波器。 + +mindspore.dataset.audio.BassBiquad +给音频波形施加低音控制效果，即双极点低频搁架滤波器。 + +mindspore.dataset.audio.Biquad +Perform a biquad filter of input audio. + +mindspore.dataset.audio.ComplexNorm +计算复数序列的范数。 + +mindspore.dataset.audio.ComputeDeltas +Compute delta coefficients of a spectrogram. + +mindspore.dataset.audio.Contrast +给音频波形施加对比度增强效果。 + +mindspore.dataset.audio.DBToAmplitude +Turn a waveform from the decibel scale to the power/amplitude scale. + +mindspore.dataset.audio.DCShift +Apply a DC shift to the audio. + +mindspore.dataset.audio.DeemphBiquad +Design two-pole deemph filter for audio waveform of dimension of (…, time). + +mindspore.dataset.audio.DetectPitchFrequency +Detect pitch frequency. + +mindspore.dataset.audio.Dither +Dither increases the perceived dynamic range of audio stored at a particular bit-depth by eliminating nonlinear truncation distortion. + +mindspore.dataset.audio.EqualizerBiquad +Design biquad equalizer filter and perform filtering. + +mindspore.dataset.audio.Fade +Add a fade in and/or fade out to an waveform. + +mindspore.dataset.audio.Flanger +Apply a flanger effect to the audio. + +mindspore.dataset.audio.FrequencyMasking +给音频波形施加频域掩码。 + +mindspore.dataset.audio.Gain +Apply amplification or attenuation to the whole waveform. + +mindspore.dataset.audio.GriffinLim +Approximate magnitude spectrogram inversion using the GriffinLim algorithm. + +mindspore.dataset.audio.HighpassBiquad +Design biquad highpass filter and perform filtering. + +mindspore.dataset.audio.InverseMelScale +Solve for a normal STFT form a mel frequency STFT, using a conversion matrix. + +mindspore.dataset.audio.LFilter +Design two-pole filter for audio waveform of dimension of (…, time). + +mindspore.dataset.audio.LowpassBiquad +给音频波形施加双极点低通滤波器。 + +mindspore.dataset.audio.Magphase +Separate a complex-valued spectrogram with shape (…, 2) into its magnitude and phase. + +mindspore.dataset.audio.MaskAlongAxis +Apply a mask along axis. + +mindspore.dataset.audio.MaskAlongAxisIID +Apply a mask along axis. + +mindspore.dataset.audio.MelScale +Convert normal STFT to STFT at the Mel scale. + +mindspore.dataset.audio.MuLawDecoding +Decode mu-law encoded signal. + +mindspore.dataset.audio.MuLawEncoding +Encode signal based on mu-law companding. + +mindspore.dataset.audio.Overdrive +Apply overdrive on input audio. + +mindspore.dataset.audio.Phaser +Apply a phasing effect to the audio. + +mindspore.dataset.audio.PhaseVocoder +Given a STFT tensor, speed up in time without modifying pitch by a factor of rate. + +mindspore.dataset.audio.Resample +Resample a signal from one frequency to another. + +mindspore.dataset.audio.RiaaBiquad +Apply RIAA vinyl playback equalization. + +mindspore.dataset.audio.SlidingWindowCmn +Apply sliding-window cepstral mean (and optionally variance) normalization per utterance. + +mindspore.dataset.audio.SpectralCentroid +Create a spectral centroid from an audio signal. + +mindspore.dataset.audio.Spectrogram +Create a spectrogram from an audio signal. + +mindspore.dataset.audio.TimeMasking +给音频波形施加时域掩码。 + +mindspore.dataset.audio.TimeStretch +以给定的比例拉伸音频短时傅里叶（Short Time Fourier Transform, STFT）频谱的时域，但不改变音频的音高。 + +mindspore.dataset.audio.TrebleBiquad +Design a treble tone-control effect. + +mindspore.dataset.audio.Vad +Attempt to trim silent background sounds from the end of the voice recording. + +mindspore.dataset.audio.Vol +Apply amplification or attenuation to the whole waveform. + + + +",mindspore.dataset.audio,mindspore、mindspore、ast、dataset、ib、npu +mindspore.dataset.audio§工具,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.audio.html," + + + + + + + +mindspore.dataset.audio.BorderType +Padding Mode, BorderType Type. + +mindspore.dataset.audio.DensityFunction +Density Functions. + +mindspore.dataset.audio.FadeShape +Fade Shapes. + +mindspore.dataset.audio.GainType +Gain Types. + +mindspore.dataset.audio.Interpolation +Interpolation Type. + +mindspore.dataset.audio.MelType +Mel Types. + +mindspore.dataset.audio.Modulation +Modulation Type. + +mindspore.dataset.audio.NormMode +Norm Types. + +mindspore.dataset.audio.NormType +Norm Types. + +mindspore.dataset.audio.ResampleMethod +Resample method + +mindspore.dataset.audio.ScaleType +音频标度枚举类。 + +mindspore.dataset.audio.WindowType +Window Function types, + +mindspore.dataset.audio.create_dct +Create a DCT transformation matrix with shape (n_mels, n_mfcc), normalized depending on norm. + +mindspore.dataset.audio.melscale_fbanks +Create a frequency transformation matrix with shape (n_freqs, n_mels). + + + +",mindspore.dataset.audio,mindspore、mindspore、dataset +mindspore.dataset.config§mindspore.dataset.config,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.config.html," +config模块能够设置或获取数据处理的全局配置参数。 +API示例所需模块的导入代码如下： +import mindspore.dataset as ds + + + + +mindspore.dataset.config.set_sending_batches(batch_num)¶ +在昇腾设备中使用sink_mode=True进行训练时，设置默认的发送批次。 +参数： + +batch_num (int) - 表示总的发送批次。当设置了 batch_num 时，它将会等待，除非增加发送批次。默认值为0，表示将发送数据集中的所有批次。 + +异常： + +TypeError - batch_num 不是int类型。 + +样例： +>>> # Set a new global configuration value for the sending batches +>>> ds.config.set_sending_batches(10) + + + + + +mindspore.dataset.config.load(file)¶ +根据文件内容加载项目配置文件。 +参数： + +file (str) - 表示待加载的配置文件的路径。 + +异常： + +RuntimeError - 文件无效，解析失败。 + +样例： +>>> # Set new default configuration according to values in the configuration file. +>>> # example config file: +>>> # { +>>> # ""logFilePath"": ""/tmp"", +>>> # ""numParallelWorkers"": 4, +>>> # ""seed"": 5489, +>>> # ""monitorSamplingInterval"": 30 +>>> # } +>>> config_file = ""/path/to/config/file"" +>>> ds.config.load(config_file) + + + + + +mindspore.dataset.config.set_seed(seed)¶ +设置随机种子，产生固定的随机数来达到确定的结果。 + +Note +此函数在Python随机库和numpy.random库中设置种子，以便随机进行确定性Python增强。此函数应与创建的每个迭代器一起调用，以重置随机种子。 + +参数： + +seed (int) - 表示随机数量的种子。该参数用于生成确定性随机数。 + +异常： + +TypeError - seed 不是int类型。 +ValueError - seed 小于0或 seed 大于 UINT32_MAX(4294967295) 时， seed 无效。 + +样例： +>>> # Set a new global configuration value for the seed value. +>>> # Operations with randomness will use the seed value to generate random values. +>>> ds.config.set_seed(1000) + + + + + +mindspore.dataset.config.get_seed()¶ +获取随机数的种子。如果随机数的种子已设置，则返回设置的值，否则将返回 std::mt19937::default_seed 这个默认种子值。 +返回： +int，表示种子的随机数量。 +样例： +>>> # Get the global configuration of seed. +>>> # If set_seed() is never called before, the default value(std::mt19937::default_seed) will be returned. +>>> seed = ds.config.get_seed() + + + + + +mindspore.dataset.config.set_prefetch_size(size)¶ +设置管道中线程的队列容量。 +参数： + +size (int) - 表示缓存队列的长度。 + +异常： + +TypeError - size 不是int类型。 +ValueError - size 小于等于0或 size 大于 INT32_MAX(2147483647) 时，线程的队列容量无效。 + + +Note +用于预取的总内存可能会随着工作线程数量的增加而快速增长，所以当工作线程数量大于4时，每个工作线程的预取大小将减少。 +每个工作线程在运行时预取大小将是 prefetchsize * (4 / num_parallel_workers )。 + +样例： +>>> # Set a new global configuration value for the prefetch size. +>>> ds.config.set_prefetch_size(1000) + + + + + +mindspore.dataset.config.get_prefetch_size()¶ +获取数据处理管道的输出缓存队列长度。 +如果 set_prefetch_size 方法未被调用，那么将会返回默认值16。 +返回： +int，表示预取的总行数。 +样例： +>>> # Get the global configuration of prefetch size. +>>> # If set_prefetch_size() is never called before, the default value(16) will be returned. +>>> prefetch_size = ds.config.get_prefetch_size() + + + + + +mindspore.dataset.config.set_num_parallel_workers(num)¶ +为并行工作线程数量设置新的全局配置默认值。 +此设置会影响所有数据集操作的并行性。 +参数： + +num (int) - 表示并行工作线程的数量，用作为每个数据集操作的默认值。 + +异常： + +TypeError - num 不是int类型。 +ValueError - num 小于等于0或 num 大于 INT32_MAX(2147483647) 时，并行工作线程数量设置无效。 + +样例： +>>> # Set a new global configuration value for the number of parallel workers. +>>> # Now parallel dataset operators will run with 8 workers. +>>> ds.config.set_num_parallel_workers(8) + + + + + +mindspore.dataset.config.get_num_parallel_workers()¶ +获取并行工作线程数量的全局配置。 +这是作用于每个操作的并行工作线程数量的值。 +返回： +int，表示每个操作中默认的并行工作线程的数量。 +样例： +>>> # Get the global configuration of parallel workers. +>>> # If set_num_parallel_workers() is never called before, the default value(8) will be returned. +>>> num_parallel_workers = ds.config.get_num_parallel_workers() + + + + + +mindspore.dataset.config.set_numa_enable(numa_enable)¶ +设置NUMA的默认状态为启动状态。如果 numa_enable 为True，则需要确保安装了 NUMA库 。 +参数： + +numa_enable (bool) - 表示是否使用NUMA绑定功能。 + +异常： + +TypeError - numa_enable 不是bool类型。 + +样例： +>>> # Set a new global configuration value for the state of numa enabled. +>>> # Now parallel dataset operators will run with numa bind function +>>> ds.config.set_numa_enable(True) + + + + + +mindspore.dataset.config.get_numa_enable()¶ +获取NUMA的启动/禁用状态。 +该状态将用于所有进程。 +返回： +bool，表示NUMA的启动状态。 +样例： +>>> # Get the global configuration of numa. +>>> numa_state = ds.config.get_numa_enable() + + + + + +mindspore.dataset.config.set_monitor_sampling_interval(interval)¶ +设置监测采样的默认间隔时间（毫秒）。 +参数： + +interval (int) - 表示用于性能监测采样的间隔时间（毫秒）。 + +异常： + +TypeError - interval 不是int类型。 +ValueError - interval 小于等于0或 interval 大于 INT32_MAX(2147483647) 时， interval 无效。 + +样例： +>>> # Set a new global configuration value for the monitor sampling interval. +>>> ds.config.set_monitor_sampling_interval(100) + + + + + +mindspore.dataset.config.get_monitor_sampling_interval()¶ +获取性能监控采样时间间隔的全局配置。 +如果 set_monitor_sampling_interval 方法未被调用，那么将会返回默认值1000。 +返回： +int，表示性能监控采样间隔时间（毫秒）。 +样例： +>>> # Get the global configuration of monitor sampling interval. +>>> # If set_monitor_sampling_interval() is never called before, the default value(1000) will be returned. +>>> sampling_interval = ds.config.get_monitor_sampling_interval() + + + + + +mindspore.dataset.config.set_callback_timeout(timeout)¶ +为 mindspore.dataset.WaitedDSCallback 设置的默认超时时间（秒）。 +参数： + +timeout (int) - 表示在出现死锁情况下，用于结束 mindspore.dataset.WaitedDSCallback 中等待的超时时间（秒）。 + +异常： + +TypeError - timeout 不是int类型。 +ValueError - timeout 小于等于0或 timeout 大于 INT32_MAX(2147483647) 时 timeout 无效。 + +样例： +>>> # Set a new global configuration value for the timeout value. +>>> ds.config.set_callback_timeout(100) + + + + + +mindspore.dataset.config.get_callback_timeout()¶ +获取 mindspore.dataset.WaitedDSCallback 的默认超时时间。 +如果出现死锁，等待的函数将在超时时间结束后退出。 +返回： +int，表示在出现死锁情况下，用于结束 mindspore.dataset.WaitedDSCallback 中的等待函数的超时时间（秒）。 +样例： +>>> # Get the global configuration of callback timeout. +>>> # If set_callback_timeout() is never called before, the default value(60) will be returned. +>>> callback_timeout = ds.config.get_callback_timeout() + + + + + +mindspore.dataset.config.set_auto_num_workers(enable)¶ +自动为每个数据集操作设置并行线程数量（默认情况下，此功能关闭）。 +如果启用该功能，将自动调整每个数据集操作中的并行线程数量，这可能会覆盖用户通过脚本定义的并行线程数量或通过ds.config.set_num_parallel_workers()设置的默认值（如果用户未传递任何内容）。 +目前，此函数仅针对具有per_batch_map（batch中的运行映射）的YOLOv3数据集进行了优化。 +此功能旨在为每个操作的优化线程数量分配一个基础值。 +并行线程数有所调整的数据集操作将会被记录。 +参数： + +enable (bool) - 表示是否启用自动设置线程数量的特性。 + +异常： + +TypeError - enable 不是bool类型。 + +样例： +>>> # Enable auto_num_worker feature, this might override the num_parallel_workers passed in by user +>>> ds.config.set_auto_num_workers(True) + + + + + +mindspore.dataset.config.get_auto_num_workers()¶ +获取当前是否开启自动线程调整。 +返回： +bool，表示是否开启自动线程调整。 +样例： +>>> # Get the global configuration of auto number worker feature. +>>> flag = ds.config.get_auto_num_workers() + + + + + +mindspore.dataset.config.set_enable_shared_mem(enable)¶ +设置共享内存标志的是否启用。如果 shared_mem_enable 为True，则使用共享内存队列将数据传递给为数据集操作而创建的进程，而这些数据集操作将设置 python_multiprocessing 为True。 + +Note +Windows和MacOS平台尚不支持 set_enable_shared_mem 。 + +参数： + +enable (bool) - 表示当 python_multiprocessing 为True时，是否在数据集操作中使用共享内存。 + +异常： + +TypeError - enable 不是bool类型。 + +样例： +>>> # Enable shared memory feature to improve the performance of Python multiprocessing. +>>> ds.config.set_enable_shared_mem(True) + + + + + +mindspore.dataset.config.get_enable_shared_mem()¶ +获取当前是否开启共享内存。 + +Note +Windows和MacOS平台尚不支持 get_enable_shared_mem 。 + +返回： +bool，表示是否启用共享内存。 +样例： +>>> # Get the flag of shared memory feature. +>>> shared_mem_flag = ds.config.get_enable_shared_mem() + + + + + +mindspore.dataset.config.set_enable_autotune(enable, filepath_prefix=None)¶ +设置是否开启自动数据加速。默认情况下不开启自动数据加速。 +自动数据加速用于在训练过程中根据环境资源的负载，自动调整数据处理管道全局配置，提高数据处理的速度。 +可以通过设置 json_filepath 将优化后的全局配置保存为JSON文件，以便后续复用。 +参数： + +enable (bool) - 是否开启自动数据加速。 +filepath_prefix (str，可选) - 优化后的全局配置的保存路径+文件前缀。多卡环境时，设备ID号与JSON扩展名会自动添加到 filepath_prefix +参数后面作为完整的文件路径，单卡默认设备ID号为0。例如，设置 filepath_prefix=”/path/to/some/dir/prefixname” ，设备ID为1的训练进程 +生成的调优文件将被命名为 /path/to/some/dir/prefixname_1.json 。默认值：None，表示不保存配置文件，但可以通过INFO日志查看调优配置。 + +异常： + +TypeError - 当 enable 的类型不为bool。 +TypeError - 当 json_filepath 的类型不为str。 +RuntimeError - 当 json_filepath 字符长度为0。 +RuntimeError - 当 json_filepath 为目录。 +RuntimeError - 当 json_filepath 路径不存在。 +RuntimeError - 当 json_filepath 没有写入权限。 + + +Note + +当 enable 为 False 时，json_filepath 值将会被忽略。 +生成的JSON文件可以通过 mindspore.dataset.deserialize 进行加载，得到调优后的数据处理管道。 + + +生成的JSON文件内容示例如下，”remark”字段将给出结论表明数据处理管道是否进行了调整，”summary”字段将展示数据处理管道的调优配置。 +用户可以根据调优结果修改代码脚本。 +{ + ""remark"": ""The following file has been auto-generated by the Dataset AutoTune."", + ""summary"": [ + ""CifarOp(ID:5) (num_parallel_workers: 2, prefetch_size:64)"", + ""MapOp(ID:4) (num_parallel_workers: 2, prefetch_size:64)"", + ""MapOp(ID:3) (num_parallel_workers: 2, prefetch_size:64)"", + ""BatchOp(ID:2) (num_parallel_workers: 8, prefetch_size:64)"" + ], + ""tree"": { + ... + } +} + + +样例： +>>> # enable AutoTune and save optimized data pipeline configuration +>>> ds.config.set_enable_autotune(True, ""/path/to/autotune_out.json"") +>>> +>>> # enable AutoTune +>>> ds.config.set_enable_autotune(True) + + + + + +mindspore.dataset.config.get_enable_autotune()¶ +获取当前是否开启自动数据加速。 +返回： +bool，表示是否开启自动数据加速。 +样例： +>>> # get the state of AutoTune +>>> autotune_flag = ds.config.get_enable_autotune() + + + + + +mindspore.dataset.config.set_autotune_interval(interval)¶ +设置自动数据加速的配置调整step间隔。 +默认设置为0，将在每个epoch结束后调整配置；否则，将每隔 interval 个step调整一次配置。 +参数： + +interval (int) - 配置调整的step间隔。 + +异常： + +TypeError - 当 interval 类型不为int。 +ValueError - 当 interval 的值小于零。 + +样例： +>>> # set a new interval for AutoTune +>>> ds.config.set_autotune_interval(30) + + + + + +mindspore.dataset.config.get_autotune_interval()¶ +获取当前自动数据加速的配置调整step间隔。 +返回： +int，自动数据加速的配置调整step间隔。 +样例： +>>> # get the global configuration of the autotuning interval +>>> autotune_interval = ds.config.get_autotune_interval() + + + + + +mindspore.dataset.config.set_auto_offload(offload)¶ +设置是否开启数据异构加速。 +数据异构加速可以自动将数据处理的部分运算分配到不同的异构硬件（GPU或Ascend）上，以提高数据处理的速度。 +参数： + +offload (bool) - 是否开启数据异构加速。 + +异常： + +TypeError - 当 offload 的类型不为bool。 + +样例： +>>> # Enable automatic offload feature +>>> ds.config.set_auto_offload(True) + + + + + +mindspore.dataset.config.get_auto_offload()¶ +获取当前是否开启数据异构加速。 +返回： +bool，表示是否开启数据异构加速。 + + + +mindspore.dataset.config.set_enable_watchdog(enable)¶ +设置watchdog Python线程是否启用。默认情况下，watchdog Python线程是启用的。watchdog Python线程负责清理卡死或假死的子进程。 +参数： + +enable (bool) - 是否开启watchdog Python线程。默认情况下，watchdog Python线程是启用的。 + +异常： + +TypeError - enable 不是bool类型。 + +样例： +>>> # Set a new global configuration value for the state of watchdog Python thread as enabled. +>>> ds.config.set_enable_watchdog(True) + + + + + +mindspore.dataset.config.get_enable_watchdog()¶ +获取当前是否开启watchdog Python线程。默认初始状态是开启。 +返回： +bool，表示是否开启watchdog Python线程。 +样例： +>>> # Get the global configuration of watchdog Python thread. +>>> watchdog_state = ds.config.get_enable_watchdog() + + + + + +mindspore.dataset.config.set_multiprocessing_timeout_interval(interval)¶ +设置在多进程/多线程下，主进程/主线程获取数据超时时，告警日志打印的默认时间间隔（秒）。 +参数： + +interval (int) - 表示多进程/多线程下，主进程/主线程获取数据超时时，告警日志打印的时间间隔（秒）。 + +异常： + +TypeError - interval 不是int类型。 +ValueError - interval 小于等于0或 interval 大于 INT32_MAX(2147483647) 时， interval 无效。 + +样例： +>>> # Set a new global configuration value for multiprocessing/multithreading timeout when getting data. +>>> ds.config.set_multiprocessing_timeout_interval(300) + + + + + +mindspore.dataset.config.get_multiprocessing_timeout_interval()¶ +获取在多进程/多线程下，主进程/主线程获取数据超时时，告警日志打印的时间间隔的全局配置。 +返回： +int，表示多进程/多线程下，主进程/主线程获取数据超时时，告警日志打印的时间间隔（默认300秒）。 +样例： +>>> # Get the global configuration of multiprocessing/multithreading timeout when main process/thread gets data +>>> # from subprocesses/child threads. If set_multiprocessing_timeout_interval() is never called before, the +>>> # default value(300) will be returned. +>>> multiprocessing_timeout_interval = ds.config.get_multiprocessing_timeout_interval() + + + +",mindspore.dataset.config,mindspore、mindspore、API、数据、性能、dataset、C++ +mindspore.dataset.text§mindspore.dataset.text,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.text.html," +此模块用于文本数据增强，包括 transforms 和 utils 两个子模块。 +transforms 是一个高性能文本数据增强模块，支持常见的文本数据增强处理。 +utils 提供了一些文本处理的工具方法。 +在API示例中，常用的模块导入方法如下： +import mindspore.dataset as ds +from mindspore.dataset import text + + +常用数据处理术语说明如下： + +TensorOperation，所有C++实现的数据处理操作的基类。 +TextTensorOperation，所有文本数据处理操作的基类，派生自TensorOperation。 + + +",mindspore.dataset.text,mindspore、mindspore、API、数据、性能、dataset、C++ +mindspore.dataset.text§变换,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.text.html," + + + + + + + +接口名 +概述 +说明 + +mindspore.dataset.text.BasicTokenizer +按照指定规则对输入的UTF-8编码字符串进行分词。 +Windows平台尚不支持 BasicTokenizer + +mindspore.dataset.text.BertTokenizer +使用Bert分词器对字符串进行分词。 +Windows平台尚不支持 BertTokenizer + +mindspore.dataset.text.CaseFold +将UTF-8编码字符串中的字符规范化为小写，相比 str.lower() 支持更多字符。 +Windows平台尚不支持 CaseFold + +mindspore.dataset.text.FilterWikipediaXML +Filter Wikipedia XML dumps to “clean” text consisting only of lowercase letters (a-z, converted from A-Z), and spaces (never consecutive). + + +mindspore.dataset.text.JiebaTokenizer +使用Jieba分词器对中文字符串进行分词。 +必须保证隐式马尔科夫模型分词（HMMSEgment）和最大概率法分词（MPSegment）所使用的词典文件的完整性 + +mindspore.dataset.text.Lookup +根据词表，将分词标记(token)映射到其索引值(id)。 + + +mindspore.dataset.text.Ngram +从1-D的字符串生成N-gram。 + + +mindspore.dataset.text.NormalizeUTF8 +对UTF-8编码的字符串进行规范化处理。 +Windows平台尚不支持 NormalizeUTF8 + +mindspore.dataset.text.PythonTokenizer +使用用户自定义的分词器对输入字符串进行分词。 + + +mindspore.dataset.text.RegexReplace +根据正则表达式对UTF-8编码格式的字符串内容进行正则替换。 +Windows平台尚不支持 RegexReplace + +mindspore.dataset.text.RegexTokenizer +根据正则表达式对字符串进行分词。 +Windows平台尚不支持 RegexTokenizer + +mindspore.dataset.text.SentencePieceTokenizer +使用SentencePiece分词器对字符串进行分词。 + + +mindspore.dataset.text.SlidingWindow +在输入数据的某个维度上进行滑窗切分处理，当前仅支持处理1-D的Tensor。 + + +mindspore.dataset.text.ToNumber +将字符串的每个元素转换为数字。 + + +mindspore.dataset.text.ToVectors +Look up a token into vectors according to the input vector table. + + +mindspore.dataset.text.TruncateSequencePair +截断一对 1-D 字符串的内容，使其总长度小于给定长度。 + + +mindspore.dataset.text.UnicodeCharTokenizer +使用Unicode分词器将字符串分词为Unicode字符。 + + +mindspore.dataset.text.UnicodeScriptTokenizer +使用UnicodeScript分词器对UTF-8编码的字符串进行分词。 +Windows平台尚不支持 UnicodeScriptTokenizer + +mindspore.dataset.text.WhitespaceTokenizer +基于ICU4C定义的空白字符（’ ‘, ‘\t’, ‘\r’, ‘\n’）对输入的UTF-8字符串进行分词。 +Windows平台尚不支持 WhitespaceTokenizer + +mindspore.dataset.text.WordpieceTokenizer +将输入的字符串切分为子词。 + + + + +",mindspore.dataset.text,mindspore、mindspore、接口、数据、dataset、Windows、npu +mindspore.dataset.text§工具,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.text.html," + + + + + + + +接口名 +概述 +说明 + +mindspore.dataset.text.CharNGram +CharNGram object that is used to map tokens into pre-trained vectors. + + +mindspore.dataset.text.FastText +FastText object that is used to map tokens into vectors. + + +mindspore.dataset.text.GloVe +GloVe object that is used to map tokens into vectors. + + +mindspore.dataset.text.JiebaMode +mindspore.dataset.text.JiebaTokenizer 的枚举值。 + + +mindspore.dataset.text.NormalizeForm +Unicode规范化模式 枚举类。 + + +mindspore.dataset.text.SentencePieceModel +SentencePiece分词方法的枚举类。 + + +mindspore.dataset.text.SentencePieceVocab +用于执行分词的SentencePiece对象。 + + +mindspore.dataset.text.SPieceTokenizerLoadType +mindspore.dataset.text.SentencePieceTokenizer 加载类型的枚举值。 + + +mindspore.dataset.text.SPieceTokenizerOutType +mindspore.dataset.text.SentencePieceTokenizer 输出类型的枚举值。 + + +mindspore.dataset.text.Vectors +Vectors object that is used to map tokens into vectors. + + +mindspore.dataset.text.Vocab +用于查找单词的Vocab对象。 + + +mindspore.dataset.text.to_bytes +基于 encoding 字符集对每个元素进行编码，将 string 的NumPy数组转换为 bytes 的数组。 + + +mindspore.dataset.text.to_str +基于 encoding 字符集对每个元素进行解码，借此将 bytes 的NumPy数组转换为 string 的数组。 + + + + +",mindspore.dataset.text,mindspore、mindspore、接口、Model、ast、dataset +mindspore.dataset.transforms§mindspore.dataset.transforms,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.transforms.html," +此模块用于通用数据增强，其中一部分增强操作是用C++实现的，具有较好的高性能，另一部分是基于Python实现，使用了NumPy模块作为支持。 +在API示例中，常用的模块导入方法如下： +import mindspore.dataset as ds +import mindspore.dataset.transforms as transforms + + +注意：旧的API导入方式已经过时且会逐步废弃，因此推荐使用上面的方式，但目前仍可按以下方式导入： +from mindspore.dataset.transforms import c_transforms +from mindspore.dataset.transforms import py_transforms + + +更多详情请参考 通用数据处理与增强 _。 +常用数据处理术语说明如下： + +TensorOperation，所有C++实现的数据处理操作的基类。 +PyTensorOperation，所有Python实现的数据处理操作的基类。 + + +",mindspore.dataset.transforms,mindspore、mindspore、API、数据、性能、dataset、C++ +mindspore.dataset.transforms§变换,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.transforms.html," + + + + + + + +mindspore.dataset.transforms.Compose +将多个数据增强算子组合使用。 + +mindspore.dataset.transforms.Concatenate +在Tensor的某一个轴上进行元素拼接。 + +mindspore.dataset.transforms.Duplicate +将输入的数据列复制得到新的数据列，每次仅可以输入1个数据列进行复制。 + +mindspore.dataset.transforms.Fill +将Tensor的所有元素都赋值为指定的值，输出Tensor将与输入Tensor具有与具有相同的shape和数据类型。 + +mindspore.dataset.transforms.Mask +用给条件判断输入Tensor的内容，并返回一个掩码Tensor。 + +mindspore.dataset.transforms.OneHot +将Tensor进行OneHot编码。 + +mindspore.dataset.transforms.PadEnd +对输入Tensor进行填充，要求 pad_shape 与输入Tensor的维度保持一致。 + +mindspore.dataset.transforms.RandomApply +指定一组数据增强处理及其被应用的概率，在运算时按概率随机应用其中的增强处理。 + +mindspore.dataset.transforms.RandomChoice +在一组数据增强中随机选择部分增强处理进行应用。 + +mindspore.dataset.transforms.RandomOrder +给一个数据增强的列表，随机打乱数据增强处理的顺序。 + +mindspore.dataset.transforms.Slice +对Tensor进行切片操作，功能类似于NumPy的索引(目前只支持1D形状的Tensor)。 + +mindspore.dataset.transforms.TypeCast +将输入的Tensor转换为指定的数据类型。 + +mindspore.dataset.transforms.Unique +对输入张量进行唯一运算，每次只支持对一个数据列进行变换。 + + + +",mindspore.dataset.transforms,mindspore、mindspore、算子、数据类型、ast、aten、数据、dataset +mindspore.dataset.transforms§工具,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.transforms.html," + + + + + + + +mindspore.dataset.transforms.Relational +关系操作符，可以取值为Relational.EQ、Relational.NE、Relational.GT、Relational.GE、Relational.LT、Relational.LE。 + + + +",mindspore.dataset.transforms,mindspore、mindspore、dataset +mindspore.dataset.vision§mindspore.dataset.vision,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.vision.html," +此模块用于图像数据增强，其中有一部分增强是基于C++ OpenCV实现的，具有较好的性能，而另一部分是基于Python Pillow实现的。 +API样例中常用的导入模块如下： +import mindspore.dataset as ds +import mindspore.dataset.vision as vision +import mindspore.dataset.vision.utils as utils + + +注意：旧的API导入方式已经过时且会逐步废弃，因此推荐使用上面的方式，但目前仍可按以下方式导入： +import mindspore.dataset.vision.c_transforms as c_vision +import mindspore.dataset.vision.py_transforms as py_vision +from mindspore.dataset.transforms import c_transforms + + +更多详情请参考 图像数据加载与增强。 +常用数据处理术语说明如下： + +TensorOperation，所有C++实现的数据处理操作的基类。 +PyTensorOperation，所有Python实现的数据处理操作的基类。 + + +",mindspore.dataset.vision,mindspore、mindspore、API、数据、性能、dataset、C++ +mindspore.dataset.vision§变换,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.vision.html," + + + + + + + +mindspore.dataset.vision.AdjustGamma +Apply gamma correction on input image. + +mindspore.dataset.vision.AutoAugment +Apply AutoAugment data augmentation method based on AutoAugment: Learning Augmentation Strategies from Data.This operation works only with 3-channel RGB images.. + +mindspore.dataset.vision.AutoContrast +在输入图像上应用自动对比度。 + +mindspore.dataset.vision.BoundingBoxAugment +对图像的随机标注边界框区域，应用给定的图像变换处理。 + +mindspore.dataset.vision.CenterCrop +对输入图像应用中心区域裁剪。 + +mindspore.dataset.vision.ConvertColor +更改图像的色彩空间。 + +mindspore.dataset.vision.Crop +在输入图像上裁剪出指定区域。 + +mindspore.dataset.vision.CutMixBatch +对输入批次的图像和标注应用剪切混合转换。 + +mindspore.dataset.vision.CutOut +从输入图像数组中随机裁剪出给定数量的正方形区域。 + +mindspore.dataset.vision.Decode +将输入的压缩图像解码为RGB格式。 + +mindspore.dataset.vision.Equalize +对输入图像进行直方图均衡化。 + +mindspore.dataset.vision.FiveCrop +在输入PIL图像的中心与四个角处分别裁剪指定尺寸大小的子图。 + +mindspore.dataset.vision.GaussianBlur +使用指定的高斯核对输入图像进行模糊处理。 + +mindspore.dataset.vision.Grayscale +将输入PIL图像转换为灰度图。 + +mindspore.dataset.vision.HorizontalFlip +水平翻转输入图像。 + +mindspore.dataset.vision.HsvToRgb +将输入的HSV格式numpy.ndarray图像转换为RGB格式。 + +mindspore.dataset.vision.HWC2CHW +将输入图像的shape从 转换为 。 + +mindspore.dataset.vision.Invert +在 RGB 模式下对输入图像应用像素反转，计算方式为（255 - pixel）。 + +mindspore.dataset.vision.LinearTransformation +使用指定的变换方阵和均值向量对输入numpy.ndarray图像进行线性变换。 + +mindspore.dataset.vision.MixUp +随机混合一批输入的numpy.ndarray图像及其标签。 + +mindspore.dataset.vision.MixUpBatch +对输入批次的图像和标注应用混合转换。 + +mindspore.dataset.vision.Normalize +根据均值和标准差对输入图像进行归一化。 + +mindspore.dataset.vision.NormalizePad +根据均值和标准差对输入图像进行归一化，然后填充一个全零的额外通道。 + +mindspore.dataset.vision.Pad +填充图像。 + +mindspore.dataset.vision.PadToSize +Pad the image to a fixed size. + +mindspore.dataset.vision.RandomAdjustSharpness +Randomly adjust the sharpness of the input image with a given probability. + +mindspore.dataset.vision.RandomAffine +对输入图像应用随机仿射变换。 + +mindspore.dataset.vision.RandomAutoContrast +Automatically adjust the contrast of the image with a given probability. + +mindspore.dataset.vision.RandomColor +随机调整输入图像的颜色。 + +mindspore.dataset.vision.RandomColorAdjust +随机调整输入图像的亮度、对比度、饱和度和色调。 + +mindspore.dataset.vision.RandomCrop +对输入图像进行随机区域的裁剪。 + +mindspore.dataset.vision.RandomCropDecodeResize +“裁剪”、”解码”和”调整尺寸大小”的组合处理。 + +mindspore.dataset.vision.RandomCropWithBBox +在输入图像的随机位置进行裁剪并相应地调整边界框。 + +mindspore.dataset.vision.RandomEqualize +Apply histogram equalization on the input image with a given probability. + +mindspore.dataset.vision.RandomErasing +按照指定的概率擦除输入numpy.ndarray图像上随机矩形区域内的像素。 + +mindspore.dataset.vision.RandomGrayscale +按照指定的概率将输入PIL图像转换为灰度图。 + +mindspore.dataset.vision.RandomHorizontalFlip +对输入图像按给定的概率进行水平随机翻转。 + +mindspore.dataset.vision.RandomHorizontalFlipWithBBox +对输入图像按给定的概率进行水平随机翻转并相应地调整边界框。 + +mindspore.dataset.vision.RandomInvert +Randomly invert the colors of image with a given probability. + +mindspore.dataset.vision.RandomLighting +Add AlexNet-style PCA-based noise to an image. + +mindspore.dataset.vision.RandomPerspective +按照指定的概率对输入PIL图像进行透视变换。 + +mindspore.dataset.vision.RandomPosterize +随机减少输入图像每个颜色通道的位数。 + +mindspore.dataset.vision.RandomResizedCrop +对输入图像进行随机裁剪，并使用指定的 mindspore.dataset.vision.Inter 插值方式去调整为指定的尺寸大小。 + +mindspore.dataset.vision.RandomResizedCropWithBBox +对输入图像进行随机裁剪且随机调整纵横比，并将处理后的图像调整为指定的尺寸大小，并相应地调整边界框。 + +mindspore.dataset.vision.RandomResize +对输入图像使用随机选择的 mindspore.dataset.vision.Inter 插值方式去调整它的尺寸大小。 + +mindspore.dataset.vision.RandomResizeWithBBox +对输入图像使用随机选择的 mindspore.dataset.vision.Inter 插值方式去调整它的尺寸大小，并相应地调整边界框的尺寸大小。 + +mindspore.dataset.vision.RandomRotation +在指定的角度范围内，随机旋转输入图像。 + +mindspore.dataset.vision.RandomSelectSubpolicy +从策略列表中随机选择一个子策略以应用于输入图像。 + +mindspore.dataset.vision.RandomSharpness +在固定或随机的范围调整输入图像的锐度。 + +mindspore.dataset.vision.RandomSolarize +从给定阈值范围内随机选择一个子范围，对位于给定子范围内的像素，将其像素值设置为(255 - 原本像素值)。 + +mindspore.dataset.vision.RandomVerticalFlip +以给定的概率对输入图像在垂直方向进行随机翻转。 + +mindspore.dataset.vision.RandomVerticalFlipWithBBox +以给定的概率对输入图像和边界框在垂直方向进行随机翻转。 + +mindspore.dataset.vision.Rescale +基于给定的缩放和平移因子调整图像的像素大小。 + +mindspore.dataset.vision.Resize +对输入图像使用给定的 mindspore.dataset.vision.Inter 插值方式去调整为给定的尺寸大小。 + +mindspore.dataset.vision.ResizeWithBBox +将输入图像调整为给定的尺寸大小并相应地调整边界框的大小。 + +mindspore.dataset.vision.RgbToHsv +将输入的RGB格式numpy.ndarray图像转换为HSV格式。 + +mindspore.dataset.vision.Rotate +将输入图像旋转指定的度数。 + +mindspore.dataset.vision.SlicePatches +在水平和垂直方向上将Tensor切片为多个块。 + +mindspore.dataset.vision.TenCrop +在输入PIL图像的中心与四个角处分别裁剪指定尺寸大小的子图，并将其翻转图一并返回。 + +mindspore.dataset.vision.ToNumpy +将输入PIL图像转换为numpy.ndarray图像。 + +mindspore.dataset.vision.ToPIL +将已解码的numpy.ndarray图像转换为PIL图像。 + +mindspore.dataset.vision.ToTensor +将输入PIL图像或numpy.ndarray图像转换为指定类型的numpy.ndarray图像，图像的像素值范围将从[0, 255]放缩为[0.0, 1.0]，shape将从(H, W, C)调整为(C, H, W)。 + +mindspore.dataset.vision.ToType +将输入转换为指定的MindSpore数据类型或NumPy数据类型。 + +mindspore.dataset.vision.UniformAugment +从指定序列中均匀采样一批数据处理操作，并按顺序随机执行，即采样出的操作也可能不被执行。 + +mindspore.dataset.vision.VerticalFlip +对输入图像进行垂直翻转。 + + + +",mindspore.dataset.vision,mindspore、mindspore、数据类型、pB、ast、数据、dataset、npu +mindspore.dataset.vision§工具,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.vision.html," + + + + + + + +mindspore.dataset.vision.AutoAugmentPolicy +AutoAugment policy for different datasets. + +mindspore.dataset.vision.Border +边界填充方式枚举类。 + +mindspore.dataset.vision.ConvertMode +图像色彩空间转换模式枚举类。 + +mindspore.dataset.vision.ImageBatchFormat +图像批处理输出格式枚举类。 + +mindspore.dataset.vision.Inter +图像插值方式枚举类。 + +mindspore.dataset.vision.SliceMode +Tensor切片方式枚举类。 + +mindspore.dataset.vision.get_image_num_channels +Get the number of input image channels. + +mindspore.dataset.vision.get_image_size +Get the size of input image as [height, width]. + + + +",mindspore.dataset.vision,mindspore、mindspore、dataset、npu +mindspore.mindrecord§mindspore.mindrecord,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.mindrecord.html," +MindRecord是MindSpore开发的一种高效数据格式，此模块提供了一些方法帮助用户将不同数据集转换为MindRecord格式， +也提供了一些操作MindRecord数据文件的方法如读取、写入、检索等。 +用户可以使用FileWriter API生成MindRecord格式数据集，并使用MindDataset API加载MindRecord格式数据集。 +用户还可以通过相应的子模块将其他格式数据集转换为MindRecord格式数据集。 + + +class mindspore.mindrecord.FileWriter(file_name, shard_num=1, overwrite=False)[源代码]¶ +将用户自定义的数据转为MindRecord格式数据集的类。 + +Note +生成MindRecord文件后，如果修改文件名，可能会导致读取文件失败。 + +参数： + +file_name (str) - 转换生成的MindRecord文件路径。 +shard_num (int，可选) - 生成MindRecord的文件个数。取值范围为[1, 1000]。默认值：1。 +overwrite (bool，可选) - 当指定目录存在同名文件时是否覆盖写。默认值：False。 + +异常： + +ParamValueError - file_name 或 shard_num 无效。 + +样例： +>>> from mindspore.mindrecord import FileWriter +>>> schema_json = {""file_name"": {""type"": ""string""}, ""label"": {""type"": ""int32""}, ""data"": {""type"": ""bytes""}} +>>> indexes = [""file_name"", ""label""] +>>> data = [{""file_name"": ""1.jpg"", ""label"": 0, +... ""data"": b""\x10c\xb3w\xa8\xee$o&\xd4\x00\xf8\x129\x15\xd9\xf2q\xc0\xa2\x91YFUO\x1dsE1""}, +... {""file_name"": ""3.jpg"", ""label"": 99, +... ""data"": b""\xaf\xafU<\xb8|6\xbd}\xc1\x99[\xeaj+\x8f\x84\xd3\xcc\xa0,i\xbb\xb9-\xcdz\xecp{T\xb1""}] +>>> writer = FileWriter(file_name=""test.mindrecord"", shard_num=1, overwrite=True) +>>> writer.add_schema(schema_json, ""test_schema"") +0 +>>> writer.add_index(indexes) +MSRStatus.SUCCESS +>>> writer.write_raw_data(data) +MSRStatus.SUCCESS +>>> writer.commit() +MSRStatus.SUCCESS + + + + +add_index(index_fields)[源代码]¶ +指定schema中的字段作为索引来加速MindRecord文件的读取。schema可以通过 add_schema 来添加。 + +Note + +索引字段应为Primitive类型，例如 int 、float 、str 。 +如果不调用该函数，则默认将schema中所有的Primitive类型的字段设置为索引。 +请参考类的示例 mindspore.mindrecord.FileWriter 。 + + +参数： + +index_fields (list[str]) - schema中的字段。 + +返回： +MSRStatus，SUCCESS或FAILED。 +异常： + +ParamTypeError - 索引字段无效。 +MRMDefineIndexError - 索引字段不是Primitive类型。 +MRMAddIndexError - 无法添加索引字段。 +MRMGetMetaError - 未设置schema或无法获取schema。 + + + + +add_schema(content, desc=None)[源代码]¶ +增加描述用户自定义数据的schema。 + +Note +请参考类的示例 mindspore.mindrecord.FileWriter 。 + +参数： + +content (dict) - schema内容的字典。 +desc (str，可选) - schema的描述。默认值：None。 + +返回： +int，schema ID。 +异常： + +MRMInvalidSchemaError - schema无效。 +MRMBuildSchemaError - 构建schema失败。 +MRMAddSchemaError - 添加schema失败。 + + + + +commit()[源代码]¶ +将内存中的数据同步到磁盘，并生成相应的数据库文件。 + +Note +请参考类的示例 mindspore.mindrecord.FileWriter 。 + +返回： +MSRStatus，SUCCESS或FAILED。 +异常： + +MRMOpenError - 打开MindRecord文件失败。 +MRMSetHeaderError - 设置MindRecord文件的header失败。 +MRMIndexGeneratorError - 创建索引Generator失败。 +MRMGenerateIndexError - 写入数据库失败。 +MRMCommitError - 数据同步到磁盘失败。 + + + + +open_and_set_header()[源代码]¶ +打开MindRecord文件准备写入并且设置描述其meta信息的头部，该函数仅用于并行写入，并在 write_raw_data 函数之前调用。 +返回： +MSRStatus，SUCCESS或FAILED。 +异常： + +MRMOpenError - 打开MindRecord文件失败。 +MRMSetHeaderError - 设置MindRecord文件的header失败。 + + + + +open_for_append(file_name)[源代码]¶ +打开MindRecord文件，准备追加数据。 +参数： + +file_name (str) - MindRecord格式的数据集文件的路径。 + +返回： +FileWriter，MindRecord文件的写对象。 +异常： + +ParamValueError - file_name 无效。 +FileNameError - MindRecord文件路径中包含无效字符。 +MRMOpenError - 打开MindRecord文件失败。 +MRMOpenForAppendError - 打开MindRecord文件追加数据失败。 + +样例： +>>> from mindspore.mindrecord import FileWriter +>>> schema_json = {""file_name"": {""type"": ""string""}, ""label"": {""type"": ""int32""}, ""data"": {""type"": ""bytes""}} +>>> data = [{""file_name"": ""1.jpg"", ""label"": 0, +... ""data"": b""\x10c\xb3w\xa8\xee$o&>> writer = FileWriter(file_name=""test.mindrecord"", shard_num=1, overwrite=True) +>>> writer.add_schema(schema_json, ""test_schema"") +0 +>>> writer.write_raw_data(data) +MSRStatus.SUCCESS +>>> writer.commit() +MSRStatus.SUCCESS +>>> write_append = FileWriter.open_for_append(""test.mindrecord"") +>>> write_append.write_raw_data(data) +MSRStatus.SUCCESS +>>> write_append.commit() +MSRStatus.SUCCESS + + + + + +set_header_size(header_size)[源代码]¶ +设置MindRecord文件的header，其中包含shard信息、schema信息、page的元信息等。 +header越大，MindRecord文件可以存储更多的元信息。如果header大于默认大小（16MB），需要调用本函数来设置合适的大小。 +参数： + +header_size (int) - header大小，可设置范围为16*1024(16KB)到128*1024*1024(128MB)。 + +返回： +MSRStatus，SUCCESS或FAILED。 +异常： + +MRMInvalidHeaderSizeError - 设置header大小失败。 + +样例： +>>> from mindspore.mindrecord import FileWriter +>>> writer = FileWriter(file_name=""test.mindrecord"", shard_num=1) +>>> writer.set_header_size(1 << 25) # 32MB +MSRStatus.SUCCESS + + + + + +set_page_size(page_size)[源代码]¶ +设置存储数据的page大小，page分为两种类型：raw page和blob page。 +page越大，page可以存储更多的数据。如果单个样本大于默认大小（32MB），需要调用本函数来设置合适的大小。 +参数： + +page_size (int) - page大小，可设置范围为32*1024(32KB)到256*1024*1024(256MB)。 + +返回： +MSRStatus，SUCCESS或FAILED。 +异常： + +MRMInvalidPageSizeError - 设置page大小失败。 + +样例： +>>> from mindspore.mindrecord import FileWriter +>>> writer = FileWriter(file_name=""test.mindrecord"", shard_num=1) +>>> writer.set_page_size(1 << 26) # 128MB +MSRStatus.SUCCESS + + + + + +write_raw_data(raw_data, parallel_writer=False)[源代码]¶ +根据schema校验用户自定义数据后，将数据转换为一系列连续的MindRecord格式的数据集文件。 + +Note +请参考类的示例 mindspore.mindrecord.FileWriter 。 + +参数： + +raw_data (list[dict]) - 用户自定义数据的列表。 +parallel_writer (bool，可选) - 如果为True，则并行写入用户自定义数据。默认值：False。 + +返回： +MSRStatus，SUCCESS或FAILED。 +异常： + +ParamTypeError - 索引字段无效。 +MRMOpenError - 打开MindRecord文件失败。 +MRMValidateDataError - 数据校验失败。 +MRMSetHeaderError - 设置MindRecord文件的header失败。 +MRMWriteDatasetError - 写入MindRecord格式的数据集失败。 + + + + + +class mindspore.mindrecord.FileReader(file_name, num_consumer=4, columns=None, operator=None)[源代码]¶ +读取MindRecord格式数据集。 + +Note + +如果 file_name 是文件路径的字符串，则会尝试加载同一批转换生成的所有MindRecord文件，如果缺少其中某个MindRecord文件，则会引发异常。 +如果 file_name 是文件路径组成的列表，则只加载列表中指定的MindRecord文件。 + + +参数： + +file_name (str, list[str]) - MindRecord格式的数据集文件路径或文件路径组成的列表。 +num_consumer (int，可选) - 加载数据的并发数。默认值：4。不应小于1或大于处理器的核数。 +columns (list[str]，可选) - MindRecord中待读取数据列的列表。默认值：None，读取所有的数据列。 +operator (int，可选) - 保留参数。默认值：None。 + +异常： + +ParamValueError - file_name 、num_consumer 或 columns 无效。 + + + +close()[源代码]¶ +停止数据集加载并且关闭文件句柄。 + + + +get_next()[源代码]¶ +按列名一次返回下一批的数据。 +返回： +dict，下一批数据，键值与数据列名相同。 +异常： + +MRMUnsupportedSchemaError - 当schema无效。 + + + + + +class mindspore.mindrecord.MindPage(file_name, num_consumer=4)[源代码]¶ +以分页方式读取MindRecord文件的类。 +参数： + +file_name (Union[str, list[str]]) - MindRecord格式的数据集文件或文件列表。 +num_consumer (int，可选) - 加载数据的并发数。默认值：4。不应小于1或大于处理器的核数。 + +异常： + +ParamValueError - file_name 、num_consumer 或 columns 无效。 +MRMInitSegmentError - 初始化ShardSegment失败。 + + + +property candidate_fields¶ +返回用于数据分组的候选category字段。 +返回： +list[str]，候选category 字段。 + + + +property category_field¶ +返回用于数据分组的category字段。 +返回： +list[str]，category字段。 + + + +get_category_fields()[源代码]¶ +返回用于数据分组的候选category字段。 +返回： +list[str]，候选category字段。 + + + +read_at_page_by_id(category_id, page, num_row)[源代码]¶ +以分页方式按category ID进行查询。 +参数： + +category_id (int) - category ID，参考 read_category_info 函数的返回值。 +page (int) - 分页的索引。 +num_row (int) - 每个分页的行数。 + +返回： +list[dict]，根据category ID查询的数据。 +异常： + +ParamValueError - 参数无效。 +MRMFetchDataError - 无法按category ID获取数据。 +MRMUnsupportedSchemaError - schema无效。 + + + + +read_at_page_by_name(category_name, page, num_row)[源代码]¶ +以分页方式按category字段进行查询。 +参数： + +category_name (str) - category字段对应的字符，参考 read_category_info 函数的返回值。 +page (int) - 分页的索引。 +num_row (int) - 每个分页的行数。 + +返回： +list[dict]，根据category字段查询的数据。 + + + +read_category_info()[源代码]¶ +当数据按指定的category字段进行分组时，返回category信息。 +返回： +str，分组信息的描述。 +异常： + +MRMReadCategoryInfoError - 读取category信息失败。 + + + + +set_category_field(category_field)[源代码]¶ +设置category字段。 + +Note +必须是候选category字段。 + +参数： + +category_field (str) - category字段名称。 + +返回： +MSRStatus，SUCCESS或FAILED + + + + +class mindspore.mindrecord.Cifar10ToMR(source, destination)[源代码]¶ +将CIFAR-10数据集转换为MindRecord格式数据集。 + +Note +示例的详细信息，请参见 转换CIFAR-10数据集。 + +参数： + +source (str) - 待转换的CIFAR-10数据集文件所在目录的路径。 +destination (str) - 转换生成的MindRecord文件路径，需提前创建目录并且目录下不能存在同名文件。 + +异常： + +ValueError - source 或 destination 无效。 + + + +run(fields=None)[源代码]¶ +执行从CIFAR-10数据集到MindRecord格式数据集的转换。 +参数： + +fields (list[str]，可选) - 索引字段的列表。默认值：None。 +索引字段的设置请参考函数 mindspore.mindrecord.FileWriter.add_index() 。 + +返回： +MSRStatus，SUCCESS或FAILED。 + + + +transform(fields=None)[源代码]¶ +mindspore.mindrecord.Cifar10ToMR.run() 的包装函数来保证异常时正常退出。 +参数： + +fields (list[str]，可选) - 索引字段的列表。默认值：None。 +索引字段的设置请参考函数 mindspore.mindrecord.FileWriter.add_index() 。 + +返回： +MSRStatus，SUCCESS或FAILED。 + + + + +class mindspore.mindrecord.Cifar100ToMR(source, destination)[源代码]¶ +将CIFAR-100数据集转换为MindRecord格式数据集。 + +Note +示例的详细信息，请参见 转换CIFAR-10数据集。 + +参数： + +source (str) - 待转换的CIFAR-100数据集文件所在目录的路径。 +destination (str) - 转换生成的MindRecord文件路径，需提前创建目录并且目录下不能存在同名文件。 + +异常： + +ValueError - 参数 source 或 destination 无效。 + + + +run(fields=None)[源代码]¶ +执行从CIFAR-100数据集到MindRecord格式数据集的转换。 +参数： + +fields (list[str]，可选) - 索引字段的列表，例如[‘fine_label’, ‘coarse_label’]。默认值：None。 +索引字段的设置请参考函数 mindspore.mindrecord.FileWriter.add_index() 。 + +返回： +MSRStatus，SUCCESS或FAILED。 + + + +transform(fields=None)[源代码]¶ +mindspore.mindrecord.Cifar100ToMR.run() 的包装函数来保证异常时正常退出。 +参数： + +fields (list[str]，可选) - 索引字段的列表，例如[‘fine_label’, ‘coarse_label’]。默认值：None。 +索引字段的设置请参考函数 mindspore.mindrecord.FileWriter.add_index() 。 + +返回： +MSRStatus，SUCCESS或FAILED。 + + + + +class mindspore.mindrecord.CsvToMR(source, destination, columns_list=None, partition_number=1)[源代码]¶ +将CSV格式数据集转换为MindRecord格式数据集。 + +Note +示例的详细信息，请参见 转换CSV数据集。 + +参数： + +source (str) - 待转换的CSV文件路径。 +destination (str) - 转换生成的MindRecord文件路径，需提前创建目录并且目录下不能存在同名文件。 +columns_list (list[str]，可选) - CSV中待读取数据列的列表。默认值：None，读取所有的数据列。 +partition_number (int，可选) - 生成MindRecord的文件个数。默认值：1。 + +异常： + +ValueError - 参数 source 、destination 、partition_number 无效。 +RuntimeError - 参数 columns_list 无效。 + + + +run()[源代码]¶ +执行从CSV格式数据集到MindRecord格式数据集的转换。 +返回： +MSRStatus，SUCCESS或FAILED。 + + + +transform()[源代码]¶ +mindspore.mindrecord.CsvToMR.run() 的包装函数来保证异常时正常退出。 +返回： +MSRStatus，SUCCESS或FAILED。 + + + + +class mindspore.mindrecord.ImageNetToMR(map_file, image_dir, destination, partition_number=1)[源代码]¶ +将ImageNet数据集转换为MindRecord格式数据集。 +参数： + +map_file (str) - 标签映射文件的路径。映射文件内容如下： +n02119789 0 +n02100735 1 +n02110185 2 +n02096294 3 + + + +image_dir (str) - ImageNet数据集的目录路径，目录中包含类似n02119789、n02100735、n02110185和n02096294的子目录。 +destination (str) - 转换生成的MindRecord文件路径，需提前创建目录并且目录下不能存在同名文件。 +partition_number (int，可选) - 生成MindRecord的文件个数。默认值：1。 + +异常： + +ValueError - 参数 map_file 、image_dir 或 destination 无效。 + + + +run()[源代码]¶ +执行从ImageNet数据集到MindRecord格式数据集的转换。 +返回： +MSRStatus，SUCCESS或FAILED。 + + + +transform()[源代码]¶ +mindspore.mindrecord.ImageNetToMR.run() 的包装函数来保证异常时正常退出。 +返回： +MSRStatus，SUCCESS或FAILED。 + + + + +class mindspore.mindrecord.MnistToMR(source, destination, partition_number=1)[源代码]¶ +将MNIST数据集转换为MindRecord格式数据集。 +参数： + +source (str) - 数据集目录路径，其包含t10k-images-idx3-ubyte.gz、train-images-idx3-ubyte.gz、t10k-labels-idx1-ubyte.gz和train-labels-idx1-ubyte.gz数据集文件。 +destination (str) - 转换生成的MindRecord文件路径，需提前创建目录并且目录下不能存在同名文件。 +partition_number (int，可选) - 生成MindRecord的文件个数。默认值：1。 + +异常： + +ValueError - 参数 source 、 destination 、 partition_number 无效。 + + + +run()[源代码]¶ +执行从MNIST数据集到MindRecord格式数据集的转换。 +返回： +MSRStatus，MNIST数据集是否成功转换为MindRecord格式数据集。 + + + +transform()[源代码]¶ +mindspore.mindrecord.MnistToMR.run() 函数的包装函数来保证异常时正常退出。 +返回： +MSRStatus，SUCCESS或FAILED。 + + + + +class mindspore.mindrecord.TFRecordToMR(source, destination, feature_dict, bytes_fields=None)[源代码]¶ +将TFRecord格式数据集转换为MindRecord格式数据集。 + +Note +示例的详细信息，请参见 转换TFRecord数据集。 + +参数： + +source (str) - 待转换的TFRecord文件路径。 +destination (str) - 转换生成的MindRecord文件路径，需提前创建目录并且目录下不能存在同名文件。 +feature_dict (dict[str, FixedLenFeature]) - TFRecord的feature类别的字典，当前支持 +FixedLenFeature 类型。 +bytes_fields (list[str]，可选) - feature_dict 中的字节字段，可以为字节类型的图像字段。 + +异常： + +ValueError - 无效参数。 +Exception - 找不到TensorFlow模块或其版本不正确。 + + + +run()[源代码]¶ +执行从TFRecord格式数据集到MindRecord格式数据集的转换。 +返回： +MSRStatus，SUCCESS或FAILED。 + + + +tfrecord_iterator()[源代码]¶ +生成一个字典，其key是schema中的字段，value是数据。 +返回： +Dict，key与schema中字段名相同的数据字典。 + + + +tfrecord_iterator_oldversion()[源代码]¶ +生成一个字典，其中key是schema中的字段，value是数据。该函数适用于早于2.1.0版本的TensorFlow。 +返回： +Dict，key与schema中字段名相同的数据字典。 + + + +transform()[源代码]¶ +mindspore.mindrecord.TFRecordToMR.run() 的包装函数来保证异常时正常退出。 +返回： +MSRStatus，SUCCESS或FAILED。 + + +",mindspore.mindrecord,mindspore、mindspore、API、数据、性能、dataset、C++ +mindspore.nn§mindspore.nn,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," +神经网络Cell。 +用于构建神经网络中的预定义构建块或计算单元。 +MindSpore中 mindspore.nn 接口与上一版本相比，新增、删除和支持平台的变化信息请参考 API Updates。 + +",mindspore.nn,mindspore、mindspore、接口、网络、API +mindspore.nn§基本构成单元,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.Cell +MindSpore中神经网络的基本构成单元。 +Ascend GPU CPU + +mindspore.nn.GraphCell +运行从MindIR加载的计算图。 +Ascend GPU CPU + +mindspore.nn.LossBase +损失函数的基类。 +Ascend GPU CPU + +mindspore.nn.Optimizer +用于参数更新的优化器基类。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、优化器、接口、损失函数、Optimizer、GPU、CPU、Ascend、MindIR、网络、Loss、计算图、优化、Graph +mindspore.nn§容器,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.CellList +构造Cell列表。 +Ascend GPU CPU + +mindspore.nn.SequentialCell +构造Cell顺序容器。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend +mindspore.nn§封装层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.DistributedGradReducer +分布式优化器。 +Ascend GPU + +mindspore.nn.DynamicLossScaleUpdateCell +用于动态更新损失缩放系数(loss scale)的神经元。 +Ascend GPU + +mindspore.nn.FixedLossScaleUpdateCell +固定损失缩放系数的神经元。 +Ascend GPU + +mindspore.nn.ForwardValueAndGrad +训练网络的封装。 +Ascend GPU CPU + +mindspore.nn.GetNextSingleOp +用于获取下一条数据的Cell。 +Ascend GPU + +mindspore.nn.MicroBatchInterleaved +Wrap the network with Batch Size. +Ascend GPU + +mindspore.nn.ParameterUpdate +更新参数的Cell。 +Ascend GPU CPU + +mindspore.nn.PipelineCell +将MiniBatch切分成更细粒度的MicroBatch，用于流水线并行的训练中。 +Ascend GPU + +mindspore.nn.TimeDistributed +时间序列封装层。 +Ascend GPU CPU + +mindspore.nn.TrainOneStepCell +训练网络封装类。 +Ascend GPU CPU + +mindspore.nn.TrainOneStepWithLossScaleCell +使用混合精度功能的训练网络。 +Ascend GPU + +mindspore.nn.WithEvalCell +封装前向网络和损失函数，返回用于计算评估指标的损失函数值、前向输出和标签。 +Ascend GPU CPU + +mindspore.nn.WithGradCell +Cell that returns the gradients. +Ascend GPU CPU + +mindspore.nn.WithLossCell +包含损失函数的Cell。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、并行、优化器、分布式、接口、损失函数、Pipeline、GPU、CPU、Ascend、网络、评估、Loss、TrainOneStepCell、精度、数据、loss scale、精度、优化、Eval、ib +mindspore.nn§卷积神经网络层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.Conv1d +一维卷积层。 +Ascend GPU CPU + +mindspore.nn.Conv1dTranspose +一维转置卷积层。 +Ascend GPU CPU + +mindspore.nn.Conv2d +二维卷积层。 +Ascend GPU CPU + +mindspore.nn.Conv2dTranspose +二维转置卷积层。 +Ascend GPU CPU + +mindspore.nn.Conv3d +三维卷积层。 +Ascend GPU CPU + +mindspore.nn.Conv3dTranspose +三维转置卷积层。 +Ascend GPU + +mindspore.nn.Unfold +从图像中提取滑窗的区域块。 +Ascend GPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend、网络 +mindspore.nn§循环神经网络层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.RNN +循环神经网络（RNN）层，其使用的激活函数为tanh或relu。 +Ascend GPU CPU + +mindspore.nn.RNNCell +循环神经网络单元，激活函数是tanh或relu。 +Ascend GPU CPU + +mindspore.nn.GRU +GRU（Gate Recurrent Unit）称为门控循环单元网络，是循环神经网络（Recurrent Neural Network, RNN）的一种。 +Ascend GPU CPU + +mindspore.nn.GRUCell +GRU（Gate Recurrent Unit）称为门控循环单元。 +Ascend GPU CPU + +mindspore.nn.LSTM +长短期记忆（LSTM）网络，根据输出序列和给定的初始状态计算输出序列和最终状态。 +Ascend GPU CPU + +mindspore.nn.LSTMCell +长短期记忆网络单元（LSTMCell）。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend、网络 +mindspore.nn§嵌入层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.Embedding +嵌入层。 +Ascend GPU CPU + +mindspore.nn.EmbeddingLookup +嵌入查找层。 +Ascend GPU CPU + +mindspore.nn.MultiFieldEmbeddingLookup +根据指定的索引和字段ID，返回输入Tensor的切片。 +Ascend GPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend、Embedding +mindspore.nn§非线性激活函数层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.CELU +Continuously differentiable exponential linear units activation function. +Ascend + +mindspore.nn.ELU +指数线性单元激活函数（Exponential Linear Unit activation function）。 +Ascend GPU CPU + +mindspore.nn.FastGelu +快速高斯误差线性单元激活函数（Fast Gaussian Error Linear Units activation function）。 +Ascend GPU CPU + +mindspore.nn.GELU +高斯误差线性单元激活函数（Gaussian error linear unit activation function）。 +Ascend GPU CPU + +mindspore.nn.Hardtanh +Hardtanh激活函数。 +Ascend GPU CPU + +mindspore.nn.HShrink +Hard Shrink激活函数，按输入元素计算输出，公式定义如下：。 +Ascend CPU GPU + +mindspore.nn.HSigmoid +Hard Sigmoid激活函数，按元素计算输出。 +Ascend GPU CPU + +mindspore.nn.HSwish +Hard Swish激活函数。 +GPU CPU + +mindspore.nn.LeakyReLU +Leaky ReLU激活函数。 +Ascend GPU CPU + +mindspore.nn.LogSigmoid +Log Sigmoid激活函数。 +Ascend GPU + +mindspore.nn.LogSoftmax +Log Softmax激活函数。 +Ascend GPU CPU + +mindspore.nn.LRN +局部响应归一化操作LRN(Local Response Normalization)。 +Ascend GPU CPU + +mindspore.nn.Mish +逐元素计算输入Tensor的MISH（Self Regularized Non-Monotonic Neural Activation Function 自正则化非单调神经激活函数）。 +Ascend CPU + +mindspore.nn.Softsign +Softsign激活函数。 +Ascend CPU + +mindspore.nn.PReLU +PReLU激活层（PReLU Activation Operator）。 +Ascend GPU + +mindspore.nn.ReLU +修正线性单元激活函数（Rectified Linear Unit activation function）。 +Ascend GPU CPU + +mindspore.nn.ReLU6 +ReLU6激活函数。 +Ascend GPU CPU + +mindspore.nn.RReLU +Randomized Leaky ReLU激活函数。 +Ascend GPU CPU + +mindspore.nn.SeLU +激活函数selu（Scaled exponential Linear Unit）。 +Ascend GPU CPU + +mindspore.nn.Sigmoid +Sigmoid激活函数。 +Ascend GPU CPU + +mindspore.nn.Softmax +Softmax函数，它是二分类函数 mindspore.nn.Sigmoid 在多分类上的推广，目的是将多分类的结果以概率的形式展现出来。 +Ascend GPU CPU + +mindspore.nn.SoftShrink +SoftShrink激活函数。 +Ascend CPU GPU + +mindspore.nn.Tanh +Tanh激活函数。 +Ascend GPU CPU + +mindspore.nn.Tanhshrink +Tanhshrink激活函数。 +Ascend GPU CPU + +mindspore.nn.Threshold +Threshold激活函数，按元素计算输出。 +Ascend CPU GPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend、ast、LR +mindspore.nn§线性层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.Dense +全连接层。 +Ascend GPU CPU + +mindspore.nn.BiDense +双线性全连接层。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend +mindspore.nn§Dropout层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.Dropout +随机丢弃层。 +Ascend GPU CPU + +mindspore.nn.Dropout2d +在训练期间，以服从伯努利分布的概率 p 随机将输入Tensor的某些通道归零。 +Ascend GPU CPU + +mindspore.nn.Dropout3d +在训练期间，以服从伯努利分布的概率 p 随机将输入Tensor的某些通道归零。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend +mindspore.nn§归一化层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.BatchNorm1d +对输入的二维数据进行批归一化(Batch Normalization Layer)。 +Ascend GPU CPU + +mindspore.nn.BatchNorm2d +对输入的四维数据进行批归一化(Batch Normalization Layer)。 +Ascend GPU CPU + +mindspore.nn.BatchNorm3d +对输入的五维数据进行批归一化(Batch Normalization Layer)。 +Ascend GPU CPU + +mindspore.nn.GlobalBatchNorm +The GlobalBatchNorm interface is deprecated, please use the mindspore.nn.SyncBatchNorm instead. +弃用 + +mindspore.nn.GroupNorm +在mini-batch输入上进行组归一化。 +Ascend GPU CPU + +mindspore.nn.InstanceNorm2d +对四维输入实现实例归一化（Instance Normalization Layer）。 +GPU + +mindspore.nn.LayerNorm +在mini-batch输入上应用层归一化（Layer Normalization）。 +Ascend GPU CPU + +mindspore.nn.SyncBatchNorm +在N维输入上进行跨设备同步批归一化（Batch Normalization，BN）。 +Ascend + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend、数据 +mindspore.nn§池化层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.AdaptiveAvgPool1d +对输入的多维数据进行一维平面上的自适应平均池化运算。 +Ascend GPU CPU + +mindspore.nn.AdaptiveAvgPool2d +2维自适应平均池化。 +GPU + +mindspore.nn.AdaptiveMaxPool1d +对输入的多维数据进行一维平面上的自适应最大池化运算。 +Ascend GPU CPU + +mindspore.nn.AdaptiveMaxPool2d +二维自适应最大池化运算。 +Ascend GPU CPU + +mindspore.nn.AvgPool1d +对输入的多维数据进行一维平面上的平均池化运算。 +Ascend GPU CPU + +mindspore.nn.AvgPool2d +对输入的多维数据进行二维的平均池化运算。 +Ascend GPU CPU + +mindspore.nn.MaxPool1d +对输入的多维数据进行一维平面上的最大池化运算。 +Ascend GPU CPU + +mindspore.nn.MaxPool2d +对输入的多维数据进行二维的最大池化运算。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend、数据 +mindspore.nn§填充层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.Pad +根据 paddings 和 mode 对输入进行填充。 +Ascend GPU CPU + +mindspore.nn.ConstantPad1d +将给定的常量填充到多维输入数据的最后一维。 +Ascend GPU CPU + +mindspore.nn.ConstantPad2d +将给定的常量填充到多维输入数据的最后两维。 +Ascend GPU CPU + +mindspore.nn.ConstantPad3d +将给定的常量填充到多维输入数据的最后三维。 +Ascend GPU CPU + +mindspore.nn.ZeroPad2d +将零填充到多维输入数据的最后两维。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend、数据 +mindspore.nn§损失函数,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.BCELoss +计算目标值和预测值之间的二值交叉熵损失值。 +Ascend GPU CPU + +mindspore.nn.BCEWithLogitsLoss +输入经过sigmoid激活函数后作为预测值，BCEWithLogitsLoss 计算预测值和目标值之间的二值交叉熵损失。 +Ascend GPU CPU + +mindspore.nn.CosineEmbeddingLoss +余弦相似度损失函数，用于测量两个Tensor之间的相似性。 +Ascend GPU CPU + +mindspore.nn.DiceLoss +Dice系数是一个集合相似性loss,用于计算两个样本之间的相似性。 +Ascend GPU CPU + +mindspore.nn.FocalLoss +FocalLoss函数。 +Ascend + +mindspore.nn.HuberLoss +HuberLoss计算预测值和目标值之间的误差。 +Ascend GPU CPU + +mindspore.nn.L1Loss +L1Loss用于计算预测值和目标值之间的平均绝对误差。 +Ascend GPU CPU + +mindspore.nn.MSELoss +用于计算预测值与标签值之间的均方误差。 +Ascend GPU CPU + +mindspore.nn.MultiClassDiceLoss +对于多标签问题，可以将标签通过one-hot编码转换为多个二分类标签。 +Ascend GPU CPU + +mindspore.nn.RMSELoss +RMSELoss用来测量 \(x\) 和 \(y\) 元素之间的均方根误差，其中 \(x\) 是输入Tensor， \(y\) 是目标值。 +Ascend GPU CPU + +mindspore.nn.SampledSoftmaxLoss +抽样交叉熵损失函数。 +GPU + +mindspore.nn.SmoothL1Loss +SmoothL1损失函数，如果预测值和目标值的逐个元素绝对误差小于设定阈值 beta 则用平方项，否则用绝对误差项。 +Ascend GPU CPU + +mindspore.nn.SoftMarginLoss +针对二分类问题的损失函数。 +Ascend + +mindspore.nn.SoftmaxCrossEntropyWithLogits +计算预测值与真实值之间的交叉熵。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、损失函数、GPU、CPU、Ascend、Loss、Embedding +mindspore.nn§优化器,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.Adadelta +Adadelta算法的实现。 +Ascend CPU + +mindspore.nn.Adagrad +Adagrad算法的实现。 +Ascend CPU GPU + +mindspore.nn.Adam +Adaptive Moment Estimation (Adam)算法的实现。 +Ascend GPU CPU + +mindspore.nn.AdaMax +AdaMax算法是基于无穷范数的Adam的一种变体。 +Ascend CPU + +mindspore.nn.AdamOffload +此优化器在主机CPU上运行Adam优化算法，设备上仅执行网络参数的更新，最大限度地降低内存成本。 +Ascend GPU CPU + +mindspore.nn.AdamWeightDecay +权重衰减Adam算法的实现。 +Ascend GPU CPU + +mindspore.nn.AdaSumByDeltaWeightWrapCell +Adaptive Summation (AdaSum)算法的实现，根据更新前后的参数差计算。 +Ascend GPU + +mindspore.nn.AdaSumByGradWrapCell +Adaptive Summation (AdaSum)算法的实现，根据梯度计算。 +Ascend GPU + +mindspore.nn.ASGD +Implements Average Stochastic Gradient Descent. +Ascend GPU CPU + +mindspore.nn.FTRL +FTRL算法实现。 +Ascend GPU + +mindspore.nn.Lamb +LAMB（Layer-wise Adaptive Moments optimizer for Batching training，用于批训练的分层自适应矩优化器）算法的实现。 +Ascend GPU + +mindspore.nn.LARS +LARS算法的实现。 +Ascend + +mindspore.nn.LazyAdam +Adaptive Moment Estimation (Adam)算法的实现。 +Ascend GPU CPU + +mindspore.nn.Momentum +Momentum算法的实现。 +Ascend GPU CPU + +mindspore.nn.ProximalAdagrad +ProximalAdagrad算法的实现。 +Ascend + +mindspore.nn.RMSProp +均方根传播（RMSProp）算法的实现。 +Ascend GPU CPU + +mindspore.nn.Rprop +Implements Resilient backpropagation. +Ascend GPU CPU + +mindspore.nn.SGD +随机梯度下降的实现。 +Ascend GPU CPU + +mindspore.nn.thor +通过二阶算法THOR更新参数。 +Ascend GPU + + + +",mindspore.nn,mindspore、mindspore、优化器、接口、optimizer、GPU、CPU、Ascend、网络、SGD、ast、优化 +mindspore.nn§评价指标,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.Accuracy +计算数据分类的正确率，包括二分类和多分类。 +Ascend GPU CPU + +mindspore.nn.auc +使用梯形法则计算曲线下面积AUC（Area Under the Curve，AUC）。 +Ascend GPU CPU + +mindspore.nn.BleuScore +计算具有一个或多个引用的机器翻译文本的BLEU分数。 +Ascend GPU CPU + +mindspore.nn.ConfusionMatrix +计算混淆矩阵(confusion matrix)，通常用于评估分类模型的性能，包括二分类和多分类场景。 +Ascend GPU CPU + +mindspore.nn.ConfusionMatrixMetric +计算与混淆矩阵相关的度量。 +Ascend GPU CPU + +mindspore.nn.CosineSimilarity +计算余弦相似度。 +Ascend GPU CPU + +mindspore.nn.Dice +集合相似性度量。 +Ascend GPU CPU + +mindspore.nn.F1 +计算F1 score。 +Ascend GPU CPU + +mindspore.nn.Fbeta +计算Fbeta评分。 +Ascend GPU CPU + +mindspore.nn.HausdorffDistance +计算Hausdorff距离。 +Ascend GPU CPU + +mindspore.nn.get_metric_fn +根据输入的 name 获取metric的方法。 +Ascend GPU CPU + +mindspore.nn.Loss +计算loss的平均值。 +Ascend GPU CPU + +mindspore.nn.MAE +计算平均绝对误差MAE（Mean Absolute Error）。 +Ascend GPU CPU + +mindspore.nn.MeanSurfaceDistance +计算从 y_pred 到 y 的平均表面距离。 +Ascend GPU CPU + +mindspore.nn.Metric +用于计算评估指标的基类。 +Ascend GPU CPU + +mindspore.nn.MSE +测量均方差MSE（Mean Squared Error）。 +Ascend GPU CPU + +mindspore.nn.names +获取所有metric的名称。 +Ascend GPU CPU + +mindspore.nn.OcclusionSensitivity +用于计算神经网络对给定图像的遮挡灵敏度（Occlusion Sensitivity），表示了图像的哪些部分对神经网络的分类决策最重要。 +Ascend GPU CPU + +mindspore.nn.Perplexity +计算困惑度（perplexity）。 +Ascend GPU CPU + +mindspore.nn.Precision +计算数据分类的精度，包括单标签场景和多标签场景。 +Ascend GPU CPU + +mindspore.nn.Recall +计算数据分类的召回率，包括单标签场景和多标签场景。 +Ascend GPU CPU + +mindspore.nn.ROC +计算ROC曲线。 +Ascend GPU CPU + +mindspore.nn.RootMeanSquareDistance +计算从 y_pred 到 y 的均方根表面距离。 +Ascend GPU CPU + +mindspore.nn.rearrange_inputs +此装饰器用于根据类的 indexes 属性对输入重新排列。 +Ascend GPU CPU + +mindspore.nn.Top1CategoricalAccuracy +计算top-1分类正确率。 +Ascend GPU CPU + +mindspore.nn.Top5CategoricalAccuracy +计算top-5分类正确率。 +Ascend GPU CPU + +mindspore.nn.TopKCategoricalAccuracy +计算top-k分类正确率。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend、网络、评估、Loss、Metric、精度、数据、精度、性能、npu +mindspore.nn§动态学习率,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + +LearningRateSchedule类 +本模块中的动态学习率都是LearningRateSchedule的子类，将LearningRateSchedule的实例传递给优化器。在训练过程中，优化器以当前step为输入调用该实例，得到当前的学习率。 +import mindspore.nn as nn + +min_lr = 0.01 +max_lr = 0.1 +decay_steps = 4 +cosine_decay_lr = nn.CosineDecayLR(min_lr, max_lr, decay_steps) + +net = Net() +optim = nn.Momentum(net.trainable_params(), learning_rate=cosine_decay_lr, momentum=0.9) + + + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.CosineDecayLR +基于余弦衰减函数计算学习率。 +Ascend GPU + +mindspore.nn.ExponentialDecayLR +基于指数衰减函数计算学习率。 +Ascend GPU CPU + +mindspore.nn.InverseDecayLR +基于逆时衰减函数计算学习率。 +Ascend GPU CPU + +mindspore.nn.NaturalExpDecayLR +基于自然指数衰减函数计算学习率。 +Ascend GPU CPU + +mindspore.nn.PolynomialDecayLR +基于多项式衰减函数计算学习率。 +Ascend GPU + +mindspore.nn.WarmUpLR +预热学习率。 +Ascend GPU + + + + + +Dynamic LR函数 +本模块中的动态学习率都是function，调用function并将结果传递给优化器。在训练过程中，优化器将result[current step]作为当前学习率。 +import mindspore.nn as nn + +min_lr = 0.01 +max_lr = 0.1 +total_step = 6 +step_per_epoch = 1 +decay_epoch = 4 + +lr= nn.cosine_decay_lr(min_lr, max_lr, total_step, step_per_epoch, decay_epoch) + +net = Net() +optim = nn.Momentum(net.trainable_params(), learning_rate=lr, momentum=0.9) + + + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.cosine_decay_lr +基于余弦衰减函数计算学习率。 +Ascend GPU CPU + +mindspore.nn.exponential_decay_lr +基于指数衰减函数计算学习率。 +Ascend GPU CPU + +mindspore.nn.inverse_decay_lr +基于逆时衰减函数计算学习率。 +Ascend GPU CPU + +mindspore.nn.natural_exp_decay_lr +基于自然指数衰减函数计算学习率。 +Ascend GPU CPU + +mindspore.nn.piecewise_constant_lr +获取分段常量学习率。 +Ascend GPU CPU + +mindspore.nn.polynomial_decay_lr +基于多项式衰减函数计算学习率。 +Ascend GPU CPU + +mindspore.nn.warmup_lr +预热学习率。 +Ascend GPU CPU + + + + +",mindspore.nn,mindspore、mindspore、优化器、接口、GPU、CPU、Ascend、arm、lr、学习率、优化 +mindspore.nn§稀疏层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.SparseTensorDenseMatmul +稀疏矩阵 a 乘以稠密矩阵 b 。 +CPU + +mindspore.nn.SparseToDense +将稀疏Tensor(COO Tensor)转换为稠密Tensor。 +CPU + + + +",mindspore.nn,mindspore、mindspore、接口、CPU +mindspore.nn§图像处理层,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.CentralCrop +根据指定比例裁剪出图像的中心区域。 +Ascend GPU CPU + +mindspore.nn.ImageGradients +计算每个颜色通道的图像渐变，返回为两个Tensor，分别表示高和宽方向上的变化率。 +Ascend GPU CPU + +mindspore.nn.MSSSIM +多尺度计算两个图像之间的结构相似性（SSIM）。 +Ascend GPU + +mindspore.nn.PSNR +在批处理中计算两个图像的峰值信噪比（PSNR）。 +Ascend GPU CPU + +mindspore.nn.ResizeBilinear +使用双线性插值调整输入Tensor为指定的大小。 +Ascend CPU GPU + +mindspore.nn.SSIM +计算两个图像之间的结构相似性（SSIM）。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend +mindspore.nn§矩阵处理,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.MatrixDiag +根据对角线值返回一批对角矩阵。 +Ascend + +mindspore.nn.MatrixDiagPart +返回批对角矩阵的对角线部分。 +Ascend + +mindspore.nn.MatrixSetDiag +将输入的对角矩阵的对角线值置换为输入的对角线值。 +Ascend + + + +",mindspore.nn,mindspore、mindspore、接口、Ascend +mindspore.nn§工具,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.ClipByNorm +对输入Tensor的值进行裁剪，使用 \(L_2\) 范数控制梯度。 +Ascend GPU CPU + +mindspore.nn.Flatten +对输入Tensor的第0维之外的维度进行展平操作。 +Ascend GPU CPU + +mindspore.nn.get_activation +获取激活函数。 +Ascend GPU CPU + +mindspore.nn.L1Regularizer +对权重计算L1正则化。 +Ascend GPU CPU + +mindspore.nn.Norm +计算向量的范数，目前包括欧几里得范数，即 \(L_2\)-norm。 +Ascend GPU CPU + +mindspore.nn.OneHot +对输入进行one-hot编码并返回。 +Ascend GPU CPU + +mindspore.nn.Range +根据指定步长在范围[start, limit)中创建数字序列。 +Ascend GPU CPU + +mindspore.nn.Roll +沿轴移动Tensor的元素。 +Ascend GPU + +mindspore.nn.Tril +返回一个Tensor，指定主对角线以上的元素被置为零。 +Ascend GPU CPU + +mindspore.nn.Triu +返回一个Tensor，指定主对角线以下的元素被置为0。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend、pB +mindspore.nn§数学运算,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.MatMul +The nn.MatMul interface is deprecated, please use the mindspore.ops.matmul instead. +弃用 + +mindspore.nn.Moments +沿指定轴 axis 计算输入 x 的均值和方差。 +Ascend GPU CPU + +mindspore.nn.ReduceLogSumExp +Reduces a dimension of a tensor by calculating exponential for all elements in the dimension, then calculate logarithm of the sum. +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend +mindspore.nn§梯度,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.Jvp +计算给定网络的雅可比向量积(Jacobian-vector product, JVP)。 +Ascend GPU CPU + +mindspore.nn.Vjp +计算给定网络的向量雅可比积(vector-Jacobian product, VJP)。 +Ascend GPU CPU + + + +",mindspore.nn,mindspore、mindspore、接口、GPU、CPU、Ascend、网络 +mindspore.nn.probability§Bijectors,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.probability.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.probability.bijector.Bijector +Bijector类。 +Ascend GPU + +mindspore.nn.probability.bijector.Exp +指数Bijector（Exponential Bijector）。 +Ascend GPU + +mindspore.nn.probability.bijector.GumbelCDF +GumbelCDF Bijector。 +Ascend GPU + +mindspore.nn.probability.bijector.Invert +逆映射Bijector（Invert Bijector）。 +Ascend GPU CPU + +mindspore.nn.probability.bijector.PowerTransform +乘方Bijector（PowerTransform Bijector）。 +Ascend GPU + +mindspore.nn.probability.bijector.ScalarAffine +标量仿射Bijector（Scalar Affine Bijector）。 +Ascend GPU + +mindspore.nn.probability.bijector.Softplus +Softplus Bijector。 +Ascend GPU + + + +",mindspore.nn.probability,mindspore、mindspore、接口、GPU、CPU、Ascend +mindspore.nn.probability§Distributions,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.probability.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.nn.probability.distribution.Bernoulli +伯努利分布（Bernoulli Distribution）。 +Ascend GPU + +mindspore.nn.probability.distribution.Beta +Beta 分布（Beta Distribution）。 +Ascend + +mindspore.nn.probability.distribution.Categorical +分类分布。 +Ascend GPU + +mindspore.nn.probability.distribution.Cauchy +柯西分布（Cauchy distribution）。 +Ascend + +mindspore.nn.probability.distribution.Distribution +所有分布的基类。 +Ascend GPU + +mindspore.nn.probability.distribution.Exponential +指数分布（Exponential Distribution）。 +Ascend GPU + +mindspore.nn.probability.distribution.Gamma +伽马分布（Gamma distribution）。 +Ascend + +mindspore.nn.probability.distribution.Geometric +几何分布（Geometric Distribution）。 +Ascend GPU + +mindspore.nn.probability.distribution.Gumbel +Gumbel分布（Gumbel distribution）。 +Ascend GPU + +mindspore.nn.probability.distribution.Logistic +Logistic分布（Logistic distribution）。 +Ascend GPU + +mindspore.nn.probability.distribution.LogNormal +对数正态分布（LogNormal distribution）。 +Ascend GPU + +mindspore.nn.probability.distribution.Normal +正态分布（Normal distribution）。 +Ascend GPU + +mindspore.nn.probability.distribution.Poisson +泊松分布（Poisson Distribution）。 +Ascend + +mindspore.nn.probability.distribution.TransformedDistribution +转换分布（Transformed Distribution）。 +Ascend GPU CPU + +mindspore.nn.probability.distribution.Uniform +均匀分布（Uniform Distribution）。 +Ascend GPU CPU + + + +",mindspore.nn.probability,mindspore、mindspore、接口、GPU、CPU、Ascend、metric、ib +mindspore.nn.transformer§mindspore.nn.transformer,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.transformer.html," + +Note +Transformer网络。这些是实验性接口，可能会修改或删除。 + + + +class mindspore.nn.transformer.AttentionMask(seq_length, parallel_config=default_dpmp_config)[源代码]¶ +从输入掩码中获取下三角矩阵。输入掩码是值为1或0的二维Tensor (batch_size, seq_length)。1表示当前位置是一个有效的标记，0则表示当前位置不是一个有效的标记。 +参数： + +seq_length (int) - 表示输入Tensor的序列长度。 +parallel_config (OpParallelConfig) - 表示并行配置。默认值为 default_dpmp_config ，表示一个带有默认参数的 OpParallelConfig 实例。 + +输入： + +input_mask (Tensor) - 掩码矩阵，shape为(batch_size, seq_length)，表示每个位置是否为有效输入。 + +输出： +Tensor，表示shape为(batch_size, seq_length, seq_length)的注意力掩码矩阵。 +异常： + +TypeError - seq_length 不是整数。 +ValueError - seq_length 不是正数。 +TypeError - parallel_config 不是OpParallelConfig的子类。 + +支持平台： +Ascend GPU +样例： +>>> import numpy as np +>>> from mindspore.nn.transformer import AttentionMask +>>> from mindspore import Tensor +>>> mask = AttentionMask(seq_length=4) +>>> mask_array = np.array([[1, 1, 1, 0]], np.float32) +>>> inputs = Tensor(mask_array) +>>> res = mask(inputs) +>>> print(res) +[[[1. 0. 0. 0] +[1. 1. 0. 0] +[1. 1. 1. 0] +[0. 0. 0. 0]]] + + + + + +class mindspore.nn.transformer.VocabEmbedding(vocab_size, embedding_size, parallel_config=default_embedding_parallel_config, param_init=""normal"")[源代码]¶ +根据输入的索引查找参数表中的行作为返回值。当设置并行模式为 AUTO_PARALLEL_MODE 时，如果parallel_config.vocab_emb_dp为True时，那么embedding lookup表采用数据并行的方式，数据并行度为 parallel_config.data_parallel ，否则按 parallel_config.model_parallel 对embedding表中的第0维度进行切分。 + +Note +启用 AUTO_PARALLEL / SEMI_AUTO_PARALLEL 模式时，此层仅支持2维度的输入，因为策略是为2D输入而配置的。 + +参数： + +vocab_size (int) - 表示查找表的大小。 +embedding_size (int) - 表示查找表中每个嵌入向量的大小。 +param_init (Union[Tensor, str, Initializer, numbers.Number]) - 表示embedding_table的Initializer。当指定字符串时，请参见 initializer 类了解字符串的值。默认值：’normal’。 +parallel_config (EmbeddingOpParallelConfig) - 表示网络的并行配置。默认值为 default_embedding_parallel_config ，表示带有默认参数的 EmbeddingOpParallelConfig 实例。 + +输入： + +input_ids (Tensor) - shape为(batch_size, seq_length)的输入，其数据类型为int32。 + +输出： +Tuple，表示一个包含(output, embedding_table)的元组。 + +output (Tensor) - shape为(batch_size, seq_length, embedding_size)嵌入向量查找结果。 +embedding_table (Tensor) - shape为(vocab_size, embedding_size)的嵌入表。 + +异常： + +ValueError - parallel_config.vocab_emb_dp为True时，词典的大小不是parallel_config.model_parallel的倍数。 +ValueError - vocab_size 不是正值。 +ValueError - embedding_size 不是正值。 +TypeError - parallel_config 不是OpParallelConfig的子类。 + +支持平台： +Ascend GPU +样例： +>>> import numpy as np +>>> from mindspore.nn.transformer import VocabEmbedding +>>> from mindspore import Tensor +>>> from mindspore import dtype as mstype +>>> model = VocabEmbedding(vocab_size=30, embedding_size=30) +>>> tensor = Tensor(np.ones((20, 15)), mstype.int32) +>>> output, table = model(tensor) +>>> print(output.shape) +(20, 15, 30) +>>> print(table.shape) +(30, 30) + + + + + +class mindspore.nn.transformer.MultiHeadAttention(batch_size, src_seq_length, tgt_seq_length, hidden_size, num_heads, hidden_dropout_rate=0.1, attention_dropout_rate=0.1, compute_dtype=mstype.float16, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, use_past=False, parallel_config=default_dpmp_config)[源代码]¶ +论文 Attention Is All You Need 中所述的多头注意力的实现。给定src_seq_length长度的query向量，tgt_seq_length长度的key向量和value，注意力计算流程如下： + +\[MultiHeadAttention(query, key, vector) = Dropout(Concat(head_1, \dots, head_h)W^O)\] +其中， \(head_i = Attention(QW_i^Q, KW_i^K, VW_i^V)\) 。注意：输出层的投影计算中带有偏置参数。 +如果query tensor、key tensor和value tensor相同，则上述即为自注意力机制的计算过程。 +参数： + +batch_size (int) - 表示训练批次的大小。 +src_seq_length (int) - 表示query向量的序列长度。 +tgt_seq_length (int) - 表示key向量和value向量的序列长度。 +hidden_size (int) - 表示输入的向量大小。 +num_heads (int) - 表示注意力机制中头的数量。 +hidden_dropout_rate (float) - 表示最后dense输出的丢弃率。默认值：0.1 +attention_dropout_rate (float) - 表示注意力score的丢弃率。默认值：0.1 +compute_dtype (dtype.Number) - 表示dense中矩阵乘法的计算类型。默认值：mstype.float16。其值应为mstype.float32或mstype.float16。 +param_init_type (dtype.Number) - 表示模块的参数初始化类型。默认值：mstype.float32。其值应为mstype.float32或mstype.float16。 +softmax_compute_type (dtype.Number) - 表示softmax计算模块的类型。默认值：mstype.float32。 其值应为mstype.float32或mstype.float16。 +use_past (bool) - 使用过去状态进行计算，用于增量预测。例如，如果我们有两个单词，想生成十个或以上单词。我们只需要计算一次这两个单词的状态，然后逐个生成下一个单词。当use_past为True时，有两个步骤可以执行预测。 +第一步是通过 model.add_flags_recursive(is_first_iteration=True) 将is_first_iteration设为True，并传递完整的输入。然后，通过 model.add_flags_recursive(is_first_iteration=False) 将is_first_iteration设为False。此时，传递step的输入tensor，并对其进行循环。默认值：False +parallel_config (OpParallelConfig) - 表示并行配置。默认值为 default_dpmp_config ，表示一个带有参数的 OpParallelConfig 实例。 + +输入： + +query_tensor (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, src_seq_length, hidden_size)或(batch_size * src_seq_length, hidden_size)的query向量。否则，shape必须为(batch_size, 1, hidden_size)。 +key_tensor (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, tgt_seq_length, hidden_size)或(batch_size * tgt_seq_length, hidden_size)的key向量。否则，shape必须为(batch_size, 1, hidden_size)。 +value_tensor (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, tgt_seq_length, hidden_size)或(batch_size * tgt_seq_length, hidden_size)的value向量。否则，shape必须为(batch_size, 1, hidden_size)。 +attention_mask (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, src_seq_length, tgt_seq_length)的注意力掩码矩阵。否则，shape必须为(batch_size, 1, tgt_seq_length)。 +key_past (Tensor) - shape为(batch_size, num_heads, size_per_head, tgt_seq_length)的Float16 tensor， 表示过去所计算的key向量。 +当use_past为True时，需要传入非None值用于增量预测。默认值为None。 +value_past (Tensor) - shape为(batch_size, num_heads, tgt_seq_length, size_per_head)的Float16 tensor，表示过去所计算的value向量。 +当use_past为True时，需要传入非None值用于增量预测。默认值为None。 +batch_valid_length (Tensor) - shape为(batch_size,)的Int32 tensor，表示已经计算的token索引。 +当use_past为True时，需要传入非None值用于增量预测。默认值为None。 + +输出： +Tuple，表示一个包含(output, layer_present)的元组。 + +output (Tensor) - Tensor。use_past为False或is_first_iteration为True时，表示shape为(batch_size, src_seq_length, hidden_size)或(batch_size * src_seq_length, hidden_size)的层输出的float tensor。否则，shape将为(batch_size, 1, hidden_size)。 +layer_present (Tuple) - 表示shape为((batch_size, num_heads, size_per_head, tgt_seq_length)或(batch_size, num_heads, tgt_seq_length, size_per_head))的投影key向量和value向量的Tensor的元组。 + +支持平台： +Ascend GPU +样例： +>>> import numpy as np +>>> from mindspore.nn.transformer import MultiHeadAttention +>>> from mindspore import dtype as mstype +>>> from mindspore import Tensor +>>> model = MultiHeadAttention(batch_size=2, hidden_size=15, src_seq_length=20, tgt_seq_length=20, +... num_heads=3) +>>> from_tensor = Tensor(np.ones((2, 20, 15)), mstype.float32) +>>> to_tensor = Tensor(np.ones((2, 20, 15)), mstype.float16) +>>> attention_mask = Tensor(np.ones((2, 20, 20)), mstype.float16) +>>> attn_out, past = model(from_tensor, to_tensor, to_tensor, attention_mask) +>>> print(attn_out.shape) +(2, 20, 15) +>>> print(past[0].shape) +(2, 3, 5, 20) +>>> print(past[1].shape) +(2, 3, 20, 5) +>>> # When use use_past=True, it includes two steps to implement the incremental prediction. +>>> # Step 1: set is_first_iteration=True, and input the full sequence length's state. +>>> # We need to prepare the memory parameters for saving key and value states firstly. +>>> model = MultiHeadAttention(batch_size=2, hidden_size=15, src_seq_length=20, tgt_seq_length=20, +... num_heads=3, use_past=True) +>>> key_past = Tensor(np.zeros(shape=(2, 3, 5, 20)), mstype.float16) +>>> value_past = Tensor(np.zeros(shape=(2, 3, 20, 5)), mstype.float16) +>>> batch_valid_length = Tensor(np.ones((2,)), mstype.int32) +>>> # Set is_first_iteration=True to generate the full memory states +>>> model.add_flags_recursive(is_first_iteration=True) +>>> attn_out, past = model(from_tensor, to_tensor, to_tensor, attention_mask, key_past, value_past, +... batch_valid_length) +>>> print(attn_out.shape) +(2, 20, 15) +>>> print(past[0].shape) +(2, 3, 5, 20) +>>> print(past[1].shape) +(2, 3, 20, 5) +>>> from_tensor = Tensor(np.ones((2, 1, 15)), mstype.float32) +>>> to_tensor = Tensor(np.ones((2, 1, 15)), mstype.float16) +>>> attention_mask = Tensor(np.ones((2, 1, 20)), mstype.float16) +>>> # Step 2: set is_first_iteration=False, and pass the single word to run the prediction rather than the +>>> # full sequence. +>>> model.add_flags_recursive(is_first_iteration=False) +>>> attn_out, past = model(from_tensor, to_tensor, to_tensor, attention_mask, key_past, value_past, +... batch_valid_length) +>>> print(attn_out.shape) +(2, 1, 15) +>>> print(past[0].shape) +(2, 3, 5, 20) +>>> print(past[1].shape) +(2, 3, 20, 5) + + + + + +class mindspore.nn.transformer.FeedForward(hidden_size, ffn_hidden_size, dropout_rate, hidden_act=""gelu"", expert_num=1, expert_group_size=None, param_init_type=mstype.float32, parallel_config=default_dpmp_config)[源代码]¶ +具有两层线性层的多层感知器，并在最终输出上使用Dropout。第一个线性层将输入维度从hidden_size投影到ffn_hidden_size，并在中间应用激活层。第二个线性层将该维度从ffn_hidden_size投影到hidden_size。配置parallel_config之后， +第一个线性层的权重将在输入维度上被分片，第二个线性层在输出维度上进行切分。总体过程如下 + +\[Dropout((xW_1+b_1)W_2 + b_2))\] +其中 \(W_1, W_2, b_1\) 和 \(b_2\) 为可训练参数。 +参数： + +hidden_size (int) - 表示输入的维度。 +ffn_hidden_size (int) - 表示中间隐藏大小。 +dropout_rate (float) - 表示第二个线性层输出的丢弃率。 +hidden_act (str) - 表示第一个线性层的激活。其值可为’relu’、’relu6’、’tanh’、’gelu’、’fast_gelu’、’elu’、’sigmoid’、’prelu’、’leakyrelu’、’hswish’、’hsigmoid’、’logsigmoid’等等。默认值：’gelu’。 +expert_num (int) - 表示线性层中使用的专家数量。对于expert_num > 1用例，使用BatchMatMul。BatchMatMul中的第一个维度表示expert_num。默认值：1。 +expert_group_size (int) - 表示每个数据并行组收到的词语（token）数量。默认值：None。该参数只在自动并行且非策略传播模式下起作用。 +param_init_type (dtype.Number) - 表示参数初始化类型。其值应为mstype.float32或mstype.float16。默认值：mstype.float32。 +parallel_config (OpParallelConfig) - 表示配置该网络的并行度的并行配置。更多详情，请参见 mindspore.nn.transformer.OpParallelConfig 。默认值为 default_dpmp_config ，表示一个带有默认参数的 OpParallelConfig 实例。 + +输入： + +x (Tensor) - 应为 [batch, seq_length, hidden_size]或[batch * seq_length, hidden_size] 。表示浮点Tensor。 + +输出： +Tensor，表示映射后该层的输出。shape为 [batch, seq_length, hidden_size] 或 [batch * seq_length, hidden_size] 。 +异常： + +ValueError - hidden_act 不是字符串。 +TypeError - parallel_config 不是OpParallelConfig的子类。 +ValueError - ffn_hidden_size 不是parallel_config中model_parallel的倍数。 +ValueError - hidden_size 不是parallel_config中model_parallel的倍数。 + +支持平台： +Ascend GPU +样例： +>>> import numpy as np +>>> from mindspore.nn.transformer import FeedForward +>>> from mindspore import dtype as mstype +>>> from mindspore import Tensor +>>> model = FeedForward(hidden_size=15, ffn_hidden_size=30, dropout_rate=0.1) +>>> tensor = Tensor(np.ones((2, 20, 15)), mstype.float32) +>>> output = model(tensor) +>>> print(output.shape) +(2, 20, 15) + + + + + +class mindspore.nn.transformer.TransformerEncoder(batch_size, num_layers, hidden_size, ffn_hidden_size, seq_length, num_heads, attention_dropout_rate=0.1, hidden_dropout_rate=0.1, hidden_act=""gelu"", post_layernorm_residual=False, layernorm_compute_type=mstype.float32, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, lambda_func=None, offset=0, use_past=False, moe_config=default_moe_config, parallel_config=default_transformer_config)[源代码]¶ +Transformer中的编码器模块，具有多层堆叠的 TransformerEncoderLayer ，包括多头自注意力层和前馈层。 +参数： + +batch_size (int) - 表示输入tensor的批次大小。 +num_layers (int) - 表示 TransformerEncoderLayer 的层。 +hidden_size (int) - 表示输入的隐藏大小。 +ffn_hidden_size (int) - 表示前馈层中bottleneck的隐藏大小。 +seq_length (int) - 表示输入序列长度。 +num_heads (int) - 表示注意力头的数量。 +hidden_dropout_rate (float) - 表示作用在隐藏层输出的丢弃率。默认值：0.1 +attention_dropout_rate (float) - 表示注意力score的丢弃率。默认值：0.1 +post_layernorm_residual (bool) - 表示是否在LayerNorm之前使用残差，即是否选择残差为Post-LayerNorm或者Pre-LayerNorm。默认值：False +hidden_act (str) - 表示内部前馈层的激活函数。其值可为’relu’、’relu6’、’tanh’、’gelu’、’fast_gelu’、’elu’、’sigmoid’、’prelu’、’leakyrelu’、’hswish’、’hsigmoid’、’logsigmoid’等等。默认值：gelu。 +layernorm_compute_type (dtype.Number) - 表示LayerNorm的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +softmax_compute_type (dtype.Number) - 表示注意力中softmax的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +param_init_type (dtype.Number) - 表示模块的参数初始化类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +use_past (bool) - 使用过去状态进行计算，用于增量预测。例如，如果我们有两个单词，想生成十个或以上单词。我们只需要计算一次这两个单词的状态，然后逐个生成下一个单词。当use_past为True时，有两个步骤可以运行预测。第一步是通过 model.add_flags_recursive(is_first_iteration=True) 将is_first_iteration设为True，并传递完整的输入。然后，通过 model.add_flags_recursive(is_first_iteration=False) 将is_first_iteration设为False。此时，传递step的输入tensor，并对其进行环回。默认值：False。 +lambda_func - 表示设置融合索引、pipeline阶段和重计算属性的函数。如果用户想确定pipeline阶段和梯度聚合融合，用户可以传递一个接受 network 、 layer_id 、 offset 、 parallel_config 和 layers 的函数。 network(Cell) 表示transformer块， layer_id(int) 表示当前模块的层索引，从零开始计数， offset(int) 表示如果网络中还有其他模块，则layer_index需要一个偏置。pipeline的默认设置为： (layer_id + offset) // (layers / pipeline_stage) 。默认值：None。 +offset (int) - 表示 decoder 的初始层索引。其用于设置梯度聚合的融合值和流水线并行的stage值。默认值：0。 +moe_config (MoEConfig) - 表示MoE (Mixture of Expert)的配置。默认值为 default_moe_config ，表示带有默认参数的 MoEConfig 实例。 +parallel_config (TransformerOpParallelConfig) - 表示并行配置。默认值为 default_transformer_config ，表示带有默认参数的 TransformerOpParallelConfig 实例。 + +输入： + +hidden_states (Tensor) - Tensor。如果use_past为False或者is_first_iteration为True，shape为[batch_size, seq_length, hidden_size]或者[batch_size * seq_length, hidden_size]。否则，shape应为[batch_size, 1, hidden_size]。 +attention_mask (Tensor) - Tensor，表示shape为[[batch_size, seq_length, seq_length]的注意力掩码。 +init_reset (Tensor) - shape为[1]的bool tensor，用于清除增量预测中使用的past key参数和past value参数。仅当use_past为True时有效。默认值为True。 +batch_valid_length (Tensor) - shape为[batch_size]的Int32 tensor，表示过去所计算的索引。当use_past为True时，它用于增量预测。默认值为None。 + +输出： +Tuple，表示一个包含(output, layer_present)的元组。 + +output (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, seq_length, hidden_size)或(batch_size * seq_length, hidden_size)的层输出的float tensor。否则，shape将为(batch_size, 1, hidden_size)。 +layer_present (Tuple) - 大小为num_layers的元组，其中每个元组都包含shape为((batch_size, num_heads, size_per_head, seq_length)或(batch_size, num_heads, seq_length, size_per_head))的投影key向量和value向量的Tensor的元组。 + +支持平台： +Ascend GPU +样例： +>>> import numpy as np +>>> from mindspore import dtype as mstype +>>> from mindspore.nn.transformer import TransformerEncoder +>>> from mindspore import Tensor +>>> model = TransformerEncoder(batch_size=2, num_layers=2, hidden_size=8, ffn_hidden_size=64, +... seq_length=16, num_heads=2) +>>> encoder_input_value = Tensor(np.ones((2, 16, 8)), mstype.float32) +>>> encoder_input_mask = Tensor(np.ones((2, 16, 16)), mstype.float16) +>>> output, past = model(encoder_input_value, encoder_input_mask) +>>> print(output.shape) +(2, 16, 8) +>>> print(len(past)) +2 +>>> print(past[0][0].shape) +(2, 2, 4, 16) +>>> print(past[0][1].shape) +(2, 2, 16, 4) +>>> # When use use_past=True, it includes two steps to implement the incremental prediction. +>>> # Step 1: set is_first_iteration=True, and input the full sequence length's state. +>>> batch_valid_length = Tensor(np.ones((2,)), mstype.int32) +>>> init_reset = Tensor([True], mstype.bool_) +>>> # Set is_first_iteration=True to generate the full memory states +>>> model = TransformerEncoder(batch_size=2, hidden_size=8, ffn_hidden_size=64, seq_length=16, +... num_heads=2, num_layers=2, use_past=True) +>>> model.add_flags_recursive(is_first_iteration=True) +>>> hidden, past = model(encoder_input_value, encoder_input_mask, init_reset, batch_valid_length) +>>> print(hidden.shape) +(2, 16, 8) +>>> print(past[0][0].shape) +(2, 2, 4, 16) +>>> print(past[0][1].shape) +(2, 2, 16, 4) +>>> encoder_input_value = Tensor(np.ones((2, 1, 8)), mstype.float32) +>>> encoder_input_mask = Tensor(np.ones((2, 1, 16)), mstype.float16) +>>> init_reset = Tensor([False], mstype.bool_) +>>> # Step 2: set is_first_iteration=False, and pass the single word to run the prediction rather than +>>> # the full sequence. +>>> model.add_flags_recursive(is_first_iteration=False) +>>> hidden, past = model(encoder_input_value, encoder_input_mask, init_reset, batch_valid_length) +>>> print(hidden.shape) +(2, 1, 8) +>>> print(past[0][0].shape) +(2, 2, 4, 16) +>>> print(past[0][1].shape) +(2, 2, 16, 4) + + + + + +class mindspore.nn.transformer.TransformerDecoder(num_layers, batch_size, hidden_size, ffn_hidden_size, src_seq_length, tgt_seq_length, num_heads, attention_dropout_rate=0.1, hidden_dropout_rate=0.1, post_layernorm_residual=False, layernorm_compute_type=mstype.float32, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, hidden_act=""gelu"", lambda_func=None, use_past=False, offset=0, moe_config=default_moe_config, parallel_config=default_transformer_config)[源代码]¶ +Transformer中的解码器模块，为多层堆叠的 TransformerDecoderLayer ，包括多头自注意力层、交叉注意力层和前馈层。 +参数： + +batch_size (int) - 表示输入Tensor的批次大小。 +num_layers (int) - 表示 TransformerDecoderLayer 的层数。 +hidden_size (int) - 表示输入的隐藏大小。 +ffn_hidden_size (int) - 表示前馈层中bottleneck的隐藏大小。 +src_seq_length (int) - 表示输入源序列长度。 +tgt_seq_length (int) - 表示输入目标序列长度。 +num_heads (int) - 表示注意力头的数量。 +hidden_dropout_rate (float) - 表示作用在隐藏层输出的丢弃率。默认值：0.1 +attention_dropout_rate (float) - 表示注意力score的丢弃率。默认值：0.1 +post_layernorm_residual (bool) - 表示是否在LayerNorm之前使用残差，即是否选择残差为Post-LayerNorm或者Pre-LayerNorm。默认值：False +hidden_act (str) - 表示内部前馈层的激活函数。其值可为’relu’、’relu6’、’tanh’、’gelu’、’fast_gelu’、’elu’、’sigmoid’、’prelu’、’leakyrelu’、’hswish’、’hsigmoid’、’logsigmoid’等等。默认值：gelu。 +layernorm_compute_type (dtype.Number) - 表示LayerNorm的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +use_past (bool) - 表示是否开启增量推理。在推理中会缓存注意力机制计算结果，避免冗余计算。默认值为False。 +softmax_compute_type (dtype.Number) - 表示注意力中softmax的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +param_init_type (dtype.Number) - 表示模块的参数初始化类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +offset (int) - 表示 decoder 的初始层索引偏移值。其用于设置梯度聚合的融合值和流水线并行的stage值，使其不与编码器层的相关属性重叠。默认值为0。 +lambda_func - 表示确定梯度融合索引、pipeline阶段和重计算属性的函数。如果用户想确定pipeline阶段和梯度聚合融合，用户可以传递一个接受 network 、 layer_id 、 offset 、 parallel_config 和 layers 的函数。 network(Cell) 表示transformer块， layer_id(int) 表示当前模块的层索引，从零开始计数， offset(int) 表示如果网络中还有其他模块，则layer_index需要一个偏置。pipeline的默认设置为： (layer_id + offset) // (layers / pipeline_stage) 。默认值：None。 +moe_config (MoEConfig) - 表示MoE (Mixture of Expert)的配置。默认值为 default_moe_config ，表示带有默认参数的 MoEConfig 实例。 +parallel_config (TransformerOpParallelConfig) - 表示并行配置。默认值为 default_transformer_config ，表示带有默认参数的 TransformerOpParallelConfig 实例。 + +输入： + +hidden_stats (Tensor) - shape为[batch_size, seq_length, hidden_size]或[batch_size * seq_length, hidden_size]的输入tensor。 +attention_mask (Tensor) - shape为[batch_size, seq_length, seq_length]的解码器的注意力掩码。 +encoder_output (Tensor) - shape为[batch_size, seq_length, hidden_size]或[batch_size * seq_length, hidden_size]的编码器的输出。 + +memory_mask (Tensor) - shape为[batch, tgt_seq_length, src_seq_length]的交叉注意力的memory掩码，其中tgt_seq_length表示解码器的长度。注：当网络位于最外层时，此参数不能通过None传递。默认值为None。 +init_reset (Tensor) - shape为[1]的bool tensor，用于清除增量预测中使用的past key参数和past value参数。仅当use_past为True时有效。默认值为True。 +batch_valid_length (Tensor) - shape为[batch_size]的Int32 tensor，表示过去所计算的索引。当use_past为True时，它用于增量预测。默认值为None。 + +输出： +Tuple，表示一个包含(output, layer_present)的元组。 + +output (Tensor) - 输出的logit。shape为[batch, tgt_seq_length, hidden_size]或[batch * tgt_seq_length, hidden_size]。 +layer_present (Tuple) - 大小为层数的元组，其中每个元组都是shape为((batch_size, num_heads, size_per_head, tgt_seq_length)或(batch_size, num_heads, tgt_seq_length, size_per_head)的自注意力中的投影key向量和value向量的tensor的元组，或者是shape为(batch_size, num_heads, size_per_head, src_seq_length)或(batch_size, num_heads, src_seq_length, size_per_head))的交叉注意力中的投影key向量和value向量的tensor的元组。 + +支持平台： +Ascend GPU +样例： +>>> import numpy as np +>>> from mindspore import dtype as mstype +>>> from mindspore.nn.transformer import TransformerDecoder +>>> from mindspore import Tensor +>>> model = TransformerDecoder(batch_size=2, num_layers=1, hidden_size=64, ffn_hidden_size=64, +... num_heads=2, src_seq_length=20, tgt_seq_length=10) +>>> encoder_input_value = Tensor(np.ones((2, 20, 64)), mstype.float32) +>>> decoder_input_value = Tensor(np.ones((2, 10, 64)), mstype.float32) +>>> decoder_input_mask = Tensor(np.ones((2, 10, 10)), mstype.float16) +>>> memory_mask = Tensor(np.ones((2, 10, 20)), mstype.float16) +>>> output, past = model(decoder_input_value, decoder_input_mask, encoder_input_value, memory_mask) +>>> print(output.shape) +(2, 10, 64) +>>> print(len(past)) +1 +>>> print(past[0][0].shape) +(2, 2, 32, 10) +>>> print(past[0][1].shape) +(2, 2, 10, 32) +>>> print(past[0][2].shape) +(2, 2, 32, 20) +>>> print(past[0][3].shape) +(2, 2, 20, 32) + + + + + +class mindspore.nn.transformer.TransformerEncoderLayer(batch_size, hidden_size, ffn_hidden_size, num_heads, seq_length, attention_dropout_rate=0.1, hidden_dropout_rate=0.1, post_layernorm_residual=False, layernorm_compute_type=mstype.float32, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, hidden_act=""gelu"", use_past=False, moe_config=default_moe_config, parallel_config=default_dpmp_config)[源代码]¶ +Transformer的编码器层。Transformer的编码器层上的单层的实现，包括多头注意力层和前馈层。 +参数： + +batch_size (int) - 表示输入Tensor的批次大小。 +hidden_size (int) - 表示输入的隐藏大小。 +seq_length (int) - 表示输入序列长度。 +ffn_hidden_size (int) - 表示前馈层中bottleneck的隐藏大小。 +num_heads (int) - 表示注意力头的数量。 +hidden_dropout_rate (float) - 表示作用在隐藏层输出的丢弃率。默认值：0.1 +attention_dropout_rate (float) - 表示注意力score的丢弃率。默认值：0.1 +post_layernorm_residual (bool) - 表示是否在LayerNorm之前使用残差，即是否选择残差为Post-LayerNorm或者Pre-LayerNorm。默认值：False +hidden_act (str) - 表示内部前馈层的激活函数。其值可为’relu’、’relu6’、’tanh’、’gelu’、’fast_gelu’、’elu’、’sigmoid’、’prelu’、’leakyrelu’、’hswish’、’hsigmoid’、’logsigmoid’等等。默认值：gelu。 +layernorm_compute_type (dtype.Number) - 表示LayerNorm的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +softmax_compute_type (dtype.Number) - 表示注意力中softmax的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +param_init_type (dtype.Number) - 表示模块的参数初始化类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +use_past (bool) - 使用过去状态进行计算，用于增量预测。例如，如果我们有两个单词，想生成十个或以上单词。我们只需要计算一次这两个单词的状态，然后逐个生成下一个单词。当use_past为True时，有两个步骤可以运行预测。第一步是通过 model.add_flags_recursive(is_first_iteration=True) 将is_first_iteration设为True，并传递完整的输入。然后，通过 model.add_flags_recursive(is_first_iteration=False) 将is_first_iteration设为False。此时，传递step的输入tensor，并对其进行环回。默认值：False +moe_config (MoEConfig) - 表示MoE (Mixture of Expert)的配置。默认值为 default_moe_config ，表示带有默认参数的 MoEConfig 实例。 +parallel_config (OpParallelConfig) - 表示并行配置。默认值为 default_dpmp_config ，表示一个带有默认参数的 OpParallelConfig 实例。 + +输入： + +x (Tensor) - Float Tensor。如果use_past为False或者is_first_iteration为True，shape应为[batch_size, seq_length, hidden_size]或者[batch_size * seq_length, hidden_size]。否则，shape应为[batch_size, 1, hidden_size]。 +input_mask (Tensor) - Float tensor。use_past为False或者is_first_iteration为True时，表示shape为[batch_size, seq_length, seq_length]的注意力掩码。否则，shape应为[batch_size, 1, hidden_size]。 +init_reset (Tensor) - shape为[1]的bool tensor，用于清除增量预测中使用的past key参数和past value参数。仅当use_past为True时有效。默认值为True。 +batch_valid_length (Tensor) - shape为[batch_size]的Int32 tensor，表示过去所计算的索引。当use_past为True时，它用于增量预测。默认值为None。 + +输出： +Tuple，表示一个包含(output, layer_present)的元组。 + +output (Tensor) - use_past为False或is_first_iteration为True时，表示shape为(batch_size, seq_length, hidden_size)或(batch_size * seq_length, hidden_size)的层输出的float tensor。否则，shape将为(batch_size, 1, hidden_size)。 +layer_present (Tuple) - 表示shape为((batch_size, num_heads, size_per_head, seq_length)或(batch_size, num_heads, seq_length, size_per_head))的投影key向量和value向量的Tensor的元组。 + +支持平台： +Ascend GPU +样例： +>>> import numpy as np +>>> from mindspore import dtype as mstype +>>> from mindspore.nn.transformer import TransformerEncoderLayer +>>> from mindspore import Tensor +>>> model = TransformerEncoderLayer(batch_size=2, hidden_size=8, ffn_hidden_size=64, seq_length=16, +... num_heads=2) +>>> encoder_input_value = Tensor(np.ones((2, 16, 8)), mstype.float32) +>>> encoder_input_mask = Tensor(np.ones((2, 16, 16)), mstype.float16) +>>> output, past = model(encoder_input_value, encoder_input_mask) +>>> print(output.shape) +(2, 16, 8) +>>> print(past[0].shape) +(2, 2, 4, 16) +>>> print(past[1].shape) +(2, 2, 16, 4) +>>> # When use use_past=True, it includes two steps to implement the incremental prediction. +>>> # Step 1: set is_first_iteration=True, and input the full sequence length's state. +>>> batch_valid_length = Tensor(np.ones((2,)), mstype.int32) +>>> init_reset = Tensor([True], mstype.bool_) +>>> # Set is_first_iteration=True to generate the full memory states +>>> model = TransformerEncoderLayer(batch_size=2, hidden_size=8, ffn_hidden_size=64, seq_length=16, +... num_heads=2, use_past=True) +>>> model.add_flags_recursive(is_first_iteration=True) +>>> hidden, past = model(encoder_input_value, encoder_input_mask, init_reset, batch_valid_length) +>>> print(hidden.shape) +(2, 16, 8) +>>> print(past[0].shape) +(2, 2, 4, 16) +>>> print(past[1].shape) +(2, 2, 16, 4) +>>> encoder_input_value = Tensor(np.ones((2, 1, 8)), mstype.float32) +>>> encoder_input_mask = Tensor(np.ones((2, 1, 16)), mstype.float16) +>>> init_reset = Tensor([False], mstype.bool_) +>>> # Step 2: set is_first_iteration=False, and pass the single word to run the prediction rather than +>>> # the full sequence. +>>> model.add_flags_recursive(is_first_iteration=False) +>>> hidden, past = model(encoder_input_value, encoder_input_mask, init_reset, batch_valid_length) +>>> print(hidden.shape) +(2, 1, 8) +>>> print(past[0].shape) +(2, 2, 4, 16) +>>> print(past[1].shape) +(2, 2, 16, 4) + + + + + +class mindspore.nn.transformer.TransformerDecoderLayer(hidden_size, ffn_hidden_size, num_heads, batch_size, src_seq_length, tgt_seq_length, attention_dropout_rate=0.1, hidden_dropout_rate=0.1, post_layernorm_residual=False, use_past=False, layernorm_compute_type=mstype.float32, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, hidden_act=""gelu"", moe_config=default_moe_config, parallel_config=default_dpmp_config)[源代码]¶ +Transformer的解码器层。Transformer的解码器层上的单层的实现，包括自注意力层、交叉注意力层和前馈层。当encoder_output为None时，交叉注意力将无效。 +参数： + +batch_size (int) - 表示输入Tensor的批次大小。 +hidden_size (int)：表示输入的隐藏大小。 +src_seq_length (int) - 表示输入源序列长度。 +tgt_seq_length (int) - 表示输入目标序列长度。 +ffn_hidden_size (int) - 表示前馈层中bottleneck的隐藏大小。 +num_heads (int) - 表示注意力头的数量。 +hidden_dropout_rate (float) - 表示作用在隐藏层输出的丢弃率。默认值：0.1 +attention_dropout_rate (float) - 表示注意力score的丢弃率。默认值：0.1 +post_layernorm_residual (bool) - 表示是否在LayerNorm之前使用残差，即是否选择残差为Post-LayerNorm或者Pre-LayerNorm。默认值：False +hidden_act (str) - 表示内部前馈层的激活函数。其值可为’relu’、’relu6’、’tanh’、’gelu’、’fast_gelu’、’elu’、’sigmoid’、’prelu’、’leakyrelu’、’hswish’、’hsigmoid’、’logsigmoid’等等。默认值：gelu。 +layernorm_compute_type (dtype.Number) - 表示LayerNorm的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +softmax_compute_type (dtype.Number) - 表示注意力中softmax的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +param_init_type (dtype.Number) - 表示模块的参数初始化类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +use_past (bool) - 使用过去状态进行计算，用于增量预测。默认值：False。 +moe_config (MoEConfig) - 表示MoE (Mixture of Expert)的配置。默认值为 default_moe_config ，表示带有默认参数的 MoEConfig 实例。 +parallel_config (OpParallelConfig) - 表示并行配置。默认值为 default_dpmp_config ，表示一个带有默认参数的 OpParallelConfig 实例。 + +输入： + +hidden_stats (Tensor) - shape为[batch_size, tgt_seq_length, hidden_size]或[batch_size * tgt_seq_length, hidden_size]的输入tensor。 +decoder_mask (Tensor) - shape为[batch_size, src_seq_length, seq_length]的解码器的注意力掩码。 +encoder_output (Tensor) - shape为[batch_size, seq_length, hidden_size]或[batch_size * seq_length, hidden_size]的编码器的输出。注：当网络位于最外层时，此参数不能通过None传递。默认值为None。 +memory_mask (Tensor) - shape为[batch, tgt_seq_length, src_seq_length]的交叉注意力的memory掩码，其中tgt_seq_length表示解码器的长度。注：当网络位于最外层时，此参数不能通过None传递。默认值为None。 +init_reset (Tensor) - shape为[1]的bool tensor，用于清除增量预测中使用的past key参数和past value参数。仅当use_past为True时有效。默认值为True。 +batch_valid_length (Tensor) - shape为[batch_size]的Int32 tensor，表示过去所计算的索引。当use_past为True时，它用于增量预测。默认值为None。 + +输出： +Tuple，表示一个包含(output, layer_present)的元组。 + +output (Tensor) - 此层的输出logit。shape为[batch, seq_length, hidden_size]或[batch * seq_length, hidden_size]。 +layer_present (Tuple) - 元组，其中每个元组都是shape为((batch_size, num_heads, size_per_head, tgt_seq_length)或(batch_size, num_heads, tgt_seq_length, size_per_head)的自注意力中的投影key向量和value向量的tensor的元组，或者是shape为(batch_size, num_heads, size_per_head, src_seq_length)或(batch_size, num_heads, src_seq_length, size_per_head))的交叉注意力中的投影key向量和value向量的tensor的元组。 + +支持平台： +Ascend GPU +样例： +>>> import numpy as np +>>> from mindspore import dtype as mstype +>>> from mindspore.nn.transformer import TransformerDecoderLayer +>>> from mindspore import Tensor +>>> model = TransformerDecoderLayer(batch_size=2, hidden_size=64, ffn_hidden_size=64, num_heads=2, +... src_seq_length=20, tgt_seq_length=10) +>>> encoder_input_value = Tensor(np.ones((2, 20, 64)), mstype.float32) +>>> decoder_input_value = Tensor(np.ones((2, 10, 64)), mstype.float32) +>>> decoder_input_mask = Tensor(np.ones((2, 10, 10)), mstype.float16) +>>> memory_mask = Tensor(np.ones((2, 10, 20)), mstype.float16) +>>> output, past = model(decoder_input_value, decoder_input_mask, encoder_input_value, memory_mask) +>>> print(output.shape) +(2, 10, 64) +>>> print(past[0].shape) +(2, 2, 32, 10) +>>> print(past[1].shape) +(2, 2, 10, 32) +>>> print(past[2].shape) +(2, 2, 32, 20) +>>> print(past[3].shape) +(2, 2, 20, 32) + + + + + +class mindspore.nn.transformer.Transformer(hidden_size, batch_size, ffn_hidden_size, src_seq_length, tgt_seq_length, encoder_layers=3, decoder_layers=3, num_heads=2, attention_dropout_rate=0.1, hidden_dropout_rate=0.1, hidden_act=""gelu"", post_layernorm_residual=False, layernorm_compute_type=mstype.float32, softmax_compute_type=mstype.float32, param_init_type=mstype.float32, lambda_func=None, use_past=False, moe_config=default_moe_config, parallel_config=default_transformer_config)[源代码]¶ +Transformer模块，包括编码器和解码器。与原始的实现方式的区别在于该模块在实行层归一化之前使用了残差加法。默认的激活层为 gelu 。 +详细信息可参考 Attention Is All You Need 。 + +Note +这是一个实验接口，可能会被更改或者删除。 + +参数： + +batch_size (int) - 表示输入的批次大小。 +encoder_layers (int) - 表示 TransformerEncoderLayer 的层数。 +decoder_layers (int) - 表示 TransformerDecoderLayer 的层数。 +hidden_size (int) - 表示输入向量的大小。 +ffn_hidden_size (int) - 表示前馈层中bottleneck的隐藏大小。 +src_seq_length (int) - 表示编码器的输入Tensor的seq_length。 +tgt_seq_length (int) - 表示解码器的输入Tensor的seq_length。 +num_heads (int) - 表示注意力头的数量。默认值：2 +hidden_dropout_rate (float) - 表示作用在隐藏层输出的丢弃率。默认值：0.1 +attention_dropout_rate (float) - 表示注意力score的丢弃率。默认值：0.1 +post_layernorm_residual (bool) - 表示是否在LayerNorm之前使用残差，即是否选择残差为Post-LayerNorm或者Pre-LayerNorm。默认值：False +use_past (bool) - 表示是否开启增量推理。在推理中会缓存注意力机制计算结果，避免冗余计算。默认值为False。 +layernorm_compute_type (dtype.Number) - 表示LayerNorm的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +softmax_compute_type (dtype.Number) - 表示注意力机制中softmax的计算类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +param_init_type (dtype.Number) - 表示模块的参数初始化类型。其值应为mstype.float32或mstype.float16。默认值为mstype.float32。 +hidden_act (str) - 表示前馈层的激活行为。其值可为’relu’、’relu6’、’tanh’、’gelu’、’fast_gelu’、’elu’、’sigmoid’、’prelu’、’leakyrelu’、’hswish’、’hsigmoid’、’logsigmoid’等等。默认值：gelu。 +moe_config (MoEConfig) - 表示MoE (Mixture of Expert)的配置。默认值为 default_moe_config ，表示带有默认参数的 MoEConfig 实例。 +lambda_func - 表示设置融合索引、pipeline阶段和重计算属性的函数。如果用户想确定pipeline阶段和梯度融合，用户可以传递一个接受 network 、 layer_id 、 offset 、 parallel_config 和 layers 的函数。 network(Cell) 表示transformer块， layer_id(int) 表示当前模块的层索引，从零开始计数， offset(int) 表示如果网络中还有其他模块，则layer_id需要一个偏移。pipeline的默认设置为： (layer_id + offset) // ((encoder_layers + decoder_length) / pipeline_stage) 。默认值为None。 +parallel_config (TransformerOpParallelConfig) - 表示并行配置。默认值为 default_transformer_config ，表示带有默认参数的 TransformerOpParallelConfig 实例。 + +输入： + +encoder_inputs (Tensor) - shape为[batch_size, seq_length, hidden_size]或[batch_size * seq_length, hidden_size]的输入Tensor。 +encoder_masks (Tensor) - shape为[batch_size, seq_length, seq_length]的解码器的注意力掩码。 +decoder_inputs (Tensor) - shape为[batch_size, seq_length, hidden_size]或[batch_size * seq_length, hidden_size]的编码器的输出。如果解码器层数为0，则此值应为None。 +decoder_masks (Tensor) - shape为[batch_size, seq_length, seq_length]的解码器的注意力掩码。 +memory_mask (Tensor) - shape为[batch, tgt_seq_length, src_seq_length]的交叉注意力的memory掩码，其中tgt_seq_length表示解码器的长度。如果解码器层为0，则shape为[batch_size, seq_length, hidden_size]的编码器的输出应为None。 +init_reset (Tensor) - shape为[1]的bool tensor，用于清除增量预测中使用的past key参数和past value参数。仅当use_past为True时有效。默认值为True。 +batch_valid_length (Tensor) - shape为[batch_size]的Int32 tensor，表示过去所计算的索引。当use_past为True时，它用于增量预测。默认值为None。 + +输出： +Tuple，表示包含(output, encoder_layer_present, encoder_layer_present, accum_loss)的元组。 + +output (Tensor) - 如果只有编码器，则表示编码器层的输出logit。shape为[batch, src_seq_length, hidden_size] or [batch * src_seq_length, hidden_size]。如果有编码器和解码器，则输出来自于解码器层。shape为[batch, tgt_seq_length, hidden_size]或[batch * tgt_seq_length, hidden_size]。 +encoder_layer_present (Tuple) - 大小为num_layers的元组，其中每个元组都是shape为((batch_size, num_heads, size_per_head, src_seq_length)或(batch_size, num_heads, src_seq_length, size_per_head))的自注意力中的投影key向量和value向量的tensor的元组。 +decoder_layer_present (Tuple) - 大小为num_layers的元组，其中每个元组都是shape为((batch_size, num_heads, size_per_head, tgt_seq_length)或(batch_size, num_heads, tgt_seq_length, size_per_head))的自注意力中的投影key向量和value向量的tensor的元组，或者是shape为(batch_size, num_heads, size_per_head, src_seq_length)或(batch_size, num_heads, src_seq_length, size_per_head))的交叉注意力中的投影key向量和value向量的tensor的元组。如果未设置解码器，返回值将为None。 +accum_loss (Tensor) - 表示一个辅助损失来最小化路由到每个专家的数据部分的均方，且仅仅在专家数大于1时才会返回。 + +支持平台： +Ascend GPU +样例： +>>> import numpy as np +>>> from mindspore import dtype as mstype +>>> from mindspore.nn.transformer import Transformer +>>> from mindspore import Tensor +>>> model = Transformer(batch_size=2, encoder_layers=1, decoder_layers=2, hidden_size=64, +... ffn_hidden_size=64, src_seq_length=20, tgt_seq_length=10) +>>> encoder_input_value = Tensor(np.ones((2, 20, 64)), mstype.float32) +>>> encoder_input_mask = Tensor(np.ones((2, 20, 20)), mstype.float16) +>>> decoder_input_value = Tensor(np.ones((2, 10, 64)), mstype.float32) +>>> decoder_input_mask = Tensor(np.ones((2, 10, 10)), mstype.float16) +>>> memory_mask = Tensor(np.ones((2, 10, 20)), mstype.float16) +>>> output, en_past, de_past = model(encoder_input_value, encoder_input_mask, decoder_input_value, +... decoder_input_mask, memory_mask) +>>> print(output.shape) +(2, 10, 64) +>>> print(len(en_past)) +1 +>>> print(len(de_past)) +2 +>>> print(en_past[0][0].shape) +(2, 2, 32, 20) +>>> print(en_past[0][1].shape) +(2, 2, 20, 32) +>>> print(de_past[0][0].shape) +(2, 2, 32, 10) +>>> print(de_past[0][1].shape) +(2, 2, 10, 32) +>>> print(de_past[0][2].shape) +(2, 2, 32, 20) +>>> print(de_past[0][3].shape) +(2, 2, 20, 32) + + + + + +class mindspore.nn.transformer.TransformerOpParallelConfig(data_parallel=1, model_parallel=1, expert_parallel=1, pipeline_stage=1, micro_batch_num=1, recompute=default_transformer_recompute_config, optimizer_shard=False, gradient_aggregation_group=4, vocab_emb_dp=True)[源代码]¶ +用于设置数据并行、模型并行等等并行配置的TransformerOpParallelConfig。 + +Note +除recompute参数外，当用户未将auto_parallel_context设为 SEMI_AUTO_PARALLEL 或 AUTO_PARALLEL 时，其他参数将无效。 +在训练时，micro_batch_num的值必须大于或等于equal to pipeline_stage的值。data_parallel*model_parallel *pipeline_stage的值必须等于或小于总设备的数量。设置pipeline_stage和optimizer_shard时，其配置将覆盖auto_parallel_context的配置。 + +参数： + +data_parallel (int) - 表示数据并行数。默认值：1。 +model_parallel (int) - 表示模型并行数。默认值：1。 +expert_parallel (int) - 表示专家并行数，只有在应用混合专家结构（MoE，Mixture of Experts）时才会生效。默认值：1. +pipeline_stage (int) - 表示将Transformer切分成的stage数目。其值应为正数。默认值：1。 +micro_batch_num (int) - 表示用于pipeline训练的batch的微型大小。默认值：1。 +optimizer_shard (bool) - 表示是否使能优化器切分。默认值：False。 +gradient_aggregation_group (int) - 表示优化器切分的融合组大小。默认值：4。 +recompute (bool) - 表示是否启用transformer每层的的重计算。默认值：一个按默认参数初始化的 TransformerRecomputeConfig 实例。 +vocab_emb_dp (bool) - 表示Embedding表是否为数据并行，否则将在查找表中的第0维度根据模型并行度进行切分。默认值：True。 + +支持平台： +Ascend GPU +样例： +>>> from mindspore.nn.transformer import TransformerRecomputeConfig +>>> recompute_config=TransformerRecomputeConfig(recompute=True, parallel_optimizer_comm_recompute=True, \ +... mp_comm_recompute=True, recompute_slice_activation=True) +>>> config=TransformerOpParallelConfig(data_parallel=1, model_parallel=1, recompute=recompute_config) + + + + +dp_mp_config()¶ +获取包含数据并行、模型并行度的DPMPlConfig。 + + + +embedding_dp_mp_config()¶ +获取包含数据并行、模型并行和embedding并行度的EmbeddingParallelConfig。 + + + + +class mindspore.nn.transformer.EmbeddingOpParallelConfig(data_parallel=1, model_parallel=1, vocab_emb_dp=True)[源代码]¶ +VocabEmbedding 类中的并行配置。当vocab_emb_dp为True时，设置Embedding查找为数据并行，其中model_parallel参数会被忽略。当vocab_emb_dp为False时，在Embedding表的第0轴进行按model_parallel的大小进行切分。 +参数： + +data_parallel (int) - 表示数据并行度。默认值：1。 +model_parallel (int) - 表示模型平行度。默认值：1。 +vocab_emb_dp (bool) - 表示模型并行或数据并行中的Shard embedding。默认值：True。 + +支持平台： +Ascend GPU +样例： +>>> from mindspore.nn.transformer import EmbeddingOpParallelConfig +>>> config=EmbeddingOpParallelConfig(data_parallel=1, model_parallel=1, vocab_emb_dp=True) + + + + +dp_mp_config()¶ +获取包含有data_parallel和model_parallel属性的DPMPlConfig类。 + + + + +class mindspore.nn.transformer.TransformerRecomputeConfig(recompute=False, parallel_optimizer_comm_recompute=False, mp_comm_recompute=True, recompute_slice_activation=False)[源代码]¶ +Transformer的重计算配置接口。 +参数： + +recompute (bool) - 是否使能重计算。默认值为False。 +parallel_optimizer_comm_recompute (bool) - 指定由优化器切分产生的AllGather算子是否进行重计算。默认值为False。 +mp_comm_recompute (bool) - 指定由模型并行成分产生的通信算子是否进行重计算。默认值为True。 +recompute_slice_activation (bool) - 指定激活层是否切片保存。默认值为False。 + +支持平台： +Ascend GPU +样例： +>>> from mindspore.nn.transformer import TransformerRecomputeConfig +>>> config=TransformerRecomputeConfig(recompute=True, parallel_optimizer_comm_recompute=True, \ +... mp_comm_recompute=True, recompute_slice_activation=True) + + + + + +class mindspore.nn.transformer.CrossEntropyLoss(parallel_config=default_dpmp_config)[源代码]¶ +计算输入和输出之间的交叉熵损失。 +参数： + +parallel_config (OpParallelConfig, MoEParallelConfig) - 表示并行配置。默认值为 default_dpmp_config ，表示一个带有默认参数的 OpParallelConfig 实例。 + +输入： + +logits (Tensor) - shape为(N, C)的Tensor。表示的输出logits。其中N表示任意大小的维度，C表示类别个数。数据类型必须为float16或float32。 +labels (Tensor) - shape为(N, )的Tensor。表示样本的真实标签，其中每个元素的取值区间为[0,C)。 +input_mask (Tensor) - shape为(N, )的Tensor。input_mask表示是否有填充输入。1表示有效，0表示无效，其中元素值为0的位置不会计算进损失值。 + +输出： +Tensor，表示对应的交叉熵损失。 +样例： +>>> import numpy as np +>>> from mindspore import dtype as mstype +>>> from mindspore.nn.transformer import CrossEntropyLoss +>>> from mindspore import Tensor +>>> loss = CrossEntropyLoss() +>>> logits = Tensor(np.array([[3, 5, 6, 9, 12, 33, 42, 12, 32, 72]]), mstype.float32) +>>> labels_np = np.array([1]).astype(np.int32) +>>> input_mask = Tensor(np.ones(1).astype(np.float32)) +>>> labels = Tensor(labels_np) +>>> output = loss(logits, labels, input_mask) +>>> print(output.shape) +(1,) + + + + + +class mindspore.nn.transformer.OpParallelConfig(data_parallel=1, model_parallel=1)[源代码]¶ +用于设置数据并行和模型并行的OpParallelConfig。 +参数： + +data_parallel (int) - 表示数据并行度。默认值：1 +model_parallel (int) - 表示模型并行度。默认值：1 + +支持平台： +Ascend GPU +样例： +>>> from mindspore.nn.transformer import OpParallelConfig +>>> config=OpParallelConfig(data_parallel=1, model_parallel=1) + + + + + +class mindspore.nn.transformer.FixedSparseAttention(batch_size, num_heads, size_per_head, block_size, seq_length=1024, num_different_global_patterns=4, parallel_config=default_dpmp_config)[源代码]¶ +固定稀疏注意力层。 +此接口实现了Sparse Transformer中使用的稀疏注意力原语。更多详情，请见论文（https://arxiv.org/abs/1904.10509）。 +具体来说，它包括以下内容： + +正常注意力的更快实现（不计算上三角，并且融合了许多操作）。 +如论文Sparse Transformers所述，“分散”和“固定”注意力的实现。 + +参数： + +batch_size (int) - 表示输入batch size的数量。 +num_heads (int) - 表示注意力头数。 +block_size (int) - 表示用来确定block size的整数。目前稀疏自注意力的实现基于稀疏块矩阵。此参数定义了稀疏矩阵块的大小。目前仅支持64。 +seq_length (int) - 表示输入序列的长度。目前只支持1024。默认值为1024。 +num_different_global_patterns (int) - 表示用于确定不同的全局注意力数量。虽然全局注意力由局部的代表性的块决定， +但由于有多个头，所以每个头都可以使用不同的全局代表。目前只支持4。默认值为4。 +size_per_head (int) - 表示每个注意力头的向量大小。目前仅支持64和128。 +parallel_config (OpParallelConfig) - 并行设置，内容请参阅 OpParallelConfig 的定义。默认值为 default_dpmp_config ，一个用默认参数初始化的 OpParallelConfig 的实例。 + +输入： + +q (Tensor) - Tensor query (mstype.fp16 [batch_size, seq_length, hidden_size])：表示上下文的query向量。 +k (Tensor) - Tensor key (mstype.fp16 [batch_size, seq_length, hidden_size])：表示上下文的key向量。 +v (Tensor) - Tensor value (mstype.fp16 [批次大小, seq_length, hidden_size])：表示上下文的value向量。 +attention_mask (Tensor) - Float Tensor the mask of (mstype.fp32 , mstype.fp16 [batch_size, seq_length, seq_length])： +表示掩码的下三角形矩阵。 + +输出： +Tensor，shape为[batch_size, seq_length, hidden_size]。 +支持平台： +Ascend +样例： +>>> import numpy as np +>>> from mindspore import dtype as mstype +>>> from mindspore.nn.transformer import FixedSparseAttention +>>> from mindspore import Tensor +>>> model = FixedSparseAttention(batch_size=2, +... num_heads=8, +... size_per_head=64, +... block_size=64) +>>> q = Tensor(np.ones((2, 1024, 8*64)), mstype.float16) +>>> k = Tensor(np.ones((2, 1024, 8*64)), mstype.float16) +>>> v = Tensor(np.ones((2, 1024, 8*64)), mstype.float16) +>>> attention_mask = Tensor(np.ones((2, 1024, 1024)), mstype.float32) +>>> output = model(q, k, v, attention_mask) +>>> print(output.shape) +(2, 1024, 512) + + + + + +class mindspore.nn.transformer.MoEConfig(expert_num=1, capacity_factor=1.1, aux_loss_factor=0.05, num_experts_chosen=1, expert_group_size=None)[源代码]¶ +MoE (Mixture of Expert)的配置。 +参数： + +expert_num (int) - 表示使用的专家数量。默认值：1。 +capacity_factor (float) - 表示专家处理的容量关系，其值大于等于1.0。默认值：1.1。 +aux_loss_factor (float) - 表示负载均衡损失（由路由器产生）的平衡系数。相乘的结果会加到总损失函数中。此系数的值小于1.0。默认值：0.05。 +num_experts_chosen (int) - 表示每个标识选择的专家数量，其值小于等于专家数量。默认值：1。 +expert_group_size (int) - 表示每个数据并行组收到的词语（token）数量。默认值：None。该参数只在自动并行且非策略传播模式下起作用。 + +支持平台： +Ascend +样例： +>>> from mindspore.nn.transformer import MoEConfig +>>> moe_config = MoEConfig(expert_num=4, capacity_factor=5.0, aux_loss_factor=0.05, num_experts_chosen=1, +... expert_group_size=64) + + + +",mindspore.nn.transformer,mindspore、mindspore、接口、GPU、CPU、Ascend +mindspore.numpy§mindspore.numpy,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.numpy.html," +MindSpore NumPy工具包提供了一系列类NumPy接口。用户可以使用类NumPy语法在MindSpore上进行模型的搭建。 +MindSpore Numpy具有四大功能模块：Array生成、Array操作、逻辑运算和数学运算。 +在API示例中，常用的模块导入方法如下： +import mindspore.numpy as np + + + +Note +MindSpore numpy通过组装底层算子来提供与numpy一致的编程体验接口，方便开发人员使用和代码移植。相比于MindSpore的functional和ops接口，与原始numpy的接口格式及行为一致性更好，以便于用户理解和使用。注意：由于兼容numpy的考虑，部分接口的性能可能弱于functional和ops接口。使用者可以按需选择不同类型的接口。 + + +",mindspore.numpy,mindspore、mindspore、算子、接口、API、性能 +mindspore.numpy§Array生成,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.numpy.html," +生成类算子用来生成和构建具有指定数值、类型和形状的数组(Tensor)。 +构建数组代码示例： +import mindspore.numpy as np +import mindspore.ops as ops +input_x = np.array([1, 2, 3], np.float32) +print(""input_x ="", input_x) +print(""type of input_x ="", ops.typeof(input_x)) + + +运行结果如下： +input_x = [1. 2. 3.] +type of input_x = Tensor[Float32] + + +除了使用上述方法来创建外，也可以通过以下几种方式创建。 + +生成具有相同元素的数组 +生成具有相同元素的数组代码示例： +input_x = np.full((2, 3), 6, np.float32) +print(input_x) + + +运行结果如下： +[[6. 6. 6.] + [6. 6. 6.]] + + +生成指定形状的全1数组，示例： +input_x = np.ones((2, 3), np.float32) +print(input_x) + + +运行结果如下： +[[1. 1. 1.] + [1. 1. 1.]] + + + +生成具有某个范围内的数值的数组 +生成指定范围内的等差数组代码示例： +input_x = np.arange(0, 5, 1) +print(input_x) + + +运行结果如下： +[0 1 2 3 4] + + + +生成特殊类型的数组 +生成给定对角线处下方元素为1，上方元素为0的矩阵，示例： +input_x = np.tri(3, 3, 1) +print(input_x) + + +运行结果如下： +[[1. 1. 0.] + [1. 1. 1.] + [1. 1. 1.]] + + +生成对角线为1，其他元素为0的二维矩阵，示例： +input_x = np.eye(2, 2) +print(input_x) + + +运行结果如下： +[[1. 0.] + [0. 1.]] + + + + + + + + + + + +API Name +Description +Supported Platforms + +mindspore.numpy.arange +Returns evenly spaced values within a given interval. +Ascend GPU CPU + +mindspore.numpy.array +Creates a tensor. +Ascend GPU CPU + +mindspore.numpy.asarray +Converts the input to tensor. +Ascend GPU CPU + +mindspore.numpy.asfarray +Similar to asarray, converts the input to a float tensor. +Ascend GPU CPU + +mindspore.numpy.bartlett +Returns the Bartlett window. +Ascend GPU CPU + +mindspore.numpy.blackman +Returns the Blackman window. +Ascend GPU CPU + +mindspore.numpy.copy +Returns a tensor copy of the given object. +Ascend GPU CPU + +mindspore.numpy.diag +Extracts a diagonal or construct a diagonal array. +Ascend GPU CPU + +mindspore.numpy.diag_indices +Returns the indices to access the main diagonal of an array. +Ascend GPU CPU + +mindspore.numpy.diagflat +Creates a two-dimensional array with the flattened input as a diagonal. +Ascend GPU CPU + +mindspore.numpy.diagonal +Returns specified diagonals. +Ascend GPU CPU + +mindspore.numpy.empty +Returns a new array of given shape and type, without initializing entries. +Ascend GPU CPU + +mindspore.numpy.empty_like +Returns a new array with the same shape and type as a given array. +Ascend GPU CPU + +mindspore.numpy.eye +Returns a 2-D tensor with ones on the diagonal and zeros elsewhere. +Ascend GPU CPU + +mindspore.numpy.full +Returns a new tensor of given shape and type, filled with fill_value. +Ascend GPU CPU + +mindspore.numpy.full_like +Returns a full array with the same shape and type as a given array. +Ascend GPU CPU + +mindspore.numpy.geomspace +Returns numbers spaced evenly on a log scale (a geometric progression). +Ascend GPU CPU + +mindspore.numpy.hamming +Returns the Hamming window. +Ascend GPU CPU + +mindspore.numpy.hanning +Returns the Hanning window. +Ascend GPU CPU + +mindspore.numpy.histogram_bin_edges +Function to calculate only the edges of the bins used by the histogram function. +Ascend GPU CPU + +mindspore.numpy.identity +Returns the identity tensor. +Ascend GPU CPU + +mindspore.numpy.indices +Returns an array representing the indices of a grid. +Ascend GPU CPU + +mindspore.numpy.ix_ +Constructs an open mesh from multiple sequences. +Ascend GPU CPU + +mindspore.numpy.linspace +Returns evenly spaced values within a given interval. +Ascend GPU CPU + +mindspore.numpy.logspace +Returns numbers spaced evenly on a log scale. +Ascend GPU CPU + +mindspore.numpy.meshgrid +Returns coordinate matrices from coordinate vectors. +Ascend GPU CPU + +mindspore.numpy.mgrid +mgrid is an NdGrid instance with sparse=False. +Ascend GPU CPU + +mindspore.numpy.ogrid +ogrid is an NdGrid instance with sparse=True. +Ascend GPU CPU + +mindspore.numpy.ones +Returns a new tensor of given shape and type, filled with ones. +Ascend GPU CPU + +mindspore.numpy.ones_like +Returns an array of ones with the same shape and type as a given array. +Ascend GPU CPU + +mindspore.numpy.pad +Pads an array. +Ascend GPU CPU + +mindspore.numpy.rand +Returns a new Tensor with given shape and dtype, filled with random numbers from the uniform distribution on the interval \([0, 1)\). +Ascend GPU CPU + +mindspore.numpy.randint +Return random integers from minval (inclusive) to maxval (exclusive). +Ascend GPU CPU + +mindspore.numpy.randn +Returns a new Tensor with given shape and dtype, filled with a sample (or samples) from the standard normal distribution. +Ascend GPU CPU + +mindspore.numpy.trace +Returns the sum along diagonals of the array. +Ascend GPU CPU + +mindspore.numpy.tri +Returns a tensor with ones at and below the given diagonal and zeros elsewhere. +Ascend GPU CPU + +mindspore.numpy.tril +Returns a lower triangle of a tensor. +Ascend GPU CPU + +mindspore.numpy.tril_indices +Returns the indices for the lower-triangle of an (n, m) array. +Ascend GPU CPU + +mindspore.numpy.tril_indices_from +Returns the indices for the lower-triangle of arr. +Ascend GPU CPU + +mindspore.numpy.triu +Returns an upper triangle of a tensor. +Ascend GPU CPU + +mindspore.numpy.triu_indices +Returns the indices for the upper-triangle of an (n, m) array. +Ascend GPU CPU + +mindspore.numpy.triu_indices_from +Returns the indices for the upper-triangle of arr. +Ascend GPU CPU + +mindspore.numpy.vander +Generates a Vandermonde matrix. +Ascend GPU CPU + +mindspore.numpy.zeros +Returns a new tensor of given shape and type, filled with zeros. +Ascend GPU CPU + +mindspore.numpy.zeros_like +Returns an array of zeros with the same shape and type as a given array. +Ascend GPU CPU + + + +",mindspore.numpy,mindspore、mindspore、算子、GPU、CPU、Ascend、API、metric、ib、npu +mindspore.numpy§Array操作,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.numpy.html," +操作类算子主要进行数组的维度变换，分割和拼接等。 + +数组维度变换 +矩阵转置，代码示例： +input_x = np.arange(10).reshape(5, 2) +output = np.transpose(input_x) +print(output) + + +运行结果如下： +[[0 2 4 6 8] + [1 3 5 7 9]] + + +交换指定轴，代码示例： +input_x = np.ones((1, 2, 3)) +output = np.swapaxes(input_x, 0, 1) +print(output.shape) + + +运行结果如下： +(2, 1, 3) + + + +数组分割 +将输入数组平均切分为多个数组，代码示例： +input_x = np.arange(9) +output = np.split(input_x, 3) +print(output) + + +运行结果如下： +(Tensor(shape=[3], dtype=Int32, value= [0, 1, 2]), Tensor(shape=[3], dtype=Int32, value= [3, 4, 5]), Tensor(shape=[3], dtype=Int32, value= [6, 7, 8])) + + + +数组拼接 +将两个数组按照指定轴进行拼接，代码示例： +input_x = np.arange(0, 5) +input_y = np.arange(10, 15) +output = np.concatenate((input_x, input_y), axis=0) +print(output) + + +运行结果如下： +[ 0 1 2 3 4 10 11 12 13 14] + + + + + + + + + + + +API Name +Description +Supported Platforms + +mindspore.numpy.append +Appends values to the end of a tensor. +Ascend GPU CPU + +mindspore.numpy.apply_along_axis +Applies a function to 1-D slices along the given axis. +Ascend GPU CPU + +mindspore.numpy.apply_over_axes +Applies a function repeatedly over multiple axes. +Ascend GPU CPU + +mindspore.numpy.array_split +Splits a tensor into multiple sub-tensors. +Ascend GPU CPU + +mindspore.numpy.array_str +Returns a string representation of the data in an array. +Ascend GPU CPU + +mindspore.numpy.atleast_1d +Converts inputs to arrays with at least one dimension. +Ascend GPU CPU + +mindspore.numpy.atleast_2d +Reshapes inputs as arrays with at least two dimensions. +Ascend GPU CPU + +mindspore.numpy.atleast_3d +Reshapes inputs as arrays with at least three dimensions. +Ascend GPU CPU + +mindspore.numpy.broadcast_arrays +Broadcasts any number of arrays against each other. +Ascend GPU CPU + +mindspore.numpy.broadcast_to +Broadcasts an array to a new shape. +Ascend GPU CPU + +mindspore.numpy.choose +Construct an array from an index array and a list of arrays to choose from. +Ascend GPU CPU + +mindspore.numpy.column_stack +Stacks 1-D tensors as columns into a 2-D tensor. +Ascend GPU CPU + +mindspore.numpy.concatenate +Joins a sequence of tensors along an existing axis. +Ascend GPU CPU + +mindspore.numpy.dsplit +Splits a tensor into multiple sub-tensors along the 3rd axis (depth). +Ascend GPU CPU + +mindspore.numpy.dstack +Stacks tensors in sequence depth wise (along the third axis). +Ascend GPU CPU + +mindspore.numpy.expand_dims +Expands the shape of a tensor. +Ascend GPU CPU + +mindspore.numpy.flip +Reverses the order of elements in an array along the given axis. +GPU CPU + +mindspore.numpy.fliplr +Flips the entries in each row in the left/right direction. +GPU CPU + +mindspore.numpy.flipud +Flips the entries in each column in the up/down direction. +GPU CPU + +mindspore.numpy.hsplit +Splits a tensor into multiple sub-tensors horizontally (column-wise). +Ascend GPU CPU + +mindspore.numpy.hstack +Stacks tensors in sequence horizontally. +Ascend GPU CPU + +mindspore.numpy.moveaxis +Moves axes of an array to new positions. +Ascend GPU CPU + +mindspore.numpy.piecewise +Evaluates a piecewise-defined function. +Ascend GPU CPU + +mindspore.numpy.ravel +Returns a contiguous flattened tensor. +Ascend GPU CPU + +mindspore.numpy.repeat +Repeats elements of an array. +Ascend GPU CPU + +mindspore.numpy.reshape +Reshapes a tensor without changing its data. +Ascend GPU CPU + +mindspore.numpy.roll +Rolls a tensor along given axes. +Ascend GPU CPU + +mindspore.numpy.rollaxis +Rolls the specified axis backwards, until it lies in the given position. +Ascend GPU CPU + +mindspore.numpy.rot90 +Rotates a tensor by 90 degrees in the plane specified by axes. +GPU + +mindspore.numpy.select +Returns an array drawn from elements in choicelist, depending on conditions. +Ascend GPU CPU + +mindspore.numpy.size +Returns the number of elements along a given axis. +Ascend GPU CPU + +mindspore.numpy.split +Splits a tensor into multiple sub-tensors along the given axis. +Ascend GPU CPU + +mindspore.numpy.squeeze +Removes single-dimensional entries from the shape of a tensor. +Ascend GPU CPU + +mindspore.numpy.stack +Joins a sequence of arrays along a new axis. +Ascend GPU CPU + +mindspore.numpy.swapaxes +Interchanges two axes of a tensor. +Ascend GPU CPU + +mindspore.numpy.take +Takes elements from an array along an axis. +Ascend GPU CPU + +mindspore.numpy.take_along_axis +Takes values from the input array by matching 1d index and data slices. +Ascend GPU CPU + +mindspore.numpy.tile +Constructs an array by repeating a the number of times given by reps. +Ascend GPU CPU + +mindspore.numpy.transpose +Reverses or permutes the axes of a tensor; returns the modified tensor. +Ascend GPU CPU + +mindspore.numpy.unique +Finds the unique elements of a tensor. +Ascend GPU CPU + +mindspore.numpy.unravel_index +Converts a flat index or array of flat indices into a tuple of coordinate arrays. +Ascend GPU CPU + +mindspore.numpy.vsplit +Splits a tensor into multiple sub-tensors vertically (row-wise). +Ascend GPU CPU + +mindspore.numpy.vstack +Stacks tensors in sequence vertically. +Ascend GPU CPU + +mindspore.numpy.where +Returns elements chosen from x or y depending on condition. +Ascend GPU CPU + + + +",mindspore.numpy,mindspore、mindspore、算子、GPU、CPU、Ascend、API、ast、lr、aten、Eval、npu +mindspore.numpy§逻辑运算,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.numpy.html," +逻辑运算类算子主要进行各类逻辑相关的运算。 +相等（equal）和小于（less）计算代码示例如下： +input_x = np.arange(0, 5) +input_y = np.arange(0, 10, 2) +output = np.equal(input_x, input_y) +print(""output of equal:"", output) +output = np.less(input_x, input_y) +print(""output of less:"", output) + + +运行结果如下： +output of equal: [ True False False False False] +output of less: [False True True True True] + + + + + + + + + +API Name +Description +Supported Platforms + +mindspore.numpy.array_equal +Returns True if input arrays have same shapes and all elements equal. +GPU CPU Ascend + +mindspore.numpy.array_equiv +Returns True if input arrays are shape consistent and all elements equal. +Ascend GPU CPU + +mindspore.numpy.equal +Returns the truth value of (x1 == x2) element-wise. +Ascend GPU CPU + +mindspore.numpy.greater +Returns the truth value of (x1 > x2) element-wise. +Ascend GPU CPU + +mindspore.numpy.greater_equal +Returns the truth value of (x1 >= x2) element-wise. +Ascend GPU CPU + +mindspore.numpy.in1d +Tests whether each element of a 1-D array is also present in a second array. +Ascend GPU CPU + +mindspore.numpy.isclose +Returns a boolean tensor where two tensors are element-wise equal within a tolerance. +Ascend GPU CPU + +mindspore.numpy.isfinite +Tests element-wise for finiteness (not infinity or not Not a Number). +Ascend GPU CPU + +mindspore.numpy.isin +Calculates element in test_elements, broadcasting over element only. +Ascend GPU CPU + +mindspore.numpy.isinf +Tests element-wise for positive or negative infinity. +GPU CPU + +mindspore.numpy.isnan +Tests element-wise for NaN and return result as a boolean array. +GPU CPU + +mindspore.numpy.isneginf +Tests element-wise for negative infinity, returns result as bool array. +GPU CPU + +mindspore.numpy.isposinf +Tests element-wise for positive infinity, returns result as bool array. +GPU CPU + +mindspore.numpy.isscalar +Returns True if the type of element is a scalar type. +Ascend GPU CPU + +mindspore.numpy.less +Returns the truth value of (x1 < x2) element-wise. +Ascend GPU CPU + +mindspore.numpy.less_equal +Returns the truth value of (x1 <= x2) element-wise. +Ascend GPU CPU + +mindspore.numpy.logical_and +Computes the truth value of x1 AND x2 element-wise. +Ascend GPU CPU + +mindspore.numpy.logical_not +Computes the truth value of NOT a element-wise. +Ascend GPU CPU + +mindspore.numpy.logical_or +Computes the truth value of x1 OR x2 element-wise. +Ascend GPU CPU + +mindspore.numpy.logical_xor +Computes the truth value of x1 XOR x2, element-wise. +Ascend GPU CPU + +mindspore.numpy.not_equal +Returns (x1 != x2) element-wise. +Ascend GPU CPU + +mindspore.numpy.signbit +Returns element-wise True where signbit is set (less than zero). +Ascend GPU CPU + +mindspore.numpy.sometrue +Tests whether any array element along a given axis evaluates to True. +Ascend GPU CPU + + + +",mindspore.numpy,mindspore、mindspore、算子、GPU、CPU、Ascend、API、ast、eval、npu +mindspore.numpy§数学运算,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.numpy.html," +数学运算类算子包括各类数学相关的运算：加减乘除乘方，以及指数、对数等常见函数等。 +数学计算支持类似NumPy的广播特性。 + +加法 +以下代码实现了 input_x 和 input_y 两数组相加的操作： +input_x = np.full((3, 2), [1, 2]) +input_y = np.full((3, 2), [3, 4]) +output = np.add(input_x, input_y) +print(output) + + +运行结果如下： +[[4 6] + [4 6] + [4 6]] + + + +矩阵乘法 +以下代码实现了 input_x 和 input_y 两矩阵相乘的操作： +input_x = np.arange(2*3).reshape(2, 3).astype('float32') +input_y = np.arange(3*4).reshape(3, 4).astype('float32') +output = np.matmul(input_x, input_y) +print(output) + + +运行结果如下： +[[20. 23. 26. 29.] + [56. 68. 80. 92.]] + + + +求平均值 +以下代码实现了求 input_x 所有元素的平均值的操作： +input_x = np.arange(6).astype('float32') +output = np.mean(input_x) +print(output) + + +运行结果如下： +2.5 + + + +指数 +以下代码实现了自然常数 e 的 input_x 次方的操作： +input_x = np.arange(5).astype('float32') +output = np.exp(input_x) +print(output) + + +运行结果如下： +[ 1. 2.7182817 7.389056 20.085537 54.59815 ] + + + + + + + + + + + +API Name +Description +Supported Platforms + +mindspore.numpy.absolute +Calculates the absolute value element-wise. +Ascend GPU CPU + +mindspore.numpy.add +Adds arguments element-wise. +Ascend GPU CPU + +mindspore.numpy.amax +Returns the maximum of an array or maximum along an axis. +Ascend GPU CPU + +mindspore.numpy.amin +Returns the minimum of an array or minimum along an axis. +Ascend GPU CPU + +mindspore.numpy.arccos +Trigonometric inverse cosine, element-wise. +Ascend GPU CPU + +mindspore.numpy.arccosh +Inverse hyperbolic cosine, element-wise. +Ascend GPU CPU + +mindspore.numpy.arcsin +Inverse sine, element-wise. +Ascend GPU CPU + +mindspore.numpy.arcsinh +Inverse hyperbolic sine element-wise. +Ascend GPU CPU + +mindspore.numpy.arctan +Trigonometric inverse tangent, element-wise. +Ascend GPU CPU + +mindspore.numpy.arctan2 +Element-wise arc tangent of \(x1/x2\) choosing the quadrant correctly. +Ascend CPU GPU + +mindspore.numpy.arctanh +Inverse hyperbolic tangent element-wise. +Ascend CPU + +mindspore.numpy.argmax +Returns the indices of the maximum values along an axis. +Ascend GPU CPU + +mindspore.numpy.argmin +Returns the indices of the minimum values along an axis. +Ascend GPU CPU + +mindspore.numpy.around +Evenly round to the given number of decimals. +Ascend GPU CPU + +mindspore.numpy.average +Computes the weighted average along the specified axis. +Ascend GPU CPU + +mindspore.numpy.bincount +Count number of occurrences of each value in array of non-negative ints. +Ascend GPU CPU + +mindspore.numpy.bitwise_and +Computes the bit-wise AND of two arrays element-wise. +Ascend CPU + +mindspore.numpy.bitwise_or +Computes the bit-wise OR of two arrays element-wise. +Ascend CPU + +mindspore.numpy.bitwise_xor +Computes the bit-wise XOR of two arrays element-wise. +Ascend CPU + +mindspore.numpy.cbrt +Returns the cube-root of a tensor, element-wise. +Ascend GPU CPU + +mindspore.numpy.ceil +Returns the ceiling of the input, element-wise. +Ascend GPU CPU + +mindspore.numpy.clip +Clips (limits) the values in an array. +Ascend GPU CPU + +mindspore.numpy.convolve +Returns the discrete, linear convolution of two one-dimensional sequences. +GPU CPU + +mindspore.numpy.copysign +Changes the sign of x1 to that of x2, element-wise. +Ascend GPU CPU + +mindspore.numpy.corrcoef +Returns Pearson product-moment correlation coefficients. +Ascend GPU CPU + +mindspore.numpy.correlate +Cross-correlation of two 1-dimensional sequences. +GPU + +mindspore.numpy.cos +Cosine element-wise. +Ascend GPU CPU + +mindspore.numpy.cosh +Hyperbolic cosine, element-wise. +Ascend CPU + +mindspore.numpy.count_nonzero +Counts the number of non-zero values in the tensor x. +Ascend GPU CPU + +mindspore.numpy.cov +Estimates a covariance matrix, given data and weights. +Ascend GPU CPU + +mindspore.numpy.cross +Returns the cross product of two (arrays of) vectors. +Ascend GPU CPU + +mindspore.numpy.cumprod +Returns the cumulative product of elements along a given axis. +Ascend GPU + +mindspore.numpy.cumsum +Returns the cumulative sum of the elements along a given axis. +Ascend GPU CPU + +mindspore.numpy.deg2rad +Converts angles from degrees to radians. +Ascend GPU CPU + +mindspore.numpy.diff +Calculates the n-th discrete difference along the given axis. +Ascend GPU CPU + +mindspore.numpy.digitize +Returns the indices of the bins to which each value in input array belongs. +Ascend GPU CPU + +mindspore.numpy.divide +Returns a true division of the inputs, element-wise. +Ascend GPU CPU + +mindspore.numpy.divmod +Returns element-wise quotient and remainder simultaneously. +Ascend GPU CPU + +mindspore.numpy.dot +Returns the dot product of two arrays. +Ascend GPU CPU + +mindspore.numpy.ediff1d +The differences between consecutive elements of a tensor. +Ascend GPU CPU + +mindspore.numpy.exp +Calculates the exponential of all elements in the input array. +Ascend GPU CPU + +mindspore.numpy.exp2 +Calculates 2**p for all p in the input array. +Ascend GPU CPU + +mindspore.numpy.expm1 +Calculates exp(x) - 1 for all elements in the array. +Ascend GPU CPU + +mindspore.numpy.fix +Rounds to nearest integer towards zero. +Ascend GPU CPU + +mindspore.numpy.float_power +First array elements raised to powers from second array, element-wise. +Ascend GPU CPU + +mindspore.numpy.floor +Returns the floor of the input, element-wise. +Ascend GPU CPU + +mindspore.numpy.floor_divide +Returns the largest integer smaller or equal to the division of the inputs. +Ascend GPU CPU + +mindspore.numpy.fmod +Returns the element-wise remainder of division. +Ascend GPU CPU + +mindspore.numpy.gcd +Returns the greatest common divisor of |x1| and |x2|. +Ascend GPU CPU + +mindspore.numpy.gradient +Returns the gradient of a N-dimensional array. +Ascend GPU CPU + +mindspore.numpy.heaviside +Computes the Heaviside step function. +Ascend GPU CPU + +mindspore.numpy.histogram +Computes the histogram of a dataset. +Ascend GPU CPU + +mindspore.numpy.histogram2d +Computes the multidimensional histogram of some data. +Ascend GPU CPU + +mindspore.numpy.histogramdd +Computes the multidimensional histogram of some data. +Ascend GPU CPU + +mindspore.numpy.hypot +Given the “legs” of a right triangle, returns its hypotenuse. +Ascend GPU CPU + +mindspore.numpy.inner +Returns the inner product of two tensors. +Ascend GPU CPU + +mindspore.numpy.interp +One-dimensional linear interpolation for monotonically increasing sample points. +Ascend GPU CPU + +mindspore.numpy.invert +Computes bit-wise inversion, or bit-wise NOT, element-wise. +Ascend + +mindspore.numpy.kron +Kronecker product of two arrays. +Ascend GPU CPU + +mindspore.numpy.lcm +Returns the lowest common multiple of |x1| and |x2|. +Ascend GPU CPU + +mindspore.numpy.log +Returns the natural logarithm, element-wise. +Ascend GPU CPU + +mindspore.numpy.log10 +Base-10 logarithm of x. +Ascend GPU CPU + +mindspore.numpy.log1p +Returns the natural logarithm of one plus the input array, element-wise. +Ascend GPU CPU + +mindspore.numpy.log2 +Base-2 logarithm of x. +Ascend GPU CPU + +mindspore.numpy.logaddexp +Logarithm of the sum of exponentiations of the inputs. +Ascend GPU CPU + +mindspore.numpy.logaddexp2 +Logarithm of the sum of exponentiations of the inputs in base of 2. +Ascend GPU CPU + +mindspore.numpy.matmul +Returns the matrix product of two arrays. +Ascend GPU CPU + +mindspore.numpy.matrix_power +Raises a square matrix to the (integer) power n. +Ascend GPU CPU + +mindspore.numpy.maximum +Returns the element-wise maximum of array elements. +Ascend GPU CPU + +mindspore.numpy.mean +Computes the arithmetic mean along the specified axis. +Ascend GPU CPU + +mindspore.numpy.minimum +Element-wise minimum of tensor elements. +Ascend GPU CPU + +mindspore.numpy.multi_dot +Computes the dot product of two or more arrays in a single function call, while automatically selecting the fastest evaluation order. +Ascend GPU CPU + +mindspore.numpy.multiply +Multiplies arguments element-wise. +Ascend GPU CPU + +mindspore.numpy.nancumsum +Return the cumulative sum of array elements over a given axis treating Not a Numbers (NaNs) as zero. +GPU CPU + +mindspore.numpy.nanmax +Return the maximum of an array or maximum along an axis, ignoring any NaNs. +GPU CPU + +mindspore.numpy.nanmean +Computes the arithmetic mean along the specified axis, ignoring NaNs. +GPU CPU + +mindspore.numpy.nanmin +Returns the minimum of array elements over a given axis, ignoring any NaNs. +GPU CPU + +mindspore.numpy.nanstd +Computes the standard deviation along the specified axis, while ignoring NaNs. +GPU CPU + +mindspore.numpy.nansum +Returns the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero. +GPU CPU + +mindspore.numpy.nanvar +Computes the variance along the specified axis, while ignoring NaNs. +GPU CPU + +mindspore.numpy.negative +Numerical negative, element-wise. +Ascend GPU CPU + +mindspore.numpy.norm +Matrix or vector norm. +Ascend GPU CPU + +mindspore.numpy.outer +Computes the outer product of two vectors. +Ascend GPU CPU + +mindspore.numpy.polyadd +Finds the sum of two polynomials. +Ascend GPU CPU + +mindspore.numpy.polyder +Returns the derivative of the specified order of a polynomial. +Ascend GPU CPU + +mindspore.numpy.polyint +Returns an antiderivative (indefinite integral) of a polynomial. +Ascend GPU CPU + +mindspore.numpy.polymul +Finds the product of two polynomials. +GPU + +mindspore.numpy.polysub +Difference (subtraction) of two polynomials. +Ascend GPU CPU + +mindspore.numpy.polyval +Evaluates a polynomial at specific values. +Ascend GPU CPU + +mindspore.numpy.positive +Numerical positive, element-wise. +Ascend GPU CPU + +mindspore.numpy.power +First array elements raised to powers from second array, element-wise. +Ascend GPU CPU + +mindspore.numpy.promote_types +Returns the data type with the smallest size and smallest scalar kind. +Ascend GPU CPU + +mindspore.numpy.ptp +Range of values (maximum - minimum) along an axis. +Ascend GPU CPU + +mindspore.numpy.rad2deg +Converts angles from radians to degrees. +Ascend GPU CPU + +mindspore.numpy.radians +Converts angles from degrees to radians. +Ascend GPU CPU + +mindspore.numpy.ravel_multi_index +Converts a tuple of index arrays into an array of flat indices, applying boundary modes to the multi-index. +GPU + +mindspore.numpy.reciprocal +Returns the reciprocal of the argument, element-wise. +Ascend GPU CPU + +mindspore.numpy.remainder +Returns element-wise remainder of division. +Ascend GPU CPU + +mindspore.numpy.result_type +Returns the type that results from applying the type promotion rules to the arguments. +Ascend GPU CPU + +mindspore.numpy.rint +Rounds elements of the array to the nearest integer. +Ascend GPU CPU + +mindspore.numpy.searchsorted +Finds indices where elements should be inserted to maintain order. +Ascend GPU CPU + +mindspore.numpy.sign +Returns an element-wise indication of the sign of a number. +Ascend GPU CPU + +mindspore.numpy.sin +Trigonometric sine, element-wise. +Ascend GPU CPU + +mindspore.numpy.sinh +Hyperbolic sine, element-wise. +Ascend CPU + +mindspore.numpy.sqrt +Returns the non-negative square-root of an array, element-wise. +Ascend GPU CPU + +mindspore.numpy.square +Returns the element-wise square of the input. +Ascend GPU CPU + +mindspore.numpy.std +Computes the standard deviation along the specified axis. +Ascend GPU CPU + +mindspore.numpy.subtract +Subtracts arguments, element-wise. +Ascend GPU CPU + +mindspore.numpy.sum +Returns sum of array elements over a given axis. +Ascend GPU CPU + +mindspore.numpy.tan +Computes tangent element-wise. +Ascend CPU + +mindspore.numpy.tanh +Computes hyperbolic tangent element-wise. +Ascend GPU CPU + +mindspore.numpy.tensordot +Computes tensor dot product along specified axes. +Ascend GPU CPU + +mindspore.numpy.trapz +Integrates along the given axis using the composite trapezoidal rule. +Ascend GPU CPU + +mindspore.numpy.true_divide +Returns a true division of the inputs, element-wise. +Ascend GPU CPU + +mindspore.numpy.trunc +Returns the truncated value of the input, element-wise. +Ascend GPU CPU + +mindspore.numpy.unwrap +Unwraps by changing deltas between values to 2*pi complement. +Ascend GPU CPU + +mindspore.numpy.var +Computes the variance along the specified axis. +Ascend GPU CPU + + + +",mindspore.numpy,mindspore、mindspore、算子、GPU、CPU、Ascend、API、metric、ast、dataset、eval、npu +mindspore.numpy§MindSpore Numpy与MindSpore特性结合,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.numpy.html," +mindspore.numpy能够充分利用MindSpore的强大功能，实现算子的自动微分，并使用图模式加速运算，帮助用户快速构建高效的模型。同时，MindSpore还支持多种后端设备，包括Ascend、GPU和CPU等，用户可以根据自己的需求灵活设置。以下提供了几种常用方法： + +ms_function: 将代码包裹进图模式，用于提高代码运行效率。 +GradOperation: 用于自动求导。 +mindspore.context: 用于设置运行模式和后端设备等。 +mindspore.nn.Cell: 用于建立深度学习模型。 + +使用示例如下： + +ms_function使用示例 +首先，以神经网络里经常使用到的矩阵乘与矩阵加算子为例： +import mindspore.numpy as np + +x = np.arange(8).reshape(2, 4).astype('float32') +w1 = np.ones((4, 8)) +b1 = np.zeros((8,)) +w2 = np.ones((8, 16)) +b2 = np.zeros((16,)) +w3 = np.ones((16, 4)) +b3 = np.zeros((4,)) + +def forward(x, w1, b1, w2, b2, w3, b3): + x = np.dot(x, w1) + b1 + x = np.dot(x, w2) + b2 + x = np.dot(x, w3) + b3 + return x + +print(forward(x, w1, b1, w2, b2, w3, b3)) + + +运行结果如下： +[[ 768. 768. 768. 768.] + [2816. 2816. 2816. 2816.]] + + +对上述示例，我们可以借助 ms_function 将所有算子编译到一张静态图里以加快运行效率，示例如下： +from mindspore import ms_function + +forward_compiled = ms_function(forward) +print(forward(x, w1, b1, w2, b2, w3, b3)) + + +运行结果如下： +[[ 768. 768. 768. 768.] + [2816. 2816. 2816. 2816.]] + + + +Note +目前静态图不支持在Python交互式模式下运行，并且有部分语法限制。ms_function 的更多信息可参考 API ms_function 。 + + +GradOperation使用示例 +GradOperation 可以实现自动求导。以下示例可以实现对上述没有用 ms_function 修饰的 forward 函数定义的计算求导。 +from mindspore import ops + +grad_all = ops.composite.GradOperation(get_all=True) +print(grad_all(forward)(x, w1, b1, w2, b2, w3, b3)) + + +运行结果如下： +(Tensor(shape=[2, 4], dtype=Float32, value= + [[ 5.12000000e+02, 5.12000000e+02, 5.12000000e+02, 5.12000000e+02], + [ 5.12000000e+02, 5.12000000e+02, 5.12000000e+02, 5.12000000e+02]]), + Tensor(shape=[4, 8], dtype=Float32, value= + [[ 2.56000000e+02, 2.56000000e+02, 2.56000000e+02 ... 2.56000000e+02, 2.56000000e+02, 2.56000000e+02], + [ 3.84000000e+02, 3.84000000e+02, 3.84000000e+02 ... 3.84000000e+02, 3.84000000e+02, 3.84000000e+02], + [ 5.12000000e+02, 5.12000000e+02, 5.12000000e+02 ... 5.12000000e+02, 5.12000000e+02, 5.12000000e+02] + [ 6.40000000e+02, 6.40000000e+02, 6.40000000e+02 ... 6.40000000e+02, 6.40000000e+02, 6.40000000e+02]]), + ... + Tensor(shape=[4], dtype=Float32, value= [ 2.00000000e+00, 2.00000000e+00, 2.00000000e+00, 2.00000000e+00])) + + +如果要对 ms_function 修饰的 forward 计算求导，需要提前使用 context 设置运算模式为图模式，示例如下： +from mindspore import ms_function, set_context, GRAPH_MODE + +set_context(mode=GRAPH_MODE) +grad_all = ops.composite.GradOperation(get_all=True) +print(grad_all(ms_function(forward))(x, w1, b1, w2, b2, w3, b3)) + + +运行结果如下： +(Tensor(shape=[2, 4], dtype=Float32, value= + [[ 5.12000000e+02, 5.12000000e+02, 5.12000000e+02, 5.12000000e+02], + [ 5.12000000e+02, 5.12000000e+02, 5.12000000e+02, 5.12000000e+02]]), + Tensor(shape=[4, 8], dtype=Float32, value= + [[ 2.56000000e+02, 2.56000000e+02, 2.56000000e+02 ... 2.56000000e+02, 2.56000000e+02, 2.56000000e+02], + [ 3.84000000e+02, 3.84000000e+02, 3.84000000e+02 ... 3.84000000e+02, 3.84000000e+02, 3.84000000e+02], + [ 5.12000000e+02, 5.12000000e+02, 5.12000000e+02 ... 5.12000000e+02, 5.12000000e+02, 5.12000000e+02] + [ 6.40000000e+02, 6.40000000e+02, 6.40000000e+02 ... 6.40000000e+02, 6.40000000e+02, 6.40000000e+02]]), + ... + Tensor(shape=[4], dtype=Float32, value= [ 2.00000000e+00, 2.00000000e+00, 2.00000000e+00, 2.00000000e+00])) + + +更多细节可参考 API GradOperation 。 + +mindspore.context使用示例 +MindSpore支持多后端运算，可以通过 mindspore.context 进行设置。mindspore.numpy 的多数算子可以使用图模式或者PyNative模式运行，也可以运行在CPU，CPU或者Ascend等多种后端设备上。 +from mindspore import set_context, GRAPH_MODE, PYNATIVE_MODE + +# Execucation in static graph mode +set_context(mode=GRAPH_MODE) + +# Execucation in PyNative mode +set_context(mode=PYNATIVE_MODE) + +# Execucation on CPU backend +set_context(device_target=""CPU"") + +# Execucation on GPU backend +set_context(device_target=""GPU"") + +# Execucation on Ascend backend +set_context(device_target=""Ascend"") +... + + +更多细节可参考 API mindspore.set_context 。 + +mindspore.numpy使用示例 +这里提供一个使用 mindspore.numpy 构建网络模型的示例。 +mindspore.numpy 接口可以定义在 nn.Cell 代码块内进行网络的构建，示例如下： +import mindspore.numpy as np +from mindspore import set_context, GRAPH_MODE +from mindspore.nn import Cell + +set_context(mode=GRAPH_MODE) + +x = np.arange(8).reshape(2, 4).astype('float32') +w1 = np.ones((4, 8)) +b1 = np.zeros((8,)) +w2 = np.ones((8, 16)) +b2 = np.zeros((16,)) +w3 = np.ones((16, 4)) +b3 = np.zeros((4,)) + +class NeuralNetwork(Cell): + def construct(self, x, w1, b1, w2, b2, w3, b3): + x = np.dot(x, w1) + b1 + x = np.dot(x, w2) + b2 + x = np.dot(x, w3) + b3 + return x + +net = NeuralNetwork() + +print(net(x, w1, b1, w2, b2, w3, b3)) + + +运行结果如下： +[[ 768. 768. 768. 768.] + [2816. 2816. 2816. 2816.]] + + + + +",mindspore.numpy,mindspore、自动微分、GradOperation、mindspore、算子、接口、GPU、CPU、Ascend、网络、PyNative、API、ast、 GradOperation、求导、GRAPH +mindspore.ops§mindspore.ops,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," +可用于Cell的构造函数的算子。 +import mindspore.ops as ops + + +MindSpore中 mindspore.ops 接口与上一版本相比，新增、删除和支持平台的变化信息请参考 API Updates 。 + +",mindspore.ops,mindspore、mindspore、算子、接口、API +mindspore.ops§算子原语,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + + + + + + + +mindspore.ops.Primitive +Primitive是Python中算子原语的基类。 + +mindspore.ops.PrimitiveWithCheck +PrimitiveWithCheck是Python中原语的基类，定义了检查算子输入参数的函数，但是使用了C++源码中注册的推理方法。 + +mindspore.ops.PrimitiveWithInfer +PrimitiveWithInfer是Python中的原语基类，在python中定义了跟踪推理的函数。 + + + +",mindspore.ops,mindspore、mindspore、算子、C++ +mindspore.ops§装饰器,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + + + + + + + +mindspore.ops.constexpr +创建PrimiveWithInfer算子，用于在编译时推断值。 + +mindspore.ops.custom_info_register +A decorator which is used to bind the registration information to the func parameter of mindspore.ops.Custom. + +mindspore.ops.ms_kernel +用于MindSpore Hybrid DSL函数书写的装饰器。 + +mindspore.ops.op_info_register +用于注册算子的装饰器。 + +mindspore.ops.prim_attr_register +Primitive属性的注册器。 + + + +",mindspore.ops,mindspore、mindspore、算子 +mindspore.ops§神经网络层算子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + +神经网络 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.AvgPool +对输入的多维数据进行二维平均池化运算。 +Ascend GPU CPU + +mindspore.ops.AvgPool3D +对输入的多维数据进行三维的平均池化运算。 +Ascend CPU + +mindspore.ops.BasicLSTMCell +It’s similar to operator mindspore.ops.DynamicRNN. +弃用 + +mindspore.ops.BatchNorm +对输入数据进行归一化(Batch Normalization)和更新参数。 +Ascend CPU GPU + +mindspore.ops.Conv2D +二维卷积层。 +Ascend GPU CPU + +mindspore.ops.Conv2DBackpropInput +The Conv2DBackpropInput interface is deprecated, please refer to mindspore.ops.Conv2DTranspose if you want to do unsampling. +弃用 + +mindspore.ops.Conv2DTranspose +Compute a 2D transposed convolution, which is also known as a deconvolution (although it is not an actual deconvolution). +Ascend GPU CPU + +mindspore.ops.Conv3D +3维卷积操作。 +Ascend GPU CPU + +mindspore.ops.Conv3DTranspose +计算三维转置卷积，也称为反卷积（实际不是真正的反卷积）。 +Ascend GPU + +mindspore.ops.CTCGreedyDecoder +对输入中给定的logits执行贪婪解码。 +Ascend + +mindspore.ops.DepthwiseConv2dNative +DepthwiseConv2dNative will be deprecated in the future. +弃用 + +mindspore.ops.Dropout +Dropout是一种正则化手段，通过在训练中以 \(1 - keep\_prob\) 的概率随机将神经元输出设置为0，起到减少神经元相关性的作用，避免过拟合。 +Ascend GPU CPU + +mindspore.ops.Dropout2D +在训练期间，根据概率 1 - keep_prob ，随机的将一些通道设置为0，且服从伯努利分布。 +Ascend GPU CPU + +mindspore.ops.Dropout3D +在训练期间，以服从伯努利分布的概率 \(1-keep\_prob\) 随机将输入Tensor的某些通道归零。 +Ascend GPU CPU + +mindspore.ops.DropoutDoMask +The DropoutDoMask interface is deprecated, please use the mindspore.ops.Dropout instead. +弃用 + +mindspore.ops.DropoutGenMask +The DropoutGenMask interface is deprecated, please use the mindspore.ops.Dropout instead. +弃用 + +mindspore.ops.DynamicGRUV2 +为输入序列应用一个单层GRU(gated recurrent unit)。 +Ascend + +mindspore.ops.DynamicRNN +将循环神经网络应用到输入上。 +Ascend + +mindspore.ops.Flatten +扁平化（Flatten）输入Tensor，不改变0轴的size。 +Ascend GPU CPU + +mindspore.ops.LayerNorm +在输入Tensor上应用层归一化（Layer Normalization）。 +Ascend GPU CPU + +mindspore.ops.LRN +局部响应归一化操作LRN(Local Response Normalization)。 +Ascend GPU CPU + +mindspore.ops.LSTM +Performs the Long Short-Term Memory (LSTM) on the input. +GPU CPU + +mindspore.ops.MaxPool +对输入的多维数据进行二维的最大池化运算。 +Ascend GPU CPU + +mindspore.ops.MaxPool3D +对输入的多维数据进行三维的最大池化运算。 +Ascend GPU CPU + +mindspore.ops.MaxPoolWithArgmax +对输入Tensor执行最大池化运算，并返回最大值和索引。 +Ascend GPU + +mindspore.ops.MirrorPad +通过指定的填充模式和大小对输入Tensor进行填充。 +Ascend GPU CPU + +mindspore.ops.Pad +根据参数 paddings 对输入进行填充。 +Ascend GPU CPU + +mindspore.ops.EmbeddingLookup +根据指定的索引，返回输入Tensor的切片。 +Ascend CPU GPU + +mindspore.ops.Padding +将输入Tensor的最后一个维度从1扩展到 pad_dim_size ，其填充值为0。 +Ascend GPU CPU + +mindspore.ops.ResizeNearestNeighbor +使用最近邻插值算法调整输入Tensor为指定大小。 +Ascend GPU CPU + +mindspore.ops.ResizeBilinear +使用双线性插值调整图像大小到指定的大小。 +Ascend CPU GPU + + + + + +损失函数 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.BCEWithLogitsLoss +输入经过sigmoid激活函数后作为预测值，BCEWithLogitsLoss 计算预测值和目标值之间的二值交叉熵损失。 +Ascend GPU CPU + +mindspore.ops.BinaryCrossEntropy +计算目标值和预测值之间的二值交叉熵损失值。 +Ascend GPU CPU + +mindspore.ops.CTCLoss +计算CTC(Connectionist Temporal Classification)损失和梯度。 +Ascend GPU CPU + +mindspore.ops.KLDivLoss +计算输入 logits 和 labels 的KL散度。 +Ascend GPU CPU + +mindspore.ops.L2Loss +用于计算L2范数的一半，但不对结果进行开方操作。 +Ascend GPU CPU + +mindspore.ops.NLLLoss +获取预测值和目标值之间的负对数似然损失。 +Ascend GPU CPU + +mindspore.ops.RNNTLoss +Computes the RNNTLoss and its gradient with respect to the softmax outputs. +Ascend + +mindspore.ops.SigmoidCrossEntropyWithLogits +计算预测值与真实值之间的sigmoid交叉熵。 +Ascend GPU CPU + +mindspore.ops.SmoothL1Loss +计算平滑L1损失，该L1损失函数有稳健性。 +Ascend GPU CPU + +mindspore.ops.SoftMarginLoss +SoftMarginLoss operation. +Ascend + +mindspore.ops.SoftmaxCrossEntropyWithLogits +使用one-hot编码获取预测值和真实之间的softmax交叉熵。 +Ascend GPU CPU + +mindspore.ops.SparseSoftmaxCrossEntropyWithLogits +Computes the softmax cross-entropy value between logits and sparse encoding labels. +GPU CPU + + + + + +激活函数 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.Elu +指数线性单元激活函数（Exponential Linear Unit activation function）。 +Ascend GPU CPU + +mindspore.ops.FastGeLU +快速高斯误差线性单元激活函数。 +Ascend GPU CPU + +mindspore.ops.GeLU +高斯误差线性单元激活函数（Gaussian Error Linear Units activation function）。 +Ascend GPU CPU + +mindspore.ops.HShrink +Hard Shrink激活函数。 +Ascend CPU GPU + +mindspore.ops.HSigmoid +Hard sigmoid activation function. +Ascend GPU CPU + +mindspore.ops.HSwish +Hard Swish激活函数。 +GPU CPU + +mindspore.ops.LogSoftmax +LogSoftmax激活函数。 +Ascend GPU CPU + +mindspore.ops.Mish +逐元素计算输入Tensor的MISH（Self Regularized Non-Monotonic Neural Activation Function 自正则化非单调神经激活函数）。 +Ascend GPU CPU + +mindspore.ops.PReLU +带参数的线性修正单元激活函数（Parametric Rectified Linear Unit activation function）。 +Ascend GPU + +mindspore.ops.ReLU +线性修正单元激活函数（Rectified Linear Unit）。 +Ascend GPU CPU + +mindspore.ops.ReLU6 +计算输入Tensor的ReLU（矫正线性单元），其上限为6。 +Ascend GPU CPU + +mindspore.ops.ReLUV2 +ReLUV2接口已经弃用，请使用 mindspore.ops.ReLU 替代。 +弃用 + +mindspore.ops.SeLU +激活函数SeLU（Scaled exponential Linear Unit）。 +Ascend GPU CPU + +mindspore.ops.Sigmoid +Sigmoid激活函数。 +Ascend GPU CPU + +mindspore.ops.Softmax +Softmax函数。 +Ascend GPU CPU + +mindspore.ops.Softplus +Softplus激活函数。 +Ascend GPU CPU + +mindspore.ops.SoftShrink +Soft Shrink激活函数。 +Ascend CPU GPU + +mindspore.ops.Softsign +Softsign激活函数。 +Ascend GPU CPU + +mindspore.ops.Tanh +Tanh激活函数。 +Ascend GPU CPU + + + + + +优化器 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.Adam +通过Adam算法更新梯度。 +Ascend GPU CPU + +mindspore.ops.AdamNoUpdateParam +Updates gradients by the Adaptive Moment Estimation (Adam) algorithm. +CPU + +mindspore.ops.AdamWeightDecay +Updates gradients by the Adaptive Moment Estimation algorithm with weight decay (AdamWeightDecay). +Ascend GPU CPU + +mindspore.ops.AdaptiveAvgPool2D +2维自适应平均池化。 +GPU + +mindspore.ops.ApplyAdadelta +根据Adadelta算法更新相关参数。 +Ascend CPU + +mindspore.ops.ApplyAdagrad +根据Adagrad算法更新相关参数。 +Ascend CPU GPU + +mindspore.ops.ApplyAdagradDA +根据Adagrad算法更新 var 。 +Ascend + +mindspore.ops.ApplyAdagradV2 +根据Adagrad算法更新相关参数。 +Ascend + +mindspore.ops.ApplyAdaMax +根据AdaMax算法更新相关参数。 +Ascend + +mindspore.ops.ApplyAddSign +根据AddSign算法更新相关参数。 +Ascend + +mindspore.ops.ApplyCenteredRMSProp +居中RMSProp算法优化器。 +Ascend GPU CPU + +mindspore.ops.ApplyFtrl +根据FTRL算法更新相关参数。 +Ascend GPU CPU + +mindspore.ops.ApplyGradientDescent +通过从 var 中减去 alpha * delta 来更新 var 。 +Ascend GPU + +mindspore.ops.ApplyMomentum +使用动量算法的优化器。 +Ascend GPU CPU + +mindspore.ops.ApplyPowerSign +根据AddSign算法更新相关参数。 +Ascend CPU + +mindspore.ops.ApplyProximalAdagrad +根据Proximal Adagrad算法更新网络参数。 +Ascend + +mindspore.ops.ApplyProximalGradientDescent +根据FOBOS(Forward Backward Splitting)算法更新网络参数。 +Ascend + +mindspore.ops.ApplyRMSProp + +Ascend GPU CPU + +mindspore.ops.FusedSparseAdam +Merges the duplicate value of the gradient and then updates parameters by the Adaptive Moment Estimation (Adam) algorithm. +Ascend CPU + +mindspore.ops.FusedSparseFtrl +Merges the duplicate value of the gradient and then updates relevant entries according to the FTRL-proximal scheme. +Ascend CPU + +mindspore.ops.FusedSparseLazyAdam +Merges the duplicate value of the gradient and then updates parameters by the Adaptive Moment Estimation (Adam) algorithm. +Ascend CPU + +mindspore.ops.FusedSparseProximalAdagrad +Merges the duplicate value of the gradient and then updates relevant entries according to the proximal adagrad algorithm. +Ascend CPU + +mindspore.ops.LARSUpdate +对梯度的平方和应用LARS(layer-wise adaptive rate scaling)算法。 +Ascend + +mindspore.ops.SparseApplyAdagrad +根据Adagrad算法更新相关参数。 +Ascend + +mindspore.ops.SparseApplyAdagradV2 +根据Adagrad算法更新相关参数。 +Ascend + +mindspore.ops.SparseApplyProximalAdagrad +Updates relevant entries according to the proximal adagrad algorithm. +Ascend GPU + +mindspore.ops.SGD +计算随机梯度下降。 +Ascend GPU CPU + +mindspore.ops.SparseApplyFtrl +根据FTRL-proximal算法更新相关参数。 +Ascend GPU + +mindspore.ops.SparseApplyFtrlV2 +Updates relevant entries according to the FTRL-proximal scheme. +Ascend + + + + + +距离函数 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.Cdist +计算两个tensor的p-范数距离。 +Ascend + +mindspore.ops.EditDistance +Computes the Levenshtein Edit Distance. +Ascend + +mindspore.ops.LpNorm +Returns the matrix norm or vector norm of a given tensor. +Ascend GPU CPU + + + + + +采样算子 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.ComputeAccidentalHits +计算与目标类完全匹配的抽样样本的位置id。 +Ascend + +mindspore.ops.LogUniformCandidateSampler +使用log-uniform(Zipfian)分布对一组类别进行采样。 +Ascend + +mindspore.ops.UniformCandidateSampler +使用均匀分布对一组类别进行采样。 +GPU + + + + + +图像处理 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.BoundingBoxDecode +Decodes bounding boxes locations. +Ascend GPU CPU + +mindspore.ops.BoundingBoxEncode +Encodes bounding boxes locations. +Ascend GPU CPU + +mindspore.ops.CheckValid +Checks bounding box. +Ascend GPU CPU + +mindspore.ops.CropAndResize +Extracts crops from the input image tensor and resizes them. +Ascend GPU CPU + +mindspore.ops.ExtractVolumePatches +Extract patches from input and put them in the “depth” output dimension. +Ascend + +mindspore.ops.IOU +计算矩形的IOU，即真实区域和预测区域的交并比。 +Ascend GPU CPU + +mindspore.ops.L2Normalize +L2范数归一化算子。 +Ascend GPU CPU + +mindspore.ops.NMSWithMask +非极大值抑制算法（NMS, Non-maximum Suppression）。 +Ascend GPU CPU + +mindspore.ops.ROIAlign +感兴趣区域对齐(RoI Align)运算。 +Ascend GPU CPU + + + + + +文本处理 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.NoRepeatNGram +Updates log_probs with repeat n-grams. +Ascend + + + + +",mindspore.ops,mindspore、mindspore、优化器、算子、接口、损失函数、GPU、CPU、Ascend、网络、SGD、Loss、metric、ast、weight decay、LR、数据、优化、npu、Embedding +mindspore.ops§数学运算算子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + +逐元素运算 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.Abs +逐元素计算输入Tensor的绝对值。 +Ascend GPU CPU + +mindspore.ops.AccumulateNV2 +Computes accumulation of all input tensors element-wise. +Ascend + +mindspore.ops.ACos +逐元素计算输入Tensor的反余弦。 +Ascend GPU CPU + +mindspore.ops.Acosh +逐元素计算输入Tensor的反双曲余弦。 +Ascend GPU CPU + +mindspore.ops.Add +两个输入Tensor逐元素相加。 +Ascend GPU CPU + +mindspore.ops.Addcdiv +Performs the element-wise division of tensor x1 by tensor x2, multiply the result by the scalar value and add it to input_data. +Ascend CPU + +mindspore.ops.Addcmul +Performs the element-wise product of tensor x1 and tensor x2, multiply the result by the scalar value and add it to input_data. +Ascend CPU + +mindspore.ops.AddN +逐元素将所有输入的Tensor相加。 +Ascend GPU CPU + +mindspore.ops.Asin +逐元素计算输入Tensor的反正弦值。 +Ascend GPU CPU + +mindspore.ops.Asinh +逐元素计算输入Tensor的反双曲正弦值。 +Ascend GPU CPU + +mindspore.ops.Atan +逐元素计算输入Tensor的反正切值。 +Ascend GPU CPU + +mindspore.ops.Atan2 +逐元素计算x/y的反正切值。 +Ascend CPU GPU + +mindspore.ops.Atanh +逐元素计算输入Tensor的反双曲正切值。 +Ascend CPU + +mindspore.ops.BesselI0e +逐元素计算输入数据的BesselI0e函数值。 +Ascend CPU GPU + +mindspore.ops.BesselI1e +逐元素计算输入数据的BesselI1e函数值。 +Ascend CPU GPU + +mindspore.ops.BitwiseAnd +逐元素执行两个Tensor的与运算。 +Ascend CPU + +mindspore.ops.BitwiseOr +逐元素执行两个Tensor的或运算。 +Ascend CPU + +mindspore.ops.BitwiseXor +逐元素执行两个Tensor的异或运算。 +Ascend CPU + +mindspore.ops.Ceil +向上取整函数。 +Ascend GPU CPU + +mindspore.ops.Conj +Returns a tensor of complex numbers that are the complex conjugate of each element in input. +Ascend GPU CPU + +mindspore.ops.Cos +逐元素计算输入数据的余弦。 +Ascend GPU CPU + +mindspore.ops.Cosh +逐元素计算输入数据的双曲余弦。 +Ascend GPU CPU + +mindspore.ops.Div +逐元素计算第一输入Tensor除以第二输入Tensor的商。 +Ascend GPU CPU + +mindspore.ops.DivNoNan +Computes a safe divide and returns 0 if the x2 is zero. +Ascend GPU CPU + +mindspore.ops.Einsum +This operator uses equation to represent a tuple of tensors operations, you can use this operator to perform diagonal/reducesum/transpose/matmul/mul/inner product operations, etc. +GPU + +mindspore.ops.Erf +逐元素计算 x 的高斯误差函数。 +Ascend GPU CPU + +mindspore.ops.Erfc +逐元素计算 x 的互补误差函数。 +Ascend GPU CPU + +mindspore.ops.Erfinv +Computes the inverse error function of input. +Ascend + +mindspore.ops.Exp +逐元素计算输入Tensor的指数。 +Ascend GPU CPU + +mindspore.ops.Expm1 +Returns exponential then minus 1 of a tensor element-wise. +Ascend GPU CPU + +mindspore.ops.Floor +向下取整函数。 +Ascend GPU CPU + +mindspore.ops.FloorDiv +将第一个输入Tensor除以第二个输入Tensor，并向下取整。 +Ascend GPU CPU + +mindspore.ops.FloorMod +将第一个输入Tensor除以第二个输入Tensor，并向下取余。 +Ascend GPU CPU + +mindspore.ops.Imag +Returns a new tensor containing imaginary value of the input. +GPU CPU + +mindspore.ops.Inv +按元素计算输入Tensor的倒数。 +Ascend GPU CPU + +mindspore.ops.Invert +翻转输入Tensor的所有元素。 +Ascend GPU CPU + +mindspore.ops.Lerp +Computes the minimum of input tensors element-wise. +Ascend CPU + +mindspore.ops.Log +逐元素返回Tensor的自然对数。 +Ascend GPU CPU + +mindspore.ops.Log1p +对输入Tensor逐元素加一后计算自然对数。 +Ascend GPU CPU + +mindspore.ops.LogicalAnd +逐元素计算两个Tensor的逻辑与运算。 +Ascend GPU CPU + +mindspore.ops.LogicalNot +逐元素计算两个Tensor的逻辑非运算。 +Ascend GPU CPU + +mindspore.ops.LogicalOr +逐元素计算两个Tensor的逻辑或运算。 +Ascend GPU CPU + +mindspore.ops.Mod +将第一个输入Tensor逐元素除以第二个输入Tensor，并取余。 +Ascend GPU CPU + +mindspore.ops.Mul +两个Tensor逐元素相乘。 +Ascend GPU CPU + +mindspore.ops.MulNoNan +逐元素计算输入乘积。 +Ascend CPU + +mindspore.ops.Neg +计算输入x的相反数并返回。 +Ascend GPU CPU + +mindspore.ops.Pow +计算 x 中每个元素的 y 次幂。 +Ascend GPU CPU + +mindspore.ops.Real +返回输入Tensor的实数部分。 +GPU CPU + +mindspore.ops.RealDiv +第一个输入Tensor元素为分子，第二个输入Tensor元素为分母，逐元素进行浮点型除法运算。 +Ascend GPU CPU + +mindspore.ops.Reciprocal +返回输入Tensor的倒数。 +Ascend GPU CPU + +mindspore.ops.Rint +Returns an integer that is closest to x element-wise. +Ascend GPU CPU + +mindspore.ops.Round +更多参考详见 mindspore.ops.round()。 +Ascend GPU CPU + +mindspore.ops.Rsqrt +Computes reciprocal of square root of input tensor element-wise. +Ascend GPU CPU + +mindspore.ops.Sign +符号函数，计算输入Tensor元素的执行符号。 +Ascend CPU GPU + +mindspore.ops.Sin +逐元素计算输入Tensor的正弦。 +Ascend GPU CPU + +mindspore.ops.Sinh +逐元素计算输入Tensor的双曲正弦。 +Ascend GPU CPU + +mindspore.ops.Sqrt +逐元素计算输入Tensor的平方根。 +Ascend GPU CPU + +mindspore.ops.Square +计算输入Tensor的平方。 +Ascend GPU CPU + +mindspore.ops.SquaredDifference +Subtracts the second input tensor from the first input tensor element-wise and returns square of it. +Ascend GPU CPU + +mindspore.ops.SquareSumAll +计算输入Tensor的平方和。 +Ascend GPU CPU + +mindspore.ops.Sub +逐元素用第一个输入Tensor减去第二个输入Tensor。 +Ascend GPU CPU + +mindspore.ops.Tan +逐元素计算输入元素的正切值。 +Ascend CPU GPU + +mindspore.ops.TruncateDiv +对于整数类型，将第一个输入Tensor与第二个输入Tensor逐元素相除。 +Ascend GPU + +mindspore.ops.TruncateMod +逐元素取模。 +Ascend GPU + +mindspore.ops.Xdivy +将第一个输入Tensor除以第二个输入Tensor。 +Ascend GPU + +mindspore.ops.Xlogy +计算第一个输入Tensor乘以第二个输入Tensor的对数。 +Ascend + + + + + +Reduction算子 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.Argmax +返回输入Tensor在指定轴上的最大值索引。 +Ascend GPU CPU + +mindspore.ops.ArgMaxWithValue +根据指定的索引计算最大值，并返回索引和值。 +Ascend GPU CPU + +mindspore.ops.Argmin +返回输入Tensor在指定轴上的最小值索引。 +Ascend CPU + +mindspore.ops.ArgMinWithValue +根据指定的索引计算最小值，并返回索引和值。 +Ascend GPU CPU + +mindspore.ops.ReduceAll +默认情况下，通过对指定维度所有元素进行逻辑与运算以移除该维度。 +Ascend GPU CPU + +mindspore.ops.ReduceAny +默认情况下，通过对指定维度所有元素进行逻辑或运算来移除该维度。 +Ascend GPU CPU + +mindspore.ops.ReduceMax +默认情况下，输出张量各维度上的最大值，以达到对所有维度进行归约的目的。 +Ascend GPU CPU + +mindspore.ops.ReduceMean +默认情况下，输出Tensor各维度上的平均值，以达到对所有维度进行归约的目的。 +Ascend GPU CPU + +mindspore.ops.ReduceMin +默认情况下，使用指定维度的最小值代替该维度的其他元素，以移除该维度。 +Ascend GPU CPU + +mindspore.ops.ReduceProd +默认情况下，通过计算指定维度中所有元素的乘积来移除该维度。 +Ascend GPU CPU + +mindspore.ops.ReduceSum +默认情况下，输出Tensor各维度上的和，以达到对所有维度进行归约的目的。 +Ascend GPU CPU + + + + + +比较算子 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.ApproximateEqual +逐元素计算abs(x-y)，如果小于tolerance则为True，否则为False。 +Ascend CPU + +mindspore.ops.CheckBprop +Checks whether the data type and the shape of corresponding elements from tuples x and y are the same. +Ascend GPU CPU + +mindspore.ops.Equal +逐元素比较两个输入Tensor是否相等。 +Ascend GPU CPU + +mindspore.ops.EqualCount +Computes the number of the same elements of two tensors. +Ascend GPU CPU + +mindspore.ops.Greater +按元素比较输入参数 \(x,y\) 的值，输出结果为bool值。 +Ascend GPU CPU + +mindspore.ops.GreaterEqual +输入两个数据，逐元素比较第一个数据是否大于等于第二个数据。 +Ascend GPU CPU + +mindspore.ops.InTopK +判断目标标签是否在前 k 个预测中。 +Ascend GPU CPU + +mindspore.ops.IsFinite +确定输入Tensor每个位置上的元素是否为有限数。 +Ascend GPU CPU + +mindspore.ops.IsInf +确定输入Tensor每个位置上的元素是否为无穷大或无穷小。 +GPU CPU + +mindspore.ops.IsInstance +检查输入对象是否为目标类型的实例。 +Ascend GPU CPU + +mindspore.ops.IsNan +判断输入数据每个位置上的值是否是NaN。 +GPU CPU + +mindspore.ops.IsSubClass +检查输入类型是否为其他类型的子类。 +Ascend GPU CPU + +mindspore.ops.Less +逐元素计算 \(x < y\) ，返回为bool。 +Ascend GPU CPU + +mindspore.ops.LessEqual +逐元素计算 \(x <= y\) 的bool值。 +Ascend GPU CPU + +mindspore.ops.Maximum +逐元素计算输入Tensor的最大值。 +Ascend GPU CPU + +mindspore.ops.Minimum +逐元素计算两个Tensor的最小值。 +Ascend GPU CPU + +mindspore.ops.NotEqual +逐元素计算两个Tensor是否不相等。 +Ascend GPU CPU + +mindspore.ops.SameTypeShape +Checks whether the data type and shape of two tensors are the same. +Ascend GPU CPU + + + + + +线性代数算子 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.BatchMatMul +基于batch维度的两个Tensor的矩阵乘法。 +Ascend GPU CPU + +mindspore.ops.BiasAdd +返回输入Tensor与偏置Tensor之和。 +Ascend GPU CPU + +mindspore.ops.Ger +计算两个一维Tensor的外积，即输入 x1 和输入 x2 的外积。 +Ascend GPU CPU + +mindspore.ops.MatMul +将矩阵 a 和矩阵 b 相乘。 +Ascend GPU CPU + +mindspore.ops.MatrixInverse +计算输入矩阵的逆矩阵，如果输入矩阵不可逆，将产生错误或者返回一个未知结果。 +GPU CPU + + + + +",mindspore.ops,mindspore、mindspore、算子、接口、GPU、CPU、Ascend、ateN、数据、npu +mindspore.ops§Tensor操作算子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + +Tensor创建 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.Eps +创建一个与输入数据类型和shape都相同的Tensor，元素值为对应数据类型能表达的最小值。 +Ascend GPU CPU + +mindspore.ops.Eye +创建一个主对角线上元素为1，其余元素为0的Tensor。 +Ascend GPU CPU + +mindspore.ops.Fill +创建一个指定shape的Tensor，并用指定值填充。 +Ascend GPU CPU + +mindspore.ops.LinSpace +返回一个在区间 start 和 stop （包括 start 和 stop ）内均匀分布的，包含 num 个值的1维Tensor。 +Ascend GPU CPU + +mindspore.ops.OneHot +返回一个one-hot类型的Tensor。 +Ascend GPU CPU + +mindspore.ops.Ones +创建一个值全为1的Tensor。 +Ascend GPU CPU + +mindspore.ops.OnesLike +返回值为1的Tensor，shape和数据类型与输入相同。 +Ascend GPU CPU + +mindspore.ops.Zeros +创建一个值全为0的Tensor。 +Ascend GPU CPU + +mindspore.ops.ZerosLike +返回值为0的Tensor，其shape和数据类型与输入Tensor相同。 +Ascend GPU CPU + + + + + +随机生成算子 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.Gamma +根据概率密度函数分布生成随机正值浮点数x。 +Ascend + +mindspore.ops.Multinomial +Returns a tensor sampled from the multinomial probability distribution located in the corresponding row of tensor input. +GPU + +mindspore.ops.Poisson +生成 Poisson 分布的随机数。 +Ascend + +mindspore.ops.RandomCategorical +Generates random samples from a given categorical distribution tensor. +Ascend GPU + +mindspore.ops.RandomChoiceWithMask +对输入进行随机取样，返回取样索引和掩码。 +Ascend GPU CPU + +mindspore.ops.Randperm +生成从0到n-1不重复的n个随机样本。 +Ascend GPU + +mindspore.ops.StandardLaplace +生成符合标准Laplace（mean=0, lambda=1）分布的随机数。 +Ascend + +mindspore.ops.StandardNormal +根据标准正态（高斯）随机数分布生成随机数。 +Ascend GPU CPU + +mindspore.ops.UniformInt +根据均匀分布在区间 [minval, maxval) 中生成随机数。 +Ascend GPU CPU + +mindspore.ops.UniformReal +产生随机的浮点数，均匀分布在[0，1)范围内。 +Ascend GPU CPU + + + + + +Array操作 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.BatchToSpace +Divides batch dimension with blocks and interleaves these blocks back into spatial dimensions. +Ascend GPU + +mindspore.ops.BatchToSpaceND +用块划分批次维度，并将这些块交错回空间维度。 +Ascend + +mindspore.ops.BroadcastTo +将输入shape广播到目标shape。 +Ascend GPU CPU + +mindspore.ops.Cast +转换输入Tensor的数据类型。 +Ascend GPU CPU + +mindspore.ops.Concat +在指定轴上拼接输入Tensor。 +Ascend GPU CPU + +mindspore.ops.CumProd +计算 x 沿着指定axis的元素累计积。 +Ascend GPU + +mindspore.ops.CumSum +计算输入Tensor在指定轴上的累加和。 +Ascend GPU CPU + +mindspore.ops.DataFormatDimMap +返回源数据格式中的目标数据格式的维度索引。 +Ascend GPU CPU + +mindspore.ops.DepthToSpace +Rearrange blocks of depth data into spatial dimensions. +Ascend GPU CPU + +mindspore.ops.DType +计算输入Tensor的数据类型，且返回的数据类型为 mindspore.dtype 。 +Ascend GPU CPU + +mindspore.ops.DynamicShape +与 TensorShape 相同， DynamicShape 将会被 TensorShape 替换，请使用 TensorShape 。 +Deprecated + +mindspore.ops.ExpandDims +对输入 input_x 在给定的轴上添加额外维度。 +Ascend GPU CPU + +mindspore.ops.FloatStatus +Determines if the elements contain Not a Number(NaN), infinite or negative infinite. +GPU + +mindspore.ops.Gather +返回输入Tensor在指定 axis 上 input_indices 索引对应的元素组成的切片。 +Ascend GPU CPU + +mindspore.ops.GatherD +获取指定轴的元素。 +Ascend GPU CPU + +mindspore.ops.GatherNd +根据索引获取输入Tensor指定位置上的元素。 +Ascend GPU CPU + +mindspore.ops.HistogramFixedWidth +Returns a rank 1 histogram counting the number of entries in values that fall into every bin. +Ascend + +mindspore.ops.Identity +返回与输入具有相同shape和值的Tensor。 +Ascend CPU GPU + +mindspore.ops.IndexAdd +将Tensor y 加到Tensor x 的指定 axis 和 indices 。 +Ascend GPU CPU + +mindspore.ops.InplaceAdd +将 input_v 添加到 x 的特定行。 +开发中 + +mindspore.ops.InplaceSub +从 x 的特定行减去 input_v 。 +开发中 + +mindspore.ops.InplaceUpdate +将 x 的特定行更新为 v 。 +Ascend CPU + +mindspore.ops.InvertPermutation +Computes the inverse of an index permutation. +Ascend GPU CPU + +mindspore.ops.MaskedFill +将掩码位置为True的位置填充指定的值。 +Ascend CPU + +mindspore.ops.MaskedSelect +返回一个一维张量，其中的内容是 x 张量中对应于 mask 张量中True位置的值。 +Ascend GPU CPU + +mindspore.ops.Meshgrid +从给定的Tensor生成网格矩阵。 +Ascend CPU GPU + +mindspore.ops.ParallelConcat +Concats tensor in the first dimension. +Ascend + +mindspore.ops.PopulationCount +计算二进制数中1的个数。 +Ascend + +mindspore.ops.Range +返回从 start 开始，步长为 delta ，且不超过 limit （不包括 limit ）的序列。 +GPU CPU + +mindspore.ops.Rank +返回输入Tensor的秩。 +Ascend GPU CPU + +mindspore.ops.Reshape +基于给定的shape，对输入Tensor进行重新排列。 +Ascend GPU CPU + +mindspore.ops.ReverseSequence +对输入序列进行部分反转。 +Ascend GPU + +mindspore.ops.ReverseV2 +对输入Tensor按指定维度反转。 +Ascend GPU + +mindspore.ops.ScatterNd +根据指定的索引将更新值散布到新Tensor上。 +Ascend GPU CPU + +mindspore.ops.Select +根据条件判断Tensor中的元素的值，决定输出中的相应元素是从 x （如果元素值为True）还是从 y （如果元素值为False）中选择。 +Ascend GPU CPU + +mindspore.ops.Shape +返回输入Tensor的shape。 +Ascend GPU CPU + +mindspore.ops.Size +返回一个Scalar，类型为整数，表示输入Tensor的大小，即Tensor中元素的总数。 +Ascend GPU CPU + +mindspore.ops.Slice +根据指定shape对输入Tensor进行切片。 +Ascend GPU CPU + +mindspore.ops.Sort +根据指定的轴对输入Tensor的元素进行排序。 +Ascend GPU CPU + +mindspore.ops.SpaceToBatch +SpaceToBatch is deprecated. +弃用 + +mindspore.ops.SpaceToBatchND +将空间维度划分为对应大小的块，并在批次维度重排张量。 +Ascend + +mindspore.ops.SpaceToDepth +将空间维度分块，增加Tensor深度。 +Ascend GPU CPU + +mindspore.ops.SparseGatherV2 +基于指定的索引和axis返回输入Tensor的切片。 +Ascend GPU + +mindspore.ops.Split +根据指定的轴和分割数量对输入Tensor进行分割。 +Ascend GPU CPU + +mindspore.ops.SplitV +Splits the input tensor into num_split tensors along the given dimension. +Ascend + +mindspore.ops.Squeeze +返回删除指定 axis 中大小为1的维度后的Tensor。 +Ascend GPU CPU + +mindspore.ops.Stack +在指定轴上对输入Tensor序列进行堆叠。 +Ascend GPU CPU + +mindspore.ops.StridedSlice +输入Tensor根据步长和索引进行切片提取。 +Ascend GPU CPU + +mindspore.ops.TensorScatterAdd +根据指定的更新值和输入索引，进行加法运算更新输入Tensor的值。 +Ascend GPU CPU + +mindspore.ops.TensorScatterDiv +根据指定的更新值和输入索引，进行除法运算更新输入Tensor的值。 +GPU CPU + +mindspore.ops.TensorScatterMax +根据指定的更新值和输入索引，通过最大值运算将结果赋值到输出Tensor中。 +GPU + +mindspore.ops.TensorScatterMin +根据指定的更新值和输入索引，计算原值与更新值的较小值并更新原值，返回更新后的Tensor。 +GPU + +mindspore.ops.TensorScatterMul +根据指定的更新值和输入索引，进行乘法运算更新输入Tensor的值。 +GPU CPU + +mindspore.ops.TensorScatterSub +根据指定的更新值和输入索引，进行减法运算更新输入Tensor的值。 +Ascend GPU CPU + +mindspore.ops.TensorScatterUpdate +根据指定的更新值和输入索引，通过更新操作更新输入Tensor的值。 +Ascend GPU CPU + +mindspore.ops.TensorShape +返回输入Tensor的Shape。 +Ascend GPU CPU + +mindspore.ops.Tile +按照给定的次数复制输入Tensor。 +Ascend GPU CPU + +mindspore.ops.TopK +沿最后一个维度查找 k 个最大元素和对应的索引。 +Ascend GPU CPU + +mindspore.ops.Transpose +根据指定的排列对输入的Tensor进行数据重排。 +Ascend GPU CPU + +mindspore.ops.Unique +Returns the unique elements of input tensor and also return a tensor containing the index of each value of input tensor corresponding to the output unique tensor. +Ascend GPU CPU + +mindspore.ops.UniqueWithPad +对输入一维张量中元素去重，返回一维张量中的唯一元素（使用pad_num填充）和相对索引。 +Ascend CPU + +mindspore.ops.UnsortedSegmentMax +沿分段计算输入Tensor的最大值。 +Ascend GPU CPU + +mindspore.ops.UnsortedSegmentMin +沿分段计算输入Tensor的最小值。 +Ascend GPU CPU + +mindspore.ops.UnsortedSegmentProd +沿分段计算输入Tensor元素的乘积。 +Ascend GPU + +mindspore.ops.UnsortedSegmentSum +沿分段计算输入Tensor元素的和。 +Ascend GPU CPU + +mindspore.ops.Unstack +根据指定轴对输入矩阵进行分解。 +Ascend GPU CPU + + + + + +类型转换 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.ScalarCast +Casts the input scalar to another type. +Ascend GPU CPU + +mindspore.ops.ScalarToArray +将Scalar转换为 Tensor 。 +Ascend GPU CPU + +mindspore.ops.ScalarToTensor +将Scalar转换为指定数据类型的 Tensor 。 +Ascend GPU CPU + +mindspore.ops.TupleToArray +将tuple转换为Tensor。 +Ascend GPU CPU + + + + +",mindspore.ops,mindspore、mindspore、算子、接口、GPU、CPU、Ascend、数据类型、ast、数据、ib、npu +mindspore.ops§Parameter操作算子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.Assign +为网络参数赋值。 +Ascend GPU CPU + +mindspore.ops.AssignAdd +进行加法运算更新网络参数。 +Ascend GPU CPU + +mindspore.ops.AssignSub +从网络参数减去特定数值来更新网络参数。 +Ascend CPU + +mindspore.ops.ScatterAdd +根据指定更新值和输入索引通过加法运算更新输入数据的值。 +Ascend GPU CPU + +mindspore.ops.ScatterDiv +根据指定更新值和输入索引通过除法运算更新输入数据的值。 +Ascend CPU + +mindspore.ops.ScatterMax +根据指定更新值和输入索引通过最大值运算更新输入数据的值。 +Ascend CPU GPU + +mindspore.ops.ScatterMin +根据指定更新值和输入索引通过最小值运算更新输入数据的值。 +Ascend GPU CPU + +mindspore.ops.ScatterMul +根据指定更新值和输入索引通过乘法运算更新输入数据的值。 +Ascend CPU + +mindspore.ops.ScatterNdAdd +使用给定值通过加法运算和输入索引更新Tensor值。 +Ascend GPU CPU + +mindspore.ops.ScatterNdSub +使用给定值通过减法运算和输入索引更新Tensor值。 +Ascend GPU CPU + +mindspore.ops.ScatterNdUpdate +使用给定值以及输入索引更新输入数据的值。 +Ascend GPU CPU + +mindspore.ops.ScatterNonAliasingAdd +使用给定值通过加法操作和输入索引来更新Tensor值。 +Ascend + +mindspore.ops.ScatterSub +使用给定更新值通过减法操作和输入索引来更新Tensor值。 +Ascend CPU GPU + +mindspore.ops.ScatterUpdate +使用给定的更新值和输入索引更新输入Tensor的值。 +Ascend GPU CPU + + + +",mindspore.ops,mindspore、mindspore、算子、接口、GPU、CPU、Ascend、网络、数据 +mindspore.ops§数据操作算子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.GetNext +返回数据集队列中的下一个元素。 +Ascend GPU + + + +",mindspore.ops,mindspore、mindspore、算子、接口、数据集、GPU、Ascend、数据 +mindspore.ops§通信算子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," +注意，以下列表中的接口需要先配置好通信环境变量。 +针对Ascend设备，用户需要准备rank表，设置rank_id和device_id，详见 Ascend指导文档 。 +针对GPU设备，用户需要准备host文件和mpi，详见 GPU指导文档 。 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.AllGather +在指定的通信组中汇聚Tensor。 +Ascend GPU + +mindspore.ops.AllReduce +使用指定方式对通信组内的所有设备的Tensor数据进行规约操作，所有设备都得到相同的结果。 +Ascend GPU CPU + +mindspore.ops.AlltoAll +AlltoAll is a collective operation. +Ascend + +mindspore.ops.Broadcast +对输入数据整组广播。 +Ascend GPU + +mindspore.ops.NeighborExchange +NeighborExchange is a collective operation. +Ascend + +mindspore.ops.NeighborExchangeV2 +NeighborExchangeV2 is a collective operation. +Ascend + +mindspore.ops.ReduceOp +Operation options for reducing tensors. +Ascend GPU + +mindspore.ops.ReduceScatter +Reduces and scatters tensors from the specified communication group. +Ascend GPU + + + +",mindspore.ops,mindspore、mindspore、算子、接口、GPU、CPU、Ascend、ast、lR、数据 +mindspore.ops§调试算子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.HistogramSummary +Outputs the tensor to protocol buffer through histogram summary operator. +Ascend GPU CPU + +mindspore.ops.ImageSummary +Outputs the image tensor to protocol buffer through image summary operator. +Ascend GPU CPU + +mindspore.ops.ScalarSummary +Outputs a scalar to a protocol buffer through a scalar summary operator. +Ascend GPU CPU + +mindspore.ops.TensorSummary +Outputs a tensor to a protocol buffer through a tensor summary operator. +Ascend GPU CPU + +mindspore.ops.Print +将输入Tensor或string进行打印输出。 +Ascend GPU + +mindspore.ops.NPUAllocFloatStatus +Allocates a flag to store the overflow status. +Ascend + +mindspore.ops.NPUClearFloatStatus +Clears the flag which stores the overflow status. +Ascend + +mindspore.ops.NPUGetFloatStatus +Updates the flag which is the output tensor of NPUAllocFloatStatus with the latest overflow status. +Ascend + + + +",mindspore.ops,mindspore、mindspore、算子、接口、GPU、CPU、Ascend、调试、NPU +mindspore.ops§稀疏算子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.SparseTensorDenseMatmul +Multiplies sparse matrix A by dense matrix B. +CPU + +mindspore.ops.SparseToDense +Converts a sparse representation into a dense tensor. +CPU + + + +",mindspore.ops,mindspore、mindspore、算子、接口、CPU +mindspore.ops§其他算子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.Depend +用来处理操作间的依赖关系。 +Ascend GPU CPU + +mindspore.ops.GradOperation +一个高阶函数，为输入函数生成梯度函数。 +Ascend GPU CPU + +mindspore.ops.HookBackward +This operation is used as a tag to hook gradient in intermediate variables. +Ascend GPU CPU + +mindspore.ops.HyperMap +对输入序列做集合运算。 +Ascend GPU CPU + +mindspore.ops.InsertGradientOf +为图节点附加回调函数，将在梯度计算时被调用。 +Ascend GPU CPU + +mindspore.ops.Map +Map will apply the set operation on input sequences. +Ascend GPU CPU + +mindspore.ops.MultitypeFuncGraph +Generates overloaded functions. +Ascend GPU CPU + +mindspore.ops.Partial +Makes a partial function instance. +Ascend GPU CPU + + + +",mindspore.ops,mindspore、GradOperation、mindspore、算子、接口、GPU、CPU、Ascend、Graph、npu +mindspore.ops§算子信息注册,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + + + + + + + +mindspore.ops.AiCPURegOp +Class for AiCPU operator information register. + +mindspore.ops.CustomRegOp +Class used for generating the registration information for the func parameter of mindspore.ops.Custom. + +mindspore.ops.DataType +Ascend算子的dtype和format的多种组合。 + +mindspore.ops.TBERegOp +注册TBE算子信息的类。 + +mindspore.ops.get_vm_impl_fn +通过Primitive对象或Primitive名称，获取虚拟实现函数。 + + + +",mindspore.ops,mindspore、mindspore、算子、CPU、Ascend +mindspore.ops§自定义算子,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html," + + + + + + + +mindspore.ops.Custom +Custom 算子是MindSpore自定义算子的统一接口。 + + + +",mindspore.ops,mindspore、mindspore、算子、接口 +mindspore.ops.functional§mindspore.ops.functional,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.functional.html," +functional算子是经过初始化后的Primitive，可以直接作为函数使用。functional算子的使用示例如下： +from mindspore import Tensor, ops +from mindspore import dtype as mstype + +input_x = Tensor(-1, mstype.int32) +input_dict = {'x':1, 'y':2} + +result_abs = ops.absolute(input_x) +print(result_abs) + +result_in_dict = ops.in_dict('x', input_dict) +print(result_in_dict) + +result_not_in_dict = ops.not_in_dict('x', input_dict) +print(result_not_in_dict) + +result_isconstant = ops.isconstant(input_x) +print(result_isconstant) + +result_typeof = ops.typeof(input_x) +print(result_typeof) + +# outputs: +# 1 +# True +# False +# True +# Tensor[Int32] + + + +",mindspore.ops.functional,mindspore、mindspore、算子、npu +mindspore.ops.functional§神经网络层函数,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.functional.html," + +神经网络 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.adaptive_avg_pool2d +2维自适应平均池化。 +GPU + +mindspore.ops.ctc_greedy_decoder +对输入中给定的logits执行贪婪解码。 +Ascend CPU + +mindspore.ops.dropout2d +在训练期间，以服从伯努利分布的概率 p 随机将输入Tensor的某些通道归零。 +Ascend GPU CPU + +mindspore.ops.dropout3d +在训练期间，以服从伯努利分布的概率 p 随机将输入Tensor的某些通道归零。 +Ascend GPU CPU + +mindspore.ops.flatten +扁平化（Flatten）输入Tensor，不改变0轴的size。 +Ascend GPU CPU + +mindspore.ops.padding +通过填充0，将输入张量的最后一个维度从1扩展到指定大小。 +Ascend GPU CPU + +mindspore.ops.interpolate +使用 mode 设置的插值方式调整输入 x 大小。 +Ascend CPU GPU + +mindspore.ops.lrn +局部响应归一化操作LRN(Local Response Normalization)。 +Ascend GPU CPU + + + + + +损失函数 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.smooth_l1_loss +计算平滑L1损失，该L1损失函数有稳健性。 +Ascend GPU CPU + + + + + +激活函数 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.fast_gelu +快速高斯误差线性单元激活函数。 +Ascend GPU CPU + +mindspore.ops.gumbel_softmax +返回Gumbel-Softmax分布的Tensor，在 hard = True 的时候，返回one-hot形式的离散型Tensor，hard = False 时返回在dim维进行过softmax的Tensor。 +Ascend GPU CPU + +mindspore.ops.hardshrink +Hard Shrink激活函数，按输入元素计算输出，公式定义如下：。 +Ascend GPU CPU + +mindspore.ops.log_softmax +LogSoftmax激活函数。 +Ascend GPU CPU + +mindspore.ops.mish +逐元素计算输入Tensor的MISH（Self Regularized Non-Monotonic Neural Activation Function 自正则化非单调神经激活函数）。 +Ascend CPU + +mindspore.ops.selu +激活函数selu（Scaled exponential Linear Unit）。 +Ascend GPU CPU + +mindspore.ops.soft_shrink +Soft Shrink激活函数，按输入元素计算输出，公式定义如下：。 +Ascend CPU GPU + +mindspore.ops.softsign +Softsign激活函数。 +Ascend CPU + +mindspore.ops.tanh +Tanh激活函数。 +Ascend GPU CPU + + + + +",mindspore.ops.functional,mindspore、mindspore、接口、损失函数、GPU、CPU、Ascend、网络、loss、ast、lr +mindspore.ops.functional§数学运算函数,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.functional.html," + +逐元素运算 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.abs +Returns absolute value of a tensor element-wise. +Ascend GPU CPU + +mindspore.ops.acos +Computes arccosine of input tensors element-wise. +Ascend GPU CPU + +mindspore.ops.acosh +Computes inverse hyperbolic cosine of the inputs element-wise. +Ascend GPU CPU + +mindspore.ops.add +两个输入Tensor逐元素相加。 +Ascend GPU CPU + +mindspore.ops.addn +逐元素将所有输入的Tensor相加。 +Ascend GPU CPU + +mindspore.ops.asin +Computes arcsine of input tensors element-wise. +Ascend GPU CPU + +mindspore.ops.asinh +Computes inverse hyperbolic sine of the input element-wise. +Ascend GPU CPU + +mindspore.ops.atan +Computes the trigonometric inverse tangent of the input element-wise. +Ascend GPU CPU + +mindspore.ops.atan2 +逐元素计算x/y的反正切值。 +Ascend CPU GPU + +mindspore.ops.atanh +Computes inverse hyperbolic tangent of the input element-wise. +Ascend CPU + +mindspore.ops.bernoulli +以p的概率随机将输出的元素设置为0或1，服从伯努利分布。 +GPU + +mindspore.ops.bessel_i0 +逐元素计算并返回输入Tensor的Bessel i0函数值。 +CPU + +mindspore.ops.bessel_i0e +逐元素计算并返回输入Tensor的Bessel i0e函数值。 +CPU + +mindspore.ops.bessel_i1 +逐元素计算并返回输入Tensor的Bessel i1函数值。 +CPU + +mindspore.ops.bessel_i1e +逐元素计算并返回输入Tensor的Bessel i1e函数值。 +CPU + +mindspore.ops.bessel_j0 +逐元素计算并返回输入Tensor的Bessel j0函数值。 +CPU + +mindspore.ops.bessel_j1 +逐元素计算并返回输入Tensor的Bessel j1函数值。 +CPU + +mindspore.ops.bessel_k0 +逐元素计算并返回输入Tensor的Bessel k0函数值。 +CPU + +mindspore.ops.bessel_k0e +逐元素计算并返回输入Tensor的Bessel k0e函数值。 +CPU + +mindspore.ops.bessel_k1 +逐元素计算并返回输入Tensor的Bessel k1函数值。 +CPU + +mindspore.ops.bessel_k1e +逐元素计算并返回输入Tensor的Bessel k1e函数值。 +CPU + +mindspore.ops.bessel_y0 +逐元素计算并返回输入Tensor的Bessel y0函数值。 +CPU + +mindspore.ops.bessel_y1 +逐元素计算并返回输入Tensor的Bessel y1函数值。 +CPU + +mindspore.ops.bitwise_and +逐元素执行两个Tensor的与运算。 +Ascend CPU + +mindspore.ops.bitwise_or +逐元素执行两个Tensor的或运算。 +Ascend CPU + +mindspore.ops.bitwise_xor +逐元素执行两个Tensor的异或运算。 +Ascend CPU + +mindspore.ops.ceil +向上取整函数。 +Ascend GPU CPU + +mindspore.ops.cos +Computes cosine of input element-wise. +Ascend GPU CPU + +mindspore.ops.cosh +逐元素计算 x 的双曲余弦值。 +Ascend GPU CPU + +mindspore.ops.div +Divides the first input tensor by the second input tensor in floating-point type element-wise. +Ascend GPU CPU + +mindspore.ops.erf +逐元素计算 x 的高斯误差函数。 +Ascend GPU CPU + +mindspore.ops.erfc +逐元素计算 x 的互补误差函数。 +Ascend GPU CPU + +mindspore.ops.exp +Returns exponential of a tensor element-wise. +Ascend GPU CPU + +mindspore.ops.expm1 +Returns exponential then minus 1 of a tensor element-wise. +Ascend GPU CPU + +mindspore.ops.floor +逐元素向下取整函数。 +Ascend GPU CPU + +mindspore.ops.floor_div +Divides the first input tensor by the second input tensor element-wise and round down to the closest integer. +Ascend GPU CPU + +mindspore.ops.floor_mod +Computes the remainder of division element-wise. +Ascend GPU CPU + +mindspore.ops.inv +逐元素计算输入Tensor的倒数。 +Ascend GPU CPU + +mindspore.ops.invert +对输入逐元素按位翻转。 +Ascend GPU CPU + +mindspore.ops.lerp +基于权重参数计算两个Tensor之间的线性插值。 +Ascend CPU + +mindspore.ops.log +逐元素返回Tensor的自然对数。 +Ascend GPU CPU + +mindspore.ops.logical_and +Computes the “logical AND” of two tensors element-wise. +Ascend GPU CPU + +mindspore.ops.logical_not +Computes the “logical NOT” of a tensor element-wise. +Ascend GPU CPU + +mindspore.ops.logical_or +Computes the “logical OR” of two tensors element-wise. +Ascend GPU CPU + +mindspore.ops.mul +两个Tensor逐元素相乘。 +Ascend GPU CPU + +mindspore.ops.neg +计算输入x的相反数并返回。 +Ascend GPU CPU + +mindspore.ops.pow +计算 x 中每个元素的 y 次幂。 +Ascend GPU CPU + +mindspore.ops.round +对输入数据进行四舍五入到最接近的整数数值。 +Ascend GPU CPU + +mindspore.ops.sin +Computes sine of the input element-wise. +Ascend GPU CPU + +mindspore.ops.sinh +Computes hyperbolic sine of the input element-wise. +Ascend GPU CPU + +mindspore.ops.sub +逐元素用第一个输入Tensor减去第二个输入Tensor。 +Ascend GPU CPU + +mindspore.ops.tan +计算输入元素的正切值。 +Ascend CPU GPU + + + + + + + + + +functional +Description + + + +mindspore.ops.absolute +absolute will be deprecated in the future. Please use mindspore.ops.abs instead. + +mindspore.ops.floordiv +floordiv will be deprecated in the future. Please use mindspore.ops.floor_div instead. + +mindspore.ops.floormod +floormod will be deprecated in the future. Please use mindspore.ops.floor_mod instead. + +mindspore.ops.neg_tensor +neg_tensor will be deprecated in the future. Please use mindspore.ops.neg instead. + +mindspore.ops.pows +pows will be deprecated in the future. Please use mindspore.ops.pow instead. + +mindspore.ops.sqrt +Refer to mindspore.ops.Sqrt. + +mindspore.ops.square +Refer to mindspore.ops.Square. + +mindspore.ops.tensor_add +tensor_add will be deprecated in the future. Please use mindspore.ops.add instead. + +mindspore.ops.tensor_div +tensor_div will be deprecated in the future. Please use mindspore.ops.div instead. + +mindspore.ops.tensor_exp +tensor_exp will be deprecated in the future. Please use mindspore.ops.exp instead. + +mindspore.ops.tensor_expm1 +tensor_expm1 will be deprecated in the future. Please use mindspore.ops.expm1 instead. + +mindspore.ops.tensor_floordiv +tensor_floordiv will be deprecated in the future. Please use mindspore.ops.floor_div instead. + +mindspore.ops.tensor_mod +tensor_mod will be deprecated in the future. Please use mindspore.ops.floor_mod instead. + +mindspore.ops.tensor_mul +tensor_mul will be deprecated in the future. Please use mindspore.ops.mul instead. + +mindspore.ops.tensor_pow +tensor_pow will be deprecated in the future. Please use mindspore.ops.pow instead. + +mindspore.ops.tensor_sub +tensor_sub will be deprecated in the future. Please use mindspore.ops.sub instead. + + + + + +Reduction函数 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.argmin +返回输入Tensor在指定轴上的最小值索引。 +Ascend CPU + +mindspore.ops.logsumexp +求Tensor的对数指数和。 +Ascend GPU CPU + +mindspore.ops.norm +返回给定Tensor的矩阵范数或向量范数。 +Ascend GPU CPU + + + + + + + + + +functional +Description + + + +mindspore.ops.amax +Refer to mindspore.ops.ReduceMax. + +mindspore.ops.mean +Refer to mindspore.ops.ReduceMean. + +mindspore.ops.amin +Refer to mindspore.ops.ReduceMin. + +mindspore.ops.prod +Refer to mindspore.ops.ReduceProd. + +mindspore.ops.reduce_sum +Refer to mindspore.ops.ReduceSum. + + + + + +比较函数 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.approximate_equal +Returns True if abs(x-y) is smaller than tolerance element-wise, otherwise False. +Ascend CPU + +mindspore.ops.equal +逐元素比较两个输入Tensor是否相等。 +Ascend GPU CPU + +mindspore.ops.ge +输入两个数据，逐元素比较第一个数据是否大于等于第二个数据。 +Ascend GPU CPU + +mindspore.ops.gt +按元素比较输入参数 \(x,y\) 的值，输出结果为bool值。 +Ascend GPU CPU + +mindspore.ops.intopk +判断目标标签是否在前 k 个预测中。 +Ascend GPU CPU + +mindspore.ops.isclose +返回一个布尔型Tensor，表示 x1 的每个元素与 x2 的对应元素在给定容忍度内是否“接近”，其中“接近”的数学公式为：。 +CPU + +mindspore.ops.isfinite +判断输入数据每个位置上的值是否是有限数。 +Ascend GPU CPU + +mindspore.ops.isnan +判断输入数据每个位置上的值是否是Nan。 +GPU CPU + +mindspore.ops.le +逐元素计算 \(x <= y\) 的bool值。 +Ascend GPU CPU + +mindspore.ops.less +Computes the boolean value of \(x < y\) element-wise. +Ascend GPU CPU + +mindspore.ops.maximum +逐元素计算两个输入Tensor中的最大值。 +Ascend GPU CPU + +mindspore.ops.minimum +Computes the minimum of input tensors element-wise. +Ascend GPU CPU + +mindspore.ops.ne +计算两个Tensor是否不相等。 +Ascend GPU CPU + +mindspore.ops.same_type_shape +Checks whether the data type and shape of two tensors are the same. +Ascend GPU CPU + + + + + + + + + +functional +Description + + + +mindspore.ops.check_bprop +Refer to mindspore.ops.CheckBprop. + +mindspore.ops.isinstance_ +Refer to mindspore.ops.IsInstance. + +mindspore.ops.issubclass_ +Refer to mindspore.ops.IsSubClass. + +mindspore.ops.not_equal +not_equal will be deprecated in the future. Please use mindspore.ops.ne instead. + +mindspore.ops.tensor_ge +tensor_ge will be deprecated in the future. Please use mindspore.ops.ge instead. + +mindspore.ops.tensor_gt +tensor_gt will be deprecated in the future. Please use mindspore.ops.gt instead. + +mindspore.ops.tensor_le +tensor_le will be deprecated in the future. Please use mindspore.ops.le instead. + +mindspore.ops.tensor_lt +tensor_lt will be deprecated in the future. Please use mindspore.ops.less instead. + + + + + +线性代数函数 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.batch_dot +当输入的两个Tensor是批量数据时，对其进行批量点积操作。 +Ascend GPU CPU + +mindspore.ops.dot +两个Tensor之间的点积。 +Ascend GPU CPU + +mindspore.ops.ger +计算输入一维Tensor x1 与 x2 的外积。 +Ascend GPU CPU + +mindspore.ops.matmul +计算两个数组的乘积。 +Ascend GPU CPU + +mindspore.ops.matrix_solve +求解线性方程组。 +GPU CPU + +mindspore.ops.tensor_dot +在指定轴上对Tensor a 和 b 进行点乘操作。 +Ascend GPU CPU + + + + +",mindspore.ops.functional,mindspore、mindspore、接口、GPU、CPU、Ascend、metric、数据、npu +mindspore.ops.functional§Tensor操作函数,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.functional.html," + +Tensor创建 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.eye +创建一个主对角线上元素为1，其余元素为0的Tensor。 +Ascend GPU CPU + +mindspore.ops.fill +创建一个指定shape的Tensor，并用指定值填充。 +Ascend GPU CPU + +mindspore.ops.linspace +返回一个在区间 start 和 stop （包括 start 和 stop ）内均匀分布的，包含 num 个值的1维Tensor。 +Ascend GPU CPU + +mindspore.ops.ones +创建一个值全为1的Tensor。 +Ascend GPU CPU + +mindspore.ops.ones_like +返回值为1的Tensor，shape和数据类型与输入相同。 +Ascend GPU CPU + +mindspore.ops.zeros_like +Returns a Tensor with a value of 0 and its shape and data type is the same as the input. +Ascend GPU CPU + + + + + +随机生成函数 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.gamma +根据伽马分布产生成随机数。 +Ascend + +mindspore.ops.laplace +Generates random numbers according to the Laplace random number distribution. +Ascend + +mindspore.ops.multinomial +Returns a tensor sampled from the multinomial probability distribution located in the corresponding row of the input tensor. +GPU + +mindspore.ops.normal +根据正态（高斯）随机数分布生成随机数。 +Ascend GPU CPU + +mindspore.ops.poisson +根据泊松随机数分布生成随机数。 +Ascend + +mindspore.ops.standard_normal +根据标准正态（高斯）随机数分布生成随机数。 +Ascend GPU CPU + +mindspore.ops.uniform +生成服从均匀分布的随机数。 +Ascend GPU CPU + + + + + +Array操作 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.adaptive_max_pool2d +二维自适应最大池化运算。 +Ascend GPU CPU + +mindspore.ops.broadcast_to +将输入shape广播到目标shape。 +Ascend GPU CPU + +mindspore.ops.col2im +将一组滑动局部块组合成一个大的张量。 +GPU + +mindspore.ops.concat +在指定轴上拼接输入Tensor。 +Ascend GPU CPU + +mindspore.ops.expand_dims +对输入 input_x 在给定的轴上添加额外维度。 +Ascend GPU CPU + +mindspore.ops.gather +返回输入Tensor在指定 axis 上 input_indices 索引对应的元素组成的切片。 +Ascend GPU CPU + +mindspore.ops.gather_d +获取指定轴的元素。 +Ascend GPU CPU + +mindspore.ops.gather_nd +根据索引获取输入Tensor指定位置上的元素。 +Ascend GPU CPU + +mindspore.ops.index_add +将Tensor y 加到Parameter x 的指定 axis 轴的指定 indices 位置。 +Ascend GPU CPU + +mindspore.ops.inplace_add +根据 indices，将 x 中的对应位置加上 v 。 +Ascend CPU + +mindspore.ops.inplace_sub +将 v 依照索引 indices 从 x 中减去。 +Ascend CPU + +mindspore.ops.matrix_band_part +将矩阵的每个中心带外的所有位置设置为0。 +GPU CPU + +mindspore.ops.meshgrid +从给定的Tensor生成网格矩阵。 +Ascend CPU GPU + +mindspore.ops.narrow +Returns a narrowed tensor from input tensor. +Ascend GPU CPU + +mindspore.ops.nonzero +计算x中非零元素的下标。 +GPU + +mindspore.ops.range +返回从 start 开始， 步长为 delta ，且不超过 limit （不包括 limit ）的序列。 +GPU CPU + +mindspore.ops.rank +Returns the rank of a tensor. +Ascend GPU CPU + +mindspore.ops.repeat_elements +在指定轴上复制输入Tensor的元素，类似 np.repeat 的功能。 +Ascend GPU CPU + +mindspore.ops.reshape +基于给定的shape，对输入Tensor进行重新排列。 +Ascend GPU CPU + +mindspore.ops.scatter_nd +根据指定的索引将更新值散布到新Tensor上。 +Ascend GPU CPU + +mindspore.ops.select +根据条件判断Tensor中的元素的值来，决定输出中的相应元素是从 x （如果元素值为True）还是从 y （如果元素值为False）中选择。 +Ascend GPU CPU + +mindspore.ops.sequence_mask +返回一个表示每个单元的前N个位置的掩码Tensor。 +GPU + +mindspore.ops.shape +Returns the shape of the input tensor. +Ascend GPU CPU + +mindspore.ops.size +返回一个Scalar，类型为整数，表示输入Tensor的大小，即Tensor中元素的总数。 +Ascend GPU CPU + +mindspore.ops.slice +根据指定shape对输入Tensor进行切片。 +Ascend GPU CPU + +mindspore.ops.split +根据指定的轴和分割数量对输入Tensor进行分割。 +Ascend GPU CPU + +mindspore.ops.stack +在指定轴上对输入Tensor序列进行堆叠。 +Ascend GPU CPU + +mindspore.ops.tensor_scatter_add +根据指定的更新值和输入索引，通过相加运算更新输入Tensor的值。 +Ascend GPU CPU + +mindspore.ops.tensor_scatter_div +根据索引，通过相除运算得到输出Tensor的值。 +GPU CPU + +mindspore.ops.tensor_scatter_mul +根据索引，通过乘法运算得到输出Tensor的值。 +GPU CPU + +mindspore.ops.tensor_scatter_sub +根据指定的更新值和输入索引，通过减法进行运算，将结果赋值到输出Tensor中。 +Ascend GPU CPU + +mindspore.ops.tile +按照给定的次数复制输入Tensor。 +Ascend GPU CPU + +mindspore.ops.transpose +根据指定的排列对输入的Tensor进行数据重排。 +Ascend GPU CPU + +mindspore.ops.unique +对输入Tensor中元素去重，并返回一个索引Tensor，包含输入Tensor中的元素在输出Tensor中的索引。 +Ascend GPU CPU + +mindspore.ops.unique_consecutive +对输入张量中连续且重复的元素去重。 +GPU + +mindspore.ops.unsorted_segment_max +沿分段计算输入Tensor的最大值。 +Ascend GPU CPU + +mindspore.ops.unsorted_segment_min +沿分段计算输入Tensor的最小值。 +Ascend GPU CPU + +mindspore.ops.unsorted_segment_prod +沿分段计算输入Tensor元素的乘积。 +Ascend GPU + + + + + + + + + +functional +Description + + + +mindspore.ops.cast +Refer to mindspore.ops.Cast. + +mindspore.ops.cumprod +Refer to mindspore.ops.CumProd. + +mindspore.ops.dtype +Refer to mindspore.ops.DType. + +mindspore.ops.sort +Refer to mindspore.ops.Sort. + +mindspore.ops.squeeze +Refer to mindspore.ops.Squeeze. + +mindspore.ops.strided_slice +Refer to mindspore.ops.StridedSlice. + +mindspore.ops.tensor_slice +tensor_slice will be deprecated in the future. Please use mindspore.ops.slice instead. + + + + + +类型转换 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.scalar_cast +Casts the input scalar to another type. +Ascend GPU CPU + +mindspore.ops.scalar_to_array +将Scalar转换为 Tensor 。 +Ascend GPU CPU + +mindspore.ops.scalar_to_tensor +将Scalar转换为指定数据类型的 Tensor 。 +Ascend GPU CPU + +mindspore.ops.tuple_to_array +将tuple转换为Tensor。 +Ascend GPU CPU + + + + + +稀疏函数 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.dense_to_sparse_coo +将常规Tensor转为稀疏化的COOTensor。 +GPU + +mindspore.ops.dense_to_sparse_csr +将常规Tensor转为稀疏化的CSRTensor。 +GPU + +mindspore.ops.csr_to_coo +将一个CSRTensor转化成一个COOTensor。 +GPU + + + + + +梯度剪裁 + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.clip_by_global_norm +通过权重梯度总和的比率来裁剪多个Tensor的值。 +Ascend GPU CPU + +mindspore.ops.clip_by_value +将输入Tensor值裁剪到指定的最小值和最大值之间。 +Ascend GPU CPU + + + + +",mindspore.ops.functional,mindspore、mindspore、接口、GPU、CPU、Ascend、数据类型、ast、数据、ib、npu +mindspore.ops.functional§Parameter操作函数,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.functional.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.assign +Assigns Parameter with a value. +Ascend GPU CPU + +mindspore.ops.assign_add +Updates a Parameter by adding a value to it. +Ascend GPU CPU + +mindspore.ops.assign_sub +Updates a Parameter by subtracting a value from it. +Ascend CPU + +mindspore.ops.scatter_add +根据指定的更新值和输入索引，进行加法运算更新输入Tensor的值，返回更新后的Tensor。 +Ascend GPU CPU + +mindspore.ops.scatter_div +根据指定更新值和输入索引通过除法运算更新输入数据的值。 +Ascend CPU + +mindspore.ops.scatter_min +根据指定更新值和输入索引通过最小值运算更新输入数据的值。 +Ascend GPU CPU + +mindspore.ops.scatter_max +根据指定更新值和输入索引通过最大值运算更新输入数据的值。 +Ascend CPU GPU + +mindspore.ops.scatter_nd_add +使用给定值通过加法运算和输入索引更新Tensor值。 +Ascend GPU CPU + +mindspore.ops.scatter_nd_div +使用给定值通过除法运算和输入索引更新 input_x 的值。 +GPU CPU + +mindspore.ops.scatter_nd_min +使用给定值通过最小值运算和输入索引更新 input_x 的值。 +GPU CPU + +mindspore.ops.scatter_nd_mul +使用给定值通过乘法运算和输入索引更新Parameter值。 +GPU CPU + +mindspore.ops.scatter_nd_sub +使用给定值通过减法运算和输入索引更新Tensor值。 +Ascend GPU CPU + +mindspore.ops.scatter_update +使用给定的更新值和输入索引更新输入Tensor的值。 +Ascend GPU CPU + + + +",mindspore.ops.functional,mindspore、mindspore、接口、GPU、CPU、Ascend、数据、npu +mindspore.ops.functional§微分函数,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.functional.html," + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.derivative +计算函数或网络输出对输入的高阶微分。 +Ascend GPU CPU + +mindspore.ops.grad +A wrapper function to generate the gradient function for the input function. +Ascend GPU CPU + +mindspore.ops.jet +计算函数或网络输出对输入的高阶微分。 +Ascend GPU CPU + +mindspore.ops.jvp +Compute the jacobian-vector-product of the given network. +Ascend GPU CPU + +mindspore.ops.vjp +Compute the vector-jacobian-product of the given network. +Ascend GPU CPU + +mindspore.ops.vmap +自动向量化（Vectorizing Map，vmap），是一种用于沿参数轴映射函数 fn 的高阶函数。 +Ascend GPU CPU + + + +",mindspore.ops.functional,mindspore、mindspore、接口、GPU、CPU、Ascend、网络、npu +mindspore.ops.functional§调试函数,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.functional.html," + + + + + + +functional +Description + + + +mindspore.ops.print_ +Refer to mindspore.ops.Print. + + + +",mindspore.ops.functional,mindspore、mindspore、调试 +mindspore.ops.functional§其他函数,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.functional.html," + + + + + + +functional +Description + + + +mindspore.ops.bool_and +Calculate the result of logical AND operation. (Usage is the same as “and” in Python) + +mindspore.ops.bool_eq +Determine whether the Boolean values are equal. (Usage is the same as “==” in Python) + +mindspore.ops.bool_not +Calculate the result of logical NOT operation. (Usage is the same as “not” in Python) + +mindspore.ops.bool_or +Calculate the result of logical OR operation. (Usage is the same as “or” in Python) + +mindspore.ops.depend +Refer to mindspore.ops.Depend. + +mindspore.ops.in_dict +Determine if a str in dict. + +mindspore.ops.is_not +Determine whether the input is not the same as the other one. (Usage is the same as “is not” in Python) + +mindspore.ops.is_ +Determine whether the input is the same as the other one. (Usage is the same as “is” in Python) + +mindspore.ops.isconstant +Determine whether the object is constant. + +mindspore.ops.not_in_dict +Determine whether the object is not in the dict. + +mindspore.ops.partial +Refer to mindspore.ops.Partial. + +mindspore.ops.scalar_add +Get the sum of two numbers. (Usage is the same as “+” in Python) + +mindspore.ops.scalar_div +Get the quotient of dividing the first input number by the second input number. (Usage is the same as “/” in Python) + +mindspore.ops.scalar_eq +Determine whether two numbers are equal. (Usage is the same as “==” in Python) + +mindspore.ops.scalar_floordiv +Divide the first input number by the second input number and round down to the closest integer. (Usage is the same as “//” in Python) + +mindspore.ops.scalar_ge +Determine whether the number is greater than or equal to another number. (Usage is the same as “>=” in Python) + +mindspore.ops.scalar_gt +Determine whether the number is greater than another number. (Usage is the same as “>” in Python) + +mindspore.ops.scalar_le +Determine whether the number is less than or equal to another number. (Usage is the same as “<=” in Python) + +mindspore.ops.scalar_log +Get the natural logarithm of the input number. + +mindspore.ops.scalar_lt +Determine whether the number is less than another number. (Usage is the same as “<” in Python) + +mindspore.ops.scalar_mod +Get the remainder of dividing the first input number by the second input number. (Usage is the same as “%” in Python) + +mindspore.ops.scalar_mul +Get the product of the input two numbers. (Usage is the same as “*” in Python) + +mindspore.ops.scalar_ne +Determine whether two numbers are not equal. (Usage is the same as “!=” in Python) + +mindspore.ops.scalar_pow +Compute a number to the power of the second input number. + +mindspore.ops.scalar_sub +Subtract the second input number from the first input number. (Usage is the same as “-” in Python) + +mindspore.ops.scalar_uadd +Get the positive value of the input number. + +mindspore.ops.scalar_usub +Get the negative value of the input number. + +mindspore.ops.shape_mul +The input of shape_mul must be shape multiply elements in tuple(shape). + +mindspore.ops.stop_gradient +Disable update during back propagation. (stop_gradient) + +mindspore.ops.string_concat +Concatenate two strings. + +mindspore.ops.string_eq +Determine if two strings are equal. + +mindspore.ops.typeof +Get type of object. + + + + + + + + + + +接口名 +概述 +支持平台 + +mindspore.ops.core +A decorator that adds a flag to the function. +Ascend GPU CPU + +mindspore.ops.count_nonzero +Count number of nonzero elements across axis of input tensor +Ascend GPU CPU + +mindspore.ops.cummin +Computation of the cumulative minimum of elements of ‘x’ in the dimension axis, and the index location of each maximum value found in the dimension ‘axis’. +Ascend GPU CPU + + + +",mindspore.ops.functional,mindspore、mindspore、接口、GPU、CPU、Ascend、aten、npu +mindspore.parallel.nn§mindspore.parallel.nn,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.parallel.nn.html," +Transformer接口的导入方式由 mindspore.parallel.nn 修改为 mindspore.nn.transformer ，这些接口的使用方式不变。 +原始的导入方式将保留1-2个版本。你可以通过以下样例查看差异： +# r1.5 +from mindspore.parallel.nn import Transformer + +# Current +from mindspore.nn.transformer import Transformer + + +",mindspore.parallel.nn,mindspore、mindspore、算子、npu +mindspore.scipy§mindspore.scipy,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.scipy.html," +Scipy-like interfaces in mindspore. + +",mindspore.scipy,mindspore、mindspore、scipy +mindspore.scipy§mindspore.scipy.linalg,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.scipy.html," +Linear algebra submodule. + + + + + + + +API Name +Description +Supported Platforms + +mindspore.scipy.linalg.block_diag +Create a block diagonal matrix from provided arrays. +CPU GPU + +mindspore.scipy.linalg.cho_factor +Compute the cholesky decomposition of a matrix, to use in cho_solve. +CPU GPU + +mindspore.scipy.linalg.cholesky +Compute the cholesky decomposition of a matrix. +CPU GPU + +mindspore.scipy.linalg.cho_solve +Given the cholesky factorization of a, solve the linear equation +CPU GPU + +mindspore.scipy.linalg.eigh +Solve a standard or generalized eigenvalue problem for a complex Hermitian or real symmetric matrix. +CPU GPU + +mindspore.scipy.linalg.inv +Compute the inverse of a matrix. +CPU GPU + +mindspore.scipy.linalg.lu +Compute pivoted LU decomposition of a general matrix. +CPU GPU + +mindspore.scipy.linalg.lu_factor +Compute pivoted LU decomposition of a square matrix, and its outputs can be directly used as the inputs of lu_solve. +CPU GPU + +mindspore.scipy.linalg.solve_triangular +Assuming a is a batched triangular matrix, solve the equation +CPU GPU + + + +",mindspore.scipy,mindspore、mindspore、GPU、CPU、API、metric、scipy、npu +mindspore.scipy§mindspore.scipy.optimize,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.scipy.html," +Optimize submodule. + + + + + + + +API Name +Description +Supported Platforms + +mindspore.scipy.optimize.line_search +Inexact line search that satisfies strong Wolfe conditions. +CPU GPU + +mindspore.scipy.optimize.minimize +Minimization of scalar function of one or more variables. +CPU GPU + + + +",mindspore.scipy,mindspore、mindspore、GPU、CPU、API、scipy +mindspore.scipy§mindspore.scipy.sparse.linalg,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.scipy.html," +Sparse linear algebra submodule. + + + + + + + +API Name +Description +Supported Platforms + +mindspore.scipy.sparse.linalg.cg +Use Conjugate Gradient iteration to solve the linear system: +CPU GPU + +mindspore.scipy.sparse.linalg.gmres +Given given A and b, GMRES solves the linear system: +CPU GPU + + + +",mindspore.scipy,mindspore、mindspore、GPU、CPU、API、scipy +mindspore.boost§mindspore.boost,https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.boost.html," +Boost能够自动加速网络，如减少BN/梯度冻结/累积梯度等。 + +Note +此特性为测试版本，我们仍在改进其功能。 + + + +class mindspore.boost.AutoBoost(level=""O0"", boost_config_dict="""")[源代码]¶ +MindSpore自动优化算法库。 +参数： + +level (str) - Boost的配置级别，默认值：”O0”。 + +“O0”： 不变化。 +“O1”： 启用boost模式, 性能将提升约20%, 准确率保持不变。 +“O2”： 启用boost模式, 性能将提升约30%, 准确率下降小于3%。 + + +boost_config_dict (dict) - 用户可配置的超参字典，建议的格式如下： +{ + ""boost"": { + ""mode"": ""auto"", + ""less_bn"": False, + ""grad_freeze"": False, + ""adasum"": False, + ""grad_accumulation"": False, + ""dim_reduce"": False}, + + ""common"": { + ""gradient_split_groups"": [50, 100], + ""device_number"": 8}, + + ""less_bn"": { + ""fn_flag"": True, + ""gc_flag"": True}, + + ""grad_freeze"": { + ""param_groups"": 10, + ""freeze_type"": 1, + ""freeze_p"": 0.7, + ""total_steps"": 65536}, + + ""grad_accumulation"": { + ""grad_accumulation_step"": 1}, + + ""dim_reduce"": { + ""rho"": 0.55, + ""gamma"": 0.9, + ""alpha"": 0.001, + ""sigma"": 0.4, + ""n_components"": 32, + ""pca_mat_path"": None, + ""weight_load_dir"": None, + ""timeout"": 1800} + +} + + + +boost： + +mode (str)： Boost配置模式，支持 [“auto”, “manual”, “enable_all”, “disable_all”]。默认值： “auto”。 + +auto： 自动配置，取决于Model类中的 boost_level 参数配置。 +manual： 在 boost_config_dict 中人工配置。 +enable_all： 开启所有boost算法。 +disable_all： 关闭所有boost算法。 + + +less_bn (bool)： 是否开启LessBN算法，默认：False +grad_freeze (bool)： 是否开启梯度冻结算法，默认：False。 +adasum (bool)： 是否开启自适应求和算法，默认：False。 +grad_accumulation (bool)： 是否开启梯度累加算法，默认：False。 +dim_reduce (bool)： 是否开启降维训练算法，默认：False。 +如果开启dim_reduce算法，其他算法会失效。 +如果开启grad_freeze算法，同时关闭dim_reduce，其他算法会失效。 + + + +common： + +gradient_split_groups (list)： 网络的梯度分割点，默认： [50, 100]。 +device_number (int)： 设备数，默认： 8。 + + +less_bn： + +fn_flag (bool)： 是否采用fn替换fc，默认： 替换。 +gc_flag (bool)： 是否启用gc，默认： 启用gc。 + + +grad_freeze： + +param_groups (int)： 参数分组数量，默认值： 10。 +freeze_type (int)： 梯度冻结策略，参数选择[0, 1]，默认值： 1。 +freeze_p (float)： 梯度冻结概率，默认值： 0.7。 +total_steps (int)： 总训练步数，默认值： 65536。 + + +grad_accumulation： + +grad_accumulation_step (int)： 累加梯度的步数，默认值： 1。 + + +dim_reduce： +dim_reduce主要原理： + +\[\begin{split}\begin{align} +grad\_k &= pca\_mat \cdot grad\\ +dk &= - bk \cdot grad\_k\\ +sk &= rho ^ m \cdot dk\\ +delta\_loss &= sigma \cdot grad\_k.T \cdot sk +\end{align}\end{split}\] +其中： + +pca_mat (array)： 维度(k*n)，k是 n_components 的大小，n是权重的大小。 +bk (array)： 维度(k*k)，bk是拟牛顿法中的对称正定矩阵。 + +我们需要找到满足以下条件的m： + +\[new\_loss < old\_loss + delta\_loss\] +然后使用 delta_grad 去更新模型的权重： + +\[\begin{split}\begin{align} +grad\_k\_proj &= pca\_mat.T \cdot grad\_k\\ +new\_grad\_momentum &= gamma \cdot old\_grad\_momentum + grad - grad\_k\_proj\\ +delta\_grad &= alpha \cdot new\_grad\_momentum - pca\_mat.T \cdot sk +\end{align}\end{split}\] + +rho (float)： 超参，一般无需调整，默认值： 0.55。 +gamma (float)： 超参，一般无需调整，默认值： 0.9。 +alpha (float)： 超参，一般无需调整，默认值： 0.001。 +sigma (float)： 超参，一般无需调整，默认值： 0.4。 +n_components (int)： PCA后的维度，默认值： 32。 +pca_mat_path (str)： PCA矩阵的加载路径，使用绝对路径，默认值： None。 +weight_load_dir (str)： 以checkpoint形式保存的权重加载路径，用于计算PCA矩阵，默认值： None。 +timeout (int)： 加载PCA矩阵的最长等待时间，默认值： 1800(s)。 + + + +用户可以通过加载JSON文件或者直接使用字典来配置 boost_config_dict。 +未配置的参数会使用默认值。 + + +异常： + +ValueError - Boost的模式不在[“auto”, “manual”, “enable_all”, “disable_all”]这个列表中。 + +支持平台： +Ascend +样例： +>>> from mindspore.boost import AutoBoost +>>> #1) when configuring the dict directly: +>>> boost_config_dict = {""boost"": {""mode"": ""auto""}} +>>> boost = AutoBoost(""O1"", boost_config_dict) +>>> +>>> #2) when loading the dict from a json file: +>>> import json +>>> boost_json = ""/path/boost_config.json"" +>>> with open(boost_json, 'r') as fp: +>>> boost_config_dict = json.load(fp) +>>> boost = AutoBoost(""O1"", boost_config_dict) + + + + +network_auto_process_eval(network)[源代码]¶ +使用Boost算法推理。 +参数： +network (Cell) - 推理网络。 + + + +network_auto_process_train(network, optimizer)[源代码]¶ +使用Boost算法训练。 +参数： + +network (Cell) - 训练网络。 +optimizer (Union[Cell]) - 用于更新权重的优化器。 + + + + + +class mindspore.boost.OptimizerProcess(opt)[源代码]¶ +处理Boost的优化器，目前支持给优化器添加梯度中心化和创建新的优化器。 +参数： + +opt (Cell) - 使用的优化器。 + +样例： +>>> import numpy as np +>>> from mindspore import Tensor, Parameter, nn +>>> from mindspore import ops +>>> from mindspore.boost import OptimizerProcess +>>> +>>> class Net(nn.Cell): +... def __init__(self, in_features, out_features): +... super(Net, self).__init__() +... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), +... name='weight') +... self.matmul = ops.MatMul() +... +... def construct(self, x): +... output = self.matmul(x, self.weight) +... return output +... +>>> size, in_features, out_features = 16, 16, 10 +>>> network = Net(in_features, out_features) +>>> optimizer = nn.Momentum(network.trainable_params(), learning_rate=0.1, momentum=0.9) +>>> optimizer_process = OptimizerProcess(optimizer) +>>> optimizer_process.add_grad_centralization(network) +>>> optimizer = optimizer_process.generate_new_optimizer() + + + + +add_grad_centralization(network)[源代码]¶ +添加梯度中心化。 +参数： + +network (Cell) - 训练网络。 + + + + +build_gc_params_group(params_dict, parameters)[源代码]¶ +构建梯度中心化的分组权重。 +参数： + +params_dict (dict) - 训练权重的字典。 +parameters (list) - 训练权重的列表。 + + + + +build_params_dict(network)[源代码]¶ +构建网络权重的字典。 +参数： + +network (Cell) - 训练网络。 + + + + +generate_new_optimizer()[源代码]¶ +生成新的优化器。 + + + + +class mindspore.boost.ParameterProcess[源代码]¶ +处理Boost网络的权重。当前支持创建分组参数和自动设置网络梯度切分点。 +样例： +>>> import numpy as np +>>> from mindspore import Tensor, Parameter, nn +>>> import mindspore.ops as ops +>>> from mindspore.boost import ParameterProcess +>>> +>>> class Net(nn.Cell): +... def __init__(self, in_features, out_features): +... super(Net, self).__init__() +... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), +... name='weight') +... self.weight2 = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), +... name='weight2') +... self.matmul = ops.MatMul() +... self.matmul2 = ops.MatMul() +... +... def construct(self, x): +... output = self.matmul(x, self.weight) +... output2 = self.matmul2(x, self.weight2) +... return output + output2 +... +>>> size, in_features, out_features = 16, 16, 10 +>>> network = Net(in_features, out_features) +>>> new_parameter = network.trainable_params()[:1] +>>> group_params = ParameterProcess.generate_group_params(new_parameter, network.trainable_params()) + + + + +assign_parameter_group(parameters, split_point=None)[源代码]¶ +设置分组权重。 +参数： + +parameters (list) - 训练网络的权重。 +split_point (list) - 网络梯度切分点。默认为None。 + + + + +generate_group_params(parameters, origin_params)[源代码]¶ +创建分组权重。 +参数： + +parameters (list) - 训练网络的新权重。 +origin_params (list) - 训练网络的初始权重。 + + + + + +class mindspore.boost.BoostTrainOneStepCell(network, optimizer, sens=1.0)[源代码]¶ +Boost网络训练封装类。 +用优化器封装网络，使用输入训练网络来获取结果。反向图在 construct 函数中自动创建，并且支持多种不同的并行模式。 +参数： + +network (Cell) - 训练网络，当前网络只支持单个输出。 +optimizer (Union[Cell]) - 用于更新网络参数的优化器。 +sens (numbers.Number) - 作为反向传播输入要填充的缩放数，默认值为1.0。 + +输入： + +(*inputs) (Tuple(Tensor)) - 网络的所有输入组成的元组。 + +输出： +Tuple，包含三个Tensor，分别为损失函数值、溢出状态和当前损失缩放系数。 + +loss(Tensor)，标量Tensor。 +overflow(Tensor)，标量Tensor，类型为bool。 +loss scaling value(Tensor)，标量Tensor。 + +异常： + +TypeError - 如果 sens 不是一个数字。 + +支持平台： +Ascend GPU CPU +样例： +>>> from mindspore import boost +>>> net = Net() +>>> loss_fn = nn.SoftmaxCrossEntropyWithLogits() +>>> optim = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9) +>>> #1) Using the WithLossCell existing provide +>>> loss_net = nn.WithLossCell(net, loss_fn) +>>> train_net = boost.BoostTrainOneStepCell(loss_net, optim) +>>> +>>> #2) Using user-defined WithLossCell +>>> class MyWithLossCell(Cell): +... def __init__(self, backbone, loss_fn): +... super(MyWithLossCell, self).__init__(auto_prefix=False) +... self._backbone = backbone +... self._loss_fn = loss_fn +... +... def construct(self, x, y, label): +... out = self._backbone(x, y) +... return self._loss_fn(out, label) +... +... @property +... def backbone_network(self): +... return self._backbone +... +>>> loss_net = MyWithLossCell(net, loss_fn) +>>> train_net = boost.BoostTrainOneStepCell(loss_net, optim) + + + + +adasum_process(loss, grads)[源代码]¶ +使用Adasum算法训练。 +参数： + +loss (Tensor) - 网络训练的loss值。 +grads (Tuple(Tensor)) - 网络训练过程中的梯度。 + +返回： +Tensor，网络训练过程中得到的loss值。 + + + +check_adasum_enable()[源代码]¶ +Adasum算法仅在多卡或者多机场景生效，并且要求卡数符合2的n次方，该函数用来判断adasum算法能否生效。 +返回： +enable_adasum (bool)，Adasum算法是否生效。 + + + +check_dim_reduce_enable()[源代码]¶ +获取当前是否使用降维二阶训练算法训练。 +返回： +enable_dim_reduce (bool)，降维二阶训练算法是否生效。 + + + +gradient_accumulation_process(loss, grads, sens, *inputs)[源代码]¶ +使用梯度累积算法训练。 +参数： + +loss (Tensor) - 网络训练的loss值。 +grads (Tuple(Tensor)) - 网络训练过程中的梯度。 +sens (Tensor) - 作为反向传播输入要填充的缩放数。 +inputs (Tuple(Tensor)) - 网络训练的输入。 + +返回： +Tensor，网络训练过程中得到的loss值。 + + + +gradient_freeze_process(*inputs)[源代码]¶ +使用梯度冻结算法训练。 +参数： + +inputs (Tuple(Tensor)) - 网络训练的输入。 + +返回： +Tensor，网络训练过程中得到的loss值。 + + + + +class mindspore.boost.BoostTrainOneStepWithLossScaleCell(network, optimizer, scale_sense)[源代码]¶ +使用混合精度功能的Boost训练网络。 +实现了包含损失缩放（loss scale）的单次训练。它使用网络、优化器和用于更新损失缩放系数（loss scale）的Cell(或一个Tensor)作为参数。可在host侧或device侧更新损失缩放系数。 +如果需要在host侧更新，使用Tensor作为 scale_sense ，否则，使用可更新损失缩放系数的Cell实例作为 scale_sense 。 +参数： + +network (Cell) - 训练网络，当前网络只支持单个输出。 +optimizer (Union[Cell]) - 用于更新网络参数的优化器。 +scale_sense (Union[Tensor, Cell]) - 如果此值为Cell类型，BoostTrainOneStepWithLossScaleCell 会调用它来更新损失缩放系数。如果此值为Tensor类型，可调用 set_sense_scale 来更新损失缩放系数，shape为 \(()\) 或 \((1,)\) 。 + +输入： + +(*inputs) (Tuple(Tensor)) - 网络的所有输入组成的元组。 + +输出： +Tuple，包含三个Tensor，分别为损失函数值、溢出状态和当前损失缩放系数。 + +loss (Tensor) - 标量Tensor。 +overflow (Tensor) - 标量Tensor，类型为bool。 +loss scaling value (Tensor) - 标量Tensor。 + +异常： + +TypeError - scale_sense 既不是Cell，也不是Tensor。 +ValueError - scale_sense 的shape既不是(1,)也不是()。 + +支持平台： +Ascend GPU +样例： +>>> import numpy as np +>>> from mindspore import Tensor, Parameter, nn +>>> import mindspore.ops as ops +>>> from mindspore.nn import WithLossCell +>>> from mindspore import dtype as mstype +>>> from mindspore import boost +>>> +>>> class Net(nn.Cell): +... def __init__(self, in_features, out_features): +... super(Net, self).__init__() +... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), +... name='weight') +... self.matmul = ops.MatMul() +... +... def construct(self, x): +... output = self.matmul(x, self.weight) +... return output +... +>>> size, in_features, out_features = 16, 16, 10 +>>> #1) when the type of scale_sense is Cell: +>>> net = Net(in_features, out_features) +>>> loss = nn.MSELoss() +>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9) +>>> net_with_loss = WithLossCell(net, loss) +>>> manager = nn.DynamicLossScaleUpdateCell(loss_scale_value=2**12, scale_factor=2, scale_window=1000) +>>> train_network = boost.BoostTrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=manager) +>>> input = Tensor(np.ones([out_features, in_features]), mstype.float32) +>>> labels = Tensor(np.ones([out_features,]), mstype.float32) +>>> output = train_network(input, labels) +>>> +>>> #2) when the type of scale_sense is Tensor: +>>> net = Net(in_features, out_features) +>>> loss = nn.MSELoss() +>>> optimizer = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9) +>>> net_with_loss = WithLossCell(net, loss) +>>> inputs = Tensor(np.ones([size, in_features]).astype(np.float32)) +>>> label = Tensor(np.zeros([size, out_features]).astype(np.float32)) +>>> scaling_sens = Tensor(np.full((1), np.finfo(np.float32).max), dtype=mstype.float32) +>>> train_network = boost.BoostTrainOneStepWithLossScaleCell(net_with_loss, optimizer, scale_sense=scaling_sens) +>>> output = train_network(inputs, label) + + + + + +class mindspore.boost.LessBN(network, fn_flag=False)[源代码]¶ +LessBN算法，可以在不损失网络精度的前提下，自动减少网络中批归一化（Batch Normalization）的数量，来提升网络性能。 +参数： + +network (Cell) - 待训练的网络模型。 +fn_flag (bool) - 是否将网络中最后一个全连接层替换为全归一化层。默认值：False。 + +样例： +>>> network = boost.LessBN(network) + + + + + +class mindspore.boost.GradientFreeze(param_groups, freeze_type, freeze_p, total_steps)[源代码]¶ +梯度冻结算法，根据指定策略随机冻结某些层的梯度，来提升网络训练性能。 +冻结的层数和冻结的概率均可由用户配置。 +参数： + +param_groups (Union[tuple, list]) - 梯度冻结训练的权重。 +freeze_type (int) - 梯度冻结训练的策略。 +freeze_p (float) - 梯度冻结训练的概率。 +total_steps (int) - 整个训练过程的总的步数。 + +样例： +>>> gradient_freeze_class = boost.GradientFreeze(10, 1, 0.5, 2000) +>>> network, optimizer = gradient_freeze_class.freeze_generate(network, optimizer) + + + + +freeze_generate(network, optimizer)[源代码]¶ +生成梯度冻结的网络与优化器。 +参数： + +network (Cell) - 训练网络。 +optimizer (Union[Cell]) - 用于更新权重的优化器。 + + + + +generate_freeze_index_sequence(parameter_groups_number, freeze_strategy, freeze_p, total_steps)[源代码]¶ +生成梯度冻结每一步需要冻结的层数。 +参数： + +parameter_groups_number (numbers.Number) - 梯度冻结训练的权重个数。 +freeze_strategy (int) - 梯度冻结训练的策略。 +freeze_p (float) - 梯度冻结训练的概率。 +total_steps (numbers.Number) - 整个训练过程的总的步数。 + + + + +split_parameters_groups(net, freeze_para_groups_number)[源代码]¶ +拆分用于梯度冻结训练的权重。 +参数： + +net (Cell) - 训练网络。 +freeze_para_groups_number (int) - 梯度冻结训练的权重个数。 + + + + + +class mindspore.boost.FreezeOpt(opt, train_parameter_groups=None, train_strategy=None)[源代码]¶ +支持梯度冻结训练的优化器。 +参数： + +opt (Cell) - 非冻结优化器实例，如 Momentum，SGD。 +train_parameter_groups (Union[tuple, list]) - 梯度冻结训练的权重。 +train_strategy (Union[tuple(int), list(int), Tensor]) - 梯度冻结训练的策略。 + +支持平台： +Ascend + + + +mindspore.boost.freeze_cell(reducer_flag, network, optimizer, sens, grad, use_grad_accumulation, mean=None, degree=None, max_accumulation_step=1)[源代码]¶ +提供带梯度冻结的网络Cell。 +参数： + +reducer_flag (bool): 是否分布式训练。 +network (Cell): 训练网络。 +optimizer (Cell): 优化器。 +sens (numbers.Number): 损失缩放系数。 +grad (tuple(Tensor)): 网络梯度。 +use_grad_accumulation (bool): 是否使用梯度累积。 +mean (bool): 可选参数，梯度是否求平均，仅分布式训练时生效。默认值为None。 +degree (int): 可选参数，device卡数，仅分布式训练时生效。默认值为None。 +max_accumulation_step (int): 可选参数，梯度累积步数。默认值为1。 + +样例： +>>> import numpy as np +>>> from mindspore import Tensor, Parameter, nn +>>> import mindspore.ops as ops +>>> from mindspore.boost.grad_freeze import freeze_cell, FreezeOpt +>>> +>>> class Net(nn.Cell): +... def __init__(self, in_features, out_features): +... super(Net, self).__init__() +... self.weight = Parameter(Tensor(np.ones([in_features, out_features]).astype(np.float32)), +... name='weight') +... self.matmul = ops.MatMul() +... +... def construct(self, x): +... output = self.matmul(x, self.weight) +... return output +... +>>> in_features, out_features = 16, 10 +>>> network = Net(in_features, out_features) +>>> optimizer = nn.Momentum(network.trainable_params(), learning_rate=0.1, momentum=0.9) +>>> optimizer = FreezeOpt(optimizer) +>>> grad = ops.GradOperation(get_by_list=True, sens_param=True) +>>> freeze_nets = freeze_cell(False, network, optimizer, 1.0, grad, False, None, None, 1) + + + + + +class mindspore.boost.GradientAccumulation(max_accumulation_step, optimizer)[源代码]¶ +梯度累积算法，在累积多个step的梯度之后，再用来更新网络权重，可以提高训练效率。 +参数： + +max_accumulation_step (int) - 累积梯度的步数。 +optimizer (Cell) - 网络训练使用的优化器。 + + + + +class mindspore.boost.AdaSum(rank, device_number, group_number, parameter_tuple)[源代码]¶ +Adaptive Summation(AdaSum)是一种优化深度学习模型并行训练的算法，它可以提升不同规模集群训练的精度，减小不同规模集群调参难度。 +参数： + +rank (int) - 总的训练的卡数。 +device_number (int) - 单机的卡数。 +group_number (int) - 分组的数量。 +parameter_tuple (Tuple(Parameter)) - 网络训练权重组成的元组。 + +输入： + +delta_weights (Tuple(Tensor)) - 梯度tuple。 +parameters (Tuple(Parameter)) - 当前权重组成的元组。 +old_parameters (Tuple(Parameter)) - 旧的权重组成的元组。 + +输出： + +adasum_parameters (Tuple(Tensor)) - adasum处理后更新的权重。 + + + + +class mindspore.boost.DimReduce(network, optimizer, weight, pca_mat_local, n_components, rho, gamma, alpha, sigma, rank, rank_size)[源代码]¶ +降维训练(dimension reduce training)是一种优化深度学习模型训练的算法，它可以加速模型的收敛。 +算法主要原理： + +\[\begin{split}\begin{align} +grad\_k &= pca\_mat \cdot grad\\ +dk &= - bk \cdot grad\_k\\ +sk &= rho ^ m \cdot dk\\ +delta\_loss &= sigma \cdot grad\_k.T \cdot sk +\end{align}\end{split}\] +其中: + +pca_mat (array): PCA矩阵，维度(k*n)，k是 n_components 的大小，n是权重的大小。 +bk (array): 维度(k*k)，bk是拟牛顿法中的对称正定矩阵。 + +我们需要找到满足以下条件的m: + +\[new\_loss < old\_loss + delta\_loss\] +然后使用delta_grad去更新模型的权重: + +\[\begin{split}\begin{align} +grad\_k\_proj &= pca\_mat.T \cdot grad\_k\\ +new\_grad\_momentum &= gamma \cdot old\_grad\_momentum + grad - grad\_k\_proj\\ +delta\_grad &= alpha \cdot new\_grad\_momentum - pca\_mat.T \cdot sk +\end{align}\end{split}\] +参数： + +network (Cell) - 训练网络，只支持单输出。 +optimizer (Union[Cell]) - 更新权重的优化器。 +weight (Tuple(Parameter)) - 网络权重组成的元组。 +pca_mat_local (numpy.ndarray) - 用于PCA操作的，经过切分的PCA转换矩阵，维度为k*n，k是切分的 n_components 的大小，n是权重的大小。 +n_components (int) - PCA的主成分维度(components)。 +rho (float) - 超参。 +gamma (float) - 超参。 +alpha (float) - 超参。 +sigma (float) - 超参。 +rank (int) - Rank编号。 +rank_size (int) - Rank总数。 + +输入： + +loss (Tensor) - 网络loss，标量Tensor。 +old_grad (Tuple(Tensor)) - 网络权重提取组成的元组。 +weight (Tuple(Tensor)) - 网络权重组成的元组。 +weight_clone (Tuple(Tensor)) - 网络权重的副本。 +(*inputs) (Tuple(Tensor)) - 网络的所有输入组成的元组。 + +输出： + +loss (Tensor) - 网络loss，标量Tensor。 + + + + +class mindspore.boost.GroupLossScaleManager(init_loss_scale, loss_scale_groups)[源代码]¶ +增强型混合精度算法支持不同loss scale的多层应用和损失尺度的动态更新。 +参数： + +init_loss_scale (Number) - 初始化loss scale。 +loss_scale_groups (List) - 从参数列表里分离出来的loss scale组。 + +输入： + +x (Tensor) - 最后一个operator的输出。 +layer1 (int) - 当前网络层的值。 +layer2 (int) - 最后一个网络层的值。 + +输出： + +x (Tensor) - _DynamicLossScale operator的输出。 + +支持平台： +Ascend +样例： +>>> import mindspore as ms +>>> from mindspore import boost, nn +>>> +>>> class Net(nn.Cell): +... def __init__(self, enhanced_amp, num_class=10, num_channel=1): +... super(Net, 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='ones') +... self.fc2 = nn.Dense(120, 84, weight_init='ones') +... self.fc3 = nn.Dense(84, num_class, weight_init='ones') +... self.relu = nn.ReLU() +... self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2) +... self.flatten = nn.Flatten() +... self.enhanced_amp = enhanced_amp +... +... def construct(self, x): +... x = self.enhanced_amp(x, 0, 1) +... x = self.max_pool2d(self.relu(self.conv1(x))) +... x = self.max_pool2d(self.relu(self.conv2(x))) +... x = self.flatten(x) +... x = self.enhanced_amp(x, 1, 2) +... x = self.relu(self.fc1(x)) +... x = self.relu(self.fc2(x)) +... x = self.fc3(x) +... x = self.enhanced_amp(x, 2, 3) +... return x +>>> +>>> loss_scale_manager = boost.GroupLossScaleManager(4096, []) +>>> net = Net(loss_scale_manager) +>>> param_group1 = [] +>>> param_group2 = [] +>>> for param in net.trainable_params(): +>>> if 'conv' in param.name: +>>> param_group1.append(param) +>>> else: +>>> param_group2.append(param) +>>> loss_scale_manager.loss_scale_groups = [param_group1, param_group2] +>>> loss = nn.SoftmaxCrossEntropyWithLogits() +>>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9) +>>> boost_config_dict = {""boost"": {""mode"": ""manual"", ""less_bn"": False, ""grad_freeze"": False, ""adasum"": False, >>> ""grad_accumulation"": False, ""dim_reduce"": False, ""loss_scale_group"": True}} +>>> model = ms.Model(net, loss_fn=loss, optimizer=optim, metrics=None, loss_scale_manager=loss_scale_manager, >>> boost_level=""O1"", boost_config_dict=boost_config_dict) +>>> # For details about how to build the dataset, please refer to the variable `dataset_train` in tutorial +>>> # document on the official website: +>>> # https://www.mindspore.cn/tutorials/zh-CN/master/beginner/quick_start.html +>>> dataset = create_custom_dataset() +>>> model.train(2, dataset) + + + + +get_loss_scale()[源代码]¶ +获取loss scale的值。 +返回： +bool，loss_scale 的值。 + + + +get_update_cell()[源代码]¶ +返回 mindspore.boost.GroupLossScaleManager 实例。 +返回： +mindspore.boost.GroupLossScaleManager 实例。 + + + +set_loss_scale_status(loss_scale_number, init_loss_scale)[源代码]¶ +生成动态loss scale元组，并设置溢出状态列表。 +参数： + +loss_scale_number (int) - loss scale的数量。 +init_loss_scale (float) - 已初始化的loss scale。 + + + + +update_loss_scale_status(layer, update_ratio)[源代码]¶ +更新动态loss scale。 +参数： + +layer (int) - 当前层。 +update_ratio (float) - 更新loss scale的当前比例。 + +输出： +float，新loss scale的值。 + + +",mindspore.boost,mindspore、mindspore、scipy +mindspore§接口汇总,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," + +类 + + + +类名 +描述 + + + + +Context +保存执行中的环境变量。 + + +DeviceInfoContext +不同硬件设备的环境信息。 + + +CPUDeviceInfo +模型运行在CPU上的配置，仅MindSpore Lite支持。 + + +GPUDeviceInfo +模型运行在GPU上的配置。 + + +KirinNPUDeviceInfo +模型运行在NPU上的配置，仅MindSpore Lite支持。 + + +Ascend910DeviceInfo +模型运行在Ascend910上的配置，MindSpore Lite不支持。 + + +Ascend310DeviceInfo +模型运行在Ascend310上的配置。 + + +Serialization +汇总了模型文件读写的方法。 + + +Buffer +Buff数据类。 + + +Model +MindSpore中的模型，便于计算图管理。 + + +MSTensor +MindSpore中的张量。 + + +QuantParam +MSTensor中的一组量化参数。 + + +MSKernelCallBack +MindSpore回调函数包装器，仅MindSpore Lite支持。 + + +MSCallBackParam +MindSpore回调函数的参数，仅MindSpore Lite支持。 + + +Delegate +MindSpore Lite接入第三方AI框架的代理，仅MindSpore Lite支持。 + + +SchemaVersion +MindSpore Lite 执行推理时模型文件的版本，仅MindSpore Lite支持。 + + +KernelIter +MindSpore Lite 算子列表的迭代器，仅MindSpore Lite支持。 + + +DelegateModel +MindSpore Lite Delegate机制封装的模型，仅MindSpore Lite支持。 + + +TrainCfg +MindSpore Lite训练配置类，仅MindSpore Lite支持。 + + +MixPrecisionCfg +MindSpore Lite训练混合精度配置类，仅MindSpore Lite支持。 + + +AccuracyMetrics +MindSpore Lite训练精度类，仅MindSpore Lite支持。 + + +Metrics +MindSpore Lite训练指标类，仅MindSpore Lite支持。 + + +TrainCallBack +MindSpore Lite训练回调类，仅MindSpore Lite支持。 + + +TrainCallBackData +定义了训练回调的一组参数，仅MindSpore Lite支持。 + + +CkptSaver +MindSpore Lite训练模型文件保存类，仅MindSpore Lite支持。 + + +LossMonitor +MindSpore Lite训练学习率调度类，仅MindSpore Lite支持。 + + +LRScheduler +MindSpore Lite训练配置类，仅MindSpore Lite支持。 + + +StepLRLambda +MindSpore Lite训练学习率的一组参数，仅MindSpore Lite支持。 + + +MultiplicativeLRLambda +每个epoch将学习率乘以一个因子，仅MindSpore Lite支持。 + + +TimeMonitor +MindSpore Lite训练时间监测类，仅MindSpore Lite支持。 + + +TrainAccuracy +MindSpore Lite训练学习率调度类，仅MindSpore Lite支持。 + + +CharVersion +获取当前版本号，仅MindSpore Lite支持。 + + +Version +获取当前版本号，仅MindSpore Lite支持。 + + +Allocator +内存管理基类。 + + +Status +返回状态类。 + + +Graph +图类。 + + +CellBase +容器基类。 + + +Cell +容器类。 + + +GraphCell +图容器类。 + + +RunnerConfig +模型并发推理配置参数。 + + +ModelParallelRunner +模型并发推理类。 + + + + + +枚举 + + + +接口名 +描述 + + + + +mindspore::DataType +MindSpore MSTensor保存的数据支持的类型。 + + +mindspore::Format +MindSpore MSTensor保存的数据支持的排列格式。 + + + + + +全局方法 + + + +方法名 +描述 + + + + +StringToChar +将std::string转换成std::vector。 + + +CharToString +将std::vector转换成std::string。 + + +PairStringToChar +将std::pair转换成std::pair, int32_t>。 + + +PairCharToString +将std::pair, int32_t>转换成std::pair。 + + +VectorStringToChar +将std::vector转换成std::vector>。 + + +VectorCharToString +将std::vector>转换成std::vector。 + + +SetStringToChar +将std::set转换成std::set>。 + + +SetCharToString +将std::set>转换成std::set。 + + +MapStringToChar +将std::map转换成std::map, int32_t>。 + + +MapCharToString +将std::map, int32_t>转换成std::map。 + + +UnorderedMapStringToChar +将std::unordered_map转换成std::map, std::vector>。 + + +UnorderedMapCharToString +将std::map, std::vector>转换成std::unordered_map。 + + +ClassIndexStringToChar +将std::vector>>转换成std::vector, std::vector>>。 + + +ClassIndexCharToString +将std::vector, std::vector>>转换成std::vector>>。 + + +PairStringInt64ToPairCharInt64 +将std::vector>转换成std::vector, int64_t>>。 + + +PadInfoStringToChar +将std::map转换成std::map, T>。 + + +PadInfoCharToString +将std::map, T>转换成std::map。 + + +TensorMapCharToString +将std::map, T>转换成std::unordered_map。 + + + + +",mindspore,mindspore、mindspore、算子、接口、CallBack、GPU、CPU、Ascend、Model、Loss、Metric、LR、学习率、精度、数据、计算图、精度、迭代、框架、Graph、NPU +mindspore§Context,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +Context类用于保存执行中的环境变量。 + +构造函数和析构函数 +Context(); +~Context() = default; + + + + +公有成员函数 + +SetThreadNum +void SetThreadNum(int32_t thread_num); + + +设置运行时的线程数，该选项仅MindSpore Lite有效。 + +参数 + +thread_num: 运行时的线程数。 + + + + + +GetThreadNum +int32_t GetThreadNum() const; + + +获取当前线程数设置。 + +返回值 +当前线程数设置。 + + + + +SetInterOpParallelNum +void SetInterOpParallelNum(int32_t parallel_num); + + +设置运行时的算子并行推理数目，该选项仅MindSpore Lite有效。 + +参数 + +parallel_num: 运行时的算子并行数。 + + + + + +GetInterOpParallelNum +int32_t GetInterOpParallelNum() const; + + +获取当前算子并行数设置。 + +返回值 +当前算子并行数设置。 + + + + +SetThreadAffinity +void SetThreadAffinity(int mode); + + +设置运行时的CPU绑核策略，该选项仅MindSpore Lite有效。 + +参数 + +mode: 绑核的模式，有效值为0-2，0为默认不绑核，1为绑大核，2为绑小核。 + + + + + +GetThreadAffinityMode +int GetThreadAffinityMode() const; + + +获取当前CPU绑核策略，该选项仅MindSpore Lite有效。 + +返回值 +当前CPU绑核策略，有效值为0-2，0为默认不绑核，1为绑大核，2为绑小核。 + + + + +SetThreadAffinity +void SetThreadAffinity(const std::vector &core_list); + + +设置运行时的CPU绑核列表，该选项仅MindSpore Lite有效。如果SetThreadAffinity和SetThreadAffinity同时设置，core_list生效，mode不生效。 + +参数 + +core_list: CPU绑核的列表。 + + + + + +GetThreadAffinityCoreList +std::vector GetThreadAffinityCoreList() const; + + +获取当前CPU绑核列表，该选项仅MindSpore Lite有效。 + +返回值 +当前CPU绑核列表。 + + + + +SetEnableParallel +void SetEnableParallel(bool is_parallel); + + +设置运行时是否支持并行，该选项仅MindSpore Lite有效。 + +参数 + +is_parallel: bool量，为true则支持并行。 + + + + + +GetEnableParallel +bool GetEnableParallel() const; + + +获取当前是否支持并行，该选项仅MindSpore Lite有效。 + +返回值 +返回值为为true，代表支持并行。 + + + + +SetDelegate +void SetDelegate(const std::shared_ptr &delegate); + + +设置Delegate，Delegate定义了用于支持第三方AI框架接入的代理，该选项仅MindSpore Lite有效。 + +参数 + +delegate: Delegate指针。 + + + + + +GetDelegate +std::shared_ptr GetDelegate() const; + + +获取当前Delegate，该选项仅MindSpore Lite有效。 + +返回值 +当前Delegate的指针。 + + + + +MutableDeviceInfo +std::vector> &MutableDeviceInfo(); + + +修改该context下的DeviceInfoContext数组，仅MindSpore Lite支持数组中有多个成员是异构场景。 + +返回值 +存储DeviceInfoContext的vector的引用。 + + + + +",mindspore,mindspore、mindspore、并行、算子、CPU、框架 +mindspore§DeviceInfoContext,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +DeviceInfoContext类定义不同硬件设备的环境信息。 + +构造函数和析构函数 +DeviceInfoContext(); +virtual ~DeviceInfoContext() = default; + + + + +公有成员函数 + +GetDeviceType +virtual enum DeviceType GetDeviceType() const = 0; + + +获取该DeviceInfoContext的类型。 + +返回值 +该DeviceInfoContext的类型。 +enum DeviceType { + kCPU = 0, + kGPU, + kKirinNPU, + kAscend910, + kAscend310, + // add new type here + kInvalidDeviceType = 100, +}; + + + + + + +Cast +template std::shared_ptr Cast(); + + +在打开-fno-rtti编译选项的情况下提供类似RTTI的功能，将DeviceInfoContext转换为T类型的指针，若转换失败返回nullptr。 + +返回值 +转换后T类型的指针，若转换失败则为nullptr。 + + + + +GetProvider +std::string GetProvider() const; + + +获取设备的生产商名。 + + +SetProvider +void SetProvider(const std::string &provider); + + +设置设备生产商名。 + +参数 + +provider: 生产商名。 + + + + + +GetProviderDevice +std::string GetProviderDevice() const; + + +获取生产商设备名。 + + +SetProviderDevice +void SetProviderDevice(const std::string &device); + + +设备生产商设备名。 + +参数 + +device: 设备名。 + + + + + +SetAllocator +void SetAllocator(const std::shared_ptr &allocator); + + +设置内存管理器。 + +参数 + +allocator: 内存管理器。 + + + + + +GetAllocator +std::shared_ptr GetAllocator() const; + + +获取内存管理器。 + + +",mindspore,mindspore、mindspore、GPU、CPU、Ascend、ast、NPU +mindspore§CPUDeviceInfo,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +派生自DeviceInfoContext，模型运行在CPU上的配置，仅MindSpore Lite支持该选项。 + +公有成员函数 + + + +函数 +说明 + + + + +enum DeviceType GetDeviceType() const +- 返回值: DeviceType::kCPU + + +void SetEnableFP16(bool is_fp16) +用于指定是否以FP16精度进行推理 - is_fp16: 是否以FP16精度进行推理 + + +bool GetEnableFP16() const +- 返回值: 已配置的精度模式 + + + + +",mindspore,mindspore、mindspore、CPU、精度、精度 +mindspore§GPUDeviceInfo,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +派生自DeviceInfoContext，模型运行在GPU上的配置，仅MindSpore Lite支持该选项。 + +公有成员函数 + + + +函数 +说明 + + + + +enum DeviceType GetDeviceType() const +- 返回值: DeviceType::kGPU + + +void SetDeviceID(uint32_t device_id) +用于指定设备ID - device_id: 设备ID + + +uint32_t GetDeviceID() const +- 返回值: 已配置的设备ID + + +void SetPrecisionMode(const std::string &precision_mode) +用于指定推理时算子精度 - precision_mode: 可选值origin(以模型中指定精度进行推理), fp16(以FP16精度进行推理)，默认值: origin + + +std::string GetPrecisionMode() const +- 返回值: 已配置的精度模式 + + +int GetRankID() const +- 返回值: 当前运行的RANK ID + + +void SetEnableFP16(bool is_fp16) +用于指定是否以FP16精度进行推理 - is_fp16: 是否以FP16精度进行推理 + + +bool GetEnableFP16() const +- 返回值: 已配置的精度模式 + + +void SetGLContext(void *gl_context) +用于指定OpenGL EGLContext - *gl_context: OpenGL的当前运行时的EGLContext值 + + +void *GetGLContext() const +- 返回值: 已配置的指向OpenGL EGLContext的指针 + + +void SetGLDisplay(void *gl_display) +用于指定OpenGL EGLDisplay - *gl_display: OpenGL的当前运行时的EGLDisplay值 + + +void *GetGLDisplay() const +- 返回值: 已配置的指向OpenGL EGLDisplay的指针 + + + + +",mindspore,mindspore、mindspore、算子、GPU、精度、精度 +mindspore§KirinNPUDeviceInfo,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +派生自DeviceInfoContext，模型运行在NPU上的配置，仅MindSpore Lite支持该选项。 + +公有成员函数 + + + +函数 +说明 + + + + +enum DeviceType GetDeviceType() const +- 返回值: DeviceType::kGPU + + +void SetFrequency(int frequency) +用于指定NPU频率 - frequency: 设置为1（低功耗）、2（均衡）、3（高性能）、4（极致性能），默认为3 + + +int GetFrequency() const +- 返回值: 已配置的NPU频率模式 + + + + +",mindspore,mindspore、mindspore、GPU、性能、NPU +mindspore§Ascend910DeviceInfo,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +派生自DeviceInfoContext，模型运行在Ascend910上的配置，MindSpore Lite不支持该选项。 + +公有成员函数 + + + +函数 +说明 + + + + +void SetDeviceID(uint32_t device_id) +用于指定设备ID - device_id: 设备ID + + +uint32_t GetDeviceID() const +- 返回值: 已配置的设备ID + + + + +",mindspore,mindspore、mindspore、Ascend +mindspore§Ascend310DeviceInfo,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +派生自DeviceInfoContext，模型运行在Ascend310上的配置。 + +公有成员函数 + + + +函数 +说明 + + + + +void SetDeviceID(uint32_t device_id) +用于指定设备ID - device_id: 设备ID + + +uint32_t GetDeviceID() const +- 返回值: 已配置的设备ID + + +void SetInsertOpConfigPath(const std::string &cfg_path) +模型插入AIPP算子 - cfg_path: AIPP配置文件路径 + + +std::string GetInsertOpConfigPath() +- 返回值: 已配置的AIPP + + +void SetInputFormat(const std::string &format) +指定模型输入formatt - format: 可选有""NCHW""，""NHWC""等 + + +std::string GetInputFormat() +- 返回值: 已配置模型输入format + + +void SetInputShape(const std::string &shape) +指定模型输入shape - shape: 如""input_op_name1:1,2,3,4;input_op_name2:4,3,2,1"" + + +std::string GetInputShape() +- 返回值: 已配置模型输入shape + + +void SetOutputType(enum DataType output_type) +指定模型输出type - output_type: 仅支持uint8、fp16和fp32 + + +enum DataType GetOutputType() +- 返回值: 已配置模型输出type + + +void SetPrecisionMode(const std::string &precision_mode) +配置模型精度模式 - precision_mode: 可选有""force_fp16""，""allow_fp32_to_fp16""，""must_keep_origin_dtype""或者""allow_mix_precision""，默认为""force_fp16"" + + +std::string GetPrecisionMode(t) +- 返回值: 已配置模型精度模式 + + +void SetOpSelectImplMode(const std::string &op_select_impl_mode) +配置算子选择模式 - op_select_impl_mode: 可选有""high_performance""和""high_precision""，默认为""high_performance"" + + +std::string GetOpSelectImplMode() +- 返回值: 已配置算子选择模式 + + + + +",mindspore,mindspore、mindspore、算子、Ascend、精度、精度、AIPP、npu +mindspore§Serialization,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +Serialization类汇总了模型文件读写的方法。 + +静态公有成员函数 + +Load +从文件加载模型。 +Status Load(const std::string &file, ModelType model_type, Graph *graph, const Key &dec_key = {}, + const std::string &dec_mode = kDecModeAesGcm); + + + +参数 + +file: 模型文件路径。 +model_type: 模型文件类型，可选有ModelType::kMindIR、ModelType::kMindIR_Lite、ModelType::kOM。MindSpore Lite支持ModelType::kMindIR、ModelType::kMindIR_Lite类型。 +graph: 输出参数，保存图数据的对象。 +dec_key: 解密密钥，用于解密密文模型，密钥长度为16、24或32。MindSpore Lite不支持该参数。 +dec_mode: 解密模式，可选有AES-GCM、AES-CBC。MindSpore Lite不支持该参数。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Load +从多个文件加载多个模型，MindSpore Lite未提供此功能。 +Status Load(const std::vector &files, ModelType model_type, std::vector *graphs, + const Key &dec_key = {}, const std::string &dec_mode = kDecModeAesGcm); + + + +参数 + +files: 多个模型文件路径，用vector存储。 +model_type: 模型文件类型，可选有ModelType::kMindIR、ModelType::kMindIR_Lite、ModelType::kOM。MindSpore Lite支持ModelType::kMindIR、ModelType::kMindIR_Lite类型。 +graphs: 输出参数，依次保存图数据的对象。 +dec_key: 解密密钥，用于解密密文模型，密钥长度为16、24或32。 +dec_mode: 解密模式，可选有AES-GCM、AES-CBC。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Load +从内存缓冲区加载模型。 +Status Load(const void *model_data, size_t data_size, ModelType model_type, Graph *graph, + const Key &dec_key = {}, const std::string &dec_mode = kDecModeAesGcm); + + + +参数 + +model_data：模型数据指针。 +data_size：模型数据字节数。 +model_type: 模型文件类型，可选有ModelType::kMindIR、ModelType::kMindIR_Lite、ModelType::kOM。MindSpore Lite支持ModelType::kMindIR、ModelType::kMindIR_Lite类型。 +graph：输出参数，保存图数据的对象。 +dec_key: 解密密钥，用于解密密文模型，密钥长度为16、24或32。MindSpore Lite不支持该参数。 +dec_mode: 解密模式，可选有AES-GCM、AES-CBC。MindSpore Lite不支持该参数。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +SetParameters +配置模型参数。MindSpore Lite未提供此功能。 +static Status SetParameters(const std::map ¶meters, Model *model); + + + +参数 + +parameters：参数。 +model：模型。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +ExportModel +导出训练模型，MindSpore Lite未提供此功能。 +static Status ExportModel(const Model &model, ModelType model_type, Buffer *model_data); + + + +参数 + +model：模型数据。 +model_type：模型文件类型。 +model_data：模型参数数据。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +ExportModel +导出训练模型，MindSpore Lite训练使用。 +static Status ExportModel(const Model &model, ModelType model_type, const std::string &model_file, + QuantizationType quantization_type = kNoQuant, bool export_inference_only = true, + std::vector output_tensor_name = {}); + + + +参数 + +model：模型数据。 +model_type：模型文件类型。 +model_file：保存的模型文件。 +quantization_type: 量化类型。 +export_inference_only: 是否导出只做推理的模型。 +output_tensor_name: 设置导出的推理模型的输出张量的名称，默认为空，导出完整的推理模型。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +",mindspore,mindspore、mindspore、MindIR、Model、数据、Graph +mindspore§Buffer,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +Buffer定义了MindSpore中Buffer数据的结构。 + +构造函数和析构函数 + Buffer(); + Buffer(const void *data, size_t data_len); + ~Buffer(); + + + + +公有成员函数 + +Data +const void *Data() const; + + +获取只读的数据地址。 + +返回值 +const void指针。 + + + + +MutableData +void *MutableData(); + + +获取可写的数据地址。 + +返回值 +void指针。 + + + + +DataSize +size_t DataSize() const; + + +获取data大小。 + +返回值 +当前data大小。 + + + + +ResizeData +bool ResizeData(size_t data_len); + + +重置data大小。 + +参数 + +data_len: data大小 + + +返回值 +是否配置成功。 + + + + +SetData +bool SetData(const void *data, size_t data_len); + + +配置Data和大小。 + +参数 + +data: data地址 +data_len: data大小 + + +返回值 +是否配置成功。 + + + + +Clone +Buffer Clone() const; + + +拷贝一份自身的副本。 + +返回值 +指向副本的指针。 + + + + +",mindspore,mindspore、mindspore、数据 +mindspore§Model,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +Model定义了MindSpore中的模型，便于计算图管理。 + +构造函数和析构函数 +Model(); +~Model(); + + + + +公有成员函数 + +Build +Status Build(GraphCell graph, const std::shared_ptr &model_context = nullptr, + const std::shared_ptr &train_cfg = nullptr); + + +将GraphCell存储的模型编译至可在Device上运行的状态。 + +参数 + +graph: GraphCell是Cell的一个派生，Cell目前没有开放使用。GraphCell可以由Graph构造，如model.Build(GraphCell(graph), context)。 +model_context: 模型Context。 +train_cfg: train配置文件TrainCfg。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Build +Status Build(const void *model_data, size_t data_size, ModelType model_type, + const std::shared_ptr &model_context = nullptr); + + +从内存缓冲区加载模型，并将模型编译至可在Device上运行的状态。 + +参数 + +model_data: 指向存储读入模型文件缓冲区的指针。 +data_size: 缓冲区大小。 +model_type: 模型文件类型，可选有ModelType::kMindIR、ModelType::kMindIR_Lite、ModelType::kOM。MindSpore Lite支持ModelType::kMindIR、ModelType::kMindIR_Lite类型。 +model_context: 模型Context。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Build +Status Build(const void *model_data, size_t data_size, ModelType model_type, + const std::shared_ptr &model_context = nullptr, const Key &dec_key = {}, + const std::string &dec_mode = kDecModeAesGcm, const std::string &cropto_lib_path); + + +从内存缓冲区加载模型，并将模型编译至可在Device上运行的状态。 + +参数 + +model_data: 指向存储读入模型文件缓冲区的指针。 +data_size: 缓冲区大小。 +model_type: 模型文件类型，可选有ModelType::kMindIR、ModelType::kMindIR_Lite、ModelType::kOM。MindSpore Lite支持ModelType::kMindIR、ModelType::kMindIR_Lite类型。 +model_context: 模型Context。 +dec_key: 解密密钥，用于解密密文模型，密钥长度为16。 +dec_mode: 解密模式，可选有AES-GCM。 +cropto_lib_path: OpenSSL Crypto解密库路径。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Build +Status Build(const std::string &model_path, ModelType model_type, + const std::shared_ptr &model_context = nullptr); + + +根据路径读取加载模型，并将模型编译至可在Device上运行的状态。 + +参数 + +model_path: 模型文件路径。 +model_type: 模型文件类型，可选有ModelType::kMindIR、ModelType::kMindIR_Lite、ModelType::kOM。MindSpore Lite支持ModelType::kMindIR、ModelType::kMindIR_Lite类型。 +model_context: 模型Context。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Build +Status Build(const std::string &model_path, ModelType model_type, + const std::shared_ptr &model_context = nullptr, const Key &dec_key = {}, + const std::string &dec_mode = kDecModeAesGcm, const std::string &cropto_lib_path); + + +根据路径读取加载模型，并将模型编译至可在Device上运行的状态。 + +参数 + +model_path: 模型文件路径。 +model_type: 模型文件类型，可选有ModelType::kMindIR、ModelType::kMindIR_Lite、ModelType::kOM。MindSpore Lite支持ModelType::kMindIR、ModelType::kMindIR_Lite类型。 +model_context: 模型Context。 +dec_key: 解密密钥，用于解密密文模型，密钥长度为16。 +dec_mode: 解密模式，可选有AES-GCM。 +cropto_lib_path: OpenSSL Crypto解密库路径。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + +Build之后对model_context的其他修改不再生效。 + + + +Predict +Status Predict(const std::vector &inputs, std::vector *outputs, const MSKernelCallBack &before = nullptr, const MSKernelCallBack &after = nullptr) + + +推理模型。 + +参数 + +inputs: 模型输入按顺序排列的vector。 +outputs: 输出参数，按顺序排列的vector的指针，模型输出会按顺序填入该容器。 +before: 一个MSKernelCallBack 结构体。定义了运行每个节点之前调用的回调函数。 +after: 一个MSKernelCallBack 结构体。定义了运行每个节点之后调用的回调函数。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Predict +Status Predict(const MSKernelCallBack &before = nullptr, const MSKernelCallBack &after = nullptr) + + +推理模型。 + +参数 + +before: 一个MSKernelCallBack 结构体。定义了运行每个节点之前调用的回调函数。 +after: 一个MSKernelCallBack 结构体。定义了运行每个节点之后调用的回调函数。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +LoadConfig +Status LoadConfig(const std::string &config_path); + + +根据路径读取配置文件。 + +参数 + +config_path: 配置文件路径。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + +用户可以调用LoadConfig接口进行混合精度推理的设置，配置文件举例如下： +[execution_plan] +op_name1=data_type:float16 +op_name2=data_type:float32 + + + +UpdateConfig +Status UpdateConfig(const std::string §ion, const std::pair &config); + + +刷新配置，读文件相对比较费时，如果少部分配置发生变化可以通过该接口更新部分配置。 + +参数 + +section: 配置的章节名。 +config: 要更新的配置对。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +GetInputs +std::vector GetInputs(); + + +获取模型所有输入张量。 + +返回值 +包含模型所有输入张量的容器类型变量。 + + + + +GetInputByTensorName +MSTensor GetInputByTensorName(const std::string &tensor_name); + + +获取模型指定名字的输入张量。 + +返回值 +指定名字的输入张量，如果该名字不存在则返回非法张量。 + + + + +GetGradients +std::vector GetGradients() const; + + +获取所有Tensor的梯度。 + +返回值 +获取所有Tensor的梯度。 + + + + +ApplyGradients +Status ApplyGradients(const std::vector &gradients); + + +应用所有Tensor的梯度。 + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +GetOptimizerParams +std::vector GetOptimizerParams() const; + + +获取optimizer参数MSTensor。 + +返回值 +所有optimizer参数MSTensor。 + + + + +SetOptimizerParams +Status SetOptimizerParams(const std::vector ¶ms); + + +更新optimizer参数。 + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +GetOutputs +std::vector GetOutputs(); + + +获取模型所有输出张量。 + +返回值 +包含模型所有输出张量的容器类型变量。 + + + + +GetOutputTensorNames +std::vector GetOutputTensorNames(); + + +获取模型所有输出张量的名字。 + +返回值 +包含模型所有输出张量名字的容器类型变量。 + + + + +GetOutputByTensorName +MSTensor GetOutputByTensorName(const std::string &tensor_name); + + +获取模型指定名字的输出张量。 + +返回值 +指定名字的输出张量，如果该名字不存在则返回非法张量。 + + + + +GetOutputsByNodeName +std::vector GetOutputsByNodeName(const std::string &node_name); + + +通过节点名获取模型的MSTensors输出张量。不建议使用，将在2.0版本废弃。 + +参数 + +node_name: 节点名称。 + + +返回值 +包含在模型输出Tensor中的该节点输出Tensor的vector。 + + + + +BindGLTexture2DMemory + Status BindGLTexture2DMemory(const std::map &inputGLTexture, + std::map *outputGLTexture); + + +将OpenGL纹理数据与模型的输入和输出进行绑定。 + +参数 + +inputGLTexture: 模型输入的OpenGL纹理数据, key为输入Tensor的名称，value为OpenGL纹理。 +outputGLTexture: 模型输出的OpenGL纹理数据，key为输出Tensor的名称，value为OpenGL纹理。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +InitMetrics +Status InitMetrics(std::vector metrics); + + +训练指标参数初始化。 + +参数 + +metrics: 训练指标参数。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +GetMetrics +std::vector GetMetrics(); + + +获取训练指标参数。 + +返回值 +训练指标参数。 + + + + +SetTrainMode +Status SetTrainMode(bool train); + + +session设置训练模式。 + +参数 + +train: 是否为训练模式。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +GetTrainMode +bool GetTrainMode() const; + + +获取session是否是训练模式。 + +返回值 +bool类型，表示是否是训练模式。 + + + + +Train +Status Train(int epochs, std::shared_ptr ds, std::vector cbs); + + +模型训练。 + +参数 + +epochs: 迭代轮数。 +ds: 训练数据。 +cbs: 包含训练回调类对象的vector。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Evaluate +Status Evaluate(std::shared_ptr ds, std::vector cbs); + + +模型验证。 + +参数 + +ds: 训练数据。 +cbs: 包含训练回调类对象的vector。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Resize +Status Resize(const std::vector &inputs, const std::vector> &dims); + + +调整已编译模型的输入形状。 + +参数 + +inputs: 模型输入按顺序排列的vector。 +dims: 输入形状，按输入顺序排列的由形状组成的vector，模型会按顺序依次调整张量形状。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +CheckModelSupport +static bool CheckModelSupport(enum DeviceType device_type, ModelType model_type); + + +检查设备是否支持该模型。 + +参数 + +device_type: 设备类型，例如kMaliGPU。 +model_type: 模型类型，例如MindIR。 + + +返回值 +状态码。 + + + + +",mindspore,mindspore、mindspore、接口、Optimizer、CallBack、GPU、MindIR、Model、Metric、精度、数据、计算图、精度、迭代、dataset、Eval、Graph、ib、npu +mindspore§MSTensor,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +MSTensor定义了MindSpore中的张量。 + +构造函数和析构函数 +MSTensor(); +explicit MSTensor(const std::shared_ptr &impl); +MSTensor(const std::string &name, DataType type, const std::vector &shape, const void *data, size_t data_len); +explicit MSTensor(std::nullptr_t); +~MSTensor(); + + +注意：MSTensor构造时，若data指针通过malloc生成，用户在构造完成MSTensor后，需自行释放free，否则存在内存泄露。 + + +静态公有成员函数 + +CreateTensor +MSTensor *CreateTensor(const std::string &name, DataType type, const std::vector &shape, + const void *data, size_t data_len) noexcept; + + +创建一个MSTensor对象，其数据需复制后才能由Model访问，必须与DestroyTensorPtr成对使用。 + +参数 + +name: 名称。 +type：数据类型。 +shape：形状。 +data：数据指针，指向一段已开辟的内存。 +data_len：数据长度，以字节为单位。 + + +返回值 +MStensor指针。 + + + + +CreateRefTensor +MSTensor *CreateRefTensor(const std::string &name, DataType type, const std::vector &shape, void *data, + size_t data_len) noexcept; + + +创建一个MSTensor对象，其数据可以直接由Model访问，必须与DestroyTensorPtr成对使用。 + +参数 + +name: 名称。 +type：数据类型。 +shape：形状。 +data：数据指针，指向一段已开辟的内存。 +data_len：数据长度，以字节为单位。 + + +返回值 +MStensor指针。 + + + + +CreateDevTensor +static inline MSTensor *CreateDevTensor(const std::string &name, DataType type, const std::vector &shape, + const void *data, size_t data_len) noexcept; + + +创建一个MSTensor对象，其device数据可以直接由Model访问，必须与DestroyTensorPtr成对使用。 + +参数 + +name: 名称。 +type：数据类型。 +shape：形状。 +data：数据指针，指向一段已开辟的device内存。 +data_len：数据长度，以字节为单位。 + + +返回值 +MStensor指针。 + + + + +StringsToTensor +MSTensor *StringsToTensor(const std::string &name, const std::vector &str); + + +创建一个字符串类型的MSTensor对象，其数据需复制后才能由Model访问，必须与DestroyTensorPtr成对使用。 + +参数 + +name: 名称。 +str：装有若干个字符串的vector容器。 + + +返回值 +MStensor指针。 + + + + +TensorToStrings +std::vector TensorToStrings(const MSTensor &tensor); + + +将字符串类型的MSTensor对象解析为字符串。 + +参数 + +tensor: 张量对象。 + + +返回值 +装有若干个字符串的vector容器。 + + + + +DestroyTensorPtr +void DestroyTensorPtr(MSTensor *tensor) noexcept; + + +销毁一个由Clone、StringsToTensor、CreateRefTensor或CreateTensor所创建的对象，请勿用于销毁其他来源的MSTensor。 + +参数 + +tensor: 由Clone、StringsToTensor、CreateRefTensor或CreateTensor返回的指针。 + + + + + + +公有成员函数 + +Name +std::string Name() const; + + +获取MSTensor的名字。 + +返回值 +MSTensor的名字。 + + + + +DataType +enum DataType DataType() const; + + +获取MSTensor的数据类型。 + +返回值 +MSTensor的数据类型。 + + + + +Shape +const std::vector &Shape() const; + + +获取MSTensor的Shape。 + +返回值 +MSTensor的Shape。 + + + + +ElementNum +int64_t ElementNum() const; + + +获取MSTensor的元素个数。 + +返回值 +MSTensor的元素个数。 + + + + +Data +std::shared_ptr Data() const; + + +获取指向MSTensor中的数据拷贝的智能指针。 + +返回值 +指向MSTensor中的数据拷贝的智能指针。 + + + + +MutableData +void *MutableData(); + + +获取MSTensor中的数据的指针。如果为空指针，为MSTensor的数据申请内存，并返回申请内存的地址，如果不为空，返回数据的指针。 + +返回值 +指向MSTensor中的数据的指针。 + + + + +DataSize +size_t DataSize() const; + + +获取MSTensor中的数据的以字节为单位的内存长度。 + +返回值 +MSTensor中的数据的以字节为单位的内存长度。 + + + + +IsDevice +bool IsDevice() const; + + +判断MSTensor中是否在设备上。仅MindSpore云侧支持。 + +返回值 +MSTensor中是否在设备上。 + + + + +Clone +MSTensor *Clone() const; + + +拷贝一份自身的副本。 + +返回值 +指向深拷贝副本的指针，必须与DestroyTensorPtr成对使用。 + + + + +operator==(std::nullptr_t) +bool operator==(std::nullptr_t) const; + + +判断MSTensor是否合法。 + +返回值 +MSTensor是否合法。 + + + + +operator!=(std::nullptr_t) +bool operator!=(std::nullptr_t) const; + + +判断MSTensor是否合法。 + +返回值 +MSTensor是否合法。 + + + + +operator==(const MSTensor &tensor) +bool operator==(const MSTensor &tensor) const; + + +判断MSTensor是否与另一个MSTensor相等，仅MindSpore Lite支持。 + +返回值 +MSTensor是否与另一个MSTensor相等。 + + + + +SetShape +void SetShape(const std::vector &shape); + + +设置MSTensor的Shape，仅MindSpore Lite支持，目前在Delegate机制使用。 + + +SetDataType +void SetDataType(enum DataType data_type); + + +设置MSTensor的DataType，仅MindSpore Lite支持，目前在Delegate机制使用。 + + +SetTensorName +void SetTensorName(const std::string &name); + + +设置MSTensor的名字，仅MindSpore Lite支持，目前在Delegate机制使用。 + + +SetAllocator +void SetAllocator(std::shared_ptr allocator); + + +设置MSTensor数据所属的内存池，仅MindSpore Lite支持。 + +参数 + +model: 指向Allocator的指针。 + + + + + +allocator +std::shared_ptr allocator() const; + + +获取MSTensor数据所属的内存池，仅MindSpore Lite支持。 + +返回值 + +指向Allocator的指针。 + + + + + +SetFormat +void SetFormat(mindspore::Format format); + + +设置MSTensor数据的format，仅MindSpore Lite支持，目前在Delegate机制使用。 + + +format +mindspore::Format format() const; + + +获取MSTensor数据的format，仅MindSpore Lite支持，目前在Delegate机制使用。 + + +SetData +void SetData(void *data); + + +设置指向MSTensor数据的指针。 + + +QuantParams +std::vector QuantParams() const; + + +获取MSTensor的量化参数，仅MindSpore Lite支持，目前在Delegate机制使用。 + + +SetQuantParams +void SetQuantParams(std::vector quant_params); + + +设置MSTensor的量化参数，仅MindSpore Lite支持，目前在Delegate机制使用。 + + +impl +const std::shared_ptr impl() + + +获取实现类的指针，仅MindSpore Lite支持。 + + +",mindspore,mindspore、mindspore、数据类型、Model、数据 +mindspore§QuantParam,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +一个结构体。QuantParam定义了MSTensor的一组量化参数。 + +公有属性 + +bit_num +bit_num + + +int 类型变量。量化的bit数。 + + +scale +scale + + +double 类型变量。 + + +zero_point +zero_point + + +int32_t 类型变量。 + + +",mindspore,mindspore、mindspore +mindspore§MSKernelCallBack,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +using MSKernelCallBack = std::function &inputs, const std::vector &outputs, const MSCallBackParam &opInfo)> + + +一个函数包装器。MSKernelCallBack 定义了指向回调函数的指针。 +",mindspore,mindspore、mindspore、CallBack、npu +mindspore§MSCallBackParam,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +一个结构体。MSCallBackParam定义了回调函数的输入参数。 + +公有属性 + +node_name +node_name + + +string 类型变量。节点名参数。 + + +node_type +node_type + + +string 类型变量。节点类型参数。 + + +",mindspore,mindspore、mindspore、CallBack +mindspore§Delegate,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +Delegate定义了第三方AI框架接入MindSpore Lite的代理接口。 + +构造函数和析构函数 +Delegate() = default; +virtual ~Delegate() = default; + + + + +公有成员函数 + +Init +virtual Status Init() = 0; + + +初始化Delegate资源。 + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Build +virtual Status Build(DelegateModel *model) = 0; + + +Delegate在线构图。 + +参数 + +model: 指向存储DelegateModel实例的指针。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +",mindspore,mindspore、mindspore、接口、Model、框架 +mindspore§SchemaVersion,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +定义了Lite执行在线推理时模型文件的版本。 +typedef enum { + SCHEMA_INVALID = -1, /**< invalid version */ + SCHEMA_CUR, /**< current version for ms model defined in model.fbs*/ + SCHEMA_V0, /**< previous version for ms model defined in model_v0.fbs*/ +} SchemaVersion; + + +",mindspore,mindspore、mindspore、model +mindspore§KernelIter,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +定义了Lite Kernel列表的迭代器。 +using KernelIter = std::vector::iterator; + + +",mindspore,mindspore、mindspore、迭代 +mindspore§DelegateModel,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +DelegateModel定义了MindSpore Lite Delegate机制操作的的模型对象。 + +构造函数 +DelegateModel(std::vector *kernels, const std::vector &inputs, + const std::vector &outputs, + const std::map &primitives, SchemaVersion version); + + + + +析构函数 +~DelegateModel() = default; + + + + +保护成员 + +kernels_ +std::vector *kernels_; + + +Kernel的列表，保存模型的所有算子。 + + +inputs_ +const std::vector &inputs_; + + +MSTensor的列表，保存这个算子的输入tensor。 + + +outputs_ +const std::vector &outputs; + + +MSTensor的列表，保存这个算子的输出tensor。 + + +primitives_ +const std::map &primitives_; + + +Kernel和schema::Primitive的Map，保存所有算子的属性。 + + +version_ +SchemaVersion version_; + + +enum值，当前执行推理的模型的版本SchemaVersion。 + + + +公有成员函数 + +GetPrimitive +const schema::Primitive *GetPrimitive(kernel::Kernel *kernel) const; + + +获取一个Kernel的属性值。 + +参数 + +kernel: 指向Kernel的指针。 + + +返回值 +const schema::Primitive *，输入参数Kernel对应的该算子的属性值。 + + + + +BeginKernelIterator +KernelIter BeginKernelIterator(); + + +返回DelegateModel Kernel列表起始元素的迭代器。 + +返回值 +KernelIter，指向DelegateModel Kernel列表起始元素的迭代器。 + + + + +EndKernelIterator +KernelIter EndKernelIterator(); + + +返回DelegateModel Kernel列表末尾元素的迭代器。 + +返回值 +KernelIter，指向DelegateModel Kernel列表末尾元素的迭代器。 + + + + +Replace +KernelIter Replace(KernelIter from, KernelIter end, kernel::Kernel *graph_kernel); + + +用Delegate子图Kernel替换Delegate支持的连续Kernel列表。 + +参数 + +from: Delegate支持的连续Kernel列表的起始元素迭代器。 +end: Delegate支持的连续Kernel列表的末尾元素迭代器。 +graph_kernel: 指向Delegate子图Kernel实例的指针。 + + +返回值 +KernelIter，用Delegate子图Kernel替换之后，子图Kernel下一个元素的迭代器，指向下一个未被访问的Kernel。 + + + + +inputs +const std::vector &inputs(); + + +返回DelegateModel输入tensor列表。 + +返回值 +MSTensor的列表。 + + + + +outputs +const std::vector &outputs(); + + +返回DelegateModel输出tensor列表。 + +返回值 +MSTensor的列表。 + + + + +GetVersion +const SchemaVersion GetVersion() { return version_; } + + +返回当前执行推理的模型文件的版本。 + +返回值 +enum值，0: r1.2及r1.2之后的版本，1: r1.1及r1.1之前的版本，-1: 无效版本。 + + + + +",mindspore,mindspore、mindspore、算子、Model、迭代、graph、npu +mindspore§TrainCfg,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +TrainCfgMindSpore Lite训练的相关配置参数。 + +构造函数 +TrainCfg() { this->loss_name_ = ""_loss_fn""; } + + + + +公有成员变量 +OptimizationLevel optimization_level_ = kO0; + + +优化的数据类型。 +enum OptimizationLevel : uint32_t { + kO0 = 0, + kO2 = 2, + kO3 = 3, + kAuto = 4, + kOptimizationType = 0xFFFFFFFF +}; + + +std::string loss_name_; + + +损失节点的名称。 +MixPrecisionCfg mix_precision_cfg_; + + +混合精度配置。 +bool accumulate_gradients_; + + +是否累积梯度。 + +",mindspore,mindspore、mindspore、数据类型、loss、精度、数据、精度、优化 +mindspore§MixPrecisionCfg,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +MixPrecisionCfgMindSpore Lite训练混合精度配置类。 + +构造函数 + MixPrecisionCfg() { + dynamic_loss_scale_ = false; + loss_scale_ = 128.0f; + num_of_not_nan_iter_th_ = 1000; + } + + + + +共有成员变量 +bool dynamic_loss_scale_ = false; + + +混合精度训练中是否启用动态损失比例。 +float loss_scale_; + + +初始损失比例。 +uint32_t num_of_not_nan_iter_th_; + + +动态损失阈值。 +bool is_raw_mix_precision_; + + +原始模型是否是原生混合精度模型。 + +",mindspore,mindspore、mindspore、loss、精度、精度 +mindspore§AccuracyMetrics,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +AccuracyMetricsMindSpore Lite训练精度类。 + +构造函数和析构函数 +explicit AccuracyMetrics(int accuracy_metrics = METRICS_CLASSIFICATION, const std::vector &input_indexes = {1}, const std::vector &output_indexes = {0}); +virtual ~AccuracyMetrics(); + + + + +公有成员函数 + +Clear +void Clear() override; + + +精度清零。 + + +Eval +float Eval() override; + + +模型验证。 + +返回值 +float，模型验证精度。 + + + + +",mindspore,mindspore、mindspore、Metric、精度、精度、Eval、npu +mindspore§Metrics,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +MetricsMindSpore Lite训练指标类。 + +析构函数 +virtual ~Metrics() = default; + + + + +公有成员函数 + +Clear +virtual void Clear() {} + + +训练指标清零。 + + +Eval +virtual float Eval() { return 0.0; } + + +模型验证。 + +返回值 +float，模型验证精度。 + + + + +Update +virtual void Update(std::vector inputs, std::vector outputs) {} + + +模型输入输出数据更新。 + +参数 + +inputs: 模型输入MSTensor的vector。 +outputs: 模型输输出MSTensor的vector。 + + + + + +",mindspore,mindspore、mindspore、Metric、精度、数据、精度、Eval、npu +mindspore§TrainCallBack,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +MetricsMindSpore Lite训练回调类。 + +析构函数 +virtual ~TrainCallBack() = default; + + + + +公有成员函数 + +Begin +virtual void Begin(const TrainCallBackData &cb_data) {} + + +网络执行前调用。 + +参数 + +cb_data: 回调参数。 + + + + + +End + virtual void End(const TrainCallBackData &cb_data) {} + + +网络执行后调用。 + +参数 + +cb_data: 回调参数。 + + + + + +EpochBegin + virtual void EpochBegin(const TrainCallBackData &cb_data) {} + + +每轮迭代前回调。 + +参数 + +cb_data: 回调参数。 + + + + + +EpochEnd + virtual CallbackRetValue EpochEnd(const TrainCallBackData &cb_data) { return kContinue; } + + +每轮迭代后回调。 + +参数 + +cb_data: 回调参数。 + + +返回值 +CallbackRetValue，表示是否在训练中继续循环。 +enum CallbackRetValue : uint32_t { + kContinue = 0, + kStopTraining = 1, + kExit = 2, + kUnknownRetValue = 0xFFFFFFFF +}; + + + + + + +StepBegin + virtual void StepBegin(const TrainCallBackData &cb_data) {} + + +每步迭代前回调。 + +参数 + +cb_data: 回调参数。 + + + + + +StepEnd + virtual void StepEnd(const TrainCallBackData &cb_data) {} + + +每步迭代后回调。 + +参数 + +cb_data: 回调参数。 + + + + + +",mindspore,mindspore、mindspore、CallBack、网络、pB、Metric、迭代 +mindspore§TrainCallBackData,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +一个结构体。TrainCallBackData定义了训练回调的一组参数。 + +公有属性 + +train_mode_ +train_mode_ + + +bool 类型变量。训练模式。 + + +epoch_ +epoch_ + + +unsigned int 类型变量。训练迭代的epoch次数。 + + +step_ +step_ + + +unsigned int 类型变量。训练迭代的step次数。 + + +model_ +model_ + + +Model 类型指针。训练模型对象。 + + +",mindspore,mindspore、mindspore、CallBack、model、迭代 +mindspore§CkptSaver,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +MetricsMindSpore Lite训练模型文件保存类。 + +构造函数和析构函数 + explicit CkptSaver(int save_every_n, const std::string &filename_prefix); + virtual ~CkptSaver(); + + + +",mindspore,mindspore、mindspore、Metric +mindspore§LossMonitor,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +MetricsMindSpore Lite训练损失函数类。 + +构造函数和析构函数 + explicit LossMonitor(int print_every_n_steps = INT_MAX); + virtual ~LossMonitor(); + + + + +公有成员函数 + +GetLossPoints + const std::vector &GetLossPoints(); + + +获取训练损失数据。 + +返回值 +包含GraphPoint数据的vector，训练的损失数据。 + + + + +",mindspore,mindspore、mindspore、损失函数、Loss、Metric、数据、Graph +mindspore§LRScheduler,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +MetricsMindSpore Lite训练学习率调度类。 + +构造函数和析构函数 + explicit LRScheduler(LR_Lambda lambda_func, void *lr_cb_data = nullptr, int step = 1); + virtual ~LRScheduler(); + + + +",mindspore,mindspore、mindspore、Metric、LR、学习率 +mindspore§StepLRLambda,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +一个结构体。StepLRLambda定义了训练学习率的一组参数。 + +公有属性 + +step_size +step_size + + +int 类型变量。学习率衰减步长。 + + +gamma +gamma + + +float 类型变量。学习率衰减因子。 + + +",mindspore,mindspore、mindspore、LR、学习率 +mindspore§MultiplicativeLRLambda,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +每个epoch将学习率乘以一个因子。 +using LR_Lambda = std::function; +int MultiplicativeLRLambda(float *lr, int epoch, void *multiplication); + + +学习率更新。 + +参数 + +lr: 学习率。 +epoch: 迭代轮数。 +multiplication: 更新方式。 + + +返回值 +int类型返回值，表示是否更新，DONT_UPDATE_LR为0表示不更新，UPDATE_LR为1表示更新。 +constexpr int DONT_UPDATE_LR = 0; +constexpr int UPDATE_LR = 1; + + + + +",mindspore,mindspore、mindspore、LR、学习率、迭代 +mindspore§TimeMonitor,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +MetricsMindSpore Lite训练时间监测类。 + +析构函数 + virtual ~TimeMonitor() = default; + + + + +公有成员函数 + +EpochBegin + void EpochBegin(const TrainCallBackData &cb_data) override; + + +每轮迭代前调用。 + +参数 + +cb_data: 回调参数。 + + +返回值 +CallbackRetValue，表示是否在训练中继续循环。 + + + + +EpochEnd + CallbackRetValue EpochEnd(const TrainCallBackData &cb_data) override; + + +每轮迭代后调用。 + +参数 + +cb_data: 回调参数。 + + +返回值 +CallbackRetValue，表示是否在训练中继续循环。 + + + + +",mindspore,mindspore、mindspore、CallBack、Metric、迭代 +mindspore§TrainAccuracy,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +MetricsMindSpore Lite训练学习率调度类。 + +构造函数和析构函数 +explicit TrainAccuracy(int print_every_n = INT_MAX, int accuracy_metrics = METRICS_CLASSIFICATION, const std::vector &input_indexes = {1}, const std::vector &output_indexes = {0}); +virtual ~TrainAccuracy(); + + + +参数 + +print_every_n: 间隔print_every_n步打印一次。 +accuracy_metrics: 精度指标，默认值为METRICS_CLASSIFICATION表示0，METRICS_MULTILABEL表示1。 +input_indexes: 输入索引。 +output_indexes: 输出索引。 + + + +constexpr int METRICS_CLASSIFICATION = 0; +constexpr int METRICS_MULTILABEL = 1; + + + +GetAccuracyPoints + const std::vector &GetAccuracyPoints(); + + +获取训练精度。 + +返回值 +包含GraphPoint的vector，训练精度数据。 + + + + +",mindspore,mindspore、mindspore、Metric、学习率、精度、数据、精度、Graph、npu +mindspore§CharVersion,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +std::vector CharVersion(); + + +全局方法，用于获取版本的字符vector。 + +返回值 +MindSpore Lite版本的字符vector。 + + +",mindspore,mindspore、mindspore +mindspore§Version,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +std::string Version() + + +全局方法，用于获取版本的字符串。 + +返回值 +MindSpore Lite版本的字符串。 + + +",mindspore,mindspore、mindspore +mindspore§Allocator,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html,"r +std::shared_ptr allocator() const; + + +获取MSTensor数据所属的内存池，仅MindSpore Lite支持。 + +返回值 + +指向Allocator的指针。 + + + +",mindspore,mindspore、mindspore、数据 +mindspore§Status,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include + +构造函数和析构函数 +Status(); +inline Status(enum StatusCode status_code, const std::string &status_msg = """"); +inline Status(const StatusCode code, int line_of_code, const char *file_name, const std::string &extra = """"); +~Status() = default; + + + +StatusCode +enum StatusCode StatusCode() const; + + +获取状态码。 + +返回值 +状态码。 + + + + +ToString +inline std::string ToString() const; + + +状态码转成字符串。 + +返回值 +状态码的字符串。 + + + + +GetLineOfCode +int GetLineOfCode() const; + + +获取代码行数。 + +返回值 +代码行数。 + + + + +GetErrDescription +inline std::string GetErrDescription() const; + + +获取错误描述字符串。 + +返回值 +错误描述字符串。 + + + + +SetErrDescription +inline std::string SetErrDescription(const std::string &err_description); + + +配置错误描述字符串。 + +参数 + +err_description: 错误描述字符串。 + + +返回值 +状态信息字符串。 + + + + +operator<<(std::ostream &os, const Status &s) +friend std::ostream &operator<<(std::ostream &os, const Status &s); + + +状态信息写到输出流。 + +参数 + +os: 输出流。 +s: 状态类。 + + +返回值 +输出流。 + + + + +operator==(const Status &other) +bool operator==(const Status &other) const; + + +判断是否与另一个Status相等。 + +参数 + +other: 另一个Status。 + + +返回值 +是否与另一个Status相等。 + + + + +operator==(enum StatusCode other_code) +bool operator==(enum StatusCode other_code) const; + + +判断是否与一个StatusCode相等。 + +参数 + +other_code: 一个StatusCode。 + + +返回值 +是否与一个StatusCode相等。 + + + + +operator!=(enum StatusCode other_code) +bool operator!=(enum StatusCode other_code) const; + + +判断是否与一个StatusCode不等。 + +参数 + +other_code: 一个StatusCode。 + + +返回值 +是否与一个StatusCode不等。 + + + + +operator bool() +explicit operator bool() const; + + +重载bool操作。 + + +explicit operator int() const +explicit operator int() const; + + +重载int操作。 + + +OK +static Status OK(); + + +获取kSuccess的状态码。 + +返回值 +StatusCode::kSuccess。 + + + + +IsOk +bool IsOk() const; + + +判断是否是kSuccess的状态码。 + +返回值 +是否是kSuccess。 + + + + +IsError +bool IsError() const; + + +判断是否不是kSuccess的状态码。 + +返回值 +是否不是kSuccess。 + + + + +CodeAsString +static inline std::string CodeAsString(enum StatusCode c); + + +获取StatusCode对应的字符串。 + +参数 + +c: 状态码枚举值。 + + +返回值 +状态码对应的字符串。 + + + + +",mindspore,mindspore、mindspore +mindspore§Graph,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include + +构造函数和析构函数 + Graph(); + explicit Graph(const std::shared_ptr &graph_data); + explicit Graph(std::shared_ptr &&graph_data); + explicit Graph(std::nullptr_t); + ~Graph(); + + + +参数 + +graph_data: 输出通道数。 + + + + + +公有成员函数 + +ModelType + enum ModelType ModelType() const; + + +获取模型类型。 + +返回值 +模型类型。 + + + + +operator==(std::nullptr_t) + bool operator==(std::nullptr_t) const; + + +判断是否为空指针。 + +返回值 +是否为空指针。 + + + + +operator!=(std::nullptr_t) + bool operator!=(std::nullptr_t) const; + + +判断是否为非空指针。 + +返回值 +是否为非空指针。 + + + + +",mindspore,mindspore、mindspore、Model、Graph +mindspore§CellBase,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include + +构造函数和析构函数 + CellBase() = default; + virtual ~CellBase() = default; + + + + +公有成员函数 + +Clone + virtual std::shared_ptr Clone() const = 0; + + +拷贝一份自身的副本。 + +返回值 +指向副本的指针。 + + + + +",mindspore,mindspore、mindspore +mindspore§Cell,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include + +析构函数 + virtual ~Cell() = default; + + + + +公有成员函数 + +Clone + std::shared_ptr Clone() const; + + +拷贝一份自身的副本。 + +返回值 +指向副本的指针。 + + + + +",mindspore,mindspore、mindspore +mindspore§GraphCell,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include + +构造函数和析构函数 + GraphCell() = default; + ~GraphCell() override = default; + explicit GraphCell(const Graph &); + explicit GraphCell(Graph &&); + explicit GraphCell(const std::shared_ptr &); + + + + +公有成员函数 + +GetGraph + const std::shared_ptr &GetGraph() const { return graph_; } + + +获取Graph指针。 + +返回值 +指向Graph的指针。 + + + + +",mindspore,mindspore、mindspore、Graph +mindspore§RunnerConfig,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +RunnerConfig定义了ModelParallelRunner中使用的配置选项参数。 + +构造函数和析构函数 +RunnerConfig(); +~RunnerConfig(); + + + + +公有成员函数 + +SetWorkersNum +void SetWorkersNum(int32_t workers_num); + + +设置RunnerConfig的worker的个数。 + +参数 + +workers_num: worker的数量。 + + + + + +GetWorkersNum +int32_t GetWorkersNum() const; + + +获取RunnerConfig配置的上下文参数。 + +返回值 +RunnerConfig类中配置的worker数量。 + + + + +SetContext +void SetContext(const std::shared_ptr &context); + + +设置RunnerConfig的context参数。 + +参数 + +context: worker上下文配置。 + + + + + +GetContext +std::shared_ptr GetContext() const; + + +获取RunnerConfig配置的上下文参数。 + +返回值 +上下文配置类Context对象。 + + + + +SetConfigInfo +void SetConfigInfo(const std::string &key, const std::map &config); + + +设置RunnerConfig的配置参数。 + +参数 + +key: string类型关键字。 +config: map类型的配置参数。 + + + + + +GetConfigInfo +std::map> GetConfigInfo() const; + + +获取RunnerConfig配置参数信息。 + +返回值 +map类型的配置信息。 + + + + +",mindspore,mindspore、mindspore、model、lR +mindspore§ModelParallelRunner,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html," +#include +ModelParallelRunner定义了MindSpore的多个Model以及并发策略，便于多个Model的调度与管理。 + +构造函数和析构函数 +ModelParallelRunner(); +~ModelParallelRunner(); + + + + +公有成员函数 + +Init +Status Init(const std::string &model_path, const std::shared_ptr &runner_config = nullptr); + + +根据路径读取加载模型，生成一个或者多个模型，并将所有模型编译至可在Device上运行的状态。 + +参数 + +model_path: 模型文件路径。 +runner_config: 一个RunnerConfig类。定义了并发推理模型的配置参数。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +Predict +Status Predict(const std::vector &inputs, std::vector *outputs, + const MSKernelCallBack &before = nullptr, const MSKernelCallBack &after = nullptr); + + +并发推理模型。 + +参数 + +inputs: 模型输入按顺序排列的vector。 +outputs: 输出参数，按顺序排列的vector的指针，模型输出会按顺序填入该容器。 +before: 一个MSKernelCallBack 结构体。定义了运行每个节点之前调用的回调函数。 +after: 一个MSKernelCallBack 结构体。定义了运行每个节点之后调用的回调函数。 + + +返回值 +状态码类Status对象，可以使用其公有函数StatusCode或ToString函数来获取具体错误码及错误信息。 + + + + +GetInputs +std::vector GetInputs(); + + +获取模型所有输入张量。 + +返回值 +包含模型所有输入张量的容器类型变量。 + + + + +GetOutputs +std::vector GetOutputs(); + + +获取模型所有输出张量。 + +返回值 +包含模型所有输出张量的容器类型变量。 + + + + +",mindspore,mindspore、mindspore、CallBack、Model、lR、npu +mindspore-nn§Functions,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_NN.html," + +Function mindspore::NN::Adam +Function mindspore::NN::GraphWithLoss +Function mindspore::NN::Input +Function mindspore::NN::NetWithLoss +Function mindspore::NN::SoftmaxCrossEntropy + +",mindspore::NN,mindspore、mindspore、Loss、Graph、npu +mindspore-abstract§Classes,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_abstract.html," + +Class AbstractBase +Class AbstractCOOTensor +Class AbstractCSRTensor +Class AbstractDictionary +Class AbstractEllipsis +Class AbstractError +Class AbstractFunction +Class AbstractIOMonad +Class AbstractJTagged +Class AbstractKeywordArg +Class AbstractList +Class AbstractMonad +Class AbstractNone +Class AbstractNull +Class AbstractRefTensor +Class AbstractRowTensor +Class AbstractScalar +Class AbstractScript +Class AbstractSequence +Class AbstractSlice +Class AbstractSparseTensor +Class AbstractTensor +Class AbstractTimeOut +Class AbstractTuple +Class AbstractType +Class AbstractUMonad +Class AbstractUndetermined +Class BaseShape +Class EnvSetSparseResultMgr +Class ListShape +Class NoShape +Class RegisterHostDependsHelper +Class RegisterStandardPrimitiveEvalHelper +Class SequenceShape +Class Shape +Class TupleShape + +",mindspore::abstract,mindspore、mindspore、Eval +mindspore-abstract§Functions,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_abstract.html," + +Function mindspore::abstract::AbstractBasePtrListDeepEqual +Function mindspore::abstract::AbstractBasePtrListHash +Function mindspore::abstract::AbstractJoin +Function mindspore::abstract::AbstractJoin +Function mindspore::abstract::BroadcastShape +Template Function mindspore::abstract::CheckArg +Function mindspore::abstract::CheckArgsSize +Template Function mindspore::abstract::CheckArgsSpec +Function mindspore::abstract::CheckAttrIntOrTuple +Function mindspore::abstract::CheckAttrStringSet +Function mindspore::abstract::CheckAxis +Function mindspore::abstract::CheckDtypeSame +Function mindspore::abstract::CheckMinMaxShape +Function mindspore::abstract::CheckRequiredArgsSize +Function mindspore::abstract::CheckScalarType +Function mindspore::abstract::CheckShapeAllPositive +Function mindspore::abstract::CheckShapeAnyAndPositive +Function mindspore::abstract::CheckShapeSame +Function mindspore::abstract::CheckTensorDType +Function mindspore::abstract::CheckTensorsDTypeSame +Function mindspore::abstract::CheckType +Function mindspore::abstract::ExtractLoggingInfo +Function mindspore::abstract::GetDependsFormMap +Function mindspore::abstract::GetDependsFormMap +Function mindspore::abstract::GetPrimitiveInferImpl +Function mindspore::abstract::GetPrimitiveToBackendEvalImplMap +Function mindspore::abstract::GetPrimitiveToEvalImplMap +Function mindspore::abstract::MakeAbstract +Function mindspore::abstract::MakeAbstractTensor +Function mindspore::abstract::MakeMonadAbstract +Function mindspore::abstract::RegisterHostDependsImpl +Function mindspore::abstract::RegisterStandardPrimitiveImpl +Function mindspore::abstract::SensitivityTransform +Function mindspore::abstract::ShapeJoin +Template Function mindspore::abstract::ShapeSize +Function mindspore::abstract::SynchronizeSequenceElementsUseFlagsRecursively +Function mindspore::abstract::TypeIdSize +Function mindspore::abstract::TypeJoin +Function mindspore::abstract::ValueJoin + +",mindspore::abstract,mindspore、mindspore、ast、Eval +mindspore-api§Classes,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_api.html," + +Class AbstractBase +Class AbstractScalar +Class AbstractSequence +Class AbstractTensor +Class AbstractTuple +Class AnfNode +Class Base +Class BoolImm +Class CNode +Class FloatImm +Class FP32Imm +Class FuncGraph +Class FuncGraphManager +Class Int64Imm +Class IntegerImm +Class LogStream +Class LogWriter +Class Parameter +Class Primitive +Class Scalar +Class Shape +Template Class SharedPtr +Class StringImm +Class Tensor +Class TensorType +Class Type +Class UInt8Imm +Class Value +Class ValueNode +Class ValueSequence +Class ValueTuple + +",mindspore::api,mindspore、mindspore、api、Graph +mindspore-api§Enums,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_api.html," + +Enum LogLevel + +",mindspore::api,mindspore、mindspore、api +mindspore-api§Functions,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_api.html," + +Template Function mindspore::api::GetValue +Template Function mindspore::api::GetValue +Function mindspore::api::GetValueNode +Function mindspore::api::IsDataNode +Function mindspore::api::IsPrimitive +Function mindspore::api::IsPrimitiveCNode +Template Function mindspore::api::MakeShared +Template Function mindspore::api::MakeValue +Function mindspore::api::MakeValue +Function mindspore::api::MakeValue +Function mindspore::api::MakeValue +Template Function mindspore::api::MakeValue +Template Function mindspore::api::NewValueNode +Template Function mindspore::api::NewValueNode + +",mindspore::api,mindspore、mindspore、api、eVal +mindspore-api-utils§Functions,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_api_utils.html," + +Template Function mindspore::api::utils::cast +Template Function mindspore::api::utils::cast +Function mindspore::api::utils::CloneGraph +Function mindspore::api::utils::GetPadMode +Template Function mindspore::api::utils::isa +Template Function mindspore::api::utils::isa + +",mindspore::api::utils,mindspore、mindspore、api、ast、Graph +mindspore-common§Functions,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_common.html," + +Function mindspore::common::GetEnv +Template Function mindspore::common::IsAttrsEqual +Template Function mindspore::common::IsEqual +Function mindspore::common::IsLittleByteOrder +Function mindspore::common::SafeCStr +Function mindspore::common::SafeCStr +Function mindspore::common::SetEnv +Function mindspore::common::SetOMPThreadNum +Function mindspore::common::UseMPI + +",mindspore::common,mindspore、mindspore +mindspore-converter§mindspore-converter,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_converter.html," + +以下描述了Mindspore Lite转换支持的模型类型及用户扩展所需的必要信息。 + +",mindspore::converter,mindspore、mindspore +mindspore-converter§接口汇总,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_converter.html," + + + +类名 +描述 + + + + +FmkType +Mindspore Lite支持的框架类型。 + + +ConverterParameters +模型解析时的只读参数。 + + +ConverterContext +模型转换时的基本信息设置与获取。 + + +NodeParser +op节点的解析基类。 + + +ModelParser +模型解析的基类。 + + + +",mindspore::converter,mindspore、mindspore、接口、Model、框架 +mindspore-converter§FmkType,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_converter.html," +#include +enum类型变量，定义MindSpore Lite转换支持的框架类型。 + + + +类型定义 +值 +描述 + + + + +kFmkTypeTf +0 +表示tensorflow框架。 + + +kFmkTypeCaffe +1 +表示caffe框架。 + + +kFmkTypeOnnx +2 +表示onnx框架。 + + +kFmkTypeMs +3 +表示mindspore框架。 + + +kFmkTypeTflite +4 +表示tflite框架。 + + + +",mindspore::converter,mindspore、mindspore、tensorflow、Onnx、框架、Caffe +mindspore-converter§ConverterParameters,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_converter.html," +#include +struct类型结构体，定义模型解析时的转换参数，用于模型解析时的只读参数。 +struct ConverterParameters { + FmkType fmk; // 框架类型 + std::string model_file; // 原始模型文件路径 + std::string weight_file; // 原始模型权重文件路径，仅在Caffe框架下有效 + std::map attrs; // 预留参数接口，暂未启用 +}; + + +",mindspore::converter,mindspore、mindspore、接口、model、框架、Caffe +mindspore-converter§ConverterContext,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_converter.html," +#include +模型转换过程中，基本信息的设置与获取。 + +ConverterContext +ConverterContext() = default; + + +构造函数。 + + +~ConverterContext +~ConverterContext() = default; + + +析构函数。 + + +公有成员函数 + +SetGraphOutputTensorNames +static void SetGraphOutputTensorNames(const std::vector &output_names); + + +静态方法，设置导出模型的输出名称。 + +参数 + +output_names: 模型的输出名称。 + + + + + +GetGraphOutputTensorNames +static std::vector GetGraphOutputTensorNames(); + + +静态方法，获取模型的输出名称。 + +返回值 +模型的输出名称，默认与原始模型的输出名称一致。 + + + + +",mindspore::converter,mindspore、mindspore、Graph +mindspore-converter§NodeParser,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_converter.html," +#include +op节点的解析基类。 + +NodeParser +NodeParser() = default; + + +构造函数。 + + +~NodeParser +virtual ~NodeParser() = default; + + +析构函数。 + + +公有成员函数 + +Parse +ops::PrimitiveC *Parse(const onnx::GraphProto &onnx_graph, const onnx::NodeProto &onnx_node); + + +onnx节点解析接口函数。 + +参数 + +onnx_graph: 模型结构，包含模型的所有信息。 +onnx_node: 待解析节点。 + + +返回值 +PrimitiveC类指针对象，存储节点属性。 + + + + +Parse +ops::PrimitiveC *Parse(const caffe::LayerParameter &proto, const caffe::LayerParameter &weight); + + +caffe节点解析接口函数。 + +参数 + +proto: 待解析节点，包含节点的属性信息。 +weight: 待解析节点的权重信息。 + + +返回值 +PrimitiveC类指针对象，存储节点属性。 + + + + +Parse +ops::PrimitiveC *Parse(const tensorflow::NodeDef &tf_op, + const std::map &tf_node_map, + std::vector *inputs, int *output_size); + + +tf节点解析接口函数。 + +参数 + +tf_op: 待解析节点。 +tf_node_map: 模型的所有节点信息。 +inputs: 用户指定当前节点需要哪些原始输入，及其解析后的输入顺序。 +output_size: 用户指定当前节点的输出个数。 + + +返回值 +PrimitiveC类指针对象，存储节点属性。 + + + + +Parse +ops::PrimitiveC *Parse(const std::unique_ptr &tflite_op, + const std::unique_ptr &tflite_model); + + +tflite节点解析接口函数。 + +参数 + +tflite_op: 待解析节点，包含节点的属性信息。 +tflite_model: 模型结构，包含模型的所有信息。 + + +返回值 +PrimitiveC类指针对象，存储节点属性。 + + + + +",mindspore::converter,mindspore、mindspore、接口、tensorflow、onnx、Model、模型结构、Graph、caffe、npu +mindspore-converter§NodeParserPtr,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_converter.html," +#include +NodeParser类的共享智能指针类型。 +using NodeParserPtr = std::shared_ptr; + + +",mindspore::converter,mindspore、mindspore +mindspore-converter§ModelParser,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_converter.html," +#include +解析原始模型的基类。 + +ModelParser +ModelParser() = default; + + +构造函数。 + + +~ModelParser +virtual ~ModelParser() = default; + + +析构函数。 + + +公有成员函数 + +Parse +api::FuncGraphPtr Parse(const converter::ConverterParameters &flags); + + +模型解析接口。 + +参数 + +flags: 解析模型时基本信息，具体见ConverterParameters。 + + +返回值 +FuncGraph的共享智能指针。 + + + + + +保护数据成员 + +res_graph_ +api::FuncGraphPtr res_graph_ = nullptr; + + +FuncGraph的共享智能指针。 + + +",mindspore::converter,mindspore、mindspore、接口、api、Model、数据、Graph +mindspore-dataset§Dataset函数,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset.html," + +Vision + + + + + + +API +重载的API（重载的Sampler） + + + +Function mindspore::dataset::Album +Function mindspore::dataset::Album (raw ptr Sampler) +Function mindspore::dataset::Album (reference Sampler) + + +Function mindspore::dataset::Mnist +Function mindspore::dataset::Mnist (raw ptr Sampler) +Function mindspore::dataset::Mnist (reference Sampler) + + + + + +",mindspore::dataset,mindspore、mindspore、API、dataset +mindspore-dataset§Dataset类,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset.html," + +Class Dataset +Class Iterator +Class PullIterator + +",mindspore::dataset,mindspore、mindspore、dataset +mindspore-dataset§Sampler类,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset.html," + +Class Sampler +Class DistributedSampler +Class PKSampler +Class RandomSampler +Class SequentialSampler +Class SubsetRandomSampler +Class SubsetSampler +Class WeightedRandomSampler + +",mindspore::dataset,mindspore、mindspore、dataset、ib +mindspore-dataset§Eager类,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset.html," + +Class Execute + +",mindspore::dataset,mindspore、mindspore、dataset +mindspore-dataset§常量,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset.html," + +Enum BorderType +Enum ImageBatchFormat +Enum ImageFormat +Enum InterpolationMode +Enum JiebaMode +Enum MapTargetDevice +Enum NormalizeForm +Enum RelationalOp +Enum SamplingStrategy +Enum SentencePieceModel +Enum ShuffleMode +Enum SPieceTokenizerLoadType +Enum SPieceTokenizerOutType +Enum TensorImpl +Variable mindspore::dataset::kCfgCallbackTimeout +Variable mindspore::dataset::kCfgDefaultCacheHost +Variable mindspore::dataset::kCfgDefaultCachePort +Variable mindspore::dataset::kCfgDefaultRankId +Variable mindspore::dataset::kCfgDefaultSeed +Variable mindspore::dataset::kCfgMonitorSamplingInterval +Variable mindspore::dataset::kCfgOpConnectorSize +Variable mindspore::dataset::kCfgParallelWorkers +Variable mindspore::dataset::kCfgRowsPerBuffer +Variable mindspore::dataset::kCfgWorkerConnectorSize +Variable mindspore::dataset::kCVInvalidType +Variable mindspore::dataset::kDecimal +Variable mindspore::dataset::kDeMaxDim +Variable mindspore::dataset::kDeMaxFreq +Variable mindspore::dataset::kDeMaxRank +Variable mindspore::dataset::kDeMaxTopk +Variable mindspore::dataset::kDftAutoNumWorkers +Variable mindspore::dataset::kDftMetaColumnPrefix +Variable mindspore::dataset::kDftNumConnections +Variable mindspore::dataset::kMaxLegalPort +Variable mindspore::dataset::kMinLegalPort + +",mindspore::dataset,mindspore、mindspore、Callback、Model、dataset +mindspore-dataset§其他,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset.html," + +类 + +Class SentencePieceVocab +Class Slice +Class SliceOption +Class TensorTransform +Class Vocab + + + +函数 + +Function mindspore::dataset::Schema +Function mindspore::dataset::SchemaCharIF + + + +定义类型 + +Typedef mindspore::dataset::connection_id_type +Typedef mindspore::dataset::dsize_t +Typedef mindspore::dataset::MSTensorMap +Typedef mindspore::dataset::MSTensorMapChar +Typedef mindspore::dataset::MSTensorVec +Typedef mindspore::dataset::row_id_type +Typedef mindspore::dataset::session_id_type +Typedef mindspore::dataset::uchar + + +",mindspore::dataset,mindspore、mindspore、dataset +mindspore-dataset§Lite-CV,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset.html," + +类 + +Class LiteMat +Class LDataType + + + +函数 + +Function mindspore::dataset::Affine +Function mindspore::dataset::Affine +Function mindspore::dataset::ApplyNms +Function mindspore::dataset::Canny +Function mindspore::dataset::Conv2D +Function mindspore::dataset::ConvertRgbToGray +Function mindspore::dataset::ConvertTo +Function mindspore::dataset::Crop +Function mindspore::dataset::Divide +Function mindspore::dataset::ExtractChannel +Function mindspore::dataset::GaussianBlur +Function mindspore::dataset::GetAffineTransform +Function mindspore::dataset::GetPerspectiveTransform +Function mindspore::dataset::GetRotationMatrix2D +Function mindspore::dataset::HWC2CHW +Function mindspore::dataset::InitFromPixel +Function mindspore::dataset::Merge +Function mindspore::dataset::Multiply +Function mindspore::dataset::Pad +Function mindspore::dataset::ResizeBilinear +Function mindspore::dataset::ResizePreserveARWithFiller +Function mindspore::dataset::Sobel +Function mindspore::dataset::Split +Function mindspore::dataset::SubStractMeanNormalize +Function mindspore::dataset::Subtract +Function mindspore::dataset::Transpose +Function mindspore::dataset::WarpAffineBilinear +Function mindspore::dataset::WarpPerspectiveBilinear + + + +常量 / 结构体 + +Enum PaddBorderType +Struct Point + + +",mindspore::dataset,mindspore、mindspore、dataset +mindspore-dataset-config§函数,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset_config.html," + +Function mindspore::dataset::config::get_callback_timeout +Function mindspore::dataset::config::get_monitor_sampling_interval +Function mindspore::dataset::config::get_num_parallel_workers +Function mindspore::dataset::config::get_prefetch_size +Function mindspore::dataset::config::get_seed +Function mindspore::dataset::config::load +Function mindspore::dataset::config::load (overloaded) +Function mindspore::dataset::config::set_callback_timeout +Function mindspore::dataset::config::set_monitor_sampling_interval +Function mindspore::dataset::config::set_num_parallel_workers +Function mindspore::dataset::config::set_prefetch_size +Function mindspore::dataset::config::set_seed + +",mindspore::dataset::config,mindspore、mindspore、callback、dataset +mindspore-dataset-text§类,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset_text.html," + +Class BasicTokenizer +Class BertTokenizer +Class CaseFold +Class JiebaTokenizer +Class Lookup +Class Ngram +Class NormalizeUTF8 +Class RegexReplace +Class RegexTokenizer +Class SentencePieceTokenizer +Class SlidingWindow +Class ToNumber +Class TruncateSequencePair +Class UnicodeCharTokenizer +Class UnicodeScriptTokenizer +Class WhitespaceTokenizer +Class WordpieceTokenizer + +",mindspore::dataset::text,mindspore、mindspore、dataset +mindspore-dataset-transforms§类,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset_transforms.html," + +Class Compose +Class Concatenate +Class Duplicate +Class Fill +Class Mask +Class OneHot +Class PadEnd +Class RandomApply +Class RandomChoice +Class Slice +Class TypeCast +Class Unique + +",mindspore::dataset::transforms,mindspore、mindspore、ast、aten、dataset +mindspore-dataset-vision§类,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset_vision.html," + +Class AdjustGamma +Class Affine +Class AutoContrast +Class BoundingBoxAugment +Class CenterCrop +Class ConvertColor +Class Crop +Class CutMixBatch +Class CutOut +Class Decode +Class DvppDecodePng +Class DvppDecodeResizeCropJpeg +Class DvppDecodeResizeJpeg +Class Equalize +Class GaussianBlur +Class HorizontalFlip +Class HWC2CHW +Class Invert +Class MixUpBatch +Class Normalize +Class NormalizePad +Class Pad +Class RandomAffine +Class RandomColor +Class RandomColorAdjust +Class RandomCrop +Class RandomCropDecodeResize +Class RandomCropWithBBox +Class RandomHorizontalFlip +Class RandomHorizontalFlipWithBBox +Class RandomPosterize +Class RandomResize +Class RandomResizedCrop +Class RandomResizedCropWithBBox +Class RandomResizeWithBBox +Class RandomRotation +Class RandomSelectSubpolicy +Class RandomSharpness +Class RandomSolarize +Class RandomVerticalFlip +Class RandomVerticalFlipWithBBox +Class Rescale +Class Resize +Class ResizePreserveAR +Class ResizeWithBBox +Class RGB2BGR +Class RGB2GRAY +Class RGBA2BGR +Class RGBA2RGB +Class Rotate +Class SlicePatches +../generate/classmindspore_dataset_vision_SoftDvppDecodeRandomCropResizeJpeg +../generate/classmindspore_dataset_vision_SoftDvppDecodeResizeJpeg +Class SwapRedBlue +Class UniformAugment +Class VerticalFlip + +",mindspore::dataset::vision,mindspore、mindspore、pB、ast、dataset +mindspore-datatype§DataType,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_datatype.html," +enum类型变量。 + + + +类型定义 +值 +描述 + + + + +kTypeUnknown +0 +表示未知的数据类型 + + +kObjectTypeString +12 +表示String数据类型。 + + +kObjectTypeList +13 +表示List数据类型。 + + +kObjectTypeTuple +14 +表示Tuple数据类型。 + + +kObjectTypeTensorType +17 +表示TensorList数据类型。 + + +kNumberTypeBegin +29 +表示Number类型的起始。 + + +kNumberTypeBool +30 +表示Bool数据类型。 + + +kNumberTypeInt8 +32 +表示Int8数据类型。 + + +kNumberTypeInt16 +33 +表示Int16数据类型。 + + +kNumberTypeInt32 +34 +表示Int32数据类型。 + + +kNumberTypeInt64 +35 +表示Int64数据类型。 + + +kNumberTypeUInt +36 +表示UInt数据类型。 + + +kNumberTypeUInt8 +37 +表示UInt8数据类型。 + + +kNumberTypeUInt16 +38 +表示UInt16数据类型。 + + +kNumberTypeUInt32 +39 +表示UInt32数据类型。 + + +kNumberTypeUInt64 +40 +表示UInt64数据类型。 + + +kNumberTypeFloat16 +42 +表示Float16数据类型。 + + +kNumberTypeFloat32 +43 +表示Float32数据类型。 + + +kNumberTypeFloat64 +44 +表示Float64数据类型。 + + +kNumberTypeEnd +46 +表示Number类型的结尾。 + + +kInvalidType +INT32_MAX +表示无效的数据类型 + + +",mindspore::DataType,mindspore、mindspore、数据类型、数据 +mindspore-format§Format,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_format.html," +enum类型变量。 + + + +定义 +值 + + + + +NCHW +0 + + +NHWC +1 + + +NHWC4 +2 + + +HWKC +3 + + +HWCK +4 + + +KCHW +5 + + +CKHW +6 + + +KHWC +7 + + +CHWK +8 + + +HW +9 + + +HW4 +10 + + +NC +11 + + +NC4 +12 + + +NC4HW4 +13 + + +NUM_OF_FORMAT +14 + + +NCDHW +15 + + +NWC +16 + + +NCW +17 + + +",mindspore::Format,mindspore、mindspore +mindspore-id-generator§Functions,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_id_generator.html," + +Function mindspore::id_generator::get_id +Function mindspore::id_generator::reset_id +Function mindspore::id_generator::reset_id_with_offset + +",mindspore::id_generator,mindspore、mindspore +mindspore-kernel§接口汇总,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_kernel.html," + + + +类名 +描述 + + + + +Kernel +算子基类。 + + +KernelInterface +算子扩展能力基类。 + + + +",mindspore::kernel,mindspore、mindspore、算子、接口 +mindspore-kernel§Kernel,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_kernel.html," +#include +Kernel是算子实现的基类，定义了几个必须实现的接口。 +",mindspore::kernel,mindspore、mindspore、算子、接口 +mindspore-kernel§构造函数,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_kernel.html," + +Kernel +Kernel() + +Kernel(const std::vector &inputs, const std::vector &outputs, + const schema::Primitive *primitive, const mindspore::Context *ctx) + + +Kernel的默认与带参构造函数，构造Kernel实例。 + +参数 + +inputs: 算子输入MSTensor。 +outputs: 算子输出MSTensor。 +primitive: 算子经由flatbuffers反序化为Primitive后的结果。 +ctx: 算子的上下文Context。 + + + + +",mindspore::kernel,mindspore、mindspore、算子、npu +mindspore-kernel§析构函数,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_kernel.html," + +~Kernel +virtual ~Kernel() + + +Kernel的析构函数。 + +",mindspore::kernel,mindspore、mindspore +mindspore-kernel§公有成员函数,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_kernel.html," + +Prepare +virtual int Prepare() + + +进行算子运行前相关的准备工作，MindSpore Lite 框架运行时会对所有算子执行一遍Prepare后再执行Execute。 + + +Execute +virtual int Execute() + + +运行算子。 + + +ReSize +virtual int ReSize() + + +在用户调用Model::Resize接口时，或是模型推理中需要重新推理算子形状时，会调用到该接口。 +在ReSize函数中，若有必要，根据输入的形状态重新推理输出形状，并分配算子运算中需要的内存。 + + +type +virtual schema::PrimitiveType type() + + +返回算子的类型。 + + +quant_type +virtual schema::QuantType quant_type() + + +返回算子的量化类型。 + + +set_inputs +virtual void set_inputs(const std::vector &in_tensors) + + +设置算子的输入列表。 + +参数 + +in_tensors: 算子的所有输入MSTensor列表。 + + + + + +set_input +virtual set_input(mindspore::MSTensor in_tensor, int index) + + +设置算子指定位置的输入。 + +参数 + +in_tensor: 算子的输入MSTensor。 +index: 算子输入在所有输入中的下标，从0开始计数。 + + + + + +set_outputs +virtual void set_outputs(const std::vector &out_tensors) + + +设置算子的输出列表。 + +参数 + +out_tensor: 算子的所有输出MSTensor列表。 + + + + + +set_output +virtual void set_output(mindspore::MSTensor out_tensor, int index) + + +设置算子指定位置的输出。 + +参数 + +out_tensor: 算子的输出MSTensor。 +index: 算子输出在所有输出中的下标，从0开始计数。 + + + + + +inputs +virtual const std::vector &inputs() + + +返回算子的所有输入MSTensor列表。 + + +outputs +virtual const std::vector &outputs() + + +返回算子的所有输出MSTensor列表。 + + +name +std::string name() + + +返回算子的名称。 + + +set_name +void set_name(const std::string &name) + + +设置算子的名称。 + +参数 + +name: 算子名称。 + + + + + +context +const lite::Context *context() const + + +返回算子对应的Context。 + + +primitive +const schema::Primitive *primitive() const + + +返回算子经由flatbuffers反序化为Primitive后的结果。 + + +GetAttr +std::string GetAttr(const std::string &key) const + + +获取指定配置名对应的配置。 + +参数 + +key: 配置名。 + + + + + +SetConfig +void SetConfig(const std::map> *config) + + +保存配置内容的常量指针到kernel里，该接口当前是由框架在加载配置文件时自动触发调用的，不建议用户使用。 + +参数 + +config: 配置的常量指针。 + + + + + +GetConfig +std::map GetConfig(const std::string §ion) const + + +获取指定章节名对应的配置。 + +参数 + +section: 配置的章节名称。 + + + + +",mindspore::kernel,mindspore、mindspore、算子、接口、模型推理、Model、框架、npu +mindspore-kernel§KernelInterface,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_kernel.html," +#include +算子扩展能力基类。 + +~KernelInterface +virtual ~KernelInterface() + + +析构函数。 + + +KernelInterfaceCreator +using KernelInterfaceCreator = std::function()> + + +创建KernelInterface的函数原型声明。 + + +公有成员函数 + +Infer +算子的InferShape能力，用于根据输入推导出输出的形状、数据类型以及format。 +virtual int Infer(std::vector *inputs, std::vector *outputs, const schema::Primitive *primitive, const Kernel *kernel) + + + +参数 + +inputs: 算子输入MSTensor。 +outputs: 算子输出MSTensor。 +primitive: 算子经过flatbuffers反序化后的结果，存储算子属性。 +kernel: 算子的基类结构，在Build阶段，kernel是空指针，Build完成后框架传递的kernel才有值，当kernel非空时就不建议去操作primitive了，因为有可能primtive已经无效了。 + + + + + +Infer +算子的InferShape能力，用于根据输入推导出输出的shape、数据类型以及format。 +该接口已不推荐使用，建议使用带有kernel参数的Infer接口。因为如果模型通过以下Build接口执行编译，编译后框架会自动释放模型的内存，导致primitive不可用。 +Status Build(GraphCell graph, const std::shared_ptr &model_context = nullptr, + const std::shared_ptr &train_cfg = nullptr) + + +virtual int Infer(std::vector *inputs, std::vector *outputs, const schema::Primitive *primitive) + + + +参数 + +inputs: 算子输入MSTensor。 +outputs: 算子输出MSTensor。 +primitive: 算子经过flatbuffers反序化后的结果，存储算子属性。 + + + + + +",mindspore::kernel,mindspore、mindspore、算子、接口、数据类型、原型、model、数据、框架、Graph、npu +mindspore-label-manage§Enums,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_label_manage.html," + +Enum TraceLabelType + +",mindspore::label_manage,mindspore、mindspore +mindspore-label-manage§Functions,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_label_manage.html," + +Function mindspore::label_manage::GetGlobalTraceLabelType +Function mindspore::label_manage::Label + +",mindspore::label_manage,mindspore、mindspore +mindspore-ops§Classes,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_ops.html," + +Class Abs +Class Activation +Class Adam +Class Add +Class AdderFusion +Class AddFusion +Class AddN +Class Affine +Class All +Class AllGather +Class ApplyMomentum +Class ArgMax +Class ArgMaxFusion +Class ArgMinFusion +Class Assert +Class Assign +Class AssignAdd +Class Attention +Class AudioSpectrogram +Class AvgPool +Class AvgPoolFusion +Class BaseOperator +Class BatchNorm +Class BatchToSpace +Class BatchToSpaceND +Class BiasAdd +Class BinaryCrossEntropy +Class Broadcast +Class Call +Class Cast +Class Ceil +Class Clip +Class Concat +Class ConstantOfShape +Class Conv2D +Class Conv2DBackpropFilterFusion +Class Conv2DBackpropInputFusion +Class Conv2DFusion +Class Conv2DTranspose +Class Conv2dTransposeFusion +Class Cos +Class Crop +Class CropAndResize +Class CumSum +Class Custom +Class CustomExtractFeatures +Class CustomNormalize +Class CustomPredict +Class Depend +Class DepthToSpace +Class DetectionPostProcess +Class Div +Class DivFusion +Class Dropout +Class DynamicQuant +Class Eltwise +Class Elu +Class EmbeddingLookupFusion +Class Equal +Class Erf +Class Exp +Class ExpandDims +Class ExpFusion +Class FakeQuantWithMinMaxVars +Class FakeQuantWithMinMaxVarsPerChannel +Class FftImag +Class FftReal +Class Fill +Class Flatten +Class Floor +Class FloorDiv +Class FloorMod +Class FullConnection +Class FusedBatchNorm +Class Gather +Class GatherNd +Class GLU +Class Greater +Class GreaterEqual +Class GRU +Class HashtableLookup +Class InstanceNorm +Class InvertPermutation +Class IsFinite +Class L2NormalizeFusion +Class LayerNormFusion +Class LeakyRelu +Class Less +Class LessEqual +Class LinSpace +Class Log +Class LogicalAnd +Class LogicalNot +Class LogicalOr +Class LogSoftmax +Class LpNormalization +Class LRN +Class LshProjection +Class LSTM +Class MakeTuple +Class MatMulFusion +Class Maximum +Class MaxPool +Class MaxPoolFusion +Class Mfcc +Class Minimum +Class Mod +Class Mul +Class MulFusion +Class Neg +Class NLLLoss +Class NonMaxSuppression +Class NonZero +Class NotEqual +Class OneHot +Class OnesLike +Class OperatorRegister +Class OperatorRegisterHelper +Class Pad +Class PadFusion +Class PartialFusion +Class Pow +Class PowFusion +Class PReLU +Class PReLUFusion +Class PriorBox +Class QuantDTypeCast +Class RaggedRange +Class RandomNormal +Class RandomStandardNormal +Class Range +Class Rank +Class RealDiv +Class Reciprocal +Class Reduce +Class ReduceFusion +Class ReduceScatter +Class Reshape +Class Resize +Class Return +Class ReverseSequence +Class ReverseV2 +Class Rfft +Class ROIPooling +Class Round +Class Rsqrt +Class Scale +Class ScaleFusion +Class ScatterNd +Class ScatterNdUpdate +Class Select +Class SGD +Class Shape +Class SigmoidCrossEntropyWithLogits +Class Sin +Class Size +Class SkipGram +Class SliceFusion +Class SmoothL1Loss +Class Softmax +Class SoftmaxCrossEntropyWithLogits +Class SpaceToBatch +Class SpaceToBatchND +Class SpaceToDepth +Class SparseSoftmaxCrossEntropyWithLogits +Class SparseToDense +Class Splice +Class Split +Class SplitWithOverlap +Class Sqrt +Class Square +Class SquaredDifference +Class Squeeze +Class Stack +Class StridedSlice +Class Sub +Class SubFusion +Class Switch +Class SwitchLayer +Class TensorArray +Class TensorArrayRead +Class TensorArrayWrite +Class TensorListFromTensor +Class TensorListGetItem +Class TensorListReserve +Class TensorListSetItem +Class TensorListStack +Class Tile +Class TileFusion +Class TopK +Class TopKFusion +Class Transpose +Class TupleGetItem +Class UniformReal +Class Unique +Class UnsortedSegmentSum +Class Unsqueeze +Class Unstack +Class Where +Class ZerosLike + +",mindspore::ops,mindspore、mindspore、SGD、Loss、ast、LR、roce、npu、Embedding +mindspore-ops§Enums,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_ops.html," + +Enum Dims +Enum Index + +",mindspore::ops,mindspore、mindspore +mindspore-ops§Functions,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_ops.html," + +Function mindspore::ops::AdamInfer +Function mindspore::ops::AddFusionInfer +Function mindspore::ops::AddInfer +Function mindspore::ops::AddNInfer +Function mindspore::ops::ApplyMomentumInfer +Function mindspore::ops::ArgMaxFusionInfer +Function mindspore::ops::ArgMaxInfer +Function mindspore::ops::ArgMinFusionInfer +Function mindspore::ops::AssertInfer +Function mindspore::ops::AssignAddInfer +Function mindspore::ops::AssignInfer +Function mindspore::ops::AudioSpectrogramInfer +Function mindspore::ops::AvgPoolFusionInfer +Function mindspore::ops::AvgPoolInfer +Function mindspore::ops::BatchNormInfer +Function mindspore::ops::BatchToSpaceInfer +Function mindspore::ops::BatchToSpaceNDInfer +Function mindspore::ops::BiasAddInfer +Function mindspore::ops::BroadcastInfer +Function mindspore::ops::CastInfer +Function mindspore::ops::CeilInfer +Function mindspore::ops::ConcatInfer +Function mindspore::ops::ConstantOfShapeInfer +Function mindspore::ops::Conv2dInfer +Function mindspore::ops::Conv2DTransposeInfer +Function mindspore::ops::CosInfer +Function mindspore::ops::CropInfer +Function mindspore::ops::CumSumInfer +Function mindspore::ops::CustomExtractFeaturesInfer +Function mindspore::ops::CustomNormalizeInfer +Function mindspore::ops::CustomPredictInfer +Function mindspore::ops::DependInfer +Function mindspore::ops::DepthToSpaceInfer +Function mindspore::ops::DetectionPostProcessInfer +Function mindspore::ops::DivInfer +Function mindspore::ops::DynamicQuantInfer +Function mindspore::ops::EluInfer +Function mindspore::ops::EqualInfer +Function mindspore::ops::ErfInfer +Function mindspore::ops::ExpandDimsInfer +Function mindspore::ops::ExpInfer +Function mindspore::ops::FakeQuantWithMinMaxVarsInfer +Function mindspore::ops::FakeQuantWithMinMaxVarsPerChannelInfer +Function mindspore::ops::FftImagInfer +Function mindspore::ops::FftRealInfer +Function mindspore::ops::FillInfer +Function mindspore::ops::FlattenInfer +Function mindspore::ops::FloorDivInfer +Function mindspore::ops::FloorInfer +Function mindspore::ops::FloorModInfer +Function mindspore::ops::FullConnectionInfer +Function mindspore::ops::GatherNdInfer +Function mindspore::ops::GreaterEqualInfer +Function mindspore::ops::GreaterInfer +Function mindspore::ops::HashtableLookupInfer +Function mindspore::ops::InferImplDropout +Function mindspore::ops::LayerNormFusionInfer +Function mindspore::ops::LeakyReluInfer +Function mindspore::ops::LessEqualInfer +Function mindspore::ops::LessInfer +Function mindspore::ops::LogicalAndInfer +Function mindspore::ops::LogicalNotInfer +Function mindspore::ops::LogicalOrInfer +Function mindspore::ops::LogInfer +Function mindspore::ops::LrnInfer +Function mindspore::ops::LshProjectionInfer +Function mindspore::ops::LstmInfer +Function mindspore::ops::MaximumInfer +Function mindspore::ops::MaxPoolFusionInfer +Function mindspore::ops::MaxPoolInfer +Function mindspore::ops::MfccInfer +Function mindspore::ops::MinimumInfer +Function mindspore::ops::ModInfer +Function mindspore::ops::MulInfer +Function mindspore::ops::NegInfer +Function mindspore::ops::NonMaxSuppressionInfer +Function mindspore::ops::NonZeroInfer +Function mindspore::ops::NotEqualInfer +Function mindspore::ops::OnesLikeInfer +Function mindspore::ops::PadInfer +Function mindspore::ops::PowInfer +Function mindspore::ops::PReLUInfer +Function mindspore::ops::PriorBoxInfer +Function mindspore::ops::QuantDTypeCastInfer +Function mindspore::ops::RaggedRangeInfer +Function mindspore::ops::RandomStandardNormalInfer +Function mindspore::ops::RangeInfer +Function mindspore::ops::RankInfer +Function mindspore::ops::RealDivInfer +Function mindspore::ops::ReciprocalInfer +Function mindspore::ops::ReduceFusionInfer +Function mindspore::ops::ReduceInfer +Function mindspore::ops::ReshapeInfer +Function mindspore::ops::ResizeInfer +Function mindspore::ops::ReverseSequenceInfer +Function mindspore::ops::ReverseV2Infer +Function mindspore::ops::RfftInfer +Function mindspore::ops::ROIPoolingInfer +Function mindspore::ops::RoundInfer +Function mindspore::ops::RsqrtInfer +Function mindspore::ops::ScatterNdInfer +Function mindspore::ops::ScatterNdUpdateInfer +Function mindspore::ops::SGDInfer +Function mindspore::ops::SigmoidCrossEntropyWithLogitsInfer +Function mindspore::ops::SinInfer +Function mindspore::ops::SkipGramInfer +Function mindspore::ops::SliceFusionInfer +Function mindspore::ops::SmoothL1LossInfer +Function mindspore::ops::SoftmaxCrossEntropyWithLogitsInfer +Function mindspore::ops::SoftmaxInfer +Function mindspore::ops::SpaceToBatchInfer +Function mindspore::ops::SpaceToBatchNDInfer +Function mindspore::ops::SpaceToDepthInfer +Function mindspore::ops::SparseSoftmaxCrossEntropyWithLogitsInfer +Function mindspore::ops::SparseToDenseInfer +Function mindspore::ops::SplitInfer +Function mindspore::ops::SquaredDifferenceInfer +Function mindspore::ops::SquareInfer +Function mindspore::ops::SqueezeInfer +Function mindspore::ops::StackInfer +Function mindspore::ops::StridedSliceInfer +Function mindspore::ops::SubInfer +Function mindspore::ops::TensorListFromTensorInfer +Function mindspore::ops::TensorListStackInfer +Function mindspore::ops::TileInfer +Function mindspore::ops::TopKInfer +Function mindspore::ops::TransposeInfer +Function mindspore::ops::UniformRealInfer +Function mindspore::ops::UnsortedSegmentSumInfer +Function mindspore::ops::UnsqueezeInfer +Function mindspore::ops::UnstackInfer +Function mindspore::ops::WhereInfer +Function mindspore::ops::ZerosLikeInfer + +",mindspore::ops,mindspore、mindspore、SGD、Loss、ast、Lr、roce +mindspore-registry§接口汇总,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," + + + +类名 +描述 + + + + +NodeParserRegistry +扩展Node解析的注册类。 + + +REG_NODE_PARSER +注册扩展Node解析。 + + +ModelParserRegistry +扩展Model解析的注册类。 + + +REG_MODEL_PARSER +注册扩展Model解析。 + + +PassBase +Pass的基类。 + + +PassPosition +扩展Pass的运行位置。 + + +PassRegistry +扩展Pass注册构造类。 + + +REG_PASS +注册扩展Pass。 + + +REG_SCHEDULED_PASS +注册扩展Pass的调度顺序。 + + +RegisterKernel +算子注册实现类。 + + +KernelReg +算子注册构造类。 + + +REGISTER_KERNEL +注册算子。 + + +REGISTER_CUSTOM_KERNEL +注册Custom算子注册。 + + +RegisterKernelInterface +算子扩展能力注册实现类。 + + +KernelInterfaceReg +算子扩展能力注册构造类。 + + +REGISTER_KERNEL_INTERFACE +注册算子扩展能力。 + + +REGISTER_CUSTOM_KERNEL_INTERFACE +注册Custom算子扩展能力。 + + + +",mindspore::registry,mindspore、mindspore、算子、接口、Model、lR +mindspore-registry§NodeParserRegistry,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +NodeParserRegistry类用于注册及获取NodeParser类型的共享智能指针。 + +NodeParserRegistry +NodeParserRegistry(converter::FmkType fmk_type, const std::string &node_type, + const converter::NodeParserPtr &node_parser); + + +构造函数。 + +参数 + +fmk_type: 框架类型，具体见FmkType说明。 +node_type: 节点的类型。 +node_parser: NodeParser类型的共享智能指针实例, 具体见NodeParserPtr说明。 + + + + + +~NodeParserRegistry +~NodeParserRegistry = default; + + +析构函数。 + + +公有成员函数 + +GetNodeParser +static converter::NodeParserPtr GetNodeParser(converter::FmkType fmk_type, const std::string &node_type); + + +静态方法，获取NodeParser类型的共享智能指针实例。 + +参数 + +fmk_type: 框架类型，具体见FmkType说明。 +node_type: 节点的类型。 + + + + + +",mindspore::registry,mindspore、mindspore、框架 +mindspore-registry§REG_NODE_PARSER,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +#define REG_NODE_PARSER(fmk_type, node_type, node_parser) + + +注册NodeParser宏。 + +参数 + +fmk_type: 框架类型，具体见FmkType说明。 +node_type: 节点的类型。 +node_parser: NodeParser类型的共享智能指针实例, 具体见NodeParserPtr说明。 + + + +",mindspore::registry,mindspore、mindspore、框架 +mindspore-registry§ModelParserCreator,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +typedef converter::ModelParser *(*ModelParserCreator)() + + +创建ModelParser的函数原型声明。 +",mindspore::registry,mindspore、mindspore、原型、Model +mindspore-registry§ModelParserRegistry,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +ModelParserRegistry类用于注册及获取ModelParserCreator类型的函数指针。 + +ModelParserRegistry +ModelParserRegistry(FmkType fmk, ModelParserCreator creator) + + +构造函数，构造ModelParserRegistry对象，进行Model解析注册。 + +参数 + +fmk: 框架类型，具体见FmkType说明。 +creator: ModelParserCreator类型的函数指针, 具体见ModelParserCreator说明。 + + + + + +~ModelParserRegistry +~ModelParserRegistry() + + +析构函数。 + + +公有成员函数 + +GetModelParser +static ModelParser *GetModelParser(FmkType fmk) + + +获取ModelParserCreator类型的函数指针。 + +参数 + +fmk: 框架类型，具体见FmkType说明。 + + + + + +",mindspore::registry,mindspore、mindspore、Model、框架 +mindspore-registry§REG_MODEL_PARSER,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +#define REG_MODEL_PARSER(fmk, parserCreator) + + +注册ModelParserCreator类。 + +参数 + +fmk: 框架类型，具体见FmkType说明。 +creator: ModelParserCreator类型的函数指针, 具体见ModelParserCreator说明。 + + + + +用户自定义的ModelParser，框架类型必须满足设定支持的框架类型FmkType。 + +",mindspore::registry,mindspore、mindspore、MODEL、框架 +mindspore-registry§PassBase,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +PassBase定义了图优化的基类，以供用户继承并自定义图优化算法。 + +PassBase +PassBase(const std::string &name = ""PassBase"") + + +构造函数，构造PassBase类对象。 + +参数 + +name: PassBase类对象的标识，需保证唯一性。 + + + + + +~PassBase +virtual ~PassBase() = default; + + +析构函数。 + + +公有成员函数 + +Execute +virtual bool Execute(const api::FuncGraphPtr &func_graph) = 0; + + +对图进行操作的接口函数。 + +参数 + +func_graph: FuncGraph的指针类对象。 + + + + + +",mindspore::registry,mindspore、mindspore、接口、api、优化、Graph +mindspore-registry§PassBasePtr,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +PassBase类的共享智能指针类型。 +using PassBasePtr = std::shared_ptr + + +",mindspore::registry,mindspore、mindspore +mindspore-registry§PassPosition,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +enum类型变量，定义扩展Pass的运行位置。 +enum PassPosition { + POSITION_BEGIN = 0, // 扩展Pass运行于内置融合Pass前 + POSITION_END = 1 // 扩展Pass运行于内置融合Pass后 +}; + + +",mindspore::registry,mindspore、mindspore +mindspore-registry§PassRegistry,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +PassRegistry类用于注册及获取Pass类实例。 + +PassRegistry +PassRegistry(const std::string &pass_name, const PassBasePtr &pass) + + +构造函数，构造PassRegistry对象，进行注册Pass。 + +参数 + +pass_name: Pass的命名标识，保证唯一性。 +pass: PassBase类实例。 + + + +PassRegistry(PassPosition position, const std::vector &names) + + +构造函数，构造PassRegistry对象，指定扩展Pass的运行位置及其运行顺序。 + +参数 + +position: 扩展Pass的运行位置，具体见PassPosition说明。 +names: 用户指定在该运行位置处，调用Pass的命名标识，命名标识的顺序即为指定Pass的调用顺序。 + + + + + +~PassRegistry +~PassRegistry() + + +析构函数。 + + +公有成员函数 + +GetOuterScheduleTask +static std::vector GetOuterScheduleTask(PassPosition position) + + +获取指定位置处，外部设定的调度任务。 + +参数 + +position: 扩展Pass的运行位置，具体见PassPosition说明。 + + + + + +GetPassFromStoreRoom +static PassBasePtr GetPassFromStoreRoom(const std::string &pass_name) + + +获取PassBase实例，根据指定的Pass命名标识。 + +参数 + +pass_name: Pass的命名标识。 + + + + + +",mindspore::registry,mindspore、mindspore +mindspore-registry§REG_PASS,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +#define REG_PASS(name, pass) + + +注册Pass宏。 + +参数 + +name: Pass的命名标识，保证唯一性。 +pass: PassBase类实例。 + + + +",mindspore::registry,mindspore、mindspore +mindspore-registry§REG_SCHEDULED_PASS,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +#define REG_SCHEDULED_PASS(position, names) + + +指定扩展Pass的运行位置及其运行顺序。 + +参数 + +position: 扩展Pass的运行位置，具体见PassPosition说明。 +names: 用户指定在该运行位置处，调用Pass的命名标识，命名标识的顺序即为指定Pass的调用顺序。 + + + + +MindSpore Lite开放了部分内置Pass，请见以下说明。用户可以在names参数中添加内置Pass的命名标识，以在指定运行处调用内置Pass。 + +ConstFoldPass: 将输入均是常量的节点进行离线计算，导出的模型将不含该节点。特别地，针对shape算子，在inputShape给定的情形下，也会触发预计算。 +DumpGraph: 导出当前状态下的模型。请确保当前模型为NHWC或者NCHW格式的模型，例如卷积算子等。 +ToNCHWFormat: 将当前状态下的模型转换为NCHW的格式，例如，四维的图输入、卷积算子等。 +ToNHWCFormat: 将当前状态下的模型转换为NHWC的格式，例如，四维的图输入、卷积算子等。 +DecreaseTransposeAlgo: transpose算子的优化算法，删除冗余的transpose算子。 + +ToNCHWFormat与ToNHWCFormat需配套使用。在开放的运行位置处，用户所得到的模型已统一为NHWC的格式，用户也需确保在当前运行位置处返回之时，模型也是NHWC的格式。 +例: 指定names为{“ToNCHWFormat”， “UserPass”，”ToNHWCFormat”}。 + +",mindspore::registry,mindspore、mindspore、算子、优化、Graph、npu +mindspore-registry§KernelDesc,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +struct类型结构体，定义扩展kernel的基本属性。 +struct KernelDesc { + DataType data_type; // kernel的计算数据类型 + int type; // 算子的类型 + std::string arch; // 设备标识 + std::string provider; // 用户标识 +}; + + +",mindspore::registry,mindspore、mindspore、算子、数据类型、数据 +mindspore-registry§RegisterKernel,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include + +CreateKernel +using CreateKernel = std::function( + const std::vector &inputs, const std::vector &outputs, const schema::Primitive *primitive, + const mindspore::Context *ctx)> + + +创建算子的函数原型声明。 + +参数 + +inputs: 算子输入MSTensor。 +outputs: 算子输出MSTensor。 +primitive: 算子经由flatbuffers反序化为Primitive后的结果。 +ctx: 算子的上下文Context。 + + + + + +公有成员函数 + +RegKernel +static Status RegKernel(const std::string &arch, const std::string &provider, DataType data_type, int type, const CreateKernel creator) + + +算子注册。 + +参数 + +arch: 算子运行的平台，由用户自定义，如果算子是运行在CPU平台，或者算子运行完后的output tensor里的内存是在CPU平台上的，则此处也写CPU，MindSpore Lite内部会切成一个子图，在异构并行场景下有助于性能提升。 +provider: 生产商名，由用户自定义。 +data_type: 算子支持的数据类型，具体见DataType。 +op_type: 算子类型，定义在ops.fbs中，编绎时会生成到ops_generated.h，该文件可以在发布件中获取。 +creator: 创建算子的函数指针，具体见CreateKernel的说明。 + + + + + +RegCustomKernel +static Status RegCustomKernel(const std::string &arch, const std::string &provider, DataType data_type, const std::string &type, const CreateKernel creator) + + +Custom算子注册。 + +参数 + +arch: 算子运行的平台，由用户自定义，如果算子是运行在CPU平台，或者算子运行完后的output tensor里的内存是在CPU平台上的，则此处也写CPU，MindSpore Lite内部会切成一个子图，在异构并行场景下有助于性能提升。 +provider: 生产商名，由用户自定义。 +data_type: 算子支持的数据类型，具体见DataType。 +type: 算子类型，由用户自定义，确保唯一即可。 +creator: 创建算子的函数指针，具体见CreateKernel的说明。 + + + + + +GetCreator +static CreateKernel GetCreator(const schema::Primitive *primitive, KernelDesc *desc); + + +获取算子的创建函数。 + +参数 + +primitive: 算子经由flatbuffers反序化为Primitive后的结果。 +desc: 算子的基本属性,具体见KernelDesc说明。 + + + + + +",mindspore::registry,mindspore、mindspore、并行、算子、CPU、数据类型、原型、数据、性能、npu +mindspore-registry§KernelReg,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include + +~KernelReg +~KernelReg() = default + + +析构函数。 + + +KernelReg +KernelReg(const std::string &arch, const std::string &provider, DataType data_type, int op_type, const CreateKernel creator) + + +构造函数，构造注册算子，进行算子注册。 + +参数 + +arch: 算子运行的平台，由用户自定义，如果算子是运行在CPU平台，或者算子运行完后的output tensor里的内存是在CPU平台上的，则此处也写CPU，MindSpore Lite内部会切成一个子图，在异构并行场景下有助于性能提升。 +provider: 生产商名，由用户自定义。 +data_type: 算子支持的数据类型，具体见DataType。 +op_type: 算子类型，定义在ops.fbs中，编绎时会生成到ops_generated.h，该文件可以在发布件中获取。 +creator: 创建算子的函数指针，具体见CreateKernel的说明。 + + + +KernelReg(const std::string &arch, const std::string &provider, DataType data_type, const std::string &op_type, const CreateKernel creator) + + +构造函数，构造注册Custom算子，进行算子注册。 + +参数 + +arch: 算子运行的平台，由用户自定义，如果算子是运行在CPU平台，或者算子运行完后的output tensor里的内存是在CPU平台上的，则此处也写CPU，MindSpore Lite内部会切成一个子图，在异构并行场景下有助于性能提升。 +provider: 生产商名，由用户自定义。 +data_type: 算子支持的数据类型，具体见DataType。 +op_type: 算子类型，由用户自定义，确保唯一即可。 +creator: 创建算子的函数指针，具体见CreateKernel的说明。 + + + + +",mindspore::registry,mindspore、mindspore、并行、算子、CPU、数据类型、lR、数据、性能 +mindspore-registry§REGISTER_KERNEL,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#define REGISTER_KERNEL(arch, provider, data_type, op_type, creator) + + +注册算子宏。 + +参数 + +arch: 算子运行的平台，由用户自定义，如果算子是运行在CPU平台，或者算子运行完后的output tensor里的内存是在CPU平台上的，则此处也写CPU，MindSpore Lite内部会切成一个子图，在异构并行场景下有助于性能提升。 +provider: 生产商名，由用户自定义。 +data_type: 算子支持的数据类型，具体见DataType。 +op_type: 算子类型，定义在ops.fbs中，编绎时会生成到ops_generated.h，该文件可以在发布件中获取。 +creator: 创建算子的函数指针，具体见CreateKernel的说明。 + + + +",mindspore::registry,mindspore、mindspore、并行、算子、CPU、数据类型、数据、性能 +mindspore-registry§REGISTER_CUSTOM_KERNEL,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#define REGISTER_CUSTOM_KERNEL(arch, provider, data_type, op_type, creator) + + +注册Custom算子。 + +参数 + +arch: 算子运行的平台，由用户自定义，如果算子是运行在CPU平台，或者算子运行完后的output tensor里的内存是在CPU平台上的，则此处也写CPU，MindSpore Lite内部会切成一个子图，在异构并行场景下有助于性能提升。 +provider: 生产商名，由用户自定义。 +data_type: 算子支持的数据类型，具体见DataType。 +op_type: 算子类型，由用户自定义，确保唯一即可。 +creator: 创建算子的函数指针，具体见CreateKernel的说明。 + + + +",mindspore::registry,mindspore、mindspore、并行、算子、CPU、数据类型、数据、性能 +mindspore-registry§KernelInterfaceCreator,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +定义创建算子的函数指针类型。 +using KernelInterfaceCreator = std::function()>; + + +",mindspore::registry,mindspore、mindspore、算子 +mindspore-registry§RegisterKernelInterface,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +算子扩展能力注册实现类。 + +公有成员函数 + +CustomReg +static Status CustomReg(const std::string &provider, const std::string &op_type, const KernelInterfaceCreator creator) + + +Custom算子的扩展能力注册。 + +参数 + +provider: 生产商，由用户自定义。 +op_type: 算子类型，由用户自定义。 +creator: KernelInterface的创建函数，详细见KernelInterfaceCreator的说明。 + + + + + +Reg +static Status Reg(const std::string &provider, int op_type, const KernelInterfaceCreator creator) + + +算子的扩展能力注册。 + +参数 + +provider: 生产商，由用户自定义。 +op_type: 算子类型，定义在ops.fbs中，编绎时会生成到ops_generated.h，该文件可以在发布件中获取。 +creator: KernelInterface的创建函数，详细见KernelInterfaceCreator的说明。 + + + + + +GetKernelInterface +static std::shared_ptr GetKernelInterface(const std::string &provider, const schema::Primitive *primitive, const kernel::Kernel *kernel) + + +获取注册的算子扩展能力。 + +参数 + +provider：生产商名，由用户自定义。 +primitive：算子经过flatbuffers反序化后的结果，存储算子属性。 +kernel：算子的内核，不传的话默认为空，为空时必须保证primitive非空有效。 + + + + + +",mindspore::registry,mindspore、mindspore、算子 +mindspore-registry§KernelInterfaceReg,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +算子扩展能力注册构造类。 + +KernelInterfaceReg +KernelInterfaceReg(const std::string &provider, int op_type, const KernelInterfaceCreator creator) + + +构造函数，构造注册算子的扩展能力。 + +参数 + +provider: 生产商，由用户自定义。 +op_type: 算子类型，定义在ops.fbs中，编绎时会生成到ops_generated.h，该文件可以在发布件中获取。 +creator: KernelInterface的创建函数，详细见KernelInterfaceCreator的说明。 + + + +KernelInterfaceReg(const std::string &provider, const std::string &op_type, const KernelInterfaceCreator creator) + + +构造函数，构造注册custom算子的扩展能力。 + +参数 + +provider: 生产商，由用户自定义。 +op_type: 算子类型，由用户自定义。 +creator: KernelInterface的创建函数，详细见KernelInterfaceCreator的说明。 + + + + +",mindspore::registry,mindspore、mindspore、算子 +mindspore-registry§REGISTER_KERNEL_INTERFACE,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +注册KernelInterface的实现。 +#define REGISTER_KERNEL_INTERFACE(provider, op_type, creator) + + + +参数 + +provider: 生产商，由用户自定义。 +op_type: 算子类型，定义在ops.fbs中，编绎时会生成到ops_generated.h，该文件可以在发布件中获取。 +creator: 创建KernelInterface的函数指针，具体见KernelInterfaceCreator的说明。 + + + +",mindspore::registry,mindspore、mindspore、算子 +mindspore-registry§REGISTER_CUSTOM_KERNEL_INTERFACE,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html," +#include +注册Custom算子对应的KernelInterface实现。 +#define REGISTER_CUSTOM_KERNEL_INTERFACE(provider, op_type, creator) + + + +参数 + +provider: 生产商名，由用户自定义。 +op_type: 算子类型，由用户自定义，确保唯一同时要与REGISTER_CUSTOM_KERNEL时注册的op_type保持一致。 +creator: 创建算子的函数指针，具体见KernelInterfaceCreator的说明。 + + + +",mindspore::registry,mindspore、mindspore、算子 +mindspore-registry-opencl§接口汇总,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry_opencl.html," + + + +类名 +描述 + + + + +OpenCLRuntimeWrapper +端侧GPU操作的接口类 + + + +",mindspore::registry::opencl,mindspore、mindspore、接口、Runtime、GPU、LR +mindspore-registry-opencl§OpenCLRuntimeWrapper,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry_opencl.html," +#include +OpenCLRuntimeWrapper类包装了内部OpenCL的相关接口，用于支持南向GPU算子的开发。 + +OpenCLRuntimeWrapper +OpenCLRuntimeWrapper() = default; + + +构造函数。 + + +~OpenCLRuntimeWrapper +~OpenCLRuntimeWrapper = default; + + +析构函数。 + +",mindspore::registry::opencl,mindspore、mindspore、算子、接口、Runtime、GPU、LR +mindspore-registry-opencl§公有成员函数,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry_opencl.html," + +LoadSource +Status LoadSource(const std::string &program_name, const std::string &source); + + +加载OpenCL源代码并指定程序名。 + +参数 + +program_name: OpenCL源程序名称。 +source: OpenCL源程序。 + + + + + +BuildKernel +Status BuildKernel(cl::Kernel *kernel, const std::string &program_name, const std::string &kernel_name, + const std::vector &build_options_ext = {}); + + +构建OpenCL代码。 + +参数 + +kernel: 用于返回已编译的内核。 +program_name: OpenCL源程序名称。 +kernel_name: OpenCL内核名称。 +build_options_ext: OpenCL内核构建选项。 + + + + + +SetKernelArg +Status SetKernelArg(const cl::Kernel &kernel, uint32_t index, void *const value); + + +设置OpenCL内核运行时指针类参数的值。 + +参数 + +kernel: OpenCL内核。 +index: OpenCL内核参数索引。 +value: OpenCL内核参数值指针。 + + + +template + typename std::enable_if::value, Status>::type SetKernelArg(const cl::Kernel &kernel, + uint32_t index, const T value); + + +设置OpenCL内核运行时非指针类参数的值。 + +参数 + +kernel: OpenCL内核。 +index: OpenCL内核参数索引。 +value: OpenCL内核参数值。 + + + + + +RunKernel +Status RunKernel(const cl::Kernel &kernbel, const cl::NDRange &global, const cl::NDRange &local); + + +运行OpenCL内核。 + +参数 + +kernel: OpenCL内核。 +global: 定义工作项的总数量。 +local: 定义每个工作组中工作项的数量。 + + + + + +SyncCommandQueue +Status SyncCommandQueue(); + + +同步指令队列。 + + +GetAllocator +std::shared_ptr GetAllocator(); + + +获取GPU内存分配器的智能指针。通过Allocator接口，可申请GPU内存，用于OpenCL内核的运算。 + + +MapBuffer +void *MapBuffer(void *host_ptr, int flags, bool sync = true); + + +重新将GPU内存映射到主机内存地址，以便读写。 + +参数 + +host_ptr: 主机内存地址（为GPU内存所映射的CPU地址）。 +flags: 内存映射的OpenCL功能符号，如CL_MAP_READ，CL_MAP_WRITE。 +sync: 是否同步标志。 + + + + + +UnmapBuffer +Status UnmapBuffer(void *host_ptr); + + +将改变后的内存数据，写入GPU。 + +参数 + +host_ptr: 主机内存地址（为GPU内存所映射的CPU地址）。 + + + + + +ReadImage +Status ReadImage(void *buffer, void *dst_data); + + +读取解析Image形式的GPU内存到目标地址，写入的数据格式为NHWC4（C轴4数据对齐的NHWC格式数据）。 + +参数 + +buffer: Image格式的GPU内存所映射的主机内存地址。 +dst_data: 目标地址。 + + + + + +WriteImage +Status WriteImage(void *buffer, void *src_data); + + +从源地址src_data读取数据，写入到Image形式的GPU内存buffer。 + +参数 + +buffer: Image格式的GPU内存所映射的主机内存地址。 +src_data: 源地址。 + + + + + +DeviceMaxWorkGroupSize +uint64_t DeviceMaxWorkGroupSize(); + + +获取支持的最大工作组数量。 + + +GetMaxImage2DWidth +uint64_t GetMaxImage2DWidth(); + + +获取Image内存数据支持的最大宽度。 + + +GetMaxImage2DHeight +uint64_t GetMaxImage2DHeight(); + + +获取Image内存数据支持的最大高度。 + + +GetMaxImage2DWidth +uint64_t GetImagePitchAlignment(); + + +获取Image内存数据的宽度对齐值。 + +",mindspore::registry::opencl,mindspore、mindspore、接口、GPU、CPU、pB、数据 +mindspore-tensor§Classes,https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_tensor.html," + +Class COOTensor +Class CSRTensor +Class MetaSparseTensor +Class MetaTensor +Class RowTensor +Class Tensor +Class TensorData +Class WaitEvent + +",mindspore::tensor,mindspore、mindspore、aTen diff --git a/Design_Migration_Grammar_API_dataset/API_dataset/html_api_data_generate.py b/Design_Migration_Grammar_API_dataset/API_dataset/html_api_data_generate.py new file mode 100644 index 0000000..0c4dbdf --- /dev/null +++ b/Design_Migration_Grammar_API_dataset/API_dataset/html_api_data_generate.py @@ -0,0 +1,205 @@ +import requests +import csv +from bs4 import BeautifulSoup +import re + +#定义寻找特征字符位置的函数 +def find_en(st, text): + position = [] + n = 0 + for m in range(0, 1000): + pos = body.find(st, n, len(text)) + n = pos + 1 + position.append(pos) + if position[m] == -1: + break + return position + +#定义修正中英文冒号的函数，将中文冒号的QA插入 +def correct(datalist1, datalist2): + if len(datalist1) != 1: + for m in range(0, len(datalist1)-1): + for n in range(0, len(datalist2)-1): + if datalist2[n] > datalist1[m]: + datalist2.insert(n, datalist1[m]) + break + +#去除可能出现在A中的小标题 +def delete(list1): + for m in range(0, len(list1)): + l = list1[m].find('\n\n\n\n') + if l != -1: + list1[m] = list1[m][0:l + 1] + +if __name__ == "__main__": + #定义列表和特征字符 + #url_ipynb = ['https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/training_visual_design.html'] + url_html = ['https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.html', 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.common.initializer.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.communication.html', 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.audio.html', 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.config.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.text.html', 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.transforms.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.dataset.vision.html', 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.mindrecord.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.html', 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.probability.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.nn.transformer.html', 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.numpy.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.html', 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.ops.functional.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.parallel.nn.html', 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.scipy.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.8/api_python/mindspore.boost.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore.html', \ + 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_NN.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_abstract.html', \ + 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_api.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_api_utils.html', \ + 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_common.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_converter.html', \ + 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset_config.html', \ + 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset_text.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset_transforms.html', \ + 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_dataset_vision.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_datatype.html', \ + 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_format.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_id_generator.html', \ + 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_kernel.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_label_manage.html', \ + 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_ops.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry.html', \ + 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_registry_opencl.html', 'https://www.mindspore.cn/lite/api/zh-CN/r1.8/api_cpp/mindspore_tensor.html'] + + process = ['mindspore', 'mindspore.common.initializer', 'mindspore.communication', 'mindspore.dataset', 'mindspore.dataset.audio', 'mindspore.dataset.config', 'mindspore.dataset.text', \ + 'mindspore.dataset.transforms', 'mindspore.dataset.vision', 'mindspore.mindrecord', 'mindspore.nn', 'mindspore.nn.probability', 'mindspore.nn.transformer', \ + 'mindspore.numpy', 'mindspore.ops', 'mindspore.ops.functional', 'mindspore.parallel.nn', 'mindspore.scipy', 'mindspore.boost', 'mindspore', \ + 'mindspore::NN', 'mindspore::abstract', 'mindspore::api', 'mindspore::api::utils', 'mindspore::common', 'mindspore::converter', \ + 'mindspore::dataset', 'mindspore::dataset::config', 'mindspore::dataset::text', 'mindspore::dataset::transforms', 'mindspore::dataset::vision', \ + 'mindspore::DataType', 'mindspore::Format', 'mindspore::id_generator', 'mindspore::kernel', 'mindspore::label_manage', 'mindspore::ops', \ + 'mindspore::registry', 'mindspore::registry::opencl', 'mindspore::tensor'] + + tag = ['白皮书', 'MindSpore', '全场景', '自动微分', 'GradOperation', 'MindSpore', 'Parameter Server', \ + '并行', '优化器', 'Host&Device', '分布式', '算子', '接口', '数据集', '集合通信', '同步模式', '损失函数', '控制流', \ + '自由变量', '闭包', 'MindRecord', 'Pipeline', 'Adaptor', 'Optimizer', 'Runtime', 'Operators', 'Callback', \ + 'MindSpore AKG', 'Auto-Tiling', 'Auto-Mapping', 'Davinci', '样例脚本', 'GPU', 'CPU', 'CuBLAS库', 'Linux', 'Ascend', \ + '模型推理', 'MindInsight', 'plugin_name', 'MindArmour', 'AI Fuzzer', 'MINDIR', '缩略语', \ + '数据类型', '原型', '运算符', '语句', '内置函数', '网络', \ + 'PyNative', 'MindConverter', '评估', 'TensorFlow', 'Pytorch', 'ONNX', 'PB', 'API', 'Model', 'SGD', 'loss', 'metric', 'ARM', 'AST', \ + 'TensorBoard', 'Dataloader', 'GeneratorDataset', ' GradOperation', 'TrainOneStepCell', '反向传播', '求导', 'weight decay', 'LR', '学习率', \ + 'Aten', '调试', 'MindOptimizer', '精度', 'checklist', '数据', 'loss scale', '超参', '计算图', '精度', '可视化', '模型结构', \ + '优化', '迭代', 'ModelZoo', 'MindSpore Serving', '脚本', '单机', 'profiling', 'MindData', '框架', '性能', 'Dataset', 'macOS', 'SDK版本', 'SciPy',\ + 'whl包', 'protobuf', 'Ubuntu', 'Windows', 'WSL', 'Conda', 'Serving', 'gmp', 'cuda', 'JupyterLab', 'eval', 'NLP', 'HCLL', 'ModelArts', 'Graph', \ + 'C++', 'AIPP', 'OpenMPI', 'NCLL', 'RDMA', 'IB', 'RoCE', 'taichi', 'Caffe', 'NPU', 'Embedding', 'Parameter Server', 'JIT Fallback'] + tag_change = [] + Dataset = [] + #转义tag中的特殊符号 + for i in tag: + tag_change.append(re.escape(i)) + #十一个语料库大循环 + for numbers in range(0, len(process)): + #获取网页文本 + req = requests.get(url=url_html[numbers]) + req.encoding = 'utf-8' + html = req.text + bs = BeautifulSoup(html, "html.parser")#html.parser是解析器 + All_title = bs.find_all("div", attrs={"class": "section"})#所有标题 + + #定义二级标题及其内容 + pre_title_2 = []#二级标题 + pre_title_1 = []#一级标题 + title = [] + content = [] + + #获取所有二级标题 + for one_title in All_title: + h_1 = one_title.find('h1') + h_2 = one_title.find('h2') + if h_1 != None: + #标题有特殊符号需要替换 + flag_a = "::" in process[numbers] + flag_b = "_" in process[numbers] + mis_process = process[numbers] + if flag_a == True: + mis_process = mis_process.replace('::', '-') + if flag_b == True: + mis_process = mis_process.replace('_', '-') + pre_title_1.append(mis_process.lower())# 一级标题名字，大写字母需要转换成小写字母 + + if h_1 == None and h_2 != None: + title_2 = h_2.get_text()#二级标题名字 + pre_title_2.append(title_2) + + #提取一级标题和二级标题之间的内容 + # 针对API模块的一级标题中"." + flag_0 = "." in pre_title_1[0] + if flag_0 == True: + mis_title_1 = pre_title_1[0].replace(".", "-") + else: + mis_title_1 = pre_title_1[0] + result = bs.select("#" + mis_title_1) + body = result[0].get_text() + title_1_location = find_en("¶", body) + # 有二级标题 如："二阶优化器THOR介绍" or "训练可视总体设计" + if len(pre_title_2) > 0: + title_2_location = find_en(pre_title_2[0], body) + body_1 = body[title_1_location[0] + 1: title_2_location[0]] + # 判断一级标题到二级标题间有无内容 + if len(body_1) > 20: + title.append(pre_title_1[0] + "§" + pre_title_1[0]) + content.append(body_1) + # 没有二级标题 如："全场景统一" or "术语" + else: + body_1 = body[title_1_location[0] + 1: ] + title.append(pre_title_1[0] + "§" + pre_title_1[0]) + content.append(body_1) + + #提取二级标题及其内容 + if len(pre_title_2) > 0: + for title_2 in pre_title_2: + title_mis = title_2.rstrip('¶') + # 标题有特殊符号需要替换 + flag_1 = "&" in title_mis + flag_2 = " " in title_mis + flag_3 = "（" in title_mis + flag_4 = "." in title_mis + flag_5 = "_" in title_mis + if flag_1 == True: + title_mis = title_mis.replace("&", "") + if flag_2 == True: + title_mis = title_mis.replace(" ", "-") + if flag_3 == True: + title_mis = title_mis.replace("（", "") + title_mis = title_mis.replace("）", "") + if flag_4 == True: + title_mis = title_mis.replace(".", "-") + if flag_5 == True: + title_mis = title_mis.replace("_", "-") + title_mis = title_mis.lower() + result = bs.select("#" + title_mis) + # if result == []: + # print(process[numbers]) + # print(title_mis) + body = result[0].get_text() + # if pre_title_1[0] == "mindspore.numpy": + # print(pre_title_2) + # print(body) + title_2_location = find_en(title_2, body) + body_1 = body[title_2_location[0] + len(title_2):] + body_1 = body_1.replace('¶', '') + title_2 = title_2.rstrip('¶') + title.append(pre_title_1[0] + "§" + title_2) + content.append(body_1) + + # 匹配tag + tag1 = [] + tag2 = [] + for m in range(0, len(title)): + str8 = title[m] + content[m] + for i in tag_change: + t = re.search(i, str8, flags=re.IGNORECASE) + if t != None: + tag2.append(t.group(0)) + tag1.append(tag2) + tag2 = [] + # 将tag列表合并为字符串 + FinalTag = [] + for m in range(0, len(title)): + ft_str = '、'.join(tag1[m]) + FinalTag.append(ft_str) + + # 将各个二级标题元素合并，用于写入csv文件 + for n in range(0, len(title)): + Dataset.append([title[n], url_html[numbers], content[n], process[numbers], FinalTag[n]]) + + # 插入csv + headers = ('title', 'link', 'content', 'process', 'tag') + with open('html_api_data_dataset.csv', 'w', encoding='utf-8', newline='') as f: + write = csv.writer(f) # 创建writer对象 + write.writerow(headers) + for n in range(len(Dataset)): + write.writerow(Dataset[n]) diff --git a/Design_Migration_Grammar_API_dataset/Design_dataset/html_design_data_generate.py b/Design_Migration_Grammar_API_dataset/Design_dataset/html_design_data_generate.py new file mode 100644 index 0000000..2b5e845 --- /dev/null +++ b/Design_Migration_Grammar_API_dataset/Design_dataset/html_design_data_generate.py @@ -0,0 +1,166 @@ +import requests +import csv +from bs4 import BeautifulSoup +import re + +#定义寻找特征字符位置的函数 +def find_en(st, text): + position = [] + n = 0 + for m in range(0, 1000): + pos = body.find(st, n, len(text)) + n = pos + 1 + position.append(pos) + if position[m] == -1: + break + return position + +#定义修正中英文冒号的函数，将中文冒号的QA插入 +def correct(datalist1, datalist2): + if len(datalist1) != 1: + for m in range(0, len(datalist1)-1): + for n in range(0, len(datalist2)-1): + if datalist2[n] > datalist1[m]: + datalist2.insert(n, datalist1[m]) + break + +#去除可能出现在A中的小标题 +def delete(list1): + for m in range(0, len(list1)): + l = list1[m].find('\n\n\n\n') + if l != -1: + list1[m] = list1[m][0:l + 1] + +if __name__ == "__main__": + #定义列表和特征字符 + #url_ipynb = ['https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/training_visual_design.html'] + url_html = ['https://www.mindspore.cn/docs/zh-CN/r1.7/design/technical_white_paper.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/all_scenarios_architecture.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/gradient.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/dynamic_graph_and_static_graph.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/heterogeneous_training.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/distributed_training_design.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/mindir.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/data_engine.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/graph_kernel_fusion_engine.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/enable_graph_kernel_fusion.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/thor.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/cv_resnet50_second_order_optimizer.html', \ + 'https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/training_visual_design.html', 'https://www.mindspore.cn/mindarmour/docs/zh-CN/r1.7/design.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.7/design/glossary.html'] + + process = ['技术白皮书', '全场景统一', '函数式微分编程', '动静态图结合', '异构并行训练', '分布式并行', '中间表达MindIR', '高性能数据处理引擎', \ + '图算融合加速引擎介绍', '使能图算融合', '二阶优化器THOR介绍', '在ResNet-50网络上应用二阶优化实践', '训练可视总体设计', \ + '安全可信总体设计', '术语'] + + tag = ['白皮书', 'MindSpore', '全场景', '自动微分', 'GradOperation', 'MindSpore', 'Parameter Server', \ + '并行', '优化器', 'Host&Device', '分布式', '算子', '接口', '数据集', '集合通信', '同步模式', '损失函数', '控制流', \ + '自由变量', '闭包', 'MindRecord', 'Pipeline', 'Adaptor', 'Optimizer', 'Runtime', 'Operators', 'Callback', \ + 'MindSpore AKG', 'Auto-Tiling', 'Auto-Mapping', 'Davinci', '样例脚本', 'GPU', 'CPU', 'CuBLAS库', 'Linux', 'Ascend', \ + '模型推理', 'MindInsight', 'plugin_name', 'MindArmour', 'AI Fuzzer', 'MINDIR', '缩略语', \ + '数据类型', '原型', '运算符', '语句', '内置函数', '网络', \ + 'PyNative', 'MindConverter', '评估', 'TensorFlow', 'Pytorch', 'ONNX', 'PB', 'API', 'Model', 'SGD', 'loss', 'metric', 'ARM', 'AST', \ + 'TensorBoard', 'Dataloader', 'GeneratorDataset', ' GradOperation', 'TrainOneStepCell', '反向传播', '求导', 'weight decay', 'LR', '学习率', \ + 'Aten', '调试', 'MindOptimizer', '精度', 'checklist', '数据', 'loss scale', '超参', '计算图', '精度', '可视化', '模型结构', \ + '优化', '迭代', 'ModelZoo', 'MindSpore Serving', '脚本', '单机', 'profiling', 'MindData', '框架', '性能', 'Dataset', 'macOS', 'SDK版本', 'SciPy',\ + 'whl包', 'protobuf', 'Ubuntu', 'Windows', 'WSL', 'Conda', 'Serving', 'gmp', 'cuda', 'JupyterLab', 'eval', 'NLP', 'HCLL', 'ModelArts', 'Graph', \ + 'C++', 'AIPP', 'OpenMPI', 'NCLL', 'RDMA', 'IB', 'RoCE', 'taichi', 'Caffe', 'NPU', 'Embedding', 'Parameter Server', 'JIT Fallback'] + tag_change = [] + Dataset = [] + #转义tag中的特殊符号 + for i in tag: + tag_change.append(re.escape(i)) + #十一个语料库大循环 + for numbers in range(0, len(process)): + #获取网页文本 + req = requests.get(url=url_html[numbers]) + req.encoding = 'utf-8' + html = req.text + bs = BeautifulSoup(html, "html.parser")#html.parser是解析器 + #print(bs) + All_title = bs.find_all("div", attrs={"class": "section"})#所有标题 + + #定义二级标题及其内容 + pre_title_2 = []#二级标题 + pre_title_1 = []#一级标题 + title = [] + content = [] + #获取所有二级标题 + for one_title in All_title: + h_1 = one_title.find('h1') + h_2 = one_title.find('h2') + + if h_1 != None: + pre_title_1.append(process[numbers].lower())# 一级标题名字 + if h_1 == None and h_2 != None: + title_2 = h_2.get_text()#二级标题名字 + + pre_title_2.append(title_2) + + #提取一级标题和二级标题之间的内容 + result = bs.select("#" + pre_title_1[0]) + + body = result[0].get_text() + title_1_location = find_en("¶", body) + # 有二级标题 如："二阶优化器THOR介绍" or "训练可视总体设计" + if len(pre_title_2) > 0: + title_2_location = find_en(pre_title_2[0], body) + body_1 = body[title_1_location[0] + 1 : title_2_location[0]] + # 判断一级标题到二级标题间有无内容 + if len(body_1) > 20: + title.append(pre_title_1[0] + "§" + pre_title_1[0]) + content.append(body_1) + # 没有二级标题 如："全场景统一" or "术语" + else: + body_1 = body[title_1_location[0] + 1: ] + title.append(pre_title_1[0] + "§" + pre_title_1[0]) + content.append(body_1) + + #提取二级标题及其内容 + for title_2 in pre_title_2: + title_mis = title_2.rstrip('¶') + # 标题有特殊符号需要替换 + flag_1 = "&" in title_mis + flag_2 = " " in title_mis + flag_3 = "（" in title_mis + if flag_1 == True: + title_mis = title_mis.replace("&", "") + if flag_2 == True: + title_mis = title_mis.replace(" ", "-") + if flag_3 == True: + title_mis = title_mis.replace("（", "") + title_mis = title_mis.replace("）", "") + title_mis = title_mis.lower() + result = bs.select("#" + title_mis) + if result == []: + print(bs) + print("#" + title_mis) + print(process[numbers]) + body = result[0].get_text() + title_2_location = find_en(title_2, body) + body_1 = body[title_2_location[0] + len(title_2):] + body_1 = body_1.replace('¶', '') + title_2 = title_2.rstrip('¶') + title.append(pre_title_1[0] + "§" + title_2) + content.append(body_1) + + # 匹配tag + tag1 = [] + tag2 = [] + for m in range(0, len(title)): + str8 = title[m] + content[m] + for i in tag_change: + t = re.search(i, str8, flags=re.IGNORECASE) + if t != None: + tag2.append(t.group(0)) + tag1.append(tag2) + tag2 = [] + # 将tag列表合并为字符串 + FinalTag = [] + for m in range(0, len(title)): + ft_str = '、'.join(tag1[m]) + FinalTag.append(ft_str) + + # 将各个二级标题元素合并，用于写入csv文件 + for n in range(0, len(title)): + Dataset.append([title[n], url_html[numbers], content[n], process[numbers], FinalTag[n]]) + # 插入csv + headers = ('title', 'link', 'content', 'process', 'tag') # + with open('html_design_dataset.csv', 'w', encoding='utf-8', newline='') as f: + write = csv.writer(f) # 创建writer对象 + write.writerow(headers) + for n in range(len(Dataset)): + write.writerow(Dataset[n]) diff --git a/Design_Migration_Grammar_API_dataset/Design_dataset/html_design_dataset.csv b/Design_Migration_Grammar_API_dataset/Design_dataset/html_design_dataset.csv new file mode 100644 index 0000000..33ba4af --- /dev/null +++ b/Design_Migration_Grammar_API_dataset/Design_dataset/html_design_dataset.csv @@ -0,0 +1,2850 @@ +title,link,content,process,tag +技术白皮书§引言,https://www.mindspore.cn/docs/zh-CN/r1.7/design/technical_white_paper.html," +深度学习研究和应用在近几十年得到了爆炸式的发展，掀起了人工智能的第三次浪潮，并且在图像识别、语音识别与合成、无人驾驶、机器视觉等方面取得了巨大的成功。这也对算法的应用以及依赖的框架有了更高级的要求。深度学习框架的不断发展使得在大型数据集上训练神经网络模型时，可以方便地使用大量的计算资源。 +深度学习是使用多层结构从原始数据中自动学习并提取高层次特征的一类机器学习算法。通常，从原始数据中提取高层次、抽象的特征是非常困难的。目前有两种主流的深度学习框架：一种是在执行之前构造一个静态图，定义所有操作和网络结构，典型代表是TensorFlow，这种方法以牺牲易用性为代价，来提高训练期间的性能；另一种是立即执行的动态图计算，典型代表是PyTorch。通过比较可以发现，动态图更灵活、更易调试，但会牺牲性能。因此，现有深度学习框架难以同时满足易开发、高效执行的要求。 +",技术白皮书,白皮书、数据集、网络、TensorFlow、PyTorch、调试、数据、框架、性能 +技术白皮书§简介,https://www.mindspore.cn/docs/zh-CN/r1.7/design/technical_white_paper.html," +MindSpore作为新一代深度学习框架，是源于全产业的最佳实践，最佳匹配昇腾处理器算力，支持终端、边缘、云全场景灵活部署，开创全新的AI编程范式，降低AI开发门槛。MindSpore是一种全新的深度学习计算框架，旨在实现易开发、高效执行、全场景覆盖三大目标。为了实现易开发的目标，MindSpore采用基于源码转换（Source Code Transformation，SCT）的自动微分（Automatic Differentiation，AD）机制，该机制可以用控制流表示复杂的组合。函数被转换成函数中间表达（Intermediate Representation，IR），中间表达构造出一个能够在不同设备上解析和执行的计算图。在执行前，计算图上应用了多种软硬件协同优化技术，以提升端、边、云等不同场景下的性能和效率。MindSpore支持动态图，更易于检查运行模式。由于采用了基于源码转换的自动微分机制，所以动态图和静态图之间的模式切换非常简单。为了在大型数据集上有效训练大模型，通过高级手动配置策略，MindSpore可以支持数据并行、模型并行和混合并行训练，具有很强的灵活性。此外，MindSpore还有“自动并行”能力，它通过在庞大的策略空间中进行高效搜索来找到一种快速的并行策略。MindSpore框架的具体优势，请查看详细介绍。 +查看技术白皮书 +",技术白皮书,白皮书、MindSpore、全场景、自动微分、MindSpore、并行、数据集、控制流、数据、计算图、优化、框架、性能 +全场景统一§全场景统一,https://www.mindspore.cn/docs/zh-CN/r1.7/design/all_scenarios_architecture.html," + +MindSpore旨在提供端边云全场景的AI框架。MindSpore可部署于端、边、云不同的硬件环境，满足不同环境的差异化需求，如支持端侧的轻量化部署，支持云侧丰富的训练功能如自动微分、混合精度、模型易用编程等。 + +MindSpore全场景的几个重要特性： + +端边云统一的C++ 推理接口，支持算法代码可快速迁移到不同硬件环境执行。 +模型统一，端云使用相同的模型格式和定义，软件架构一致。MindSpore支持Ascend、GPU、CPU（x86、arm、…）等多种硬件的执行，一次训练多处部署使用。 +多样化算力支持。提供统一的南向接口，支持新硬件的快捷添加使用。 +模型小型化技术，适配不同硬件环境和业务场景的要求，如量化等。以及端边云协同技术的快速应用，如联邦学习等技术。 + + +如上图所示，在MindSpore上训练出来的模型文件，可通过Serving部署在云服务中执行，也可用过Lite执行在服务器、端侧等设备上。同时Lite支持通过独立工具convert进行模型的离线优化，实现推理时框架的轻量化以及模型执行高性能的目标。 +MindSpore抽象各个硬件下的统一算子接口，因此，在不同硬件环境下，网络模型的编程代码可以保持一致。同时加载相同的模型文件，在MindSpore支持的各个不同硬件上均能有效执行推理。 +推理考虑到大量用户使用C++/C编程方式，因此提供了C++的推理编程接口，相关编程接口在形态上与Python接口的风格较接近。 +同时，通过提供第三方硬件的自定义离线优化注册，第三方硬件的自定义算子注册机制，实现快速对接新的硬件，同时对外的模型编程接口以及模型文件保持不变。 +",全场景统一,白皮书、数据集、网络、TensorFlow、PyTorch、调试、数据、框架、性能 +函数式微分编程§自动微分简介,https://www.mindspore.cn/docs/zh-CN/r1.7/design/gradient.html," +深度学习等现代AI算法通过使用大量的数据来学习拟合出一个优化后带参模型，其中使用的学习算法多是基于现实数据自模型中的经验误差来反向传播以更新模型的参数，自动微分技术（Automatic Differentiation， AD）正是其中的关键技术。 +自动微分是一种介于数值微分与符号微分之间的一种求导方法。自动微分的核心思想是将计算机程序中的运算操作分解为一个有限的基本操作合集，且合集中基本操作的求导规则均为已知的。 在完成每一个基本操作的求导后，使用链式求导法则将结果组合得到整体程序的求导结果。 +链式求导法则： \((f\circ g)^{'}(x)=f^{'}(g(x))g^{'}(x)\) +根据对分解后的基本操作求导和链式规则的组合不同，自动微分可以分为前向模式和反向模式。 +我们以下方函数为例介绍前向微分与反向微分的具体计算方式： + +\[y=f(x_{1},x_{2})=ln(x_{1})+x_{1}x_{2}-sin(x_{2})\] +当我们使用前向自动微分求取函数在\(x_{1}=2,x_{2}=5\)处的导数\(\frac{\partial y}{\partial x_{1}}\)时，前向自动微分的求导方向与原函数的求值方向一致，原函数结果与微分结果可以被同时获得。 + +当使用反向自动微分时，反向自动微分的求导方向与原函数的求值方向相反，微分结果需要依赖原函数的运行结果。 + +MindSpore先构建的是基于反向自动微分的GradOperation方法，并在该方法的基础上实现了正向微分。 +为了进一步说明前向微分与反向微分的区别， 我们将被求导的原函数泛化为具有N输入与M输出的函数F： + +\[ (Y_{1},Y_{2},...,Y_{M})=F(X_{1},X_{2},...,X_{N})\] +F函数的导数本身为一个雅可比矩阵(Jacobian matrix)。 + +\[\begin{split} + \left[ + \begin{matrix} + \frac{\partial Y_{1}}{\partial X_{1}}& ... & \frac{\partial Y_{1}}{\partial X_{N}} \\ + ... & ... & ... \\ + \frac{\partial Y_{M}}{\partial X_{1}} & ... & \frac{\partial Y_{M}}{\partial X_{N}} + \end{matrix} + \right] +\end{split}\] + +前向自动微分 +在前向自动微分当中，我们是从输入开始向输出的方向计算的，因此每一次计算我们可以求得输出对某一输入的导数，即雅可比矩阵中的一列。 + +\[\begin{split} + \left[ + \begin{matrix} + \frac{\partial Y_{1}}{\partial X_{1}}\\ + ... \\ + \frac{\partial Y_{M}}{\partial X_{1}} + \end{matrix} + \right] +\end{split}\] +为了求取该列的值， 自动微分将程序分解为一系列求导规则已知的基本操作，这些基本操作也可以被泛化表达为具有\(n\)输入和\(m\)输出的函数\(f\)： + +\[ (y_{1},y_{2},...,y_{m})=f(x_{1},x_{2},...,x_{n})\] +由于我们的已知基础函数\(f\)的求导规则，即\(f\)的雅可比矩阵是已知的。 于是我们可以对\(f\)计算雅可比向量积（Jvp, Jacobian-vector-product），并应用链式求导法则获得导数结果。 + +\[\begin{split} + \left[ + \begin{matrix} + \frac{\partial y_{1}}{\partial X_{i}}\\ + ... \\ + \frac{\partial y_{m}}{\partial X_{i}} + \end{matrix} + \right]=\left[ + \begin{matrix} + \frac{\partial y_{1}}{\partial x_{1}}& ... & \frac{\partial y_{1}}{\partial x_{n}} \\ + ... & ... & ... \\ + \frac{\partial y_{m}}{\partial x_{1}} & ... & \frac{\partial y_{M}}{\partial x_{n}} + \end{matrix} + \right]\left[ + \begin{matrix} + \frac{\partial x_{1}}{\partial X_{i}}\\ + ... \\ + \frac{\partial x_{n}}{\partial X_{i}} + \end{matrix} + \right] +\end{split}\] + + +反向自动微分 +在反向自动微分当中，我们是从输出开始向输入的方向计算的，因此每一次计算我们可以求得某一输出对输入的导数，即雅可比矩阵中的一行。 + +\[\begin{split} + \left[ + \begin{matrix} + \frac{\partial Y_{1}}{\partial X_{1}}& ... & \frac{\partial Y_{1}}{\partial X_{N}} \\ + \end{matrix} + \right] +\end{split}\] +为了求取该列的值， 自动微分将程序分解为一系列求导规则已知的基本操作，这些基本操作也可以被泛化表达为具有n输入和m输出的函数\(f\)： + +\[ (y_{1},y_{2},...,y_{m})=f(x_{1},x_{2},...,x_{n})\] +由于我们的已知基础函数\(f\)的求导规则，即f的雅可比矩阵是已知的。 于是我们可以对\(f\)计算向量雅可比积(Vjp, Vector-jacobian-product)，并应用链式求导法则获得导数结果。 + +\[\begin{split} + \left[ + \begin{matrix} + \frac{\partial Y_{j}}{\partial x_{1}}& ... & \frac{\partial Y_{j}}{\partial x_{N}} \\ + \end{matrix} + \right]=\left[ + \begin{matrix} + \frac{\partial Y_{j}}{\partial y_{1}}& ... & \frac{\partial Y_{j}}{\partial y_{m}} \\ + \end{matrix} + \right]\left[ + \begin{matrix} + \frac{\partial y_{1}}{\partial x_{1}}& ... & \frac{\partial y_{1}}{\partial x_{n}} \\ + ... & ... & ... \\ + \frac{\partial y_{m}}{\partial x_{1}} & ... & \frac{\partial y_{m}}{\partial x_{n}} + \end{matrix} + \right] +\end{split}\] + +",函数式微分编程,MindSpore、自动微分、GradOperation、MindSpore、反向传播、求导、数据、优化 +函数式微分编程§GradOperation实现,https://www.mindspore.cn/docs/zh-CN/r1.7/design/gradient.html," +GradOperation使用的是反向自动微分模式，即从正向网络的输出开始计算梯度。 + +GradOperation算法设计 +设模型定义的原函数为：\(f(g(x, y, z))\) ， +则\(f\)对\(x\)的梯度为：\(\frac{df}{dx}=\frac{df}{dg}\frac{dg}{dx}\frac{dx}{dx}+\frac{df}{dg}\frac{dg}{dy}\frac{dy}{dx}+\frac{df}{dg}\frac{dg}{dz}\frac{dz}{dx}\), \(\frac{df}{dy}\)和\(\frac{df}{dz}\)与\(\frac{df}{dx}\)类似。 +应用链式求导法则，对每个函数(包括算子和图)定义梯度函数bprop: dout->(df, dinputs)，这里df表示函数对自由变量（函数外定义的变量）的梯度，dinputs是对函数输入的梯度。在此基础上，应用全微分法则，将(df, dinputs)累加到对应的变量。 +MindSporeIR实现了分支，循环，闭包的函数表达式，所以对相应的算子实现正确的反向规则即可求得输入函数的梯度函数。 +定义运算符K，反向自动微分算法可以简单表示如下： +v = (func, inputs) +F(v): { + (result, bprop) = K(func)(K(inputs)) + df, dinputs = bprop(dout) + v.df += df + v.dinputs += dinputs +} + + + + +GradOperation算法实现 +在自动微分流程中，需要进行自动微分的函数会被取出。并作为自动微分模块的输入, 并输出对应的梯度图。 自动微分模块实现了从原函数对象到梯度函数对象的转换。转换后的对象为fprop形式的梯度函数对象。fprop = (forward_result, bprop), forward_result是前向计算图的输出节点， bprop是以fprop的闭包对象形式生成的梯度函数，它只有dout一个入参， inputs和outputs是引用的fprop的输入和输出。 + MapObject(); // 实现ValueNode/Parameter/FuncGraph/Primitive对象的映射 + MapMorphism(); // 实现CNode的态射 + res = k_graph(); // res就是梯度函数的fprop对象 + + +在生成梯度函数对象的过程中，需要完成从原函数到梯度函数的一系列的映射， 即为每个原函数中的节点生成其所对应的梯度函数的节点，再按照反向自动微分的规则将这些节点连接在一起，生成梯度函数图。 每张原函数对象的子图都会都会生成一个Dfunctor对象，负责将该原函数对象映射为梯度函数对象。DFunctor主要需要经过 MapObject, MapMorphism两步来实现这种映射关系。 +MapObject实现了原函数节点到梯度函数节点的映射，具体包括对自由变量，参数节点以及ValueNode的映射。 +MapFvObject(); // 自由变量的映射 +MapParamObject(); // 参数节点的映射 +MapValueObject(); // ValueNode的映射 + + +MapFvObject是对自由变量的映射， MapParamObject是对参数节点的映射。 MapValueObject中主要对Primitive以及FuncGraph对象进行映射。其中，对FuncGraph进行的映射同样需要为该子图创造相应的DFunctor，是一个递归的过程。 Primitive表明了算子的种类，为了支持自动微分，需要为每一种Primitive定义其对应的反向微分函数。 MindSpore将这些定义放在了Python侧，以sin算子为例： +@bprop_getters.register(P.Sin) +def get_bprop_sin(self): + """"""Grad definition for `Sin` operation."""""" + cos = P.Cos() + + def bprop(x, out, dout): + dx = dout * cos(x) + return (dx,) + + return bprop + + +x为原函数对象sin的输入，out为原函数对象sin的输出，dout为当前累加的梯度输入。 +当MapObject完成对以上节点的映射后，MapMorphism从原函数的输出节点开始以递归的方式实现对CNode的态射，建立起节点间的反向传播链接，实现梯度累加。 + + +GradOperation示例 +我们构建一个简单的网络，并对其输入x求导， 网络的结构为： +class Net(nn.Cell): + def __init__(self): + super(Net, self).__init__() + self.sin = ops.Sin() + self.cos = ops.Cos() + + def construct(self, x): + a = self.sin(x) + out = self.cos(a) + return out + + +正向网络的结构为： + +对该网络进行反向微分后，所得微分网络结构为： + + +",函数式微分编程,MindSpore、自动微分、GradOperation、MindSpore、算子、自由变量、闭包、运算符、网络、反向传播、求导、计算图、Graph、npu +函数式微分编程§前向自动微分实现,https://www.mindspore.cn/docs/zh-CN/r1.7/design/gradient.html," +除了支持反向自动微分的GradOperation之外，MindSpore还扩展实现了前向自动微分Jvp（Jacobian-Vector-Product）。相比于反向自动微分，前向自动微分更适合于求取输入维度小于输出维度的网络的梯度。MindSpore的前向自动微分是基于反向自动微分接口GradOperation开发的。 + +黑色为网络的正向流程，第一次求导为针对\(x\)的求导，得到的是蓝色的图。第二次的为蓝色图针对\(v\)的求导，得到的是黄色的图。黄色的图就是我们所需要的前向模式自动微分的结果图。由于蓝色图可以视为关于\(v\)的线性函数，蓝色节点与黄色节点之间不会存在连边。蓝色节点全部为悬空节点，会被消除，真正运行的就只有原函数节点以及前向微分的节点。因此，该方法不会有额外的运行开销。 + +参考文献 +[1] Baydin, A.G. et al., 2018. Automatic differentiation in machine learning: A survey. arXiv.org. Available at: https://arxiv.org/abs/1502.05767 [Accessed September 1, 2021]. + +",函数式微分编程,MindSpore、自动微分、GradOperation、MindSpore、接口、网络、求导 +动静态图结合§静态图和动态图的概念,https://www.mindspore.cn/docs/zh-CN/r1.7/design/dynamic_graph_and_static_graph.html," +目前主流的深度学习框架的执行模式有两种，分别为静态图模式和动态图模式。 +静态图模式下，程序在编译执行时先生成神经网络的图结构，然后再执行图中涉及的计算操作。因此，在静态图模式下，编译器利用图优化等技术对执行图进行更大程度的优化，从而获得更好的执行性能，有助于规模部署和跨平台运行。 +动态图模式下，程序按照代码的编写顺序执行，在执行正向过程中根据反向传播的原理，动态生成反向执行图。这种模式下，编译器将神经网络中的各个算子逐一下发执行，方便用户编写和调试神经网络模型。 +",动静态图结合,算子、网络、反向传播、调试、优化、框架、性能 +动静态图结合§MindSpore静态图,https://www.mindspore.cn/docs/zh-CN/r1.7/design/dynamic_graph_and_static_graph.html," +在MindSpore中，静态图模式又被称为Graph模式，可以通过context.set_context(mode=context.GRAPH_MODE)来设置成静态图模式。静态图模式比较适合网络固定且需要高性能的场景。在静态图模式下，基于图优化、计算图整图下沉等技术，编译器可以针对图进行全局的优化，因此在静态图下能获得较好的性能，但是执行图是从源码转换而来，因此在静态图下不是所有的Python语法都能支持，详细请查看语法支持。 + +Graph模式执行原理 +在Graph模式下，MindSpore通过源码转换的方式，将Python的源码转换成IR，再在此基础上进行相关的图优化，最终在硬件设备上执行优化后的图。MindSpore使用的是一种基于图表示的函数式IR，即MindIR，采用了接近于ANF函数式的语义。Graph模式是基于MindIR进行编译优化的，使用Graph模式时，需要使用nn.Cell类并且在construct函数中编写执行代码， 或者调用@ms_function装饰器。 +Graph模式的代码用例如下所示： + +[1]: + + +import numpy as np +import mindspore.nn as nn +import mindspore.ops as ops +from mindspore import context, Tensor + +context.set_context(mode=context.GRAPH_MODE, device_target=""CPU"") + +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) + +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)) + +net = Net() +print(net(x, y)) + + + + + + + + +[ 4. 10. 18.] + + + + +Graph模式自动微分原理 +在MindSpore中，Graph模式下的自动微分原理可以参考自动微分。 + +",动静态图结合,MindSpore、自动微分、MindSpore、CPU、MindIR、网络、ast、计算图、优化、性能、Graph +动静态图结合§MindSpore动态图,https://www.mindspore.cn/docs/zh-CN/r1.7/design/dynamic_graph_and_static_graph.html," +在MindSpore中，动态图模式又被称为PyNative模式，可以通过context.set_context(mode=context.PYNATIVE_MODE)来设置成动态图模式。在脚本开发和网络流程调试中，推荐使用动态图模式进行调试，支持执行单算子、普通函数和网络、以及单独求梯度的操作。 + +PyNative模式执行原理 +在PyNative模式下，用户可以使用完整的Python API，此外针对使用MindSpore提供的API时，框架会根据用户选择的硬件平台（Ascend，GPU，CPU），将算子API的操作在对应的硬件平台上执行，并返回相应的结果。框架整体的执行过程如下： + +通过前端的Python API，调用到框架层，最终到相应的硬件设备上进行计算。例如：完成一个加法 + +[2]: + + +import numpy as np +import mindspore.context as context +import mindspore.nn as nn +from mindspore import Tensor +import mindspore.ops as ops + +context.set_context(mode=context.PYNATIVE_MODE, device_target=""CPU"") +x = Tensor(np.ones([1, 3, 3, 4]).astype(np.float32)) +y = Tensor(np.ones([1, 3, 3, 4]).astype(np.float32)) +output = ops.add(x, y) +print(output.asnumpy()) + + + + + + + + +[[[[2. 2. 2. 2.] + [2. 2. 2. 2.] + [2. 2. 2. 2.]] + + [[2. 2. 2. 2.] + [2. 2. 2. 2.] + [2. 2. 2. 2.]] + + [[2. 2. 2. 2.] + [2. 2. 2. 2.] + [2. 2. 2. 2.]]]] + + +此例中，当调用到Python接口ops.add(x, y)时，会将Python的接口调用通过Pybind11调用到框架的C++层，转换成C++的调用，接着框架会根据用户设置的device_target选择对应的硬件设备，在该硬件设备上执行add这个操作。 +从上述原理可以看到，在PyNative模式下，Python脚本代码会根据Python的语法进行执行，而执行过程中涉及到MindSpore的API，会根据用户设置在不同的硬件上进行执行，从而进行加速。因此，在PyNative模式下，用户可以随意使用Python的语法以及调试方法。例如可以使用常见的PyCharm、VS Code等IDE进行代码的调试。 + + +PyNative模式自动微分原理 +在前面的介绍中，我们可以看出，在PyNative下执行正向过程完全是按照Python的语法进行执行。在PyNative下是基于Tensor进行实现反向传播的，我们在执行正向过程中，将所有应用于Tensor的操作记录下来，并针对每个操作求取其反向，并将所有反向过程串联起来形成整体反向传播图（简称反向图）。最终，将反向图在设备上进行执行计算出梯度。 +反向构图过程示例，如下代码，对矩阵x乘上固定参数z，然后与y进行矩阵乘法，最终对x进行求导。 + +[3]: + + +import numpy as np +import mindspore.nn as nn +import mindspore.ops as ops +from mindspore import Tensor, context +from mindspore import Parameter +from mindspore import dtype as mstype + +context.set_context(mode=context.PYNATIVE_MODE, device_target=""CPU"") + +class Net(nn.Cell): + def __init__(self): + super(Net, self).__init__() + self.matmul = ops.MatMul() + self.z = Parameter(Tensor(np.array([2.0], np.float32)), name='z') + + def construct(self, x, y): + x = x * self.z + out = self.matmul(x, y) + return out + +class GradNetWrtX(nn.Cell): + def __init__(self, net): + super(GradNetWrtX, self).__init__() + self.net = net + self.grad_op = ops.GradOperation() + + def construct(self, x, y): + gradient_function = self.grad_op(self.net) + return gradient_function(x, y) + +x = Tensor([[0.8, 0.6, 0.2], [1.8, 1.3, 1.1]], dtype=mstype.float32) +y = Tensor([[0.11, 3.3, 1.1], [1.1, 0.2, 1.4], [1.1, 2.2, 0.3]], dtype=mstype.float32) +output = GradNetWrtX(Net())(x, y) +print(output) + + + + + + + + +[[9.02 5.4 7.2000003] + [9.02 5.4 7.2000003]] + + + +根据上述PyNative下构图原理，我们可以看到，在正向传播过程中，我们记录了Mul的计算过程，根据Mul对应的反向bprop的定义，得到了反向的MulGrad算子，根据Mul算子的bprop定义，如下： + +[4]: + + +from mindspore.ops._grad.grad_base import bprop_getters + +@bprop_getters.register(ops.Mul) +def get_bprop_mul(self): + """"""Grad definition for `Mul` operation."""""" + mul_func = P.Mul() + + def bprop(x, y, out, dout): + bc_dx = mul_func(y, dout) + bc_dy = mul_func(x, dout) + return binop_grad_common(x, y, bc_dx, bc_dy) + + return bprop + + + +可以看到对Mul的输入求反向，需要两个输入和输出的反向传播梯度值，此时根据实际的输入值，可以将z连接到MulGrad。以此类推，对下一个算子Matmul，相应的得到MatmulGrad信息，再根据bprop的输入输出，将上下文梯度传播连接起来。 +最终，对于初始传播，在MindSpore中使用sens进行缩放，默认值为1。同理对于输入y求导，可以使用同样的过程进行推导。 + + +PyNative模式下的控制流 +在PyNative模式下，脚本按照Python的语法执行，因此在MindSpore中，针对控制流语法并没有做特殊处理，直接按照Python的语法直接展开执行，进而对展开的执行算子进行自动微分的操作。例如，对于for循环，在PyNative下会根据具体的循环次数，不断的执行for循环中的语句，并对其算子进行自动微分的操作。 + +",动静态图结合,MindSpore、自动微分、GradOperation、MindSpore、算子、接口、控制流、GPU、CPU、Ascend、语句、网络、PyNative、API、arm、ast、反向传播、求导、调试、脚本、框架、C++ +动静态图结合§动静统一,https://www.mindspore.cn/docs/zh-CN/r1.7/design/dynamic_graph_and_static_graph.html," + +概述 +当前在业界支持动态图和静态图两种模式，动态图通过解释执行，具有动态语法亲和性，表达灵活；静态图使用jit编译优化执行，偏静态语法，在语法上有较多限制。动态图和静态图的编译流程不一致，语法约束不一致。MindSpore针对动态图和静态图模式，首先统一API表达，在两种模式下使用相同的API；其次统一动态图和静态图的底层微分机制。 + + + +动态图和静态图互相转换 +在MindSpore中，我们可以通过控制模式输入参数来切换执行使用动态图还是静态图。例如： + +[5]: + + +context.set_context(mode=context.PYNATIVE_MODE) + + + +由于在静态图下，对于Python语法有所限制，因此从动态图切换成静态图时，需要符合静态图的语法限制，才能正确使用静态图来进行执行。更多静态图的语法限制可以参考静态图语法限制。 + + +动静结合 +MindSpore支持在动态图下使用静态编译的方式来进行混合执行，通过使用ms_function修饰需要用静态图来执行的函数对象，即可实现动态图和静态图的混合执行，更多ms_function的使用可参考ms_function文档。 +例如： + +[6]: + + +import numpy as np +import mindspore as ms +import mindspore.nn as nn +from mindspore import Tensor +from mindspore import ms_function +from mindspore import Parameter +import mindspore.context as context + +class AddMulMul(nn.Cell): + def __init__(self): + super(AddMulMul, self).__init__() + self.param = Parameter(Tensor(0.5, ms.float32)) + + @ms_function + def construct(self, x): + x = x + x + x = x * self.param + x = x * x + return x + +class CellCallSingleCell(nn.Cell): + def __init__(self): + super(CellCallSingleCell, self).__init__() + self.conv = nn.Conv2d(1, 2, kernel_size=2, stride=1, padding=0, weight_init=""ones"", pad_mode=""valid"") + self.bn = nn.BatchNorm2d(2, momentum=0.99, eps=0.00001, gamma_init=""ones"") + self.relu = nn.ReLU() + self.add_mul_mul = AddMulMul() + + def construct(self, x): + x = self.conv(x) + x = self.bn(x) + x = self.add_mul_mul(x) + x = self.relu(x) + return x + +context.set_context(mode=context.PYNATIVE_MODE, device_target=""CPU"") +inputs = Tensor(np.ones([1, 1, 2, 2]).astype(np.float32)) +net = CellCallSingleCell() +out = net(inputs) +print(out) + + + + + + + + +[[[[15.99984]] + + [[15.99984]]]] + + + + +JIT Fallback +JIT Fallback是为了实现动静统一提出的功能特性。通过JIT Fallback等特性，静态图可以支持尽量多的动态图语法，使得静态图提供接近动态图的语法使用体验。 +JIT Fallback是从静态图的角度出发考虑静态图和动态图的统一。MindSpore默认使用静态图模式，用户编写程序时需要遵循MindSpore静态图语法支持，语法使用存在约束限制。而在动态图模式下，Python脚本代码会根据Python语法进行执行，用户可以使用任意Python语法。可以看出，静态图和动态图的语法约束限制是不同的。JIT Fallback特性可以使得静态图支持尽量多的动态图语法，用户能够灵活地进行静态图和动态图的切换。 +当前JIT Fallback支持静态图模式的部分常量场景，包括调用第三方库、创建及使用Tensor、调用Python的print打印等。更多JIT Fallback的说明和使用，请参考JIT Fallback文档。 +代码用例如下，其中，MindSpore静态图模式不支持在construct中调用NumPy第三方库和创建Tensor对象，因此用例中的x = np.array([1, 2, 3])和y = Tensor(x)将会通过JIT Fallback特性进行支持。 + +[7]: + + +import numpy as np +import mindspore.nn as nn +from mindspore import context, Tensor + +context.set_context(mode=context.GRAPH_MODE, device_target=""CPU"") + +class Net(nn.Cell): + def construct(self): + x = np.array([1, 2, 3]) + y = Tensor(x) + return y + +net = Net() +print(net()) + + + + + + + + +[1 2 3] + + + +",动静态图结合,MindSpore、MindSpore、CPU、PYNATIVE、API、ast、优化、脚本、GRAPH、npu、JIT Fallback +异构并行训练§概述,https://www.mindspore.cn/docs/zh-CN/r1.7/design/heterogeneous_training.html," +异构并行训练方法是通过分析图上算子内存占用和计算密集度，将内存消耗巨大或适合CPU逻辑处理的算子切分到CPU子图，将内存消耗较小计算密集型算子切分到硬件加速器子图，框架协同不同子图进行网络训练，使得处于不同硬件且无依赖关系的子图能够并行进行执行的过程。 +",异构并行训练,并行、算子、CPU、网络、框架 +异构并行训练§计算流程,https://www.mindspore.cn/docs/zh-CN/r1.7/design/heterogeneous_training.html," +MindSpore异构并行训练典型的计算流程如下图所示： + + +用户设置网络执行的后端 + + +[ ]: + + +from mindspore import context +context.set_context(device_target=""GPU"") + + + + +用户设置特定算子执行后端 + + +[1]: + + +from mindspore import ops + +prim = ops.Add() + +prim.add_prim_attr(""primitive_target"", ""CPU"") + + + + +框架根据计算图算子标志进行切图 +框架调度不同后端执行子图 + +当前典型使用异构并行计算的场景有：优化器异构、Embedding异构、PS异构。 +",异构并行训练,MindSpore、MindSpore、并行、优化器、算子、GPU、CPU、网络、计算图、优化、框架、Embedding +异构并行训练§优化器异构,https://www.mindspore.cn/docs/zh-CN/r1.7/design/heterogeneous_training.html," +在盘古或GPT3大模型训练过程中，优化器状态占用了大量内存，进而限制了可训练的模型规模。使用优化器异构，将优化器指定到CPU上执行，可以极大扩展可训练模型规模： + +如图所示，将Adam算子配置到CPU执行同时指定加速器进行FP16计算，可以将参数内存占用降低到原始的1/3。 + +配置优化器算子到CPU执行 +初始化FP16的权重参数以及FP32的优化器状态变量 +将输入优化器的梯度转为FP16（如果本来就是FP16梯度，可忽略这步） +权重和梯度转为FP32参与优化器运算 +更新后的FP32权重赋值给FP16的权重 + +优化器异构代码样例如下： + +[2]: + + +import numpy as np +from mindspore import dtype as mstype +import mindspore.ops as ops +from mindspore.common.initializer import initializer +from mindspore import Tensor +from mindspore import ParameterTuple +from mindspore.nn import Optimizer +_adam_opt = ops.MultitypeFuncGraph(""adam_opt"") +host_assign = ops.Assign() +host_assign.add_prim_attr(""primitive_target"", ""CPU"") +host_cast = ops.Cast() +host_cast.add_prim_attr(""primitive_target"", ""CPU"") +device_cast = ops.Cast() + +@_adam_opt.register(""Function"", ""Tensor"", ""Tensor"", ""Tensor"", ""Tensor"", ""Number"", ""Tensor"", ""Tensor"", ""Tensor"", + ""Tensor"", ""Bool"", ""Bool"") +def _update_run_kernel(opt, beta1, beta2, eps, lr, weight_decay, param, m, v, gradient, decay_flags, optim_filter): + """""" + Update parameters by AdamWeightDecay op. + """""" + success = True + if optim_filter: + param32 = host_cast(param, mstype.float32) + gradient = device_cast(gradient, mstype.float32) + if decay_flags: + next_param = opt(param32, m, v, lr, beta1, beta2, eps, weight_decay, gradient) + else: + next_param = opt(param32, m, v, lr, beta1, beta2, eps, 0.0, gradient) + ret = host_assign(param, host_cast(ops.depend(param32, next_param), ops.dtype(param))) + return ops.depend(success, ret) + return success + +class AdamWeightDecayOp(Optimizer): + def __init__(self, params, learning_rate=1e-3, beta1=0.9, beta2=0.999, eps=1e-6, weight_decay=0.0): + super(AdamWeightDecayOp, self).__init__(learning_rate, params, weight_decay) + self.beta1 = Tensor(np.array([beta1]).astype(np.float32)) + self.beta2 = Tensor(np.array([beta2]).astype(np.float32)) + self.eps = Tensor(np.array([eps]).astype(np.float32)) + self.moments1 = self.clone_param32(prefix=""adam_m"", init='zeros') + self.moments2 = self.clone_param32(prefix=""adam_v"", init='zeros') + self.opt = ops.AdamWeightDecay() + self.hyper_map = ops.HyperMap() + self.opt.add_prim_attr(""primitive_target"", ""CPU"") + + def construct(self, gradients): + """"""AdamWeightDecayOp"""""" + lr = self.get_lr() + if self.is_group: + if self.is_group_lr: + optim_result = self.map_reverse(ops.partial(_adam_opt, self.opt, self.beta1, self.beta2, self.eps), + lr, self.weight_decay, self.parameters, self.moments1, self.moments2, + gradients, self.decay_flags, self.optim_filter) + else: + optim_result = self.map_reverse(ops.partial(_adam_opt, self.opt, self.beta1, self.beta2, self.eps, lr), + self.weight_decay, self.parameters, self.moments1, self.moments2, + gradients, self.decay_flags, self.optim_filter) + else: + optim_result = self.map_reverse(ops.partial(_adam_opt, self.opt, self.beta1, self.beta2, self.eps, lr, + self.weight_decay), self.parameters, self.moments1, self.moments2, + gradients, self.decay_flags, self.optim_filter) + return optim_result + + def clone_param32(self, prefix, init=None): + new = [] + for old_param in self.parameters: + param_init = init + if init is None: + param_init = old_param.init + new_state = old_param.clone() + new_state.set_dtype(mstype.float32) + new_state.set_data(initializer(param_init, shape=old_param.shape, dtype=mstype.float32)) + new_state.name = prefix + '.' + new_state.name + new.append(new_state) + return ParameterTuple(new) + + + +步骤4、5也可以直接融合到优化器算子中做进一步优化，完整的优化器异构训练流程可以参考： https://gitee.com/mindspore/models/tree/r1.7/official/nlp/pangu_alpha +",异构并行训练,mindspore、mindspore、并行、优化器、算子、Optimizer、CPU、model、ast、lr、优化、nlp、Graph +异构并行训练§Embedding异构,https://www.mindspore.cn/docs/zh-CN/r1.7/design/heterogeneous_training.html," +在一些需要查Embedding大表的网络中，Embedding表往往有上百G的规模，受加速器内存大小限制，无法直接将整表加载到加速器上执行。通过将与权重表相连的算子放到CPU上执行，避免加速器由于内存限制而无法训练网络的问题。 + + +配置EmbeddingLookup算子到CPU执行 + + +[3]: + + +ops.EmbeddingLookup().add_prim_attr('primitive_target', 'CPU') + + + + +配置EmbeddingLookup相关优化器到CPU执行 + + +[4]: + + +use_locking = False +use_nesterov = False +ops.FusedSparseLazyAdam(use_locking, use_nesterov).add_prim_attr(""primitive_target"", ""CPU"") + + + +EmbeddingLookup算子设置代码样例如下： + +[5]: + + +import mindspore.nn as nn +import mindspore.ops as ops +from mindspore import Parameter +from mindspore.common.initializer import initializer + +class EmbeddingLookup(nn.Cell): + def __init__(self, vocab_size, embedding_size, param_init='normal', + target='CPU', sparse=True): + """"""Initialize EmbeddingLookup."""""" + super(EmbeddingLookup, self).__init__() + validator.check_value_type('sparse', sparse, [bool], self.cls_name) + self.vocab_size = validator.check_positive_int(vocab_size, 'vocab_size') + self.target = target + self.sparse = sparse + if target not in ('CPU', 'DEVICE'): + raise ValueError('Attr \'target\' of \'EmbeddingLookup\' Op passed ' + + str(target) + ', should be one of values in \'CPU\', \'DEVICE\'.') + if not sparse and target == 'CPU': + raise ValueError('When target is CPU, embedding_lookup must be sparse.') + if sparse: + self.gatherv2 = ops.SparseGatherV2() + else: + self.gatherv2 = ops.Gather() + self.embeddinglookup = ops.EmbeddingLookup().add_prim_attr('primitive_target', 'CPU') + self.embedding_size = validator.check_positive_int(embedding_size, 'embedding_size') + self.embedding_table = Parameter(initializer(param_init, [self.vocab_size, self.embedding_size]), + name='embedding_table') + + def construct(self, indices): + if self.target == ""CPU"": + out = self.embeddinglookup(self.embedding_table, indices, 0) + else: + out = self.gatherv2(self.embedding_table, indices, 0) + return out + + + +当前nn目录下的EmbeddingLookup、FTRL、LazyAdam等算子已经封装好异构接口，用户只需设置target属性为CPU或DEVICE即可切换执行后端。 +整体调用流程可以参考：https://gitee.com/mindspore/models/tree/r1.7/official/recommend/wide_and_deep +",异构并行训练,mindspore、mindspore、并行、优化器、算子、接口、CPU、网络、model、优化、Embedding +异构并行训练§PS异构,https://www.mindspore.cn/docs/zh-CN/r1.7/design/heterogeneous_training.html," +在EmbeddingTable达到T级别，单机内存无法放下时，使用Parameter Server，通过异构的Pull/Push算子进行权重的拉取和更新。 + +Parameter Server封装异构流程，用户只需配置参数使用PS即可，具体配置流程请参考Parameter Server训练流程。 +此外，wide&deep网络中也有使用PS的流程，可参考：https://gitee.com/mindspore/models/tree/r1.7/official/recommend/wide_and_deep +",异构并行训练,mindspore、mindspore、Parameter Server、并行、算子、网络、model、单机、Embedding、Parameter Server +异构并行训练§约束,https://www.mindspore.cn/docs/zh-CN/r1.7/design/heterogeneous_training.html," +当前需要用户指定算子执行的后端，不支持根据网络进行自动化配置。 +",异构并行训练,并行、算子、网络 +分布式并行§背景,https://www.mindspore.cn/docs/zh-CN/r1.7/design/distributed_training_design.html," +随着深度学习的快速发展，为了提升神经网络的精度和泛化能力，数据集和参数量都在呈指数级向上攀升。分布式并行训练成为一种解决超大规模网络性能瓶颈的发展趋势。MindSpore支持了当前主流的分布式训练范式并开发了一套自动混合并行解决方案。本篇设计文档将会集中介绍几种并行训练方式的设计原理，同时指导用户进行自定义开发。 +",分布式并行,MindSpore、MindSpore、并行、分布式、数据集、网络、精度、数据、精度、性能 +分布式并行§概念,https://www.mindspore.cn/docs/zh-CN/r1.7/design/distributed_training_design.html," + +集合通信 +集合通信指在一组进程间通信，组内所有进程满足一定规则的发送和接收数据。MindSpore通过集合通信的方式进行并行训练过程中的数据传输工作，在Ascend芯片上它依赖于华为集合通信库HCCL完成，在GPU上它依赖于英伟达集合通信库NCCL完成。 + + +同步模式 +在同步模式下，所有的设备同时开始训练，并且当反向传播算法完成之后同步更新参数的取值。MindSpore目前采用的是同步训练模式。 + +",分布式并行,MindSpore、MindSpore、并行、分布式、集合通信、同步模式、GPU、Ascend、反向传播、数据 +分布式并行§数据并行,https://www.mindspore.cn/docs/zh-CN/r1.7/design/distributed_training_design.html," +这个小节介绍了在MindSpore中ParallelMode.DATA_PARALLEL数据并行模式是如何工作的。 + +数据并行原理 + + +环境依赖 +每次开始进行并行训练前，通过调用mindspore.communication.init接口初始化通信资源，并自动创建全局通信组WORLD_COMM_GROUP。 + +数据分发（Data distribution） +数据并行的核心在于将数据集在样本维度拆分并下发到不同的卡上。在mindspore.dataset模块提供的所有数据集加载接口中都有num_shards和shard_id两个参数，它们用于将数据集拆分为多份并循环采样的方式，采集batch大小的数据到各自的卡上，当出现数据量不足的情况时将会从头开始采样。 + +网络构图 +数据并行网络的书写方式与单机网络没有差别，这是因为在正反向传播（Forward propagation & Backward Propagation）过程中各卡的模型间是独立执行的，只是保持了相同的网络结构。唯一需要特别注意的是为了保证各卡间训练同步，相应的网络参数初始化值应当是一致的，在DATA_PRALLEL和HYBRID_PARALLEL模式下建议通过使能parameter_broadcast达到权重广播的目的；在AUTO_PRALLEL和SEMI_AUTO_PARALLEL模式下，框架内部会自动分析参数的并行度，并设置相应的随机数种子，保证在数据并行维度的设备上参数初始化值一致。 + +梯度聚合（Gradient aggregation） +数据并行理论上应该实现和单机一致的训练效果，为了保证计算逻辑的一致性，在梯度计算完成后插入AllReduce算子实现各卡间的梯度聚合操作。MindSpore设置了mean开关，用户可以选择是否要对求和后的梯度值进行求平均操作，也可以将其视为超参项，打开开关等价于学习率倍数缩小。 + +参数更新（Parameter update） +因为引入了梯度聚合操作，所以各卡的模型会以相同的梯度值一起进入参数更新步骤。因此MindSpore实现的是一种同步数据并行训练方式。理论上最终每卡训练出来的模型是相同的，如果网络中含有在样本维度的归约类型操作，网络的输出可能会有所差别，这是由数据并行的切分性质决定的。 + + + + +数据并行代码 + +集合通信 + +management.py：这个文件中涵盖了集合通信过程中常用的helper函数接口，例如获取集群数量和卡的序号等。当在Ascend芯片上执行时，框架会加载环境上的libhccl.so库文件，通过它来完成从Python层到底层的通信接口调用。 +comm_ops.py：MindSpore将支持的集合通信操作都封装为算子的形式放在这个文件下，包括AllReduce、AllGather、ReduceScatter和Broadcast等。PrimitiveWithInfer中除了定义算子所需属性外，还包括构图过程中输入到输出的shape和dtype推导。 + + +梯度聚合 + +grad_reducer.py：这个文件实现了梯度聚合的过程。对入参grads用HyperMap展开后插入AllReduce算子，这里采用的是全局通信组，用户也可以根据自己网络的需求仿照这个模块进行自定义开发。MindSpore中单机和分布式执行共用一套网络封装接口，在Cell内部通过ParallelMode来区分是否要对梯度做聚合操作，网络封装接口建议参考TrainOneStepCell代码实现。 + + + + +",分布式并行,MindSpore、MindSpore、并行、分布式、算子、接口、数据集、集合通信、Ascend、网络、ast、TrainOneStepCell、反向传播、lR、学习率、数据、超参、单机、框架、dataset、ib +分布式并行§自动并行,https://www.mindspore.cn/docs/zh-CN/r1.7/design/distributed_training_design.html," +自动并行作为MindSpore的关键特性，用于实现自动的数据并行加模型并行的混合并行训练方式，旨在帮助用户以单机的脚本表达并行算法逻辑，降低分布式训练难度，提高算法研发效率，同时又能保持训练的高性能。这个小节介绍了在MindSpore中ParallelMode.AUTO_PARALLEL自动并行模式及ParallelMode.SEMI_AUTO_PARALLEL半自动并行模式是如何工作的。 + +自动并行原理 + + +分布式算子和张量排布模型 +在上面的架构图中，自动并行流程会对单机的正向计算图（ANF Graph）进行遍历，以分布式算子（Distributed Operator）为单位对张量进行切分建模，表示一个算子的输入输出张量如何分布到集群各个卡上（Tensor Layout）。这种模型充分地表达了张量和设备间的映射关系，用户无需感知模型各切片放到哪个设备上运行，框架会自动调度分配。 +为了得到张量的排布模型，每个算子都具有切分策略（Shard Strategy），它表示算子的各个输入在相应维度的切分情况。通常情况下只要满足以2为基、均匀分配的原则，张量的任意维度均可切分。以下图为例，这是一个三维矩阵乘（BatchMatMul）操作，它的切分策略由两个元组构成，分别表示input和weight的切分形式。其中元组中的元素与张量维度一一对应，2^N为切分份数，1表示不切。当用户想表示一个数据并行切分策略时，即input的batch维度切分，其他维度不切，可以表达为strategy=((2^N, 1, 1),(1, 1, 1))；当表示一个模型并行切分策略时，即weight的非batch维度切分，这里以channel维度切分为例，其他维度不切，可以表达为strategy=((1, 1, 1),(1, 1, 2^N))；当表示一个混合并行切分策略时，其中一种切分策略为strategy=((2^N, 1, 1),(1, 1, 2^N))。 + +依据切分策略，分布式算子中定义了推导算子输入张量和输出张量的排布模型的方法。这个排布模型由device_matrix，tensor_shape和tensor map组成，分别表示设备矩阵形状、张量形状、设备和张量维度间的映射关系。分布式算子会进一步根据张量排布模型判断是否要在图中插入额外的计算、通信操作，以保证算子运算逻辑正确。 + +张量排布变换 +当前一个算子的输出张量模型和后一个算子的输入张量模型不一致时，就需要引入计算、通信操作的方式实现张量排布间的变化。自动并行流程引入了张量重排布算法（Tensor Redistribution），可以推导得到任意排布的张量间通信转换方式。下面三个样例表示公式Z=(X×W)×V的并行计算过程， 即两个二维矩阵乘操作，体现了不同并行方式间如何转换。 +在样例一中，第一个数据并行矩阵乘的输出在行方向上存在切分，而第二个模型并行矩阵乘的输入需要全量张量，框架将会自动插入AllGather算子实现排布变换。 + +在样例二中，第一个模型并行矩阵乘的输出在列方向上存在切分，而第二个数据并行矩阵乘的输入在行方向上存在切分，框架将会自动插入等价于集合通信中AlltoAll操作的通信算子实现排布变换。 + +在样例三中，第一个混合并行矩阵乘的输出切分方式和第二个混合并行矩阵乘的输入切分方式一致，所以不需要引入重排布变换。但由于第二个矩阵乘操作中，两个输入的相关维度存在切分，所以需要插入AllReduce算子保证运算正确性。 + +综上，1、2两点是自动并行实现的基础，总体来说这种分布式表达打破了数据并行和模型并行的边界，轻松实现混合并行。从脚本层面上，用户仅需构造单机网络，即可表达并行算法逻辑，框架将自动实现对整图切分。 + +切分策略搜索算法 +当用户熟悉了算子的切分表达，并手动对算子配置切分策略，这就是SEMI_AUTO_PARALLEL半自动并行模式。这种方式对手动调优有帮助，但还是具有一定的调试难度，用户需要掌握并行原理，并根据网络结构、集群拓扑等计算分析得到高性能的并行方案。为了帮助用户加速并行网络训练过程，在半自动并行模式的基础上，AUTO_PARALLEL自动并行模式支持并行策略传播（Sharding Propagation），能够有效地降低用户手配算子切分策略的工作量，算法将切分策略由用户配置的算子向未配置的算子传播。为进一步降低用户手配算子切分策略的工作量，支持切分策略完全自动搜索。为此，围绕硬件平台构建相应的代价函数模型（Cost Model），计算出一定数据量、一定算子在不同切分策略下的计算开销（Computation Cost），内存开销（Memory Cost）及通信开销（Communication Cost）。然后通过动态规划算法（Dynamic Programming）或者递归规划算法（Recursive Programming），以单卡的内存上限为约束条件，高效地搜索出性能较优的切分策略。 +策略搜索这一步骤代替了用户手动指定模型切分，在短时间内可以得到较高性能的切分方案，极大降低了并行训练的使用门槛。 + +分布式自动微分 +传统的手动模型切分除了需要关注正向网络通信还需要考虑网络反向的并行运算，MindSpore通过将通信操作包装为算子，并利用框架原有的自动微分操作自动生成通信算子反向，所以即便在进行分布式训练时，用户同样只需关注网络的前向传播，真正实现训练的全自动并行。 + + + + +自动并行代码 + +张量排布模型 + +tensor_layout：这个目录下包含了张量排布模型相关功能的定义及实现。其中tensor_layout.h中声明了一个张量排布模型需要具备的成员变量tensor_map_origin_，tensor_shape_和device_arrangement_等。在tensor_redistribution.h中声明了实现张量排布间from_origin_和to_origin_变换的相关方法，将推导得到的重排布操作保存在operator_list_中返回，并计算得到重排布所需的通信开销comm_cost_, 内存开销memory_cost_及计算开销computation_cost_。 + + +分布式算子 + +ops_info：这个目录下包含了分布式算子的具体实现。在operator_info.h中定义了分布式算子实现的基类OperatorInfo，开发一个分布式算子需要继承于这个基类并显式实现相关的虚函数。其中InferTensorInfo，InferTensorMap和InferDevMatrixShape函数定义了推导该算子输入、输出张量排布模型的算法。InferForwardCommunication，InferMirrorOps等函数定义了切分该算子需要插入的额外计算、通信操作。CheckStrategy和GenerateStrategies函数定义了算子切分策略校验和生成。根据切分策略SetCostUnderStrategy将会产生该策略下分布式算子的并行开销值operator_cost_。 + + +策略搜索算法 + +auto_parallel：这个目录下实现了切分策略搜索的算法。graph_costmodel.h定义了构图信息，其中每个点表示一个算子OperatorInfo，有向边edge_costmodel.h表示算子的输入输出关系及重排布的代价。operator_costmodel.h中定义了每个算子的代价模型，包括计算代价、通信代价和内存代价。dp_algorithm_costmodel.h主要描述了动态规划算法的主要流程，由一系列图操作组成。在costmodel.h中定义了cost和图操作的数据结构。 + + +设备管理 + +device_manager.h：这个文件实现了集群设备通信组的创建及管理。其中设备矩阵模型由device_matrix.h定义，通信域由group_manager.h管理。 + + +整图切分 + +step_auto_parallel.h, step_parallel.h：这两个文件包含了自动并行流程的核心实现。首先由step_auto_parallel.h调用策略搜索流程并产生分布式算子的OperatorInfo，然后在step_parallel.h中处理算子切分和张量重排布等流程，对单机计算图进行分布式改造。 + + +通信算子反向 + +grad_comm_ops.py：这个文件定义了AllReduce和AllGather等通信算子的反向操作。 + + + + +",分布式并行,MindSpore、自动微分、MindSpore、并行、分布式、算子、集合通信、网络、Model、lR、调试、数据、计算图、脚本、单机、框架、性能、Graph、ib、npu +分布式并行§分布式并行高级特性,https://www.mindspore.cn/docs/zh-CN/r1.7/design/distributed_training_design.html," +随着深度学习的发展，模型规模越来越大。如NLP领域，短短几年时间，参数量就从BERT的亿级，发展到GPT-3的1700亿，再到盘古alpha 2000亿，以及当前业界甚至提出百万亿级。由此可以看出，近年来参数规模呈指数增长趋势。另一方面，随着大数据、互联网等领域相关技术的发展，可供模型训练的数据集也极速扩增，例如推荐、自然语言处理等场景的数据集可达数TB。 +面对大数据量、大规模参数的训练，单个设备要么完成模型训练的时间很长，要么因显存不足而导致无法进行训练。因此，需要引入分布式训练技术。 +当前，最常用的分布式训练技术是数据并行。数据并行将训练数据切分到多个设备上，每个设备维护相同的模型参数和相同大小的计算任务，但是处理不同的数据，并在反向传播过程中，对每个设备产生的参数梯度进行全局AllReduce同步求和。当数据集较大而模型较小时，选择数据并行较有优势，如ResNet50。但是，当模型规模较大、或数据集与模型规模均较大时，就需要借助于其他分布式特性。 +MindSpore提供以下高级特性来支撑大模型分布式训练，用户可以根据自己的需要进行灵活组合。 + +算子级并行 +算子级并行是以算子为单位，对其输入张量切分到多个设备，从而将算子进行分布式计算。一方面，可以将数据样本及模型参数同时切分到多个设备上，以完成大模型的训练。另一方面，可以充分利用集群资源进行并行计算，以提高整体速度。 +用户可以设置正向网络中每个算子的切分策略，框架根据算子的切分策略对每个算子及其输入张量进行切分建模，使得该算子的计算逻辑在切分前后保持数学等价。 + + +流水线并行 +当集群设备数很多时，如果仅采用算子级并行的方式，则需要在整个集群的通信域上进行通信，这可能使得通信效率低，从而降低整体性能。 +而流水线并行能将神经网络结构切分成多个stage，每个stage跑在一部分设备内，将集合通信的通信域限定在这部分设备范围内，而stage间采用点对点通信。 +流水线并行的优点在于：能提升通信效率、能方便的处理按层堆叠的神经网络结构。缺点在于：同一时刻内，有些节点可能处于空闲状态。 + + +优化器并行 +在数据并行或算子级并行训练时，模型的参数可能在多个设备上存在同一份副本。这使得优化器在更新该权重之时，在多个设备间存在冗余计算。在此情况下，可以通过优化器并行将优化器的计算量分散到多个设备上。它的优点在于：能减少静态内存消耗、减少优化器内的计算量。缺点在于：增加了通信开销。 + + +Host&Device异构 +在大模型训练时，因每个设备（加速器）的内存容量有限，从而总体所能训练的模型规模将受设备数的限制。为了能完成更大规模的模型训练，可以使用主机端（Host）和加速器（Device）异构的训练模式。它同时发挥了主机端内存大和加速器端计算快的优势，是超大模型训练过程中减少设备数的有效方式。 + + +重计算 +MindSpore根据正向图计算流程来自动推导出反向图，正向图和反向图一起构成了完整的计算图。在计算某些反向算子时，可能需要用到某些正向算子的计算结果，导致这些正向算子的计算结果，需要驻留在内存中直到这些反向算子计算完，它们所占的内存才会被其他算子复用。而这些正向算子的计算结果，长时间驻留在内存中，会推高计算的内存占用峰值，在大规模网络模型中尤为显著。为了降低内存峰值，重计算技术可以不保存正向激活层的计算结果，让该内存可以被复用，然后在计算反向部分时，重新计算出正向激活层的结果。 + + +切分策略传播 +在算子级并行中，需要用户配置正向网络中每个算子的切分策略（若不配置，则默认使用数据并行的策略）。而切分策略传播特性可以仅配置若干个算子的切分策略，为未配置切分策略的算子自动生成可行的切分策略，并且达到最小化通信开销的效果。 + + +Parameter Server模式 +Parameter Server(参数服务器)是分布式训练中一种广泛使用的架构，相较于数据并行同步的AllReduce训练方法，Parameter Server具有更好的灵活性、可扩展性以及节点容灾的能力。参数服务器既支持同步SGD(Stochastic Gradient Descent，随机梯度下降)，也支持异步SGD的训练算法。在扩展性上，将模型的计算与模型的更新分别部署在Worker和Server两类进程中，使得Worker和Server的资源可以独立地横向扩缩(新增或者删除Worker和Server资源)。另外，在大规模数据中心的环境下，计算设备、网络以及存储经常会出现各种故障而导致部分节点异常，而在参数服务器的架构下，能够较为容易地处理此类故障而不会对训练中的任务产生影响。 + + +通信算子融合 +在分布式训练场景下，跨设备甚至跨节点的数据传输是制约扩展性以及算力利用率的瓶颈。通信算子融合是一种提升网络资源利用率、加速数据传输效率的重要方法，其将相同源节点和目的节点的通信算子打包同时执行，以避免多个单算子执行带来的额外开销。 + + +数据集切分 +在进行分布式训练时，需要将训练数据集导入到每个设备上。常见的导入方式有两种：1）以数据并行的方式导入，即将数据按batch维度进行切分，每个设备导入一部分。2）每个设备导入全量的数据。另外，当数据的某些维度特别大时（如遥感图片的H/W维可能特别大），即使样本数很少，也需要对图片进行切分，即将数据按H/W维度进行切分，每张设备读取一部分图片。此特性能支持将数据集按特定维度切分，以满足大幅面图片处理领域的训练诉求。 + + +分布式推理 +对于大模型来说，训练好的参数巨大，如盘古alpha拥有2000亿参数。如此庞大的模型在推理时，无法简单地部署在单个设备上，推理时需要把模型切分到集群中。并且，推理和训练可能不在同一个环境中，所使用的集群大小可能不一样。因此，还需支持推理设备数与训练设备数不一致的场景。 + + +函数式算子切分 +在动态图模式下，指定网络结构中的某个部分以图模式执行，并进行各种并行操作。 + +",分布式并行,MindSpore、MindSpore、Parameter Server、并行、优化器、Host&Device、分布式、算子、数据集、集合通信、网络、SGD、ast、反向传播、lR、数据、计算图、优化、框架、性能、NLP、Parameter Server +分布式并行§特性相关接口说明,https://www.mindspore.cn/docs/zh-CN/r1.7/design/distributed_training_design.html," + + + +特性类别 +特性接口 +说明 +作用 + + + + +算子级并行 +shard(in_strategy=None, out_strategy=None)在Primitive类中 +设置算子的输入及输出张量的切分策略（其中，输出张量的切分策略仅支持部分算子，如Gather、MatMul） +通过将网络模型中每个算子涉及到的张量进行切分，降低单个设备的内存容量，以完成大模型训练/推理。或利用集群资源，进行分布式计算，减少整体执行时间。 + + + +add_prim_attr(name, value)在Primitive类中 +Gather算子：add_prim_attr(“manual_split”, config)：配置其第一个输入的非均匀切分策略，其中config类型为tuple，用于描述第一个参数第0维的切分方式。比如(10, 20, 30, 4)代表将算子第一个输入的第0维切分成4份，每份的shape大小分别为10，20，30，4。 +在推荐领域，存在数据集的每一列对应一个子表的场景。在该场景下，使用此配置能降低通信量，提升整体性能。 + + + + +EmbeddingLookUp算子：add_prim_attr(“primitive_target”, “CPU”)：配置其在CPU上执行，用于异构场景。 +在推荐领域，存在Embedding Table特别大的场景，为了节约device内存，可以使用此配置将EmbeddingLookUp放到CPU上执行，以完成推荐大模型的训练。 + + + +set_auto_parallel_context(enable_alltoall=bool_value) +表示在通信时是否允许产生AllToAll通信算子，其值为bool类型，默认为False。 +AllToAll通信能减少通信数据量，提高通信效率，但需要环境支持。 + + +流水线并行 +set_auto_parallel_context(pipeline_stages=stage_num) +设置流水线并行的stage个数，其值为正整数，取值范围为[1, 设备数]。 +指定stage的个数，将集合通信的通信域限定在stage范围内，而stage间采用点对点通信。 + + + +pipeline_stage(value)在Cell类中 +设置该Cell在哪个stage中执行。 +设置该Cell在哪个stage中执行。 + + + +PipelineCell(network, micro_size) +用于指定训练网络的MicroSize数量，其中network为待训练的网络，micro_size为正整数。 +指定micro_size，能减少stage间的空闲等待时间，提升流水线并行的整体效率。 + + +优化器并行 +set_auto_parallel_context(enable_parallel_optimizer=bool_value) +表示是否开启优化器并行，其值为bool型，默认为False。 +优化器并行能节省静态内存的开销，但增加了通信开销。 + + + +set_auto_parallel_context(parallel_optimizer_config=config) +只有开启优化器并行后，此配置才生效。其中config是个dict，支持两个键值：gradient_accumulation_shard(bool)：如果为True，则累积梯度变量将在数据并行度上进行分片，默认为False。parallel_optimizer_threshold(int)：该值表示优化器切分阈值，单位为KB（默认64KB）。当参数大小不超过该值时，将不会被切分。 +gradient_accumulation_shard为True时，将节省一份参数大小的静态内存，但增加了通信开销。优化器切分阈值，能使得shape较小的参数不进行优化器切分，以节省通信资源。 + + +重计算 +recompute(mode=True)在primitive类中 +用于指定该算子是否需要重计算，其值为bool类型，默认为True，表示开启算子重计算。 +开启算子重计算后，能减少动态内存的峰值，但增加整体计算量。 + + + +recompute(**kwargs)在Cell类中 +调用此接口后，将会对此Cell中的算子进行重计算。其中输入参数有两个bool类型选项：mp_comm_recompute：是否开启模型并行通信算子重计算，默认为True。parallel_optimizer_comm_recompute：是否开启优化器并行通信算子重计算，默认为False +开启Cell重计算，且能配置模型并行的通信算子、优化器并行的通信算子是否进行重计算。当通信算子重计算时，将消耗通信资源，但能降低动态内存的峰值。 + + +自动并行 +set_auto_parallel_context(search_mode=mode) +用于指定策略搜索算法，其值为字符串类型，可选值为：1，""sharding_propagation""：表示使用切分策略传播算法进行策略搜索；2，""dynamic_programming""：表示使用动态规划算法进行策略搜索；3，""recursive_programming""：表示使用双递归算法进行策略搜索； +自动并行可以让用户不配置或者少量配置算子的切分策略，而由框架搜索出切分策略。 + + + +set_algo_parameters(fully_use_devices=bool_value) +用于设置搜索策略时是否需要将算子切分到所有设备上。其值为bool类型，默认为True。 +如果将算子切分到所有设备上，则能缩小搜索空间，提高搜索速度，但搜索出来的策略并非全局最优。 + + + +set_auto_parallel_context(all_reduce_fusion_config=config) +配置梯度AllReduce算子融合策略，其值为list类型。例如：[20, 35]，表示将前20个AllReduce融合成1个，第20～35个AllReduce融合成1个，剩下的AllReduce融合成1个。 +减少AllReduce通信算子的操作次数，提高通信效率。 + + +通信算子融合 +set_auto_parallel_context(comm_fusion=config) +设置通信算子的融合配置，当前支持AllReduce、AllGather、ReduceScatter通信算子的配置。其值为dict类型，如comm_fusion={""allreduce"": {""mode"": ""auto"", ""config"": None}}。其中""mode""有三种选项：""auto""：自动按照数据量阈值64MB进行算子融合，配置参数“config”为None。""size""：按照手动设置数据量阈值的方式进行通信算子融合，配置参数""config""类型为int，单位MB。""index""：仅""allreduce""支持配置index，表示按照通信算子序列号进行融合的方式，配置参数""config""类型为list。例如：[20, 35]，表示将前20个AllReduce融合成1个，第20～35个AllReduce融合成1个，剩下的AllReduce融合成1个。 +减少AllReduce/AllGather/ReduceScatter通信算子的操作次数，提高通信效率 + + +数据集切分 +set_auto_parallel_context(dataset_strategy=config) +配置数据集的切分策略。其中，config为Union[str, tuple]。当传入字符串时，有两种选项：""full_batch""：表示数据集不切分；""data_parallel""：表示数据集按数据并行的方式切分。当传入tuple时，tuple中的内容代表数据集的切分策略，类似于primitive的shard()接口。若不调用此接口，则默认采用""data_parallel""的方式。 +当样本数比卡数少时，可以采用""full_batch""的方式进行导入；当样本数大、模型参数小时，可以采用""data_parallel""的方式导入；当数据集是高分辨率图像数据时，可以采用配置tuple切分策略的方式导入。 + + +分布式推理 +infer_predict_layout(*predict_data) +使用推理数据进行一次预编译，输出算子的切分信息。 +获取推理时所有权重的切分信息。 + + + +load_distributed_checkpoint(network, checkpoint_filenames, predict_strategy=None, train_strategy_filename=None) +加载分布式权重，需每台机器预先放置全量的ckpt。其中network代表推理网络，checkpoint_filenames代表checkpoint文件，predict_strategy为infer_predict_layout()的输出，train_strategy_filename为训练时保存的算子切分策略信息。 +加载分布式权重，以进行分布式推理。 + + +函数式算子切分 +shard(in_strategy, out_strategy, device=""Ascend"", level=0)在cell类中 +设置cell的输入及输出张量的切分策略，其余算子的并行策略由切分策略传播得到。 in_strategy/out_strategy指定输入/输出张量的切分策略，device指定执行设备，level指定切分策略传播算法的模式。 +在PyNative模式下指定某个cell实例以图模式执行，并且依据指定的输入输出切分策略进行算子级别的模型并行， 其余的部分仍以PyNative模式执行数据并行。 + + + +ops.shard(fn, in_strategy, out_strategy, device=""Ascend"", level=0) +传入的fn为cell实例或函数，其余输入和shard相同，返回值为函数，再调用此函数时，会以图模式执行算子级别的模型并行 +此用法可以指定某个函数进行算子级别的模型并行，具体功能和cell的shard方法相同。 + + +",分布式并行,并行、优化器、分布式、算子、接口、数据集、集合通信、pipeline、optimizer、CPU、Ascend、网络、PyNative、lR、数据、优化、框架、性能、dataset、ib、Embedding +中间表达mindir§简介,https://www.mindspore.cn/docs/zh-CN/r1.7/design/mindir.html," +中间表示（IR）是程序编译过程中介于源语言和目标语言之间的程序表示，以方便编译器进行程序分析和优化，因此IR的设计需要考虑从源语言到目标语言的转换难度，同时考虑程序分析和优化的易用性和性能。 +MindIR是一种基于图表示的函数式IR，其最核心的目的是服务于自动微分变换。自动微分采用的是基于函数式编程框架的变换方法，因此IR采用了接近于ANF函数式的语义。此外，借鉴Sea of Nodes[1]和Thorin[2]的优秀设计，采用了一种基于显性依赖图的表示方式。关于ANF-IR的具体介绍，可以参考MindSpore IR文法定义。 +在图模式context.set_context(mode=context.GRAPH_MODE)下运行用MindSpore编写的模型时，若配置中设置了context.set_context(save_graphs=True)，运行时会输出一些图编译过程中生成的一些中间文件，我们称为IR文件。当前主要有三种格式的IR文件： + +ir后缀结尾的IR文件：一种比较直观易懂的以文本格式描述模型结构的文件，可以直接用文本编辑软件查看。 +dat后缀结尾的IR文件：一种相对于ir后缀结尾的文件格式定义更为严谨的描述模型结构的文件，包含的内容更为丰富，可以直接用文本编辑软件查看。 +dot后缀结尾的IR文件：描述了不同节点间的拓扑关系，可以用graphviz将此文件作为输入生成图片，方便用户直观地查看模型结构。对于算子比较多的模型，推荐使用可视化组件MindInsight对计算图进行可视化。 + +",中间表达MindIR,MindSpore、自动微分、MindSpore、算子、MindInsight、mindir、计算图、可视化、模型结构、优化、框架、性能、GRAPH +中间表达mindir§文法定义,https://www.mindspore.cn/docs/zh-CN/r1.7/design/mindir.html," +ANF是函数式编程中常用且简洁的中间表示，其文法定义如下所示： + ::= NUMBER | STRING | VAR | BOOLEAN | PRIMOP + | (lambda (VAR …) ) + ::= ( …) + | (if ) + ::= (let ([VAR ]) ) | | + + +ANF中表达式分为原子表达式（aexp）和复合表达式（cexp），原子表达式表示一个常数值或一个变量或一个匿名函数；复合表达式由多个原子表达式复合组成，表示一个匿名函数或原语函数调用，组合的第一个输入是调用的函数，其余输入是调用的参数。 +MindIR文法继承于ANF，其定义如下所示： + ::= | + ::= Parameter + ::= Scalar | Named | Tensor | Type | Shape + | Primitive | MetaFuncGraph | FuncGraph + ::= ( …) + ::= | + + +MindIR中的ANode对应于ANF的原子表达式，ANode有两个子类分别为ValueNode和ParameterNode。ValueNode表示常数节点，可承载一个常数值（标量、符号、张量、类型、维度等），也可以是一个原语函数（Primitive）或一个元函数（MetaFuncGraph）或一个普通函数（FuncGraph），因为在函数式编程中函数定义本身也是一个值。ParameterNode是参数节点，表示函数的形参。 +MindIR中CNode对应于ANF的复合表达式，表示一次函数调用。 +在MindSpore自动微分时，会计算ParameterNode和CNode的梯度贡献，并返回最终ParameterNode的梯度，而不计算ValueNode的梯度。 +",中间表达MindIR,MindSpore、自动微分、MindSpore、mindir、Graph +中间表达mindir§示例,https://www.mindspore.cn/docs/zh-CN/r1.7/design/mindir.html," +下面以一段程序作为示例，对比理解MindIR。 +def func(x, y): + return x / y + +@ms_function +def test_f(x, y): + a = x - 1 + b = a + y + c = b * func(a, b) + return c + + +这段Python代码对应的ANF表达为： +lambda (x, y) + let a = x - 1 in + let b = a + y in + let func = lambda (x, y) + let ret = x / y in + ret end in + let %1 = func(a, b) in + let c = b * %1 in + c end + + +对应的MindIR为ir.dot： + +在MindIR中，一个函数图（FuncGraph）表示一个普通函数的定义，函数图一般由ParameterNode、ValueNode和CNode组成有向无环图，可以清晰地表达出从参数到返回值的计算过程。在上图中可以看出，python代码中两个函数test_f和func转换成了两个函数图，其参数x和y转换为函数图的ParameterNode，每一个表达式转换为一个CNode。CNode的第一个输入链接着调用的函数，例如图中的add、func、return。值得注意的是这些节点均是ValueNode，因为它们被理解为常数函数值。CNode的其他输入链接这调用的参数，参数值可以来自于ParameterNode、ValueNode和其他CNode。 +在ANF中每个表达式都用let表达式绑定为一个变量，通过对变量的引用来表示对表达式输出的依赖，而在MindIR中每个表达式都绑定为一个节点，通过节点与节点之间的有向边表示依赖关系。 +",中间表达MindIR,mindir、Graph +中间表达mindir§函数式语义,https://www.mindspore.cn/docs/zh-CN/r1.7/design/mindir.html," +MindIR较传统计算图的一个重要特性是不仅可以表达算子之间的数据依赖，还可以表达丰富的函数式语义。 + +高阶函数 +在MindIR中，函数的定义是由一个子图来定义，但其本身可以是一个被传递的值，作为其他高阶函数的输入或输出。 +例如下面一个简单的示例中，函数f作为参数传入了函数g，因此函数g是一个接收函数输入的高阶函数，函数f真正的调用点是在函数g内部。 +@ms_function +def hof(x): + def f(x): + return x + 3 + def g(function, x): + return function(x) * function(x) + res = g(f, x) + return res + + +对应的MindIR为hof.dot： + +在实际网络训练脚本中，自动求导泛函GradOperation和优化器中常用到的Partial和HyperMap都是典型的高阶函数。高阶语义极大地提升了MindSpore表达的灵活性和简洁性。 + + +控制流 +控制流在MindIR中是以高阶函数选择调用的形式表达。这样的形式把控制流转换为高阶函数的数据流，从而使得自动微分算法更加强大。不仅可以支持数据流的自动微分，还可以支持条件跳转、循环和递归等控制流的自动微分。 +下面以一个简单的斐波那契用例来演示说明。 +@ms_function +def fibonacci(n): + if(n < 1): + return 0 + elif(n == 1): + return 1 + else: + return fibonacci(n-1) + fibonacci(n-2) + + +对应的MindIR为cf.dot： + +其中fibonacci是顶层函数图，在顶层中有两个函数图被switch选择调用。✓fibonacci是第一个if的True分支，✗fibonacci是第一个if的False分支。在✗fibonacci中被调用的✓✗fibonacci是elif的True分支，✗✗fibonacci是elif的False分支。这里需要理解的关键是在MindIR中，条件跳转和递归是以高阶控制流的形式表达的。例如，✓fibonacci和✗fibonacci是作为switch算子的参数传入，switch根据条件参数选择哪一个函数作为返回值。因此，switch是把输入的函数当成普通的值做了一个二元选择操作，并没有调用，而真正的函数调用是在紧随switch后的CNode上完成。 + + +自由变量和闭包 +闭包（closure）是一种编程语言特性，它指的是代码块和作用域环境的结合。自由变量(free variable)是指在代码块中引用作用域环境中的变量而非局部变量。在MindIR中，代码块是以函数图呈现的，而作用域环境可以理解为该函数被调用时的上下文环境，自由变量的捕获方式是值拷贝而非引用。 +一个典型的闭包用例如下： +@ms_function +def func_outer(a, b): + def func_inner(c): + return a + b + c + return func_inner + +@ms_function +def ms_closure(): + closure = func_outer(1, 2) + out1 = closure(1) + out2 = closure(2) + return out1, out2 + + +对应的MindIR为closure.dot： + +在例子中，a和b是自由变量，因为func_inner中变量a和b是引用的其父图func_outer中定义的参数。变量closure是一个闭包，它是函数func_inner与其上下文func_outer(1, 2)的结合。因此，out1的结果是4，因为其等价于1+2+1，out2的结果是5，因为其等价于1+2+2。 + +",中间表达MindIR,MindSpore、自动微分、GradOperation、MindSpore、优化器、算子、控制流、自由变量、闭包、mindir、网络、求导、数据、计算图、优化、脚本、ib +中间表达mindir§参考文献,https://www.mindspore.cn/docs/zh-CN/r1.7/design/mindir.html," +[1] C. Click and M. Paleczny. A simple graph-based intermediate representation. +SIGPLAN Not., 30:35–49, March 1995. +[2] Roland Leißa, Marcel Köster, and Sebastian Hack. A graph-based higher-order intermediate +representation. In Proceedings of the 13th Annual IEEE/ACM International Symposium on +Code Generation and Optimization, pages 202–212. IEEE Computer Society, 2015. +",中间表达MindIR,mindir、ast、graph、roce +高性能数据处理引擎§背景介绍,https://www.mindspore.cn/docs/zh-CN/r1.7/design/data_engine.html," +MindSpore训练数据处理引擎核心是将训练样本（数据集）高效、灵活的转换至Tensor，并将该Tensor提供给训练网络用于训练，其关键特性主要如下： + +高效数据处理Pipeline，让数据在Pipeline内流动，实现高效处理能力； +提供常用数据集、特定格式数据集（MindRecord）、自定义数据集等多样数据加载能力，满足用户多种多样的数据集加载需求； +针对多种数据集，提供统一的采样能力，实现一份数据灵活输出； +提供大量C层数据处理算子、Python层数据处理算子，支持用户自定义数据处理算子，方便用户开箱即用； +提供MindSpore数据集格式（MindRecord），方便用户将自有数据集转换后，再通过MindDataset实现统一高效地加载； +提供了自动数据增强模式，能够基于特定策略自动对图像进行数据增强处理； +提供单节点数据缓存能力，解决重复加载、处理数据的问题，降低数据处理开销，提升端到端训练效率。 + + +MindSpore训练数据引擎同时也在科学计算-电磁仿真、图数据、遥感大幅面图像处理等领域提供数据集的高效加载、采样能力，助力MindSpore实现全场景支持。 +",高性能数据处理引擎,MindSpore、全场景、MindSpore、算子、数据集、MindRecord、Pipeline、网络、数据、MindData、性能、Dataset +高性能数据处理引擎§数据处理引擎设计,https://www.mindspore.cn/docs/zh-CN/r1.7/design/data_engine.html," + +设计目标与思路 +MindSpore的设计充分考虑了数据处理的高效性、灵活性以及在不同场景下的适配性。整个数据处理子系统分为以下模块： + + +API：数据处理过程在MindSpore中以图的形式表示，称为数据图。MindSpore对外提供Python API来定义数据图，内部实现图优化和图执行。 +Data Processing Pipeline：数据加载和预处理多步并行流水线，又包括以下部分： + +Adaptor：用于将上层语言（如Python）构建的数据图，转换为下层可执行的C++数据图（Execution Tree）； +Optimizer：数据图优化器，实现算子融合、自动参数优化等操作； +Runtime：运行优化后Execution tree的执行引擎； +数据集算子（Dataset Operators）：Execution tree中的某个节点，对应数据处理流水线中的一步具体操作，例如从图像文件夹加载数据的ImageFolderDataset和MindDataset算子，以及数据处理中的map、shuffle、repeat、concat和split等算子； +数据增强算子（Data Augmentation Operators）：也可称为Tensor算子，用于对Tensor执行特定变换，例如Decode、Resize、Crop、Pad等算子，它们通常被Dataset Operators中的map算子所调用。 + + + +数据增强后的结果，通过队列和正反向计算系统相连。 +基于以上设计，数据处理引擎实现了如下的Pipeline流程： + +另外，由于端侧场景资源有限，MindSpore提供了一套更加轻量化的数据处理Eager模式，能够解决云化场景数据处理Pipeline不适用于端侧的问题。用户可以直接对单张图像进行数据处理操作，然后传入模型进行推理。 + + +极致的处理性能 + +多段数据处理流水线 + +不同于TensorFlow和PyTorch，MindSpore采用多段并行流水线（Multi-stage Parallel Pipeline）的方式来构建数据处理Pipeline，可以更加细粒度地规划计算资源的使用。如上图所示，每个数据集算子都包含一个输出Connector，即由一组阻塞队列和计数器组成的保序缓冲队列。每个数据集算子都会从上游算子的Connector中取缓存数据进行处理，然后将这块缓存再推送到自身的输出Connector中，由此往后。这种机制的优势包括： + +数据集加载、map、batch等操作以任务调度机制来驱动，每个操作的任务互相独立，上下文之间通过Connector来实现联通； +每个操作均可以实现细粒度的多线程或多进程并行加速。数据框架为用户提供调整算子线程数和控制多进程处理的接口，可以灵活控制各个节点的处理速度，进而实现整个数据处理Pipeline性能最优； +支持用户对Connector大小进行设置，在一定程度上可以有效的控制内存的使用率，能够适应不同网络对数据处理性能的要求。 + +在这种数据处理机制下，对输出数据进行保序处理是保证训练精度的关键。保序是指数据处理流水线运行时，输出数据的顺序和数据处理前的顺序一致。MindSpore采用轮询算法来保证多线程处理时数据的有序性。 + +上图是一个数据处理Pipeline，保序操作发生在下游map算子（4并发）的取出操作中，通过单线程轮询的方式取出上游队列中的数据。Connector内部有两个计数器，expect_consumer_记录了已经有多少个consumer从queues_中取出了数据，pop_from_记录了哪个内部阻塞队列将要进行下一次取出操作。expect_consumer_对consumer取余，而pop_from_对producer取余。expect_consumer_再次为0时，说明所有的local_queues_已经处理完上一批任务，可以继续进行下一批任务的分配和处理，进而实现了上游至下游map操作的多并发保序处理。 + +数据处理与网络计算流水线 +数据处理流水线不断进行数据处理，并把处理后的数据发送到Device侧的缓存；在一个Step执行结束后，直接从Device的缓存中读取下一个Step的数据。 + + +数据处理：负责将数据集处理成网络需要的输入，并传递给发送队列中，保证数据处理的高效性； +发送队列Queue：维护数据列队，保证数据处理与网络计算过程互不影响，充当桥梁的作用； +网络计算：从发送队列中获取数据，进行迭代训练。 + +以上三者各司其职，相互独立，构筑整个训练过程Pipeline。因此，只要数据队列不为空，模型训练就不会因为等待训练数据而产生阻塞。 + +缓存技术 +当数据集尺寸较大，无法全部加载到内存缓存中时，训练所用的部分数据需要从磁盘中读取，可能会遇到I/O瓶颈，增大每个Epoch中的缓存命中率就显得尤为关键。传统的缓存管理采用LRU策略，没有考虑深度学习数据的读取特点，即在不同的Epoch之间数据是重复读取的，而在同一个Epoch中则是随机读取。每条数据的读取概率都相同，因此哪个数据被缓存并不重要，反而是已经缓存的数据在被使用之前不被换出更加关键。针对这个特点，我们使用了一个简单高效的缓存算法，即数据一旦被缓存，就不会从缓存中被换出。 +在数据图优化的过程中，MindSpore会根据流水线结构自动生成缓存算子，既可以缓存原始数据集，也可以缓存数据增强处理后的结果。 + + + + +灵活的定制能力 +用户对数据处理的需求往往多种多样，对于未固化在框架中的处理逻辑，也需要能够通过开放的定制化能力予以支持。由此，MindSpore提供了灵活的数据集加载方法、丰富的数据处理算子，以及自动数据增强、动态Shape、数据处理Callback等机制，供开发人员在各种场景中使用。 + +灵活的数据集加载方法 +针对数据集种类繁多、格式与组织方式各异的难题，MindSpore提供了三种不同的数据集加载方法： + +对于各领域的常用数据集，可以直接使用MindSpore内置的API接口进行加载。MindSpore提供了CelebADataset、Cifar10Dataset、CocoDataset、ImageFolderDataset、MnistDataset、VOCDataset等常用数据集加载接口，在保证性能的同时，能够让用户开箱即用。 +对于暂不支持直接加载的数据集，可以先转换为MindSpore数据格式，即MindRecord，再通过MindDataset接口进行加载。MindRecord可以将不同的数据集格式归一化，有聚合存储、高效读取、快速编解码、灵活控制分区大小等多种优势。 +用户也可以通过Python编写自定义数据集读取类，再使用GeneratorDataset 接口进行数据集加载。该方式可以快速集成现有代码，但由于是Python IO Reader，需要额外关注数据加载性能。 + + +通过Python层自定义和C层插件的方式支持更多算子 + +MindSpore内置了丰富的数据处理算子，根据实现的不同又可分为C层和Python层算子。C层算子往往具有更好的性能，而Python层算子则更方便集成第三方库，实现更为容易。对于框架暂不支持的算子，用户可以开发C层实现代码，编译后以插件的形式注册到MindSpore的数据处理Pipeline中；或者直接在Python层自定义数据处理逻辑，然后通过map算子进行调用。 + +支持自动数据增强策略 +MindSpore提供了基于特定策略自动对图像进行增强处理的机制，包括基于概率的自动数据增强和基于反馈的自动数据增强，可以实现算子的自动选择和执行，达到提升训练精度的目的。 +针对ImageNet数据集，利用AutoAugment方法最终搜索出的自动数据增强策略包含 25 个子策略组合，每个子策略包含2种变换，实际训练中针对每幅图像随机挑选1个子策略组合，然后以一定的概率来决定是否执行子策略中的每种变换。其流程如下图所示。 + +为了支持AutoAugment这种自动数据增强策略，MindSpore提供了以下接口。 + +RandomChoice即随机选择，允许用户定义一个数据增强操作列表，数据处理过程中将针对每张图像等概率选择列表中的一个数据增强操作执行。 +from mindspore.dataset.transforms.c_transforms import RandomChoice +from mindspore.dataset.vision.c_transforms import RandomCrop, RandomHorizontalFlip, RandomRotation + +transform_list = RandomChoice([RandomCrop((32, 32)), + RandomHorizontalFlip(0.5), + RandomRotation((90, 90))]) + + + +RandomApply即随机概率执行，允许用户定义一个数据增强操作列表和对应概率，数据处理过程中将针对每张图像以指定的概率执行列表中的数据增强操作，要么全都执行，要么全不执行。 +from mindspore.dataset.transforms.c_transforms import RandomApply +from mindspore.dataset.vision.c_transforms import RandomCrop, RandomHorizontalFlip, RandomRotation + +transform_list = RandomApply([RandomCrop((32, 32)), + RandomHorizontalFlip(0.5), + RandomRotation((90, 90))], 0.8) + + + +RandomSelectSubpolicy即随机子策略选择，允许用户定义多个数据增强操作子策略列表，并对子策略中的每个数据增强操作指定执行的概率，数据处理过程中将针对每张图像先等概率选择一个子策略，然后按顺序依照概率决定其中各个数据增强操作是否执行。 +from mindspore.dataset.vision.c_transforms import RandomSelectSubpolicy, RandomRotation, RandomVerticalFlip, \ + RandomHorizontalFlip + +transform_list = RandomSelectSubpolicy([[(RandomRotation((45, 45)), 0.5), + (RandomVerticalFlip(), 1)], + [(RandomRotation((90, 90)), 1), + (RandomHorizontalFlip(), 0.5)]]) + + + + +自动数据增强操作可以使ImageNet数据集提升1%左右的训练精度。 + +支持动态shape +MindSpore通过per_batch_map支持用户自定义控制输出训练数据的Shape，满足了网络需要基于不同场景调整数据Shape的诉求。 + + +用户通过自定义函数（User Defined Function, UDF）控制生成数据的Shape，例如在第n个Step时生成Shape为(x, y, z, …)的数据； +通过batch算子的per_batch_map参数传入该自定义函数，便可得到不同Shape训练数据。 + + +Callback机制让数据处理更加灵活 +通过Callback机制实现根据训练结果动态调整数据增强逻辑的功能，提供了更加灵活的自动数据增强。 + +MindSpore支持用户基于数据处理提供的DSCallback（包含Epoch开始、Step开始、Step结束、Epoch结束等）实现自己的数据增强逻辑（User Defined Function, UDF），并将其添加至map操作中，以实现更灵活的数据增强操作。 + + + + +端云统一架构 + +数据图与计算图的统一 +MindIR是MindSpore基于图表示的函数式IR，其最核心的目的是服务于自动微分变换。自动微分采用的是基于函数式编程框架的变换方法，因此IR采用了接近于ANF函数式的语义。 +推理数据图典型的场景包括大小缩放、中间截图、归一化和通道变换。 + +我们将推理数据图以子图的方式保存到生成的模型文件（MindIR）中，便可在推理时通过统一的接口加载模型中的数据处理流程，从而自动进行数据处理，得到模型需要的输入，达到简化用户操作，提升易用性的目的。 + + +轻量化的数据处理 +数据处理Pipeline在运行过程中会占用比较多的系统资源，包括CPU和内存。以ImageNet的训练过程为例，CPU占用达到20%，内存占用达到30到50G。云侧训练时，能够使用的资源比较充裕，但在端侧场景中，这种需求往往是不可接受的。并且数据处理Pipeline的初始化过程通常比较耗时，同样也不满足端侧需要快速启动、多次进行训练和推理的特点。因此，MindSpore提供了一套更轻量化、更适用于端侧场景的数据处理模式，解决了云化场景数据处理Pipeline不适用于端侧的问题。 + +MindSpore基于Pipeline调整架构，支持数据处理单算子独立使用（Eager 模式），支持各种场景推理，提供给AI开发人员更大的灵活性；同时，将Pipeline轻量化，实现基于Pull Base的轻量化流水线，减少资源占用并且处理速度快。 + + +通过上述两种方法，MindSpore保证了统一的数据处理架构支撑多种不同的应用场景。 + +",高性能数据处理引擎,MindSpore、自动微分、MindSpore、并行、优化器、算子、接口、数据集、MindRecord、Pipeline、Adaptor、Optimizer、Runtime、Operators、Callback、CPU、MindIR、网络、TensorFlow、PyTorch、API、GeneratorDataset、LR、精度、数据、计算图、精度、优化、迭代、MindData、框架、性能、Dataset、C++、roce +高性能数据处理引擎§高级特性,https://www.mindspore.cn/docs/zh-CN/r1.7/design/data_engine.html," + +自动数据加速 +数据异构加速 + +",高性能数据处理引擎,数据、性能 +图算融合加速引擎介绍§背景,https://www.mindspore.cn/docs/zh-CN/r1.7/design/graph_kernel_fusion_engine.html," +MindSpore等主流AI计算框架对用户提供的算子通常是从用户可理解、易使用角度进行定义。每个算子承载的计算量不等，计算复杂度也各不相同。但从硬件执行角度看，这种天然的、基于用户角度的算子计算量划分，并不高效，也无法充分发挥硬件资源计算能力。主要体现在： + +计算量过大、过复杂的算子，通常很难生成切分较好的高性能算子，从而降低设备利用率； +计算量过小的算子，由于计算无法有效隐藏数据搬移开销，也可能会造成计算的空等时延，从而降低设备利用率； +硬件Device通常为多核、众核结构，当算子shape较小或其它原因引起计算并行度不够时，可能会造成部分核的空闲，从而降低设备利用率。特别是基于专用处理器架构（Domain Specific Architecture，后文简称DSA）的芯片对这些因素更为敏感。如何最大化发挥硬件算力性能的同时使算子也能具备较好的易用性，一直以来是一个很大的挑战。 + +在AI框架设计方面，目前业界主流采用图层和算子层分层的实现方法。图层负责对计算图进行融合或重组，算子层负责将融合或重组后的算子编译为高性能的可执行算子。图层通常采用基于Tensor的High-Level IR的处理和优化，算子层则采用基于计算指令的Low-Level IR进行分析和优化。 这种人为分层处理显著增加了图、算两层进行协同优化的难度。 +MindSpore在过去几年的技术实践中，采用了图算融合的技术来较好的解决了这个问题。NLP、推荐等不同类别的典型网络在使能图算融合后训练速度都有明显收益。主要原因之一就是这些网络中存在大量小算子组合，具有较多的融合优化机会。 +",图算融合加速引擎介绍,MindSpore、MindSpore、并行、算子、网络、数据、计算图、优化、框架、性能、NLP +图算融合加速引擎介绍§图算融合架构及整体流程,https://www.mindspore.cn/docs/zh-CN/r1.7/design/graph_kernel_fusion_engine.html," +图算融合整体架构如下图所示。在图层主要思路是把复合算子打开，然后进行跨边界聚合和优化，最后进行Kernel算子拆分。主要步骤包括： + +Composite Expansion：将复合算子展开为基本算子，并构成Composite子图，方便进行后续的跨边界优化和算子拆分； +Cross-OP Aggregation：将相邻的基本算子或Composite子图进行聚合，从而构成更大的聚合子图，方便进行后续的跨边界优化和算子拆分； +High-Level Optimization：在上面两步得到的聚合子图的基础上，我们可以进行大量的跨边界优化，如代数化简、公共子表达式提取（CSE）等； +Kernel Partition：基于计算特征以及融合算子性能，对聚合计算子图进行算子拆分。 + +优化后的计算图会以一个个子图的方式传给MindSpore AKG继续进行后端优化、生成目标代码。 + +通过以上步骤，我们可以获得两方面性能收益： + +不同算子之间的跨边界性能优化收益； +通过对整个计算图进行重组拆分，得到最优粒度的融合算子。 + +",图算融合加速引擎介绍,MindSpore、MindSpore、算子、MindSpore AKG、计算图、优化、性能 +图算融合加速引擎介绍§融合算子加速优化（MindSpore AKG）,https://www.mindspore.cn/docs/zh-CN/r1.7/design/graph_kernel_fusion_engine.html," +前文提到，在HPC、深度神经网络训练等场景中，图算融合优化可带来成倍的性能提升。但随着图算融合能力的不断增强，融合算子的开发成为了继续提升图算融合能力的瓶颈点。融合算子的自动生成技术可以解决基于DSA开发融合算子编程门槛较高的问题，让程序员在算子开发过程中能够聚焦于算子的实现逻辑，无需关注后端优化，极大提高其开发效率。尤其对于后端硬件架构复杂以及存在复杂算子和融合算子的场景，算子自动生成技术更加关键。 +因此，MindSpore AKG基于多面体编译技术（Polyhedral Model），对融合算子的加速优化与自动生成，能够帮助MindSpore的图算融合模块优化后的融合算子在异构硬件平台（GPU/Ascend）上自动生成高性能的kernel，提升MindSpore的训练性能。 + +架构及整体流程 + +MindSpore AKG的整体框架如上图所示： + +IR规范化 + +MindSpore AKG的输入为MindSpore图算融合模块优化后的融合子图，通过TVM的Compute / IR Builder / Hybrid 等多种描述方式对子图中的算子进行表达。然后DSL会被转换为 Halide IR（Halide，是常见的用于开发高性能图像处理和Array计算的语言，可作为中间表达解耦算法和优化） 并进行 IR 规范化； +完成初步简化和优化后，Halide IR会被转化为Poly模块所需的调度树； + + +Poly模块调度优化 + +利用Polyhedral技术中的Pluto调度算法，实现循环的自动融合、自动重排等变换，为融合算子自动生成满足并行性、数据局部性的初始调度； +为快速适配不同硬件后端，Poly模块内的优化pass会分为硬件无关的通用优化与硬件相关的特定优化，编译时按照硬件特征拼接组合，实现异构硬件后端的快速适配。自动切分、自动映射以及自动内存提升等pass会根据不同硬件的架构性质给出不同的优化方式； + + +后端优化 + +为了进一步提升算子的性能，我们针对不同硬件后端开发了相应的优化pass，如Ascend后端中实现数据对齐、指令映射，GPU后端中实现向量化存取，插入同步指令等，最终生成相应平台代码。 + + + + + +主要特性 + +多面体调度生成 +多面体模型是计算机编译优化领域常见的一种循环嵌套优化方法，其理论基础为Presburger算术。通过多面体模型，我们可以分析程序中语句的读写依赖关系，继而为后续的循环变换提供理论支撑。多面体模型循环优化的核心即其调度算法，该调度算法可根据硬件体系结构特征（如并行性和数据局部性等）定义优化目标，将循环优化问题转为整数规划问题进行求解。在MindSpore AKG中，主要利用基于整数线性规划的ISL调度器来对输入程序进行新的调度变换。ISL调度器以Pluto算法为主，并辅以Feautrier算法，在程序的并行性和局部性之间寻求最优。 + + +自动切分（Auto-Tiling） + +什么是切分 +切分是一种广泛运用的循环变换的方法，可以改变语句实例访问顺序。如下图代码所示，这个1024 x 1024的循环，每一次循环可以看作是这个二维空间上的一个点的访问，对这个循环进行4 x 4的切分能够改变循环点的访问顺序，使得从原先的遍历大矩阵变成多次遍历4 x 4的小矩阵。 + + +切分的价值和挑战 +将数据进行分块和内存映射，可以使用更小更快的缓存来访问数据。当计算数据量大于缓存空间的时候，就需要将原来的数据进行分块后存储到缓存上，以此来适应目标架构的硬件特征。要寻找一个好的切分，开发者需要对硬件的内存层级和代码逻辑有所了解，能够分析出有哪些数据逻辑上被复用，需要被放进缓存，甚至还需要对硬件的缓存机制有所了解（例如CPU），对硬件的并行机制有所了解（例如GPU），这样的切分才能够提升硬件资源利用率，提高代码的性能。 + +MindSpore AKG的自动切分方案 +MindSpore AKG中提供了Auto-Tiling模块，其主要流程包括： + +对输入分析建模。Auto-Tiling借助Poly模块，将输入算子的逻辑转化为调度树，轴空间提取模型对调度树做分析，提取出可切分调度的总体轴空间； +对轴空间进行剪枝。Auto-Tiling使用两个约束生成模型对算子逻辑和硬件信息分别进行分析，生成对应的算子约束和硬件约束，其中这些约束根据影响算子的范围又会被分为强弱约束，它们作用在轴空间上，将轴空间缩小，即可获得一个约束轴空间； +轴空间求解。Auto-Tiling会根据算子和硬件信息生成不同的目标优化函数，求解模型基于目标优化函数，在约束轴空间上能够找到唯一一个解，生成最终的切分调度配置。 + + + + + + +自动映射（Auto-Mapping） +自动映射是指在多线程架构的硬件后端上，自动将数据和实例执行顺序映射到多线程处理单元上，例如GPU的线程块(Block)和线程(Thread)。 通过Auto-Mapping，我们可以： + +减少代码复杂度 +如下图所示，shape为8 * 12的算子，Auto-Tiling会尽量采取(a)中的分块方式，来减少(b)中蓝字所示的循环边界判断； + +接着，Auto-Mapping也尽量会对分块后的数据分配能够整除的Thread size，来提升Thread的利用率，如下例中Thread为4的方案。 + + +优化Block/Thread/Tile比例 +Auto-Mapping在分配Block size、Thread size和Tile size的时候，会考虑GPU的硬件特征，通过调整三者的比例，提升利用率、内存吞吐率、存取速度这三个方面，进行性能优化。 + + + + +数据搬移 +对于各式各样的硬件后端，其架构设计通常包含多层级缓冲区，且各缓冲区的内存空间、可支持的计算速度差异很大，适合的计算类型也不同。因此，程序员将程序放到不同硬件后端执行时，除计算指令外，也需要考虑算子在不同片上内存的划分，以及数据在不同片上Buffer的流动，以配合不同的存储结构，提升程序的并行性。 +MindSpore AKG基于Polyhedral技术来实现基于多层Buffer结构的DMA数据流识别与生成。自动数据搬移能够通过分析数据流，给出数据应该放置到什么缓冲区，以及数据在缓冲区之间搬移的顺序，进一步优化算子性能。 +以片上内存层级较为复杂的Davinci架构为例，MindSpore AKG自动数据搬移生成的步骤如下: + +依次遍历算子输入的Halide IR，识别每个compute节点的类型，并根据不同类型分析每条语句需使用到的计算模块； +根据目标芯片的片上缓存模型和具体芯片参数，对片上的高速存储Buffer进行分类； +基于每条语句使用的计算单元，以及变量间的数据依赖关系（每个计算单元，会从不同的片上Buffer读入数据，并将计算结果写回不同的片上缓存，其依赖关系可以分为读后写WAR，写后读RAW，写后写WAW三种），生成算子数据流信息； +对于可融合的场景，将算子的数据流进行优化，得到完整的算子数据流信息； +输出包含算子完整数据流信息的Halide IR。 + + + + + +算子优化方案 +下面以两类计算举例，描述MindSpore AKG如何利用以上特性进行复杂算子的自动生成和优化。 + +规约计算 Reduction +规约计算，即对Tensor的选定维度或所有维度做累积操作，常见的算子有Sum、ReduceMax/Min、ReduceAnd/Or等。 +大shape的Reduction场景通常分为两步： + +将数据分成小块，分别对各小块进行规约； +对每个小块的规约结果再次进行规约得到最终结果。 + +MindSpore AKG通过自动轴融合+多面体调度优化+AKG-Reduce模板库的方式对reduction操作进行优化，并通过原子加的方式，将两步reduce实现成一个kernel。 + +流程如上图所示： + +算子表示：首先解析算子表达，在IR规范化的阶段，进行规约轴和非规约轴的识别与分离，并通过自动轴融合，将两类轴分别融合成两根轴，同时记录相关信息如Tensor shape、规约方向等； +Poly模块：利用Pluto算法进行调度变换，通过分析之前记录的信息，计算得到最佳切分参数，并进行到共享内存、寄存器的数据搬移； +指令发射与代码生成：从调度树到Halide IR的发射阶段，插入接口调用语句并在代码生成阶段调用。调用AkgReduce模板库，实现高性能的线程块内累加；调用AkgAtomicReturn原子加接口，将各线程块的中间结果累加得到最终结果，保证计算正确性。 + + +矩阵乘 GEMM和卷积 Convolution +MindSpore AKG利用GPU的Tensor Core硬件计算单元并结合多面体编译调度优化和高性能内联PTX库，对混合精度场景下的矩阵乘计算进行加速。 +在此基础上，MindSpore AKG使用Implicit GEMM方法来处理混合精度的卷积计算。卷积的两个四维的输入矩阵，会在从全局内存搬移到共享内存的过程中，被转换成二维矩阵，进而转化为矩阵乘计算进行优化。这种方法可以解决Image to Column带来的数据冗余（Image to Column是常见的卷积优化方法，简称为Im2col，即将每个feature map转换为一个连续的column，转换后的矩阵会占据更多的全局内存）。 +以卷积计算的优化为例，流程如下： + + +分析算子DSL和Halide IR，解析GEMM表达式并记录矩阵的数据类型、shape、排布方式等信息；卷积算子的shape更复杂（通常是NHWC四个维度），在这一步MindSpore AKG会将它的四个维度抽象出来，关联到与矩阵乘对应的两个虚拟轴上； +在Poly模块中进行针对性调度优化，包含多次切分、Warp层级映射，多层级内存提升（共享内存上进行数据复用，寄存器上使用TensorCore进行高速的乘加运算）等；对于卷积算子，进行多次切分以及计算切分参数时，也需要考虑多出来的两个维度H、W； +基于Halide IR执行后端优化pass，包括数据预取——节省搬运与计算间的等待时间、数据补齐与重排——消除bank conflicts、向量化指令——提升数据加载和写入的效率等； +调用akg::wmma高性能接口（包含PTX层级的更细粒度的优化），生成最终的CUDA Kernel。 + +用户和开发者可以通过运行MindSpore AKG的测试用例了解融合算子或复杂算子的优化流程，以卷积算子的相关代码为例： +四维卷积（不含Pad操作）的计算公式如下，其中\(N = 32, H = W = 28, Co = 128, Ci = 64, Hk = Hw = 5\)。 +$\(Output(n, h, w, o)=\sum_{c=1}^{Ci} + \sum_{rh=1}^{Hk} + \sum_{rw=1}^{Wk} + (Image(n, h+rh, w+rw, c)*Filter(o, rh, rw, c))\)$ +根据其计算公式，可以使用tvm.compute编写出算子DSL： +n, in_h, in_w, in_c = data.shape +out_c, k_h, k_w, in_c = weight.shape +_, _, s_h, s_w = stride +o_h = (in_h - k_h) // s_h + 1 +o_w = (in_w - k_w) // s_w + 1 +rc = tvm.reduce_axis((0, in_c), name=""rc"") +rh = tvm.reduce_axis((0, k_h), name=""rh"") +rw = tvm.reduce_axis((0, k_w), name=""rw"") +output = tvm.compute( + (n, o_h, o_w, out_c), + lambda n, h, w, o: tvm.sum( + data[n, (h * s_h + rh), (w * s_w + rw), rc] + * weight[o, rh, rw, rc], + axis=[rc, rh, rw]), + name=output_name +) +return output + + +生成出的初始调度如下，包含7个for循环，计算效率较低： +// attr [compute(out, 0x55c9185ce710)] realize_scope = """" +realize out([0, 32], [0, 28], [0, 28], [0, 128]) { + produce out { + for (n, 0, 32) { + for (h, 0, 28) { + for (w, 0, 28) { + for (o, 0, 128) { + out(n, h, w, o) = 0h + for (rc, 0, 64) { + for (rh, 0, 5) { + for (rw, 0, 5) { + // attr [[iter_var(rc, range(min=0, ext=64)), iter_var(rh, range(min=0, ext=5)), iter_var(rw, range(min=0, ext=5))]] reduce_update = """" + out(n, h, w, o) = (out(n, h, w, o) + (input_1(n, (h + rh), (w + rw), rc)*input_2(o, rh, rw, rc))) + } + } + } + } + } + } + } + } +} + + +经过Poly模块调度优化、多个后端优化pass和代码生成后，大大提高了算子的程序并行性和数据局部性，得到的最终在GPU上执行的CUDA kernel如下： +// 引入akg_mma_lib高性能库 +#include ""akg_mma_lib/wmma.hpp"" +extern ""C"" __global__ void conv_tc_auto_float16_32_32_32_64_float16_128_5_5_64_1_1_0_0_0_0_1_1_float16_kernel0( half* __restrict__ input_1, half* __restrict__ input_2, half* __restrict__ out) { + // 缓冲区分配 + akg::wmma::fragment out_local[4]; + half input_2_shared_transfer[32]; + __shared__ half input_2_shared[13056]; + half input_1_shared_transfer[16]; + akg::wmma::fragment input_2_local[2]; + akg::wmma::fragment input_1_local[2]; + #pragma unroll + for (int cc5 = 0; cc5 < 5; ++cc5) { + // 将本次计算要用的数据从全局内存预先加载到共享内存中 + // 用float4指针进行向量化读取 + #pragma unroll + for (int cc7 = 0; cc7 < 4; ++cc7) { + ((float4*)input_2_shared_transfer)[((cc7 * 8) + 0) / 8] = ((float4*)input_2)[(((((cc7 * 51200) + ((((int)threadIdx.x) / 8) * 1600)) + (cc5 * 320)) + ((((int)threadIdx.x) % 8) * 8)) + 0) / 8]; + } + #pragma unroll + for (int cc71 = 0; cc71 < 4; ++cc71) { + ((float4*)input_2_shared)[(((((cc71 * 2176) + ((((int)threadIdx.x) / 128) * 1088)) + ((((int)threadIdx.x) % 8) * 136)) + (((((int)threadIdx.x) % 128) / 8) * 8)) + 0) / 8] = ((float4*)input_2_shared_transfer)[((cc71 * 8) + 0) / 8]; + } + #pragma unroll + for (int cc72 = 0; cc72 < 2; ++cc72) { + ((float4*)input_1_shared_transfer)[((cc72 * 8) + 0) / 8] = ((float4*)input_1)[(((((((cc72 * 1048576) + ((((int)threadIdx.x) / 16) * 65536)) + ((((int)blockIdx.y) / 14) * 2048)) + (cc5 * 2048)) + ((((int)blockIdx.y) % 14) * 128)) + ((((int)threadIdx.x) % 16) * 8)) + 0) / 8]; + } + #pragma unroll + for (int cc73 = 0; cc73 < 2; ++cc73) { + ((float4*)input_2_shared)[(((((cc73 * 2176) + ((((int)threadIdx.x) % 16) * 136)) + ((((int)threadIdx.x) / 16) * 8)) + 0) + 8704) / 8] = ((float4*)input_1_shared_transfer)[((cc73 * 8) + 0) / 8]; + } + __syncthreads(); + #pragma unroll + for (int cc6_outer = 0; cc6_outer < 4; ++cc6_outer) { + // 将下次计算要用的数据从全局内存预先加载到寄存器中 + #pragma unroll + for (int cc74 = 0; cc74 < 4; ++cc74) { + ((float4*)input_2_shared_transfer)[((cc74 * 8) + 0) / 8] = ((float4*)input_2)[(((((((cc74 * 51200) + ((((int)threadIdx.x) / 8) * 1600)) + (cc5 * 320)) + (cc6_outer * 64)) + ((((int)threadIdx.x) % 8) * 8)) + 0) + 64) / 8]; + } + #pragma unroll + for (int cc75 = 0; cc75 < 2; ++cc75) { + ((float4*)input_1_shared_transfer)[((cc75 * 8) + 0) / 8] = ((float4*)input_1)[(((((((((cc75 * 1048576) + ((((int)threadIdx.x) / 16) * 65536)) + ((((int)blockIdx.y) / 14) * 2048)) + (cc5 * 2048)) + ((((int)blockIdx.y) % 14) * 128)) + (cc6_outer * 64)) + ((((int)threadIdx.x) % 16) * 8)) + 0) + 64) / 8]; + } + // 调用高性能接口进行数据搬移、初始化和mma计算 + #pragma unroll + for (int cc11 = 0; cc11 < 8; ++cc11) { + #pragma unroll + for (int cc123 = 0; cc123 < 2; ++cc123) { + (void)akg::wmma::load_matrix_sync(input_2_local[cc123], &(input_2_shared[((((((int)threadIdx.x) / 64) * 2176) + (cc123 * 1088)) + (cc11 * 136))]), 8); + } + #pragma unroll + for (int cc124 = 0; cc124 < 2; ++cc124) { + (void)akg::wmma::load_matrix_sync(input_1_local[cc124], &(input_2_shared[((((((((int)threadIdx.x) % 64) / 32) * 2176) + (cc124 * 1088)) + (cc11 * 136)) + 8704)]), 8); + } + #pragma unroll + for (int cc21 = 0; cc21 < 2; ++cc21) { + #pragma unroll + for (int cc22 = 0; cc22 < 2; ++cc22) { + if (((cc5 == 0) && (cc6_outer == 0)) && (cc11 == 0)) { + (void)akg::wmma::fill_fragment(out_local[((cc21 * 2) + cc22)], 0.000000e+00f); + } + (void)akg::wmma::mma_sync(out_local[((cc21 * 2) + cc22)], input_1_local[cc21], input_2_local[cc22], out_local[((cc21 * 2) + cc22)]); + } + } + } + // 将下次计算要用的数据从寄存器搬到共享内存中 + __syncthreads(); + #pragma unroll + for (int cc76 = 0; cc76 < 4; ++cc76) { + ((float4*)input_2_shared)[(((((cc76 * 2176) + ((((int)threadIdx.x) / 128) * 1088)) + ((((int)threadIdx.x) % 8) * 136)) + (((((int)threadIdx.x) % 128) / 8) * 8)) + 0) / 8] = ((float4*)input_2_shared_transfer)[((cc76 * 8) + 0) / 8]; + } + #pragma unroll + for (int cc77 = 0; cc77 < 2; ++cc77) { + ((float4*)input_2_shared)[(((((cc77 * 2176) + ((((int)threadIdx.x) % 16) * 136)) + ((((int)threadIdx.x) / 16) * 8)) + 0) + 8704) / 8] = ((float4*)input_1_shared_transfer)[((cc77 * 8) + 0) / 8]; + } + __syncthreads(); + } + #pragma unroll + for (int cc111 = 0; cc111 < 8; ++cc111) { + #pragma unroll + for (int cc126 = 0; cc126 < 2; ++cc126) { + (void)akg::wmma::load_matrix_sync(input_2_local[cc126], &(input_2_shared[((((((int)threadIdx.x) / 64) * 2176) + (cc126 * 1088)) + (cc111 * 136))]), 8); + } + #pragma unroll + for (int cc127 = 0; cc127 < 2; ++cc127) { + (void)akg::wmma::load_matrix_sync(input_1_local[cc127], &(input_2_shared[((((((((int)threadIdx.x) % 64) / 32) * 2176) + (cc127 * 1088)) + (cc111 * 136)) + 8704)]), 8); + } + #pragma unroll + for (int cc211 = 0; cc211 < 2; ++cc211) { + #pragma unroll + for (int cc221 = 0; cc221 < 2; ++cc221) { + (void)akg::wmma::mma_sync(out_local[((cc211 * 2) + cc221)], input_1_local[cc211], input_2_local[cc221], out_local[((cc211 * 2) + cc221)]); + } + } + } + __syncthreads(); + } + #pragma unroll + for (int cc4 = 0; cc4 < 2; ++cc4) { + #pragma unroll + for (int cc6 = 0; cc6 < 2; ++cc6) { + (void)akg::wmma::store_matrix_sync(&(input_2_shared[((((((((int)threadIdx.x) % 64) / 32) * 4352) + (cc4 * 136)) + ((((int)threadIdx.x) / 64) * 32)) + (cc6 * 16))]), out_local[((cc4 * 2) + cc6)], 272, nvcuda::wmma::mem_row_major); + } + } + // 将计算结果搬出到全局内存的输出缓冲区 + __syncthreads(); + #pragma unroll + for (int cc41 = 0; cc41 < 4; ++cc41) { + ((float4*)out)[(((((cc41 * 802816) + ((((int)threadIdx.x) / 32) * 100352)) + (((int)blockIdx.y) * 256)) + ((((int)threadIdx.x) % 32) * 8)) + 0) / 8] = ((float4*)input_2_shared)[((((cc41 * 2176) + ((((int)threadIdx.x) / 16) * 136)) + ((((int)threadIdx.x) % 16) * 8)) + 0) / 8]; + } + __syncthreads(); +} + + + + +MindSpore AKG支持规约、矩阵乘和卷积等算子的前向、后向融合场景的生成，保证融合算子性能的同时节省算子间的I/O和内存消耗。 + +",图算融合加速引擎介绍,MindSpore、MindSpore、并行、算子、接口、MindSpore AKG、Auto-Tiling、Auto-Mapping、Davinci、GPU、CPU、Ascend、数据类型、语句、网络、Model、精度、数据、精度、优化、框架、性能、CUDA、ib、npu +使能图算融合§概述,https://www.mindspore.cn/docs/zh-CN/r1.7/design/enable_graph_kernel_fusion.html," +图算融合是MindSpore特有的网络性能优化技术。它可以通过自动分析和优化现有网络计算图逻辑，并结合目标硬件能力，对计算图进行计算化简和替代、算子拆分和融合、算子特例化编译等优化，以提升设备计算资源利用率，实现对网络性能的整体优化。相比传统优化技术，图算融合具有多算子跨边界联合优化、与MindSpore AKG（基于Polyhedral的算子编译器）跨层协同、即时编译等独特优势。另外，图算融合只需要用户打开对应配置后，整个优化过程即可自动完成，不需要网络开发人员进行其它额外感知，使得用户可以聚焦网络算法实现。 + +MindSpore默认自动安装MindSpore AKG。对于CPU后端并且通过源码安装的MindSpore，需确保已正确安装llvm 12.0.1版本。 + +图算融合的适用场景包括： + +对网络执行时间具有较高性能要求的场景； +通过拼接基本算子实现自定义组合算子，并希望对这些基本算子进行自动融合，以提升自定义组合算子性能的场景。 + +",使能图算融合,MindSpore、MindSpore、算子、MindSpore AKG、CPU、网络、计算图、优化、性能 +使能图算融合§使用方法,https://www.mindspore.cn/docs/zh-CN/r1.7/design/enable_graph_kernel_fusion.html," +当前图算融合优化默认关闭状态，我们只需在训练脚本中为context指定参数enable_graph_kernel=True即可启用图算融合： +from mindspore import context +context.set_context(enable_graph_kernel=True) + + + + +图算融合优化只支持Graph模式。 +对于CPU平台，图算融合采用了OpenMP并行计算技术进行算子性能加速。为了获取更好的执行性能，建议配置OMP_NUM_THREADS环境变量以指定OpenMP并行线程数。推荐配置为小于等于当前CPU核数的正整数，如：export OMP_NUM_THREADS=10 + + + +样例脚本 +为了说明图算融合优化场景，我们构造了一个简单网络MyNet, 包含一个乘法和加法计算。在打开图算融合进行优化之后，这两个计算便会自动合成一个融合算子: +import numpy as np +import mindspore.context as context +from mindspore import Tensor +from mindspore.nn import Cell +import mindspore.ops as ops + +context.set_context(mode=context.GRAPH_MODE, device_target=""GPU"") +# save graph ir to view fusion detail. +context.set_context(save_graphs=True) +# enable graph kernel optimization. +context.set_context(enable_graph_kernel=True) + +class MyNet(Cell): + def __init__(self): + super(MyNet, self).__init__() + self.add = ops.Add() + self.mul = ops.Mul() + + def construct(self, x): + a = self.mul(x, 2.0) + res = self.add(a, 1.0) + return res + +x = np.ones((4, 4)).astype(np.float32) * 0.5 +net = MyNet() +result = net(Tensor(x)) +print(""result: {}"".format(result)) + + +输出结果： +result: [[2. 2. 2. 2.] + [2. 2. 2. 2.] + [2. 2. 2. 2.] + [2. 2. 2. 2.]] + + +该计算图的融合结果如图1所示，其中左图为未使能图算融合时的对应计算图，右图为使能图算融合后的对应计算图。可以看到该网络中的加法和乘法被融合成一个算子。该融合过程可以通过查看中间IR，或者通过Profiling等工具跟踪算子执行过程进行验证。 + +图1：图算融合优化计算图 + +",使能图算融合,mindspore、mindspore、并行、算子、样例脚本、GPU、CPU、网络、ast、计算图、优化、脚本、Profiling、性能、graph +使能图算融合§自定义组合算子,https://www.mindspore.cn/docs/zh-CN/r1.7/design/enable_graph_kernel_fusion.html," +基于图算融合技术，用户可以很方便地实现高性能的自定义组合算子。其主要流程为： + +在脚本中用基本算子组合的方式实现自定义算子定义和使用； +打开图算融合配置； +图算融合对自定义组合算子中的基本算子自动进行算子融合，并生成高性能融合算子。 + +相比其它自定义算子方式，这种方式具有对框架无侵入、简单易用等优点。 + +样例脚本 +我们构造一个简单网络MyNet，并在其中使用了自定义算子MyOp。代码样例如下: +import numpy as np +import mindspore.context as context +from mindspore import Tensor +from mindspore.nn import Cell +import mindspore.ops as ops + +context.set_context(mode=context.GRAPH_MODE, device_target=""GPU"") +# enable graph kernel optimization. +context.set_context(enable_graph_kernel=True) + +class MyOp(Cell): + """""" my first custom OP composited by basic OPs """""" + def __init__(self): + super(MyOp, self).__init__() + self.sub = ops.Sub() + self.mul = ops.Mul() + + def construct(self, x, y): + a = self.sub(x, y) + return self.mul(a, x) + +class MyNet(Cell): + def __init__(self): + super(MyNet, self).__init__() + self.mul = ops.Mul() + self.pow = ops.Pow() + self.my_op = MyOp() + + def construct(self, x, y): + a = self.mul(x, 2.0) + b = self.pow(a, 3.0) + res = self.my_op(b, y) + return res + +x = np.ones((4, 4)).astype(np.float32) * 0.2 +y = np.ones((4, 4)).astype(np.float32) * 0.3 +net = MyNet() +result = net(Tensor(x), Tensor(y)) +print(""result: {}"".format(result)) + + +输出结果： +result: [[-0.015104 -0.015104 -0.015104 -0.015104] + [-0.015104 -0.015104 -0.015104 -0.015104] + [-0.015104 -0.015104 -0.015104 -0.015104] + [-0.015104 -0.015104 -0.015104 -0.015104]] + + +该计算图的融合结果如图2所示，其中左图为未使能图算融合时的对应计算图，右图为使能图算融合后的对应计算图。可以看到不仅自定义算子MyOp中的基本算子进行了融合，并且与主图中的其他算子也进行了更大范围融合。该融合过程可以通过查看中间IR，或者通过Profiling等工具跟踪算子执行过程进行验证。 + +图2：自定义组合算子优化计算图 + +",使能图算融合,mindspore、mindspore、算子、样例脚本、GPU、网络、ast、计算图、优化、脚本、Profiling、框架、性能、GRAPH +二阶优化器thor介绍§二阶优化器thor介绍,https://www.mindspore.cn/docs/zh-CN/r1.7/design/thor.html," + +深度学习训练过程可以看成损失函数损失值下降过程，合适的优化器可以让深度学习训练时间大大减少。优化器可以分为一阶优化器和二阶优化器，目前业界主流使用的仍然是一阶优化器，二阶优化器因为单步训练时间过久而没有被广泛应用，而近年来，将二阶优化应用到深度学习训练中有了理论突破，并取得了不错的结果。 +本文会介绍下优化器的背景，以及MindSpore团队自研二阶优化器THOR。 + +",二阶优化器THOR介绍,MindSpore、MindSpore、优化器、损失函数、优化 +二阶优化器thor介绍§优化器背景介绍,https://www.mindspore.cn/docs/zh-CN/r1.7/design/thor.html," +假设训练样本数据集：\(D = {(x_1,y_1),...,(x_i,y_i),...,(x_N,y_N)},x_i \in X,y_i\in Y\)，参数θ表述的深度神经网络模型为： \(\hat{y} = f(x;\theta),x\in{X}\)， 定义在模型输出和真实标签y之间的损失函数为：\(L(y,\hat y),y \in Y\)， 网络参数学习的过程是最小化损失函数的过程：\(\min\limits_{\theta}L(y,\hat{y})\)。给定数据集、模型、损失函数后，深度学习训练问题归结为优化问题，深度神经网络训练优化问题参数规模巨大，需要大量的计算，难以计算出解析解。因此该过程也常常被比喻成下山，如图1 所示，一个人站在山顶的时候如何在有限视距内寻找最快路径下山呢？ + +图1 深度学习训练过程模拟 +而优化器就是在做这件事情，业界的优化算法可分为一阶优化算法和二阶优化算法。下面简单介绍下业界的优化器情况。 + +一阶优化器 +梯度下降算法（Gradient Descent, GD）是机器学习中最经典的一阶优化算法，也是众多机器学习算法中最常用的优化算法。常用的一阶优化算法（比如SGD算法）中对参数的更新采用如下规则：\(\theta = \theta -\eta \nabla L_\theta\)，其中\(\theta\)是需要更新的参数，\(\eta\)是学习率，\(\nabla L_\theta\)是损失函数对于参数的梯度。 +但是主流随机梯度下降方法有以下问题：太小的学习率会导致网络收敛过于缓慢；学习率太高可能会影响收敛，并导致损失函数在最小值上波动，甚至出现发散，对参数比较敏感；容易收敛到局部最优，难以跳出鞍点。 +因此业界提出了很多随机梯度下降方法的改良算法，例如Momentum、Nesterov、AdaGrad、RMSprop、Adadelta和Adam等。这些改进后的优化算法可以利用随机梯度的历史信息来自适应地更新步长，使得它们更容易调参，而且方便使用。 + + +二阶优化器 +二阶优化算法利用目标函数的二阶导数进行曲率校正来加速一阶梯度下降。与一阶优化器相比，其收敛速度更快，能高度逼近最优值，几何上下降路径也更符合真实的最优下降路径。 +例如，二阶优化算法中的牛顿法就是用一个二次曲面去拟合你当前所处位置的局部曲面，而梯度下降法是用一个平面去拟合当前的局部曲面，通常情况下，二次曲面的拟合会比平面更好，所以牛顿法选择的下降路径会更符合真实的最优下降路径。如图2 所示，左边下降路径表示牛顿法的下降曲线，右边表示一阶梯度的下降曲线，二阶算法与一阶算法先比，可以更快的走到目的地，从而加速收敛。 + +图2 不同优化器下降路径 +从数学公式上来看，与一阶优化算法相比，二阶优化算法则是先将\(\nabla L_{\theta}\)与一个矩阵\(G^{-1}\)相乘，产生如下的更新规则：\(\theta = \theta -\eta G^{-1}\nabla L_{\theta}\)，其中G即为二阶信息矩阵，不同的二阶优化算法中的G定义是不同的，常见的二阶优化算法有牛顿法，自然梯度法等，分别对应的二阶信息矩阵G为海森矩阵，费雪矩阵。 +牛顿法有着很好的局部收敛性质，当函数L在最优值点\(\theta^{*}\)点满足\(\nabla L_{\theta^{*}}=0,\nabla^{2} L_{\theta^{*}}\)是正定矩阵, 且海森矩阵在极值点附近是李普希兹连续时，牛顿法二次收敛到最优值点。 海森矩阵是一个由多变量实值函数的所有二阶偏导数组成的方块矩阵。海森矩阵可以表示为：\(H_{ij} = \frac{\partial^2L}{\partial \theta_i \partial \theta_j}\)，其中L即为损失函数，\(\theta\)是需要更新的参数。 +在SGD中，参数空间和函数空间的度量用的都是欧式距离，但欧式距离在一些情况下不能作为函数空间准确的距离度量。例如神经网络中，参数引起的目标函数变化是概率的变化，这并不适合在欧几里得空间度量，它不是概率属性变化的合理表征。KL散度是分布之间距离的合理度量。当使用KL散度作为概率分布之间距离的度量时。此时参数更新时，用到的梯度就是自然梯度。自然梯度法中的费雪矩阵可以表示为：\(F=\mathrm{E}[\frac{\partial \mathrm {log} p(y|x,\theta)}{\partial \theta}{\frac{\partial \mathrm {log} p(y|x,\theta)}{\partial \theta}}^T]\)，其中P(y|x,θ)是网络模型的预测分布，p(y|x,θ)是其概率密度，θ是需要网络模型的参数。 +二阶优化算法虽然收敛速度快，但是计算二阶矩阵的逆的时间复杂度为\(\mathrm O(n^3)\)，当模型参数量为\(n_\theta\)时，对应的二阶信息矩阵的大小为\(n_\theta \times n_\theta\)。在深度学习模型中，\(n_\theta\)常常在数百万的量级，此时二阶信息矩阵的逆无法计算。因此如何降低二阶信息矩阵求逆的计算复杂度成为关键问题。接下来介绍下深度学习中的二阶优化器。 + +",二阶优化器THOR介绍,优化器、数据集、损失函数、网络、SGD、学习率、数据、优化 +二阶优化器thor介绍§THOR的介绍,https://www.mindspore.cn/docs/zh-CN/r1.7/design/thor.html," +当前业界已有的二阶优化算法计算量较大，与一阶相比优势不明显或者使用场景较为单一。MindSpore提出了自研算法THOR(Trace-based Hardware-driven layer-ORiented Natural Gradient Descent Computation)， +算法已被AAAI录用，THOR在多个场景中均有明显收益，如在BERT和ResNet50中，收敛速度均有明显优势。THOR主要做了以下两点创新： + +降低二阶信息矩阵更新频率 +通过实验观察费雪矩阵的F范数（Frobenius norm）在前期变化剧烈，后期逐渐变稳定，从而假设\(\Big\{{F^k}\Big\}^{n}_{k=1}\)是一个马尔可夫过程，可以收敛到一个稳态分布π，其中\(F^k\)代表第k个迭代时的费雪矩阵。因此，在训练过程中逐步增大费雪矩阵的更新间隔，可以在不影响收敛速度的情况下，减少训练时间。例如在ResNet50中，更新间隔步数随着训练的进行越来越大，到后期每个epoch只需更新一次二阶信息矩阵。 +THOR受KFAC启发，将费雪矩阵按层解耦来降低矩阵复杂度，分别针对每一层的费雪矩阵做实验，发现有些层的费雪矩阵趋于稳态的速度更快，因此在统一的更新间隔上，更加细粒度的去调整每一层的更新频率。THOR使用矩阵的迹作为判断条件，当迹的变化情况大于某一阈值时更新该层的二阶信息矩阵，否则沿用上一个迭代的二阶信息矩阵，并且引入了停止更新机制，当迹的变化量小于某个阈值时停止更新该层二阶信息矩阵，具体更新公式如下： + +\[\begin{split} +\begin{cases} +update\ F^{k}_{i} , \qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\qquad\quad\ \ if \ \Delta^{k} \in (\omega_{1},+\infty)\\ +do\ not\ update\ F^{k}_{i}\ and\ set \ F^{k}_{i}=F^{k-1}_{i}, \ \quad\qquad\qquad\qquad\quad if \ \Delta^{k} \in [\omega_{2},\omega_{1}]\\ +stop\ update\ F^{k}_{i}\ and\ set \ F^{k+t}_{t}\equiv F^{k-1}_{i}\ for\ all\ t=1,2,...\quad if \ \Delta^{k} \in [0,\omega_{2}) +\end{cases} +\end{split}\] +其中： + +\[\Delta^k=\frac{||tr(F^k_i+\lambda I)|-|tr(F^{k-1}_i+\lambda I)||}{|tr(F^{k-1}_i+\lambda I)|}\] + + +硬件感知矩阵切分 +THOR在将费雪矩阵按层解耦的基础上，进一步假设每个网络层中的输入和输出块之间也是独立的，例如将每层网络的输入输出切分为n个块，这n个块之间即是独立的，根据该假设对二阶信息矩阵做进一步的切分，从而提高了计算效率。THOR结合矩阵信息损失数据和矩阵性能数据确定了矩阵分块维度，从而大大提升费雪矩阵求逆时间。 +那么如何确定矩阵分块维度的呢。具体方法为： +（1）根据费雪矩阵中维度最大的那一层，确定矩阵切分维度，拿ResNet50举例，网络层中的最大维度为2048，确定矩阵切分维度为[1,16,32,64,128,256,512,1024,2048]。 +（2）根据确定的矩阵维度，根据谱范数计算每个维度下的矩阵损失，具体公式为： + +\[L=1-\sqrt{\frac{\lambda_{max}\ \ (\hat{A}\hat{A}^T)}{\lambda_{max}\ \ (AA^T)}}\] +其中\(\lambda_{max}(X)\)表示矩阵\(X\)的最大特征值，\(A\)表示原始未分割矩阵， \(\hat A\)表示分割后的矩阵。然后统计在该维度下损失小于1%的矩阵数量，最后通过除以总的矩阵数量得到标准化后的矩阵损失信息。 +（3）根据确定的矩阵维度，计算每个维度下的矩阵求逆时间，再通过公式\(normalized_n = \frac{p_1}{p_n}\)得到每个维度下标准化后性能数据，其中\(p_1\)表示维度最小的矩阵的性能数据，\(p_n\)表示第n个维度下的性能数据。 +（4）根据标注化后的矩阵损失信息和标准化后的性能数据绘图，如以ResNet50为例，如图3所示，图中下降曲线为性能曲线，上升曲线表示矩阵损失曲线，图中交叉点为106，与128最接近，最后确定矩阵切分维度为128。 + +图3 切分维度确定示意图 + + +实验结果 +图4展示了THOR在ResNet50+ImageNet，batchsize为256时一二阶上的训练曲线图，其中train loss表示训练误差，test accuracy表示测试精度，epoch表示迭代数，wall-clock time表示时，其中下降较快的曲线和上升较快的曲线是本算法曲线，另外差距较明显的曲线是momentum的训练曲线。 + +图4 THOR在ResNet50上的实验结果 +图4中的THOR，THOR_stop，THOR_NT分别表示(\(w_1\),\(w_2\))=(0.01,0)，(\(w_1\),\(w_2\))=(0.01,0.001)，(\(w_1\),\(w_2\))=(0,0)，从图中可以看到THOR收敛所需迭代数大约是一阶的一半，且单step的时间与一阶相差也不大。相比一阶算法需要117min，二阶优化器端到端时间提速约40%。 +THOR还测试了在不同batchsize下ResNet50+ImageNet的收敛结果，结果见下图5，其中Hardware表示硬件平台，Software是指使用的深度学习框架，Batch size是每次训练的图片数量，Optimizer表示使用的优化器，Time指总体训练时间，Accuracy是指最后收敛精度。当batchsize为8192，使用256块Ascend 910时，只需2.7分钟精度即可收敛到75.9%。 + +图5 大batchsize下THOR在ResNet50上的实验结果 +在BERT+WIkipedia中，THOR也有不错的表现效果，以MLPerf为标准，精度达到71.2%，与一阶相比端到端提升30%，实验结果见图6，图中横坐标表示训练时间，纵坐标表示测试精度，上升较快的曲线是THOR的训练曲线，另一条为Lamb的训练曲线。 + +图6 THOR在BERT上的实验结果 + +",二阶优化器THOR介绍,MindSpore、MindSpore、优化器、Optimizer、Ascend、网络、loss、精度、数据、精度、优化、迭代、框架、性能 +在resnet-50网络上应用二阶优化实践§概述,https://www.mindspore.cn/docs/zh-CN/r1.7/design/cv_resnet50_second_order_optimizer.html," +常见的优化算法可分为一阶优化算法和二阶优化算法。经典的一阶优化算法如SGD等，计算量小、计算速度快，但是收敛的速度慢，所需的迭代次数多。而二阶优化算法使用目标函数的二阶导数来加速收敛，能更快地收敛到模型最优值，所需要的迭代次数少，但由于二阶优化算法过高的计算成本，导致其总体执行时间仍然慢于一阶，故目前在深度神经网络训练中二阶优化算法的应用并不普遍。二阶优化算法的主要计算成本在于二阶信息矩阵（Hessian矩阵、FIM矩阵等）的求逆运算，时间复杂度约为\(O(n^3)\)。 +MindSpore开发团队在现有的自然梯度算法的基础上，对FIM矩阵采用近似、切分等优化加速手段，极大的降低了逆矩阵的计算复杂度，开发出了可用的二阶优化器THOR。使用8块Ascend 910 AI处理器，THOR可以在72min内完成ResNet50-v1.5网络和ImageNet数据集的训练，相比于SGD+Momentum速度提升了近一倍。 +本篇教程将主要介绍如何在Ascend 910 以及GPU上，使用MindSpore提供的二阶优化器THOR训练ResNet50-v1.5网络和ImageNet数据集。 + +你可以在这里下载完整的示例代码： +https://gitee.com/mindspore/models/tree/r1.7/official/cv/resnet 。 + +示例代码目录结构 +├── resnet + ├── README.md + ├── scripts + ├── run_distribute_train.sh # launch distributed training for Ascend 910 + ├── run_eval.sh # launch inference for Ascend 910 + ├── run_distribute_train_gpu.sh # launch distributed training for GPU + ├── run_eval_gpu.sh # launch inference for GPU + ├── src + ├── dataset.py # data preprocessing + ├── CrossEntropySmooth.py # CrossEntropy loss function + ├── lr_generator.py # generate learning rate for every step + ├── resnet.py # ResNet50 backbone + ├── model_utils + ├── config.py # parameter configuration + ├── eval.py # infer script + ├── train.py # train script + + +整体执行流程如下： + +准备ImageNet数据集，处理需要的数据集； +定义ResNet50网络； +定义损失函数和THOR优化器； +加载数据集并进行训练，训练完成后，查看结果及保存模型文件； +加载保存的模型，进行推理。 + +",在ResNet-50网络上应用二阶优化实践,MindSpore、MindSpore、优化器、数据集、损失函数、GPU、Ascend、网络、model、SGD、loss、lr、数据、优化、迭代、dataset、eval、ib、roce +在resnet-50网络上应用二阶优化实践§准备环节,https://www.mindspore.cn/docs/zh-CN/r1.7/design/cv_resnet50_second_order_optimizer.html," +实践前，确保已经正确安装MindSpore。如果没有，可以通过MindSpore安装页面安装MindSpore。 + +准备数据集 +下载完整的ImageNet2012数据集，将数据集解压分别存放到本地工作区的ImageNet2012/ilsvrc、ImageNet2012/ilsvrc_eval路径下。 +目录结构如下： +└─ImageNet2012 + ├─ilsvrc + │ n03676483 + │ n04067472 + │ n01622779 + │ ...... + └─ilsvrc_eval + │ n03018349 + │ n02504013 + │ n07871810 + │ ...... + + + + +配置分布式环境变量 + +Ascend 910 +Ascend 910 AI处理器的分布式环境变量配置参考分布式并行训练 (Ascend)。 + + +GPU +GPU的分布式环境配置参考分布式并行训练 (GPU)。 + + +",在ResNet-50网络上应用二阶优化实践,MindSpore、MindSpore、并行、分布式、数据集、GPU、Ascend、网络、数据、优化、eval +在resnet-50网络上应用二阶优化实践§加载处理数据集,https://www.mindspore.cn/docs/zh-CN/r1.7/design/cv_resnet50_second_order_optimizer.html," +分布式训练时，通过并行的方式加载数据集，同时通过MindSpore提供的数据增强接口对数据集进行处理。加载处理数据集的脚本在源码的src/dataset.py脚本中。 +import os +from mindspore import dtype as mstype +import mindspore.dataset as ds +import mindspore.dataset.vision.c_transforms as C +import mindspore.dataset.transforms.c_transforms as C2 +from mindspore.communication import init, get_rank, get_group_size + + +def create_dataset2(dataset_path, do_train, repeat_num=1, batch_size=32, target=""Ascend"", distribute=False, + enable_cache=False, cache_session_id=None): + """""" + Create a training or evaluation ImageNet2012 dataset for ResNet50. + + Args: + dataset_path(string): the path of dataset. + do_train(bool): whether the dataset is used for training or evaluation. + repeat_num(int): the repeat times of dataset. Default: 1 + batch_size(int): the batch size of dataset. Default: 32 + target(str): the device target. Default: Ascend + distribute(bool): data for distribute or not. Default: False + enable_cache(bool): whether tensor caching service is used for evaluation. Default: False + cache_session_id(int): if enable_cache is set, cache session_id need to be provided. Default: None + + Returns: + dataset + """""" + if target == ""Ascend"": + device_num, rank_id = _get_rank_info() + else: + if distribute: + init() + rank_id = get_rank() + device_num = get_group_size() + else: + device_num = 1 + + if device_num == 1: + data_set = ds.ImageFolderDataset(dataset_path, num_parallel_workers=8, shuffle=True) + else: + data_set = ds.ImageFolderDataset(dataset_path, num_parallel_workers=8, shuffle=True, + num_shards=device_num, shard_id=rank_id) + + image_size = 224 + mean = [0.485 * 255, 0.456 * 255, 0.406 * 255] + std = [0.229 * 255, 0.224 * 255, 0.225 * 255] + + # define map operations + if do_train: + trans = [ + C.RandomCropDecodeResize(image_size, scale=(0.08, 1.0), ratio=(0.75, 1.333)), + C.RandomHorizontalFlip(prob=0.5), + C.Normalize(mean=mean, std=std), + C.HWC2CHW() + ] + else: + trans = [ + C.Decode(), + C.Resize(256), + C.CenterCrop(image_size), + C.Normalize(mean=mean, std=std), + C.HWC2CHW() + ] + + type_cast_op = C2.TypeCast(mstype.int32) + + data_set = data_set.map(operations=trans, input_columns=""image"", num_parallel_workers=8) + # only enable cache for eval + if do_train: + enable_cache = False + if enable_cache: + if not cache_session_id: + raise ValueError(""A cache session_id must be provided to use cache."") + eval_cache = ds.DatasetCache(session_id=int(cache_session_id), size=0) + data_set = data_set.map(operations=type_cast_op, input_columns=""label"", num_parallel_workers=8, + cache=eval_cache) + else: + data_set = data_set.map(operations=type_cast_op, input_columns=""label"", num_parallel_workers=8) + + # apply batch operations + data_set = data_set.batch(batch_size, drop_remainder=True) + + # apply dataset repeat operation + data_set = data_set.repeat(repeat_num) + + return data_set + + + +MindSpore支持进行多种数据处理和增强的操作，各种操作往往组合使用，具体可以参考数据处理和数据增强章节。 + +",在ResNet-50网络上应用二阶优化实践,MindSpore、MindSpore、并行、分布式、接口、数据集、Ascend、网络、ast、数据、优化、脚本、dataset、eval、ib、npu +在resnet-50网络上应用二阶优化实践§定义网络,https://www.mindspore.cn/docs/zh-CN/r1.7/design/cv_resnet50_second_order_optimizer.html," +本示例中使用的网络模型为ResNet50-v1.5，定义ResNet50网络。 +网络构建完成以后，在__main__函数中调用定义好的ResNet50： +... +from src.resnet import resnet50 as resnet +... +if __name__ == ""__main__"": + ... + # define net + net = resnet(class_num=config.class_num) + ... + + +",在ResNet-50网络上应用二阶优化实践,网络、优化 +在resnet-50网络上应用二阶优化实践§定义损失函数及THOR优化器,https://www.mindspore.cn/docs/zh-CN/r1.7/design/cv_resnet50_second_order_optimizer.html," + +定义损失函数 +MindSpore支持的损失函数有SoftmaxCrossEntropyWithLogits、L1Loss、MSELoss等。THOR优化器需要使用SoftmaxCrossEntropyWithLogits损失函数。 +损失函数的实现步骤在src/CrossEntropySmooth.py脚本中。这里使用了深度网络模型训练中的一个常用trick：label smoothing，通过对真实标签做平滑处理，提高模型对分类错误标签的容忍度，从而可以增加模型的泛化能力。 +class CrossEntropySmooth(LossBase): + """"""CrossEntropy"""""" + def __init__(self, sparse=True, reduction='mean', smooth_factor=0., num_classes=1000): + super(CrossEntropySmooth, self).__init__() + self.onehot = ops.OneHot() + self.sparse = sparse + self.on_value = Tensor(1.0 - smooth_factor, mstype.float32) + self.off_value = Tensor(1.0 * smooth_factor / (num_classes - 1), mstype.float32) + self.ce = nn.SoftmaxCrossEntropyWithLogits(reduction=reduction) + + def construct(self, logit, label): + if self.sparse: + label = self.onehot(label, ops.shape(logit)[1], self.on_value, self.off_value) + loss = self.ce(logit, label) + return loss + + +在__main__函数中调用定义好的损失函数： +... +from src.CrossEntropySmooth import CrossEntropySmooth +... +if __name__ == ""__main__"": + ... + # define the loss function + if not config.use_label_smooth: + config.label_smooth_factor = 0.0 + loss = CrossEntropySmooth(sparse=True, reduction=""mean"", + smooth_factor=config.label_smooth_factor, num_classes=config.class_num) + ... + + + + +定义优化器 +THOR优化器的参数更新公式如下： + +\[ \theta^{t+1} = \theta^t + \alpha F^{-1}\nabla E\] +参数更新公式中各参数的含义如下： + +\(\theta\)：网络中的可训参数； +\(t\)：迭代次数； +\(\alpha\)：学习率值，参数的更新步长； +\(F^{-1}\)：FIM矩阵，在网络中计算获得； +\(\nabla E\)：一阶梯度值。 + +从参数更新公式中可以看出，THOR优化器需要额外计算的是每一层的FIM矩阵。FIM矩阵可以对每一层参数更新的步长和方向进行自适应的调整，加速收敛的同时可以降低调参的复杂度。 +更多THOR优化器的介绍请参考：THOR论文 +在调用MindSpore封装的二阶优化器THOR时，优化器会自动调用转换接口，把之前定义好的ResNet50网络中的Conv2d层和Dense层分别转换成对应的Conv2dThor和DenseThor。 +而在Conv2dThor和DenseThor中可以完成二阶信息矩阵的计算和存储。 + +THOR优化器转换前后的网络backbone一致，网络参数保持不变。 + +在训练主脚本中调用THOR优化器： +... +from mindspore.nn import thor +... +if __name__ == ""__main__"": + ... + # learning rate setting and damping setting + from src.lr_generator import get_thor_lr, get_thor_damping + lr = get_thor_lr(0, config.lr_init, config.lr_decay, config.lr_end_epoch, step_size, decay_epochs=39) + damping = get_thor_damping(0, config.damping_init, config.damping_decay, 70, step_size) + # define the optimizer + split_indices = [26, 53] + opt = thor(net, Tensor(lr), Tensor(damping), config.momentum, config.weight_decay, config.loss_scale, + config.batch_size, split_indices=split_indices, frequency=config.frequency) + ... + + + +",在ResNet-50网络上应用二阶优化实践,MindSpore、MindSpore、优化器、接口、损失函数、optimizer、网络、Loss、lr、学习率、优化、迭代、脚本 +在resnet-50网络上应用二阶优化实践§训练网络,https://www.mindspore.cn/docs/zh-CN/r1.7/design/cv_resnet50_second_order_optimizer.html," + +配置模型保存 +MindSpore提供了callback机制，可以在训练过程中执行自定义逻辑，这里使用框架提供的ModelCheckpoint函数。 +ModelCheckpoint可以保存网络模型和参数，以便进行后续的fine-tuning操作。 +TimeMonitor、LossMonitor是MindSpore官方提供的callback函数，可以分别用于监控训练过程中单步迭代时间和loss值的变化。 +... +from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor +... +if __name__ == ""__main__"": + ... + # define callbacks + time_cb = TimeMonitor(data_size=step_size) + loss_cb = LossMonitor() + cb = [time_cb, loss_cb] + if config.save_checkpoint: + config_ck = CheckpointConfig(save_checkpoint_steps=config.save_checkpoint_epochs * step_size, + keep_checkpoint_max=config.keep_checkpoint_max) + ckpt_cb = ModelCheckpoint(prefix=""resnet"", directory=ckpt_save_dir, config=config_ck) + cb += [ckpt_cb] + ... + + + + +配置训练网络 +通过MindSpore提供的model.train接口可以方便地进行网络的训练。THOR优化器通过降低二阶矩阵更新频率，来减少计算量，提升计算速度，故重新定义一个ModelThor类，继承MindSpore提供的Model类。在ModelThor类中获取THOR的二阶矩阵更新频率控制参数，用户可以通过调整该参数，优化整体的性能。 +MindSpore提供Model类向ModelThor类的一键转换接口。 +... +from mindspore import FixedLossScaleManager +from mindspore import Model +from mindspore.train.train_thor import ConvertModelUtils +... + +if __name__ == ""__main__"": + ... + loss_scale = FixedLossScaleManager(config.loss_scale, drop_overflow_update=False) + model = Model(net, loss_fn=loss, optimizer=opt, loss_scale_manager=loss_scale, metrics=metrics, + amp_level=""O2"", keep_batchnorm_fp32=False, eval_network=dist_eval_network) + if cfg.optimizer == ""Thor"": + model = ConvertModelUtils().convert_to_thor_model(model=model, network=net, loss_fn=loss, optimizer=opt, + loss_scale_manager=loss_scale, metrics={'acc'}, + amp_level=""O2"", keep_batchnorm_fp32=False) + ... + + + + +运行脚本 +训练脚本定义完成之后，调scripts目录下的shell脚本，启动分布式训练进程。 + +Ascend 910 +目前MindSpore分布式在Ascend上执行采用单卡单进程运行方式，即每张卡上运行1个进程，进程数量与使用的卡的数量一致。进程均放在后台执行，每个进程创建1个目录，目录名称为train_parallel+ device_id，用来保存日志信息，算子编译信息以及训练的checkpoint文件。下面以使用8张卡的分布式训练脚本为例，演示如何运行脚本。 +使用以下命令运行脚本： +bash run_distribute_train.sh [CONFIG_PATH] + + +脚本需要传入变量RANK_TABLE_FILE，DATASET_PATH和CONFIG_PATH，其中： + +RANK_TABLE_FILE：组网信息文件的路径。(rank table文件的生成，参考HCCL_TOOL) +DATASET_PATH：训练数据集路径。 +CONFIG_PATH：配置文件路径。 + +其余环境变量请参考安装教程中的配置项。 +训练过程中loss打印示例如下： +... +epoch: 1 step: 5004, loss is 4.4182425 +epoch: 2 step: 5004, loss is 3.740064 +epoch: 3 step: 5004, loss is 4.0546017 +epoch: 4 step: 5004, loss is 3.7598825 +epoch: 5 step: 5004, loss is 3.3744206 +... +epoch: 40 step: 5004, loss is 1.6907625 +epoch: 41 step: 5004, loss is 1.8217756 +epoch: 42 step: 5004, loss is 1.6453942 +... + + +训练完后，每张卡训练产生的checkpoint文件保存在各自训练目录下，device_0产生的checkpoint文件示例如下: +└─train_parallel0 + ├─ckpt_0 + ├─resnet-1_5004.ckpt + ├─resnet-2_5004.ckpt + │ ...... + ├─resnet-42_5004.ckpt + │ ...... + + +其中， +*.ckpt：指保存的模型参数文件。checkpoint文件名称具体含义：网络名称-epoch数_step数.ckpt。 + + +GPU +在GPU硬件平台上，MindSpore采用OpenMPI的mpirun进行分布式训练，进程创建1个目录，目录名称为train_parallel，用来保存日志信息和训练的checkpoint文件。下面以使用8张卡的分布式训练脚本为例，演示如何运行脚本。 +使用以下命令运行脚本： +bash run_distribute_train_gpu.sh + + +脚本需要传入变量DATASET_PATH和CONFIG_PATH，其中： + +DATASET_PATH：训练数据集路径。 +CONFIG_PATH：配置文件路径。 + +在GPU训练时，无需设置DEVICE_ID环境变量，因此在主训练脚本中不需要调用int(os.getenv('DEVICE_ID'))来获取卡的物理序号，同时context中也无需传入device_id。我们需要将device_target设置为GPU，并需要调用init()来使能NCCL。 +训练过程中loss打印示例如下： +... +epoch: 1 step: 5004, loss is 4.2546034 +epoch: 2 step: 5004, loss is 4.0819564 +epoch: 3 step: 5004, loss is 3.7005644 +epoch: 4 step: 5004, loss is 3.2668946 +epoch: 5 step: 5004, loss is 3.023509 +... +epoch: 36 step: 5004, loss is 1.645802 +... + + +训练完后，保存的模型文件示例如下: +└─train_parallel + ├─ckpt_0 + ├─resnet-1_5004.ckpt + ├─resnet-2_5004.ckpt + │ ...... + ├─resnet-36_5004.ckpt + │ ...... + ...... + ├─ckpt_7 + ├─resnet-1_5004.ckpt + ├─resnet-2_5004.ckpt + │ ...... + ├─resnet-36_5004.ckpt + │ ...... + + + + +",在ResNet-50网络上应用二阶优化实践,MindSpore、MindSpore、优化器、分布式、算子、接口、数据集、optimizer、callback、GPU、Ascend、网络、Model、Loss、metric、数据、优化、迭代、脚本、框架、性能、DATASET、eval、OpenMPI、ib +在resnet-50网络上应用二阶优化实践§模型推理,https://www.mindspore.cn/docs/zh-CN/r1.7/design/cv_resnet50_second_order_optimizer.html," +使用训练过程中保存的checkpoint文件进行推理，验证模型的泛化能力。首先通过load_checkpoint接口加载模型文件，然后调用Model的eval接口对输入图片类别作出预测，再与输入图片的真实类别做比较，得出最终的预测精度值。 + +定义推理网络 + +使用load_checkpoint接口加载模型文件。 +使用model.eval接口读入测试数据集，进行推理。 +计算得出预测精度值。 + +... +from mindspore import load_checkpoint, load_param_into_net +... + +if __name__ == ""__main__"": + ... + # define net + net = resnet(class_num=config.class_num) + + # load checkpoint + param_dict = load_checkpoint(args_opt.checkpoint_path) + load_param_into_net(net, param_dict) + net.set_train(False) + + # define loss + if args_opt.dataset == ""imagenet2012"": + if not config.use_label_smooth: + config.label_smooth_factor = 0.0 + loss = CrossEntropySmooth(sparse=True, reduction='mean', + smooth_factor=config.label_smooth_factor, num_classes=config.class_num) + else: + loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean') + + # define model + model = Model(net, loss_fn=loss, metrics={'top_1_accuracy', 'top_5_accuracy'}) + + # eval model + res = model.eval(dataset) + print(""result:"", res, ""ckpt="", args_opt.checkpoint_path) + ... + + + + +执行推理 +推理网络定义完成之后，调用scripts目录下的shell脚本，进行推理。 + +Ascend 910 +在Ascend 910硬件平台上，推理的执行命令如下： +bash run_eval.sh + + +脚本需要传入变量DATASET_PATH，CHECKPOINT_PATH和，其中： + +DATASET_PATH：推理数据集路径。 +CHECKPOINT_PATH：保存的checkpoint路径。 +CONFIG_PATH：配置文件路径。 + +目前推理使用的是单卡（默认device 0）进行推理，推理的结果如下： +result: {'top_5_accuracy': 0.9295574583866837, 'top_1_accuracy': 0.761443661971831} ckpt=train_parallel0/resnet-42_5004.ckpt + + + +top_5_accuracy：对于一个输入图片，如果预测概率排名前五的标签中包含真实标签，即认为分类正确； +top_1_accuracy：对于一个输入图片，如果预测概率最大的标签与真实标签相同，即认为分类正确。 + + + +GPU +在GPU硬件平台上，推理的执行命令如下： + bash run_eval_gpu.sh + + +脚本需要传入变量DATASET_PATH，CHECKPOINT_PATH和，其中： + +DATASET_PATH：推理数据集路径。 +CHECKPOINT_PATH：保存的checkpoint路径。 +CONFIG_PATH：配置文件路径。 + +推理的结果如下： +result: {'top_5_accuracy': 0.9287972151088348, 'top_1_accuracy': 0.7597031049935979} ckpt=train_parallel/resnet-36_5004.ckpt + + + + +",在ResNet-50网络上应用二阶优化实践,mindspore、mindspore、接口、数据集、GPU、Ascend、模型推理、网络、Model、loss、metric、精度、数据、精度、优化、脚本、dataset、eval +训练可视总体设计§训练可视总体设计,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/training_visual_design.html," + +MindInsight是MindSpore的可视化调试调优组件。通过MindInsight可以完成训练可视、性能调优、精度调优等任务。 +训练可视功能主要包括训练看板、模型溯源、数据溯源等功能，训练看板中又包括标量、参数分布图、计算图、数据图、数据抽样、张量等子功能。 +本文主要介绍MindInsight训练可视功能的逻辑架构、代码组织和数据模型。 + +",训练可视总体设计,MindSpore、MindSpore、MindInsight、调试、精度、数据、计算图、精度、可视化、性能 +训练可视总体设计§训练可视逻辑架构,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/training_visual_design.html," +在架构上，训练可视功能的逻辑架构分为两部分：训练信息收集架构，训练信息分析及展示架构。 + +图1 MindInsight训练可视逻辑架构 + +训练信息收集架构 +训练信息收集功能在MindSpore中，包括训练信息收集API模块和训练信息持久化模块。 +训练信息收集API包括： + +基于summary算子的训练信息收集API。这部分API主要包括4个summary算子，即用于记录标量数据的ScalarSummary算子，用于记录图片数据的ImageSummary算子，用于记录参数分布图（直方图）数据的HistogramSummary算子和用于记录张量数据的TensorSummary算子。请访问算子支持列表以获取关于这些算子的信息。 +基于Python API的训练信息收集API。通过SummaryRecord.add_value方法，可以在Python代码中完成训练信息的收集。 +易用的训练信息收集callback。通过SummaryCollector这一callback可以方便地收集常用训练信息到训练日志中。 + +训练信息持久化模块主要包括用于管理缓存的summary_record模块和用于并行处理数据、写入文件的write_pool模块。训练信息持久化后，存储在训练日志文件（summary文件中）。 + + +训练信息分析及展示架构 +训练信息分析及展示架构在MindInsight中，包括Web UI和后端两大部分。后端从下到上可以分为数据加载及缓存层、业务逻辑层、API 层。数据加载及缓存层主要由训练日志文件发现模块、训练日志文件解析模块及缓存管理模块组成。业务逻辑层主要由训练看板业务模块和溯源业务模块组成。API层主要由RESTful API模块组成。各模块的主要功能如下： + +训练日志文件发现模块：用于在给定的训练日志根目录（summary-base-dir）中扫描并发现含有训练日志文件的训练日志目录。只有含有训练日志文件的目录会被识别为训练日志目录。 +训练日志文件解析模块：用于解析训练日志文件。 +缓存管理模块：用于管理训练日志解析任务，缓存训练日志解析结果。其会定期调用训练日志发现模块，扫描最新的训练日志目录列表；然后调用解析模块解析文件内容，将解析结果存储在缓存中以供UI查询。 +训练看板模块：用于提供训练看板功能的业务逻辑，支撑UI查询训练看板数据。 +溯源模块：用于提供模型溯源和数据溯源的业务逻辑，支撑UI查询溯源数据。 +RESTful API模块：用于将业务模块提供的接口包装为RESTful API。 + + +",训练可视总体设计,MindSpore、MindSpore、并行、算子、接口、callback、MindInsight、API、数据 +训练可视总体设计§代码组织,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/training_visual_design.html," +以下是MindInsight代码仓库中的部分重要目录及说明。 + + + +一级目录 +二级目录 +三级目录 +说明 + + + + +build + + +编译、构建相关代码。 + + +mindinsight + + + + + + +backend + +RESTful API。 + + + + +datavisual +训练看板相关RESTful API。 + + + + +lineagemgr +溯源相关RESTful API。 + + + +datavisual + +训练看板模块。当前数据加载及缓存层的代码也在此模块中。 + + + + +data_transform +数据加载及缓存层。 + + + +lineagemgr + +溯源模块。 + + + +ui + +MindInsight Web UI。 + + +tests + + +测试用例目录。 + + + +",训练可视总体设计,MindInsight、API、数据 +训练可视总体设计§训练可视数据模型,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/training_visual_design.html," + +训练信息数据流 +训练信息产生于用户训练的过程中。用户可以通过训练信息收集API将这些训练信息收集起来，并通过训练信息持久化模块将这些训练信息保存到磁盘上，产生训练日志文件（summary文件）。训练日志文件生成后，便可以使用MindInsight对其中的信息进行可视化。 + +图2 训练信息数据流 + + +数据模型 +MindInsight的简要数据模型如图3所示。一个训练日志目录会被MindInsight识别为一个训练作业。训练作业是MindInsight的最小管理单元。一个训练作业可以关联0-1个溯源数据，关联0-1个训练过程数据。训练过程数据内部有着丰富的结构，每一个具体的数据，可以通过给定的插件名称、标签和迭代唯一确定。下面将分别介绍这些概念。 + +图3 以UML类图表示的数据模型 + +训练作业 +MindInsight通过目录来区分不同的训练作业。为了方便用户区分不同训练作业的训练日志文件，SummaryCollector、SummaryRecord都要求用户指定存放训练日志文件的目录。相同目录中的训练日志文件会被认为是同一次训练作业中产生的训练数据，不同目录中的训练日志文件会被认为是不同训练作业中产生的文件。 +在MindInsight的代码中，一次训练一般被称为一个TrainJob。TrainJob的id即该次训练的日志所在目录的目录名（例如 ./train_my_lenet_1）。 +一次训练的过程中，一般会产生该次训练的溯源数据文件（文件名以_lineage结尾）和训练过程数据文件（文件名一般以_MS结尾）。其中溯源数据主要从全局出发描述该次训练的不变性质，例如训练所用的数据集路径、训练所用的优化器、以及用户自定义的溯源信息。这些信息最突出的特点是不会在训练过程中变化。而训练过程数据主要描述该次训练的变化情况，例如loss值、参数分布、一个迭代中送入模型的图片数据等。这些信息最突出的特点是每个迭代都会发生变化。 +需要注意的是，关于训练信息是否发生变化的分类并不是绝对的。比如训练过程数据文件中会含有计算图数据，其一般在训练开始的时候就确定了。 + + +溯源数据 +溯源数据主要从全局出发描述某次训练的不变性质。当MindInsight识别到多个训练日志目录时，这若干次训练的溯源数据会被组织成表格的形式展示，以方便对比和分析。 + + +训练过程数据 + +插件名称（plugin_name） +对于训练过程数据，我们首先将这些训练数据按类型分为标量数据（scalar）、直方图数据（histogram）、图片数据（image）、张量数据（tensor）等类型，这些类型在MindInsight的中被称为插件名称（plugin_name），当前mindinsight支持的插件名称定义在mindinsight.datavisual.common.enums.PluginNameEnum中。 + +标签（tag） +无论数据属于何种类型，其都会依照tag进一步被分为不同的序列。tag一般由用户命名，用于对数据进行区分。比如记录loss值的标量数据，其tag名可以为loss。需要说明的是，MindInsight在对数据进行处理时，会根据插件名称自动为tag附加后缀。例如tag为loss的数据为标量数据，则该tag会被自动重命名为loss/scalar。 + +迭代数（step） +训练过程数据是在训练的每个迭代中产生的，为了区分这些数据，数据会被标记上该数据所对应的迭代数。 + +数据的查询和展示 +在展示数据时，用户常常希望看到某个标签下的数据随着训练过程的变化情况。因此，查询数据时，一般不会指定迭代数，而是直接指定训练作业、插件名称和标签，查询该标签下所有迭代的数据。 + + + + +",训练可视总体设计,优化器、数据集、MindInsight、plugin_name、API、loss、数据、计算图、可视化、优化、迭代 +安全可信总体设计§总体架构,https://www.mindspore.cn/mindarmour/docs/zh-CN/r1.7/design.html," +AI作为一种通用技术，带来巨大机遇和效益的同时也面临着新的安全与隐私保护的挑战。MindArmour关注AI应用场景中常见的安全与隐私问题：AI模型易受对抗样本欺骗、数据采集过程中可能收集到敏感隐私数据、模型使用过程中可能泄露隐私数据、模型资产存在被窃取风险、数据漂移导致模型失效等。并提供相应的安全与隐私保护能力。 +MindArmour总体架构如下图所示，下面介绍主要的三个部分：模型鲁棒性、模型资产安全、隐私保护。 + +模型鲁棒性：MindArmour的模型鲁棒性主要关注AI模型对于自然扰动样本及对抗扰动样本的鲁棒性。涵盖自然扰动样本生成、黑白盒对抗扰动样本生成、对抗样本检测、对抗训练、AI Fuzzer等能力，用于帮助安全工作人员快速高效的对AI模型进行鲁棒性评测、提升模型抗攻击能力。 +模型资产安全：AI模型的结构和权重是关键资产，为防止模型在传输、部署、运行时被敌手窃取，MindArmour提供了基于加密的模型文件保护功能和基于结构参数混淆的轻量级模型保护功能。在联邦学习场景中提供精度无损的安全多方计算能力防止模型窃取。 +隐私泄露度量及保护：在数据采集阶段提供数据脱敏能力，避免采集用户隐私数据；模型训练阶段提供差分隐私、抑制隐私保护机制，减少模型隐私泄露风险；在模型使用阶段提供基于成员推理、逆向攻击的隐私泄露评估技术用于评估模型泄露隐私的风险。 + + +",安全可信总体设计,MindArmour、AI Fuzzer、评估、Arm、精度、数据、精度 +安全可信总体设计§设计思路,https://www.mindspore.cn/mindarmour/docs/zh-CN/r1.7/design.html," + +模型鲁棒性 +主要关注AI模型对于自然扰动样本及对抗扰动样本的鲁棒性。 +自然扰动样本 +模拟现实生活种常见的扰动，例如聚焦模糊、抖动模糊、过曝光、旋转、平移、缩放、错切、透视变换、均匀噪声、自然噪声等。 +对抗样本 +攻击者在原始样本处加入人类不易察觉的微小扰动，导致深度学习模型误判，称为对抗样本攻击。 +MindArmour模型安全提供自然扰动样本生成、对抗样本生成、对抗样本检测、模型防御、攻防效果评估等功能，为AI模型安全研究和AI应用安全提供重要支撑。 + + +扰动样本生成模块：提供10+白盒对抗样本生成方法、5+黑盒对抗样本生成方法，15+自然扰动样本生成方法。支持安全工程师根据不同需求快速高效地生成对抗样本，用于攻击AI模型。 +检测模块：提供5+对抗样本检测方法，判断输入样本是否具有对抗性，在模型推理前识别攻击数据和攻击行为。 +防御模块：提供对抗训练的防御方法，提升模型自身的抗攻击能力。 +评测模块：提供多维度的评价指标全面评估模型鲁棒性。 + + +AI Fuzzer +不同于传统fuzz测试，AI Fuzzer根据神经网络特点，以神经元覆盖率作为测试评价准则。神经元覆盖率，是指通过一组输入观察到的激活神经元数量和神经元输出值的范围。通过神经元覆盖率增益来指导输入变异，让输入能够激活更多的神经元，神经元值的分布范围更广，从而探索不同类型的模型输出结果、错误行为，从而评测模型鲁棒性。 + +AI Fuzzer主要包括三个模块： + +Natural Threat/Adversarial Example Generator（数据变异模块）： +随机选择变异方法对种子数据变异生成多个变种。支持多种样本的变异策略， 包括： + +自然扰动样本生成方法： + + +仿射变换类方法：Translate、Scale、Shear、Rotate、Perspective、Curve； +模糊类方法：GaussianBlur、MotionBlur、GradientBlur； +亮度调整类方法：Contrast、GradientLuminance; +加噪类方法：UniformNoise、GaussianNoise、SaltAndPepperNoise、NaturalNoise。 + + +基于对抗攻击的白盒、黑盒对抗样本生成方法：FGSM（FastGradientSignMethod）、PGD（ProjectedGradientDescent）、MDIIM（MomentumDiverseInputIterativeMethod）。 + + +Fuzzer moduler（变异指导模块）: +对变异生成的数据进行fuzz测试，观察神经元覆盖率的变化情况，如果生成的数据使得神经元覆盖率增加，则加入变异的种子队列，用于下一轮的数据变异。目前支持的神经元覆盖率指标包括NC、TKNC、KMNC、NBC、SNAC。 + +Evaluation（评估模块）： +评估Fuzzer效果，生成数据的质量，变异方法的强度。支持3个类型5种指标，包括准确率、精确率、召回率等通用评价指标，神经元覆盖率指标，对抗攻击成功率指标。 + + + + + +模型资产安全 +深度学习模型具有较高的商业价值和知识属性，为保护模型资产安全，防止模型在传输、部署、运行时被被非法复制、重新分发滥用，MindArmour提供了基于加密的模型文件保护功能和基于结构参数混淆的轻量级模型保护功能。在联邦学习场景中提供精度无损的安全多方计算能力防止模型窃取。 + +模型加密 +为保护模型落盘安全，MindArmour在框架中集成了对ckpt和MINDIR加解密的功能，提供开发者在落盘前完成模型加密以及加载密文模型的能力。用户在训练阶段可以向框架传入加密秘钥和加密模式来启用模型加密功能，生成密文模型。在部署推理服务时向框架传入和加密导出时一致的加密秘钥和模式，启用运行时解密。 + + + +模型混淆 +模型混淆在不改变模型功能的同时，对模型的计算逻辑进行加扰，大大降低模型的可读性，使其逆向成本超过逆向所带来的收益，做到模型可用但不可理解。具有轻量、不依赖于特定硬件等优势。 + + + + +隐私 +保护用户隐私安全是一项重要的企业责任。MindArmour提供AI生命周期的隐私保护能力：数据采集阶段提供数据脱敏能力，避免采集用户隐私数据；模型训练阶段提供差分隐私、抑制隐私保护机制，减少模型隐私泄露风险；在模型使用阶段提供基于成员推理、逆向攻击的隐私泄露评估技术用于评估模型泄露隐私的风险。 + + +数据脱敏 +预定义隐私元素：最常见的场景是对自动驾驶的街景数据进行脱敏，对特定内容进行识别并脱敏，要求结果召回率高，即尽可能打码以防止隐私泄露带来的人工额外操作。 + + +脱敏对象：车牌，特定文字。 +脱敏目标：保护ID隐私；在保证召回率的前提下最大化数据可用性。 +处理过程： + +对预定义细粒度元素所在的粗粒度物体进行检测，并将所在区域进行裁剪保存； +再调用细粒度检测模型进行隐私元素的精准定位，如果粗粒度检测区域未发现隐私元素，为防止漏打码造成隐私泄露，应对粗粒度区域使用兜底策略进行大致定位； +最后汇总得到所有待打码区域及所对应的类别，调用脱敏接口进行个性化脱敏。 + + + + +差分隐私训练 +MindArmour的Differential-Privacy模块实现了差分隐私训练的能力。模型的训练主要由构建训练数据集、计算损失、计算梯度以及更新模型参数等过程组成，目前MindArmour的差分隐私训练主要着力于计算梯度的过程，通过相应的算法对梯度进行裁剪、加噪等处理，从而保护用户数据隐私。 + + +差分隐私优化器：差分隐私优化器继承了MindSpore优化器的能力，并使用差分隐私的噪声机制对梯度加扰保护。目前，MindArmour提供三类差分隐私优化器：固定高斯优化器、自适应高斯优化器、自适应裁剪优化器，每类差分隐私优化器从不同的角度为SGD、Momentum等常规优化器增加差分隐私保护的能力。 +噪声机制：噪声机制是构建差分隐私训练能力的基础，不同的噪声机制满足不同差分隐私优化器的需求，包括固定高斯分布噪声、自适应高斯分布噪声、自适应裁剪高斯分布噪声、拉普拉斯分布噪声等多种机制。 +检测器：Monitor提供RDP、ZCDP等回调函数，用于监测模型的差分隐私预算。 + + + +隐私泄露评估 +MindArmour提供基于成员推理攻击、模型逆向攻击等算法，评估模型隐私泄漏的风险。 + +成员推理：指攻击者拥有模型的部分访问权限(黑盒、灰盒或白盒)，能够获取到模型的输出、结构或参数等部分或全部信息，并基于这些信息推断某个样本是否属于模型的训练集。利用成员推理，我们可以评估机器学习/深度学习模型的隐私数据安全。 +逆向攻击：指攻击者利用模型梯度逆向推理用户数据。攻击者先随机生成一对输入数据和标签，导出虚拟梯度，在优化过程中更新输入数据和标签，减小虚拟梯度与真实梯度的差异，从而获得隐私输入数据。利用逆向攻击，我们可以评估深度学习模型泄露训练数据的风险。 + + + +",安全可信总体设计,MindSpore、MindSpore、优化器、接口、数据集、模型推理、MindArmour、AI Fuzzer、MINDIR、网络、评估、SGD、Arm、ast、精度、数据、精度、优化、框架、Eval、npu +术语§术语,https://www.mindspore.cn/docs/zh-CN/r1.7/design/glossary.html," + + + + +术语/缩略语 +说明 + + + + +ACL +Ascend Computer Language，提供Device管理、Context管理、Stream管理、内存管理、模型加载与执行、算子加载与执行、媒体数据处理等C++ API库，供用户开发深度神经网络应用。 + + +AIR +Ascend Intermediate Representation，类似ONNX，是华为定义的针对机器学习所设计的开放式的文件格式，能更好地适配Ascend AI处理器。 + + +Ascend +华为昇腾系列芯片的系列名称。 + + +Backpropagation +反向传播。 + + +Batch +模型训练的一次迭代（即一次梯度更新）中使用的样本集。 + + +Batch size +模型迭代一次，使用的样本集的大小。 + + +CCE +Cube-based Computing Engine，面向硬件架构编程的算子开发工具。 + + +CCE-C +Cube-based Computing Engine C，使用CCE开发的C代码。 + + +CheckPoint +MindSpore模型训练检查点，保存模型的参数，可以用于保存模型供推理，或者再训练。 + + +CIFAR-10 +一个开源的图像数据集，包含10个类别的60000个32x32彩色图像，每个类别6000个图像。有50000张训练图像和10000张测试图像。 + + +CIFAR-100 +一个开源的图像数据集，它有100个类别，每个类别包含500张训练图像和100张测试图像。 + + +Clip +梯度裁剪。 + + +Davinci +达芬奇架构，华为自研的新型芯片架构。 + + +Device +设备侧，主要执行MindSpore算子的硬件，包括Ascend、GPU、CPU等。 + + +Device_id +分布式并行中，卡的物理ID。 + + +Dimension Reduction +降维。 + + +Epoch +数据集的一次完整遍历。 + + +EulerOS +欧拉操作系统，华为自研的基于Linux标准内核的操作系统。 + + +FC Layer +Fully Conneted Layer，全连接层。整个卷积神经网络中起到分类器的作用。 + + +FE +Fusion Engine，负责对接GE和TBE算子，具备算子信息库的加载与管理、融合规则管理等能力。 + + +Fine-tuning +基于面向某任务训练的网络模型，训练面向第二个类似任务的网络模型。 + + +Format +数据格式，如NCHW、NHWC、NC0HWC1等。N: batch size; C: channel; H: height; W:width。昇腾AI软件栈中，张量数据统一采用NC0HWC1的五维数据格式。其中C0等于AI Core中矩阵计算单元的大小，对于FP16类型为16，对于INT8类型则为32，这部分数据需要连续存储；C1是将C维度按照C0进行拆分后的数目，即C1=C/C0。如果结果不整除，最后一份数据需要补零以对齐C0。 + + +FP16 +16位浮点，半精度浮点算术，消耗更小内存。 + + +FP32 +32位浮点，单精度浮点算术。 + + +GE +Graph Engine，MindSpore计算图执行引擎，主要负责根据前端的计算图完成硬件相关的优化（算子融合、内存复用等等）、device侧任务启动。 + + +GHLO +Graph High Level Optimization，计算图高级别优化。GHLO包含硬件无关的优化（如死代码消除等）、自动并行和自动微分等功能。 + + +GLLO +Graph Low Level Optimization，计算图低级别优化。GLLO包含硬件相关的优化，以及算子融合、Buffer融合等软硬件结合相关的深度优化。 + + +Graph Mode +MindSpore的静态图模式，将神经网络模型编译成一整张图，然后下发执行，性能高。 + + +HCCL +Huawei Collective Communication Library，实现了基于Davinci架构芯片的多机多卡通信。 + + +Host +主机侧，主要进行图编译、数据处理等。 + + +ImageNet +根据WordNet层次结构（目前仅名词）组织的图像数据库。 + + +Layout +分布式并行中，数据在卡上的分布情况。 + + +LeNet +一个经典的卷积神经网络架构，由Yann LeCun等人提出。 + + +Loss +损失，预测值与实际值的偏差，深度学习用于判断模型好坏的一个标准。 + + +Loss scale +为了防止梯度下溢而进行的梯度放大。 + + +LSTM +Long short-term memory，长短期记忆，对应的网络是一种时间循环神经网络，适合于处理和预测时间序列中间隔和延迟非常长的重要事件。 + + +Manifest +一种数据格式文件，华为ModelArts采用了该格式，详细说明请参见https://support.huaweicloud.com/engineers-modelarts/modelarts_23_0009.html。 + + +ME +Mind Expression，MindSpore前端，主要完成从用户源码到计算图的编译任务、训练中控制执行及上下文维护（非下沉模式配置下）、动态图（PyNative模式）等。 + + +MindArmour +MindSpore安全模块，通过差分隐私、对抗性攻防等技术手段，提升模型的保密性、完整性和可用性，阻止攻击者对模型进行恶意修改或是破解模型的内部构件，窃取模型的参数。 + + +MindData +MindSpore数据框架，提供数据加载、增强、数据集管理以及可视化。 + + +MindInsight +MindSpore可视化组件，可视化标量、图像、计算图以及模型超参等信息。 + + +MindIR +MindSpore IR，一种基于图表示的函数式IR，定义了可扩展的图结构以及算子IR表示，存储了MindSpore基础数据结构。 + + +MindRecord +MindSpore定义的一种数据格式，是一个执行读取、写入、搜索和转换MindSpore格式数据集的模块。 + + +MindSpore +华为主导开源的深度学习框架。 + + +MindSpore Lite +一个轻量级的深度神经网络推理引擎，提供了将MindSpore训练出的模型在端侧进行推理的功能。 + + +MNIST database +Modified National Institute of Standards and Technology database，一个大型手写数字数据库，通常用于训练各种图像处理系统。 + + +NCCL +Nvidia Collective multi-GPU Communication Library的简称，它是一个实现多GPU的collective communication通信库。 + + +ONNX +Open Neural Network Exchange，是一种针对机器学习所设计的开放式的文件格式，用于存储训练好的模型。 + + +PyNative Mode +MindSpore的动态图模式，将神经网络中的各个算子逐一下发执行，方便用户编写和调试神经网络模型。 + + +Proto +ProtoBuffer文件格式。 + + +ResNet-50 +Residual Neural Network 50，由微软研究院的Kaiming He等四名华人提出的残差神经网络。 + + +Rank_id +分布式并行中，卡的逻辑ID。 + + +Scalar +标量Tensor，其shape为（）。 + + +Schema +数据集结构定义文件，用于定义数据集包含哪些字段以及字段的类型。 + + +Shape +张量在各种维度中包含的元素数，如Tensor[2,3]，shape为{2,3}，表示是一个2维张量，第一维有2行，第二维有3列，共2*3=6个元素。 + + +Step或Iteration +完成一次前向计算和反向传播。 + + +Summary +是对网络中Tensor取值进行监测的一种算子，在图中是“外围”操作，不影响数据流本身。 + + +TBE +Tensor Boost Engine，华为自研的NPU算子开发工具，在TVM（ Tensor Virtual Machine ）框架基础上扩展，提供了一套Python API来实施开发活动，进行自定义算子开发。 + + +TFRecord +Tensorflow定义的数据格式。 + + +Tensor +张量，存储多维数组的数据结构。最常见的是标量、向量或矩阵。 + + +广播 +在矩阵数学运算中，是将操作数的shape扩展到与该运算兼容的维。在分布式并行中，是某卡上的参数同步到其他卡上。 + + +计算图下沉 +计算图整图下沉到Device上执行，减少Host-Device交互开销。详见on-device执行 + + +循环下沉 +在On Device执行的基础上的优化，目的是进一步减少Host侧和Device侧之间的交互次数。详见on-device执行 + + +数据下沉 +下沉即数据通过通道直接传送到Device上。详见on-device执行 + + +图模式 +又称静态图模式，将神经网络模型编译成一整张图，然后下发执行。该模式利用图优化等技术提高运行性能，同时有助于规模部署和跨平台运行。 + + +PyNative模式 +动态图模式，将神经网络中的各个算子逐一下发执行，方便用户编写和调试神经网络模型。 + + +",术语,MindArmour、AI Fuzzer、评估、Arm、精度、数据、精度 diff --git a/Design_Migration_Grammar_API_dataset/Grammar_Support_dataset/html_grammar_data_generate.py b/Design_Migration_Grammar_API_dataset/Grammar_Support_dataset/html_grammar_data_generate.py new file mode 100644 index 0000000..0dff1d5 --- /dev/null +++ b/Design_Migration_Grammar_API_dataset/Grammar_Support_dataset/html_grammar_data_generate.py @@ -0,0 +1,152 @@ +import requests +import csv +from bs4 import BeautifulSoup +import re + +#定义寻找特征字符位置的函数 +def find_en(st, text): + position = [] + n = 0 + for m in range(0, 1000): + pos = body.find(st, n, len(text)) + n = pos + 1 + position.append(pos) + if position[m] == -1: + break + return position + +#定义修正中英文冒号的函数，将中文冒号的QA插入 +def correct(datalist1, datalist2): + if len(datalist1) != 1: + for m in range(0, len(datalist1)-1): + for n in range(0, len(datalist2)-1): + if datalist2[n] > datalist1[m]: + datalist2.insert(n, datalist1[m]) + break + +#去除可能出现在A中的小标题 +def delete(list1): + for m in range(0, len(list1)): + l = list1[m].find('\n\n\n\n') + if l != -1: + list1[m] = list1[m][0:l + 1] + +if __name__ == "__main__": + #定义列表和特征字符 + #url_ipynb = ['https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/training_visual_design.html'] + url_html = ['https://www.mindspore.cn/docs/zh-CN/r1.7/note/static_graph_syntax_support.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/note/index_support.html'] + + process = ['静态图语法支持', 'Tensor索引支持'] + + tag = ['白皮书', 'MindSpore', '全场景', '自动微分', 'GradOperation', 'MindSpore', 'Parameter Server', \ + '并行', '优化器', 'Host&Device', '分布式', '算子', '接口', '数据集', '集合通信', '同步模式', '损失函数', '控制流', \ + '自由变量', '闭包', 'MindRecord', 'Pipeline', 'Adaptor', 'Optimizer', 'Runtime', 'Operators', 'Callback', \ + 'MindSpore AKG', 'Auto-Tiling', 'Auto-Mapping', 'Davinci', '样例脚本', 'GPU', 'CPU', 'CuBLAS库', 'Linux', 'Ascend', \ + '模型推理', 'MindInsight', 'plugin_name', 'MindArmour', 'AI Fuzzer', 'MINDIR', '缩略语', \ + '数据类型', '原型', '运算符', '语句', '内置函数', '网络', \ + 'PyNative', 'MindConverter', '评估', 'TensorFlow', 'Pytorch', 'ONNX', 'PB', 'API', 'Model', 'SGD', 'loss', 'metric', 'ARM', 'AST', \ + 'TensorBoard', 'Dataloader', 'GeneratorDataset', ' GradOperation', 'TrainOneStepCell', '反向传播', '求导', 'weight decay', 'LR', '学习率', \ + 'Aten', '调试', 'MindOptimizer', '精度', 'checklist', '数据', 'loss scale', '超参', '计算图', '精度', '可视化', '模型结构', \ + '优化', '迭代', 'ModelZoo', 'MindSpore Serving', '脚本', '单机', 'profiling', 'MindData', '框架', '性能', 'Dataset', 'macOS', 'SDK版本', 'SciPy',\ + 'whl包', 'protobuf', 'Ubuntu', 'Windows', 'WSL', 'Conda', 'Serving', 'gmp', 'cuda', 'JupyterLab', 'eval', 'NLP', 'HCLL', 'ModelArts', 'Graph', \ + 'C++', 'AIPP', 'OpenMPI', 'NCLL', 'RDMA', 'IB', 'RoCE', 'taichi', 'Caffe', 'NPU', 'Embedding', 'Parameter Server', 'JIT Fallback'] + tag_change = [] + Dataset = [] + #转义tag中的特殊符号 + for i in tag: + tag_change.append(re.escape(i)) + #十一个语料库大循环 + for numbers in range(0, len(process)): + #获取网页文本 + req = requests.get(url=url_html[numbers]) + req.encoding = 'utf-8' + html = req.text + bs = BeautifulSoup(html, "html.parser")#html.parser是解析器 + All_title = bs.find_all("div", attrs={"class": "section"})#所有标题 + + + #定义二级标题及其内容 + pre_title_2 = []#二级标题 + pre_title_1 = []#一级标题 + title = [] + content = [] + #获取所有二级标题 + for one_title in All_title: + h_1 = one_title.find('h1') + h_2 = one_title.find('h2') + if h_1 != None: + pre_title_1.append(process[numbers].lower())# 一级标题名字 + if h_1 == None and h_2 != None: + title_2 = h_2.get_text()#二级标题名字 + pre_title_2.append(title_2) + + #提取一级标题和二级标题之间的内容 + result = bs.select("#" + pre_title_1[0]) + body = result[0].get_text() + title_1_location = find_en("¶", body) + # 有二级标题 如："二阶优化器THOR介绍" or "训练可视总体设计" + if len(pre_title_2) > 0: + title_2_location = find_en(pre_title_2[0], body) + body_1 = body[title_1_location[0] + 1 : title_2_location[0]] + # 判断一级标题到二级标题间有无内容 + if len(body_1) > 20: + title.append(pre_title_1[0] + "§" + pre_title_1[0]) + content.append(body_1) + # 没有二级标题 如："全场景统一" or "术语" + else: + body_1 = body[title_1_location[0] + 1: ] + title.append(pre_title_1[0] + "§" + pre_title_1[0]) + content.append(body_1) + + #提取二级标题及其内容 + for title_2 in pre_title_2: + title_mis = title_2.rstrip('¶') + # 标题有特殊符号需要替换 + flag_1 = "&" in title_mis + flag_2 = " " in title_mis + flag_3 = "（" in title_mis + if flag_1 == True: + title_mis = title_mis.replace("&", "") + if flag_2 == True: + title_mis = title_mis.replace(" ", "-") + if flag_3 == True: + title_mis = title_mis.replace("（", "") + title_mis = title_mis.replace("）", "") + title_mis = title_mis.lower() + result = bs.select("#" + title_mis) + body = result[0].get_text() + title_2_location = find_en(title_2, body) + body_1 = body[title_2_location[0] + len(title_2):] + body_1 = body_1.replace('¶', '') + title_2 = title_2.rstrip('¶') + title.append(pre_title_1[0] + "§" + title_2) + content.append(body_1) + + # 匹配tag + tag1 = [] + tag2 = [] + for m in range(0, len(title)): + str8 = title[m] + content[m] + for i in tag_change: + t = re.search(i, str8, flags=re.IGNORECASE) + if t != None: + tag2.append(t.group(0)) + tag1.append(tag2) + tag2 = [] + # 将tag列表合并为字符串 + FinalTag = [] + for m in range(0, len(title)): + ft_str = '、'.join(tag1[m]) + FinalTag.append(ft_str) + + # 将各个二级标题元素合并，用于写入csv文件 + for n in range(0, len(title)): + Dataset.append([title[n], url_html[numbers], content[n], process[numbers], FinalTag[n]]) + #print(Dataset) + # 插入csv + headers = ('title', 'link', 'content', 'process', 'tag') # + with open('html_grammar_dataset.csv', 'w', encoding='utf-8', newline='') as f: + write = csv.writer(f) # 创建writer对象 + write.writerow(headers) + for n in range(len(Dataset)): + write.writerow(Dataset[n]) diff --git a/Design_Migration_Grammar_API_dataset/Grammar_Support_dataset/html_grammar_dataset.csv b/Design_Migration_Grammar_API_dataset/Grammar_Support_dataset/html_grammar_dataset.csv new file mode 100644 index 0000000..b09d91a --- /dev/null +++ b/Design_Migration_Grammar_API_dataset/Grammar_Support_dataset/html_grammar_dataset.csv @@ -0,0 +1,1832 @@ +title,link,content,process,tag +静态图语法支持§概述,https://www.mindspore.cn/docs/zh-CN/r1.7/note/static_graph_syntax_support.html," +在Graph模式下，Python代码并不是由Python解释器去执行，而是将代码编译成静态计算图，然后执行静态计算图。 +当前仅支持编译@ms_function装饰器修饰的函数、Cell及其子类的实例。 +对于函数，则编译函数定义；对于网络，则编译construct方法及其调用的其他方法或者函数。 +ms_function使用规则可参考文档：https://www.mindspore.cn/docs/zh-CN/r1.7/api_python/mindspore/mindspore.ms_function.html#mindspore.ms_function +Cell定义可参考文档：https://www.mindspore.cn/docs/zh-CN/r1.7/api_python/nn/mindspore.nn.Cell.html +由于语法解析的限制，当前在编译构图时，支持的数据类型、语法以及相关操作并没有完全与Python语法保持一致，部分使用受限。 +本文主要介绍，在编译静态图时，支持的数据类型、语法以及相关操作，这些规则仅适用于Graph模式。 + +以下所有示例都运行在Graph模式下的网络中，为了简洁，并未将网络的定义都写出来。 + +",静态图语法支持,mindspore、mindspore、数据类型、网络、api、数据、计算图、Graph +静态图语法支持§数据类型,https://www.mindspore.cn/docs/zh-CN/r1.7/note/static_graph_syntax_support.html," + +Python内置数据类型 +当前支持的Python内置数据类型包括：Number、String、List、Tuple和Dictionary。 + +Number +支持int、float、bool，不支持complex（复数）。 +支持在网络里定义Number，即支持语法：y = 1、y = 1.2、 y = True。 +当数据为常量时，编译时期可以获取到数值，因此在网络中可以支持强转Number的语法：y = int(x)、y = float(x)、y = bool(x)。 + + +String +支持在网络里构造String，即支持语法y = ""abcd""。 +不支持在网络里强转String，即不支持语法 y = str(x)。 + + +List +支持在网络里构造List，即支持语法y = [1, 2, 3]。 +不支持在网络里强转List，即不支持语法y = list(x)。 +计算图中最终需要输出的List会转换为Tuple输出。 + +支持接口 +append: 向list里追加元素。 +示例如下： +from mindspore import ms_function + +@ms_function() +def test_list(): + x = [1, 2, 3] + x.append(4) + return x + +x = test_list() +print('x:{}'.format(x)) + + +结果如下： +x: (1, 2, 3, 4) + + + +支持索引取值和赋值 +支持单层和多层索引取值以及赋值。 +索引值仅支持int和slice。 +slice内部数据必须为编译时能够确定的常量，即不能为计算后的Tensor。且不支持对slice进行赋值。 +赋值时，所赋的值支持Number、String、Tuple、List、Tensor。 +示例如下： +from mindspore import ms_function, Tensor +import numpy as np + +t = Tensor(np.array([1, 2, 3])) + +@ms_function() +def test_index(): + x = [[1, 2], 2, 3, 4] + m = x[0][1] + z = x[1::2] + x[1] = t + x[2] = ""ok"" + x[3] = (1, 2, 3) + x[0][1] = 88 + n = x[-3] + return m, z, x, n + +m, z, x, n = test_index() +print('m:{}'.format(m)) +print('z:{}'.format(z)) +print('x:{}'.format(x)) +print('n:{}'.format(n)) + + +结果如下： +m:2 +z:[2, 4] +x:[[1, 88], Tensor(shape=[3], dtype=Int64, value= [1, 2, 3]), 'ok', (1, 2, 3)] +n:[1 2 3] + + + + + + +Tuple +支持在网络里构造Tuple，即支持语法y = (1, 2, 3)。 +不支持在网络里强转Tuple，即不支持语法y = tuple(x)。 + +支持索引取值 +索引值支持int、slice、Tensor，也支持多层索引取值，即支持语法data = tuple_x[index0][index1]...。 +索引值为Tensor有如下限制： + +tuple里存放的都是Cell，每个Cell要在tuple定义之前完成定义，每个Cell的入参个数、入参类型和入参shape要求一致，每个Cell的输出个数、输出类型和输出shape也要求一致。 +索引Tensor是一个dtype为int32的标量Tensor，取值范围在[-tuple_len, tuple_len)，Ascend后端不支持负数索引。 +该语法不支持if、while、for控制流条件为变量的运行分支，仅支持控制流条件为常量。 +支持GPU和Ascend后端。 + +int、slice索引示例如下： +from mindspore import ms_function, Tensor +import numpy as np + +t = Tensor(np.array([1, 2, 3])) + +@ms_function() +def test_index(): + x = (1, (2, 3, 4), 3, 4, t) + y = x[1][1] + z = x[4] + m = x[1:4] + n = x[-4] + return y, z, m, n + +y, z, m, n = test_index() +print('y:{}'.format(y)) +print('z:{}'.format(z)) +print('m:{}'.format(m)) +print('n:{}'.format(n)) + + +结果如下： +y:3 +z:[1 2 3] +m:((2, 3, 4), 3, 4) +n:(2, 3, 4) + + +Tensor索引示例如下： +from mindspore import Tensor, nn, dtype + +class Net(nn.Cell): + def __init__(self): + super(Net, self).__init__() + self.relu = nn.ReLU() + self.softmax = nn.Softmax() + self.layers = (self.relu, self.softmax) + + def construct(self, x, index): + ret = self.layers[index](x) + return ret + +x = Tensor([-1.0], dtype.float32) + +net = Net() +ret = net(x, 0) +print('ret:{}'.format(ret)) + + +结果如下： +ret:[0.] + + + + + + +Dictionary +支持在网络里构造Dictionary，即支持语法y = {""a"": 1, ""b"": 2}，当前仅支持String作为key值。 +计算图中最终需要输出的Dictionary，会取出所有的value组成Tuple输出。 + +支持接口 +keys：取出dict里所有的key值，组成Tuple返回。 +values：取出dict里所有的value值，组成Tuple返回。 +items：取出dict里每一对key和value组成的Tuple，组成Tuple返回。 +示例如下： +from mindspore import ms_function, Tensor +import numpy as np + +x = {""a"": Tensor(np.array([1, 2, 3])), ""b"": Tensor(np.array([4, 5, 6])), ""c"": Tensor(np.array([7, 8, 9]))} + +@ms_function() +def test_dict(): + y = x.keys() + z = x.values() + q = x.items() + return y, z, q + +y, z, q = test_dict() +print('y:{}'.format(y)) +print('z:{}'.format(z)) +print('q:{}'.format(q)) + + +结果如下： +y:('a', 'b', 'c') +z:(Tensor(shape=[3], dtype=Int64, value= [1, 2, 3]), Tensor(shape=[3], dtype=Int64, value= [4, 5, 6]), Tensor(shape=[3], dtype=Int64, value= [7, 8, 9])) +q:[('a', Tensor(shape=[3], dtype=Int64, value= [1, 2, 3])), ('b', Tensor(shape=[3], dtype=Int64, value= [4, 5, 6])), ('c', Tensor(shape=[3], dtype=Int64, value= [7, 8, 9]))] + + + +支持索引取值和赋值 +取值和赋值的索引值都仅支持String。赋值时，所赋的值支持Number、Tuple、Tensor。 +示例如下： +from mindspore import ms_function, Tensor +import numpy as np + +x = {""a"": Tensor(np.array([1, 2, 3])), ""b"": Tensor(np.array([4, 5, 6])), ""c"": Tensor(np.array([7, 8, 9]))} + +@ms_function() +def test_dict(): + y = x[""b""] + x[""a""] = (2, 3, 4) + return x, y + +x, y = test_dict() +print('x:{}'.format(x)) +print('y:{}'.format(y)) + + +结果如下： +x:{'a': (2, 3, 4), 'b': Tensor(shape=[3], dtype=Int64, value= [4, 5, 6]), 'c': Tensor(shape=[3], dtype=Int64, value= [7, 8, 9])} +y:[4 5 6] + + + + + + + +MindSpore自定义数据类型 +当前MindSpore自定义数据类型包括：Tensor、Primitive、Cell和Parameter。 + +Tensor +当前不支持在网络里构造Tensor，即不支持语法x = Tensor(args...)。 +可以通过@constexpr装饰器修饰函数，在函数里生成Tensor。 +关于@constexpr的用法可参考：https://www.mindspore.cn/docs/zh-CN/r1.7/api_python/ops/mindspore.ops.constexpr.html +对于网络中需要用到的常量Tensor，可以作为网络的属性，在init的时候定义，即self.x = Tensor(args...)，然后在construct里使用。 +如下示例，通过@constexpr生成一个shape = (3, 4), dtype = int64的Tensor。 +from mindspore import Tensor +from mindspore.ops import constexpr + +@constexpr +def generate_tensor(): + return Tensor(np.ones((3, 4))) + +x = generate_tensor() +print('x:{}'.format(x)) + + +结果如下： +x:[[1. 1. 1. 1.] + [1. 1. 1. 1.] + [1. 1. 1. 1.]] + + +下面将介绍下Tensor支持的属性和接口。 + +支持属性： +shape：获取Tensor的shape，返回一个Tuple。 +dtype：获取Tensor的数据类型，返回一个MindSpore定义的数据类型。 + +支持接口： +all：对Tensor通过all操作进行归约，仅支持Bool类型的Tensor。 +any：对Tensor通过any操作进行归约，仅支持Bool类型的Tensor。 +view：将Tensorreshape成输入的shape。 +expand_as：将Tensor按照广播规则扩展成与另一个Tensor相同的shape。 +示例如下： +from mindspore import ms_function, Tensor +import numpy as np + +x = Tensor(np.array([[True, False, True], [False, True, False]])) +y = Tensor(np.ones((2, 3), np.float32)) +z = Tensor(np.ones((2, 2, 3))) + +x_shape = x.shape +x_dtype = x.dtype +x_all = x.all() +x_any = x.any() +x_view = x.view((1, 6)) +y_as_z = y.expand_as(z) + +print('x_shape:{}'.format(x_shape)) +print('x_dtype:{}'.format(x_dtype)) +print('x_all:{}'.format(x_all)) +print('x_any:{}'.format(x_any)) +print('x_view:{}'.format(x_view)) +print('y_as_z:{}'.format(y_as_z)) + + +结果如下: +x_shape:(2, 3) +x_dtype:Bool +x_all:False +x_any:True +x_view:[[ True False True False True False]] +y_as_z:[[[1. 1. 1.] + [1. 1. 1.]] + + [[1. 1. 1.] + [1. 1. 1.]]] + + + + + + +Primitive +当前支持在网络里构造Primitive及其子类的实例，即支持语法reduce_sum = ReduceSum(True)。 +但在构造时，参数只能通过位置参数方式传入，不支持通过键值对方式传入，即不支持语法reduce_sum = ReduceSum(keep_dims=True)。 +当前不支持在网络调用Primitive及其子类相关属性和接口。 +Primitive定义可参考文档：https://www.mindspore.cn/tutorials/experts/zh-CN/r1.7/operation/op_classification.html#primitive%E7%AE%97%E5%AD%90 +当前已定义的Primitive可参考文档：https://www.mindspore.cn/docs/zh-CN/r1.7/api_python/ops/mindspore.ops.Primitive.html#mindspore.ops.Primitive + + +Cell +当前支持在网络里构造Cell及其子类的实例，即支持语法cell = Cell(args...)。 +但在构造时，参数只能通过位置参数方式传入，不支持通过键值对方式传入，即不支持在语法cell = Cell(arg_name=value)。 +当前不支持在网络调用Cell及其子类相关属性和接口，除非是在Cell自己的construct中通过self调用。 +Cell定义可参考文档：https://www.mindspore.cn/docs/zh-CN/r1.7/api_python/nn/mindspore.nn.Cell.html +当前已定义的Cell可参考文档：https://www.mindspore.cn/docs/zh-CN/r1.7/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell + + +Parameter +Parameter是变量张量，代表在训练网络时，需要被更新的参数。 +Parameter的定义和使用参考：https://www.mindspore.cn/docs/en/r1.7/api_python/mindspore/mindspore.Parameter.html#mindspore.Parameter + + +",静态图语法支持,mindspore、mindspore、接口、控制流、GPU、Ascend、数据类型、网络、api、数据、计算图 +静态图语法支持§原型,https://www.mindspore.cn/docs/zh-CN/r1.7/note/static_graph_syntax_support.html," +原型代表编程语言中最紧密绑定的操作。 + +属性引用 +属性引用是后面带有一个句点加一个名称的原型。 +在MindSpore的Cell 实例中使用属性引用作为左值需满足如下要求： + +被修改的属性属于本cell对象，即必须为self.xxx。 +该属性在Cell的__init__函数中完成初始化且其为Parameter类型。 + +示例如下： +from mindspore import ms_function, Tensor, nn, dtype, Parameter +import numpy as np +from mindspore.ops import constexpr + +class Net(nn.Cell): + def __init__(self): + super().__init__() + self.weight = Parameter(Tensor(3, dtype.float32), name=""w"") + self.m = 2 + + def construct(self, x, y): + self.weight = x # 满足条件可以修改 + # self.m = 3 # self.m 非Parameter类型禁止修改 + # y.weight = x # y不是self，禁止修改 + return x + +net = Net() +ret = net(1, 2) +print('ret:{}'.format(ret)) + + +结果如下: +ret:1 + + + + +索引取值 +对序列Tuple、List、Dictionary、Tensor的索引取值操作(Python称为抽取)。 +Tuple的索引取值请参考本文的Tuple章节。 +List的索引取值请参考本文的List章节。 +Dictionary的索引取值请参考本文的Dictionary章节。 +Tensor的索引取请参考:https://www.mindspore.cn/docs/zh-CN/r1.7/note/index_support.html#%E7%B4%A2%E5%BC%95%E5%8F%96%E5%80%BC + + +调用 +所谓调用就是附带可能为空的一系列参数来执行一个可调用对象(例如：Cell、Primitive)。 +示例如下： +from mindspore import Tensor, nn, dtype, ops +import numpy as np + +class Net(nn.Cell): + def __init__(self): + super().__init__() + self.matmul = ops.MatMul() + + def construct(self, x, y): + out = self.matmul(x, y) # Primitive调用 + return out + +x = Tensor(np.ones(shape=[1, 3]), dtype.float32) +y = Tensor(np.ones(shape=[3, 4]), dtype.float32) +net = Net() +ret = net(x, y) +print('ret:{}'.format(ret)) + + +结果如下: +ret:[[3. 3. 3. 3.]] + + + +",静态图语法支持,MindSpore、MindSpore、原型 +静态图语法支持§运算符,https://www.mindspore.cn/docs/zh-CN/r1.7/note/static_graph_syntax_support.html," +算术运算符和赋值运算符支持Number和Tensor运算，也支持不同dtype的Tensor运算。 +之所以支持，是因为这些运算符会转换成同名算子进行运算，这些算子支持了隐式类型转换。 +规则可参考文档：https://www.mindspore.cn/docs/zh-CN/r1.7/note/operator_list_implicit.html#%E8%BD%AC%E6%8D%A2%E8%A7%84%E5%88%99 + +单目算术运算符 + + + +单目算术运算符 +支持类型 + + + + ++ +Number、Tensor，取正值。 + + +- +Number、Tensor，取负值。 + + +~ +Tensor， 且其数据类型为Bool。成员逐个取反。 + + + +说明： + +在Python中~操作符对输入的整数安位取反; MindSpore对~的功能重新定义为对Tensor(Bool)的逻辑取反。 + + + +二元算术运算符 + + + +二元算术运算符 +支持类型 + + + + ++ +Number + Number、String + String、Number + Tensor、Tensor + Number、Tuple + Tensor、Tensor + Tuple、List + Tensor、Tensor+List、List+List、Tensor + Tensor、Tuple + Tuple。 + + +- +Number - Number、Tensor - Tensor、Number - Tensor、Tensor - Number、Tuple - Tensor、Tensor - Tuple、List - Tensor、Tensor - List。 + + +* +Number * Number、Tensor * Tensor、Number * Tensor、Tensor * Number、List * Number、Number * List、Tuple * Number、Number * Tuple、Tuple * Tensor、Tensor * Tuple、 List * Tensor、Tensor * List。 + + +/ +Number / Number、Tensor / Tensor、Number / Tensor、Tensor / Number、Tuple / Tensor、Tensor / Tuple、List / Tensor、Tensor / List。 + + +% +Number % Number、Tensor % Tensor、Number % Tensor、Tensor % Number、Tuple % Tensor、Tensor % Tuple、List % Tensor、Tensor % List。 + + +** +Number ** Number、Tensor ** Tensor、Number ** Tensor、Tensor ** Number、Tuple ** Tensor、Tensor ** Tuple、 List ** Tensor、Tensor ** List。 + + +// +Number // Number、Tensor // Tensor、Number // Tensor、Tensor // Number、Tuple // Tensor、Tensor // Tuple、List // Tensor、Tensor // List。 + + + +限制： + +当左右操作数都为Number类型时，Number的值不可为Bool 类型。 +当左右操作数都为Number类型时，不支持Float64 和 Int32间的运算。 +当任一操作数为Tensor类型时，左右操作数的值不可同时为Bool。 +List/Tuple和Number进行*运算时表示将List/Tuple复制Number份后串联起来，List/Tuple内的数据类型必须为Number、String、None或由以上类型构成的List/Tuple。 + + + +赋值运算符 + + + +赋值运算符 +支持类型 + + + + += +MindSpore支持的Python内置数据类型和MindSpore自定义数据类型 + + ++= +Number += Number、String += String、Number += Tensor、Tensor += Number、Tuple += Tensor、Tensor += Tuple、List += Tensor、Tensor += List、List += List、Tensor += Tensor、Tuple += Tuple。 + + +-= +Number -= Number、Tensor -= Tensor、Number -= Tensor、Tensor -= Number、Tuple -= Tensor、Tensor -= Tuple、List -= Tensor、Tensor -= List。 + + +*= +Number *= Number、Tensor *= Tensor、Number *= Tensor、Tensor *= Number、List *= Number、Number *= List、Tuple *= Number、Number *= Tuple、Tuple *= Tensor、Tensor *= Tuple、 List *= Tensor、Tensor *= List。 + + +/= +Number /= Number、Tensor /= Tensor、Number /= Tensor、Tensor /= Number、Tuple /= Tensor、Tensor /= Tuple、List /= Tensor、Tensor /= List。 + + +%= +Number %= Number、Tensor %= Tensor、Number %= Tensor、Tensor %= Number、Tuple %= Tensor、Tensor %= Tuple、List %= Tensor、Tensor %= List。 + + +**= +Number **= Number、Tensor **= Tensor、Number **= Tensor、Tensor **= Number、Tuple **= Tensor、Tensor **= Tuple、 List **= Tensor、Tensor **= List。 + + +//= +Number //= Number、Tensor //= Tensor、Number //= Tensor、Tensor //= Number、Tuple //= Tensor、Tensor //= Tuple、List //= Tensor、Tensor //= List。 + + + +限制： + +对于 =来说，不支持下列场景: +在construct函数中仅支持创建Cell和Primitive类型对象，使用xx = Tensor(...)的方式创建Tensor会失败。 +在construct函数中仅支持为self 的Parameter类型的属性赋值, 详情参考：属性引用。 + +当AugAssign的左右操作数都为Number类型时，Number的值不可为Bool 类型。 +当AugAssign的左右操作数都为Number类型时，不支持Float64 和 Int32间的运算。 +当AugAssign的任一操作数为Tensor类型时，左右操作数的值不可同时为Bool。 +List/Tuple和Number进行*=运算时表示将List/Tuple复制Number份后串联起来，List/Tuple内的数据类型必须为Number、String、None或由以上类型构成的List/Tuple。 + + + +逻辑运算符 + + + +逻辑运算符 +支持类型 + + + + +and +String、 Number、 Tuple、List 、Dict、None、标量、Tensor。 + + +or +String、 Number、 Tuple、List 、Dict、None、标量、Tensor。 + + +not +Number、Tuple、List、只有一个成员的Tensor。 + + + +限制： + +当and/or的左操作数是Tensor类型时，左右操作数类型必须保持一致且Tensor成员个数只能有一个。 +当and/or的左操作数不是Tensor类型时，右操作数可以为支持的任意类型。 + + + +比较运算符 + + + +比较运算符 +支持类型 + + + + +in +Number in tuple、String in tuple、Tensor in Tuple、Number in List、String in List、Tensor in List、String in Dictionary。 + + +not in +与in相同。 + + +is +仅支持判断是None、 True或者False。 + + +is not +仅支持判断不是None、 True或者False。 + + +< +Number < Number、Number < Tensor、Tensor < Tensor、Tensor < Number。 + + +<= +Number <= Number、Number <= Tensor、Tensor <= Tensor、Tensor <= Number。 + + +> +Number > Number、Number > Tensor、Tensor > Tensor、Tensor > Number。 + + +>= +Number >= Number、Number >= Tensor、Tensor >= Tensor、Tensor >= Number。 + + +!= +Number != Number、Number != Tensor、Tensor != Tensor、Tensor != Number、mstype != mstype、String != String、Tuple ! = Tuple、List != List。 + + +== +Number == Number、Number == Tensor、Tensor == Tensor、Tensor == Number、mstype == mstype、String == String、Tuple == Tuple、List == List。 + + + +限制： + +对于<、<=、>、>=、!=来说，当左右操作数都为Number类型时，Number的值不可为Bool 类型。 +对于<、<=、>、>=、!=、==来说，当左右操作数都为Number类型时，不支持Float64 和 Int32间的运算。 +对于<、<=、>、>=、!=、==来说，当左右任一操作数为Tensor类型时，左右操作数的值不可同时为Bool。 +对于==来说，当左右操作数都为Number类型时，支持左右操作数同时为Bool，不支持只有一个操作数为Bool。 +对于!=、==来说除mstype外，其他取值均可和None进行比较来判空。 +不支持链式比较，如: a>b>c。 + + +",静态图语法支持,mindspore、mindspore、算子、数据类型、运算符、数据 +静态图语法支持§复合语句,https://www.mindspore.cn/docs/zh-CN/r1.7/note/static_graph_syntax_support.html," + +条件控制语句 + +if语句 +使用方式： + +if (cond): statements... +x = y if (cond) else z + +参数：cond – 支持Bool类型的变量，也支持类型为Number、List、Tuple、Dict、String类型的常量。 +限制： + +如果cond不为常量，在不同分支中同一符号被赋予的变量或者常量的数据类型应一致，如果是被赋予变量或者常量数据类型是Tensor，则要求Tensor的type和shape也应一致。 +if的使用数量不能超过100个。 + +示例1： +from mindspore import ms_function, Tensor, dtype + +x = Tensor([1, 2], dtype.int32) +y = Tensor([0, 3], dtype.int32) +m = 'xx' +n = 'yy' + +@ms_function() +def test_cond(x, y): + if (x > y).any(): + return m + else: + return n + +ret = test_cond(x, y) +print('ret:{}'.format(ret)) + + +if分支返回的m和else分支返回的n，二者数据类型必须一致。 +结果如下: +ret:xx + + +示例2： +from mindspore import ms_function, Tensor, dtype + +x = Tensor([1, 2], dtype.int32) +y = Tensor([0, 3], dtype.int32) +m = 'xx' +n = 'yy' + +@ms_function() +def test_cond(x, y): + out = 'init' + if (x > y).any(): + out = m + else: + out = n + return out + +ret = test_cond(x, y) +print('ret:{}'.format(ret)) + + +if分支中out被赋值的变量或者常量m与else分支中out被赋值的变量或者常量n的数据类型必须一致。 +结果如下: +ret:xx + + +示例3： +from mindspore import ms_function, Tensor, dtype + +x = Tensor([1, 2], dtype.int32) +y = Tensor([0, 3], dtype.int32) +m = 'xx' + +@ms_function() +def test_cond(x, y): + out = 'init' + if (x > y).any(): + out = m + return out + +ret = test_cond(x, y) +print('ret:{}'.format(ret)) + + +if分支中out被赋值的变量或者常量m与out初始赋值的变量或者常量init的数据类型必须一致。 +结果如下: +ret:xx + + + + + +循环语句 + +for语句 +使用方式： + +for i in sequence  statements... +for i in sequence  statements... if (cond) break +for i in sequence  statements... if (cond) continue + +参数：sequence – 遍历序列(Tuple、List、range等) +限制： + +图的算子数量和for循环的迭代次数成倍数关系，for循环迭代次数过大可能会导致图占用内存超过使用限制。 +不支持for...else...语句。 + +示例： +from mindspore import ms_function, Tensor +import numpy as np + +z = Tensor(np.ones((2, 3))) + +@ms_function() +def test_cond(): + x = (1, 2, 3) + for i in x: + z += i + return z + +ret = test_cond() +print('ret:{}'.format(ret)) + + +结果如下： +ret:[[7. 7. 7.] + [7. 7. 7.]] + + + + +while语句 +使用方式： + +while (cond)  statements... +while (cond)  statements... if (cond1) break +while (cond)  statements... if (cond1) continue + +参数：cond – 支持Bool类型的变量，也支持类型为Number、List、Tuple、Dict、String类型的常量。 +限制： + +如果cond不为常量，在循环体内外同一符号被赋值的变量或者常量的数据类型应一致，如果是被赋予数据类型Tensor，则要求Tensor的type和shape也应一致。 +不支持while...else...语句 +如果cond不为常量， 循环体内部不能更新循环体外的Number、List、Tuple类型数据， 不能更改Tensor类型数据的shape。 +while的数量不能超过100个。 + +示例1： +from mindspore import ms_function + +m = 1 +n = 2 + +@ms_function() +def test_cond(x, y): + while x < y: + x += 1 + return m + return n + +ret = test_cond(1, 5) +print('ret:{}'.format(ret)) + + +while循环内返回的m和while外返回的n数据类型必须一致。 +结果如下： +ret:1 + + +示例2： +from mindspore import ms_function + +m = 1 +n = 2 + +def ops1(a, b): + return a + b + +@ms_function() +def test_cond(x, y): + out = m + while x < y: + x += 1 + out = ops1(out, x) + return out + +ret = test_cond(1, 5) +print('ret:{}'.format(ret)) + + +while内，out在循环体内被赋值的变量op1的输出类型和初始类型m必须一致。 +结果如下： +ret:15 + + + + + +函数定义语句 + +def关键字 +用于定义函数。 +使用方式： +def function_name(args): statements... +示例如下： +from mindspore import ms_function + +def number_add(x, y): + return x + y + +@ms_function() +def test(x, y): + return number_add(x, y) + +ret = test(1, 5) +print('ret:{}'.format(ret)) + + +结果如下： +ret: 6 + + +限制： + +函数必须有返回语句。 +最外层网络模型的construct函数不支持kwargs，即不支持 def  construct(**kwargs):。 +不支持变参和非变参的混合使用，即不支持 def function(x, y, *args):和 def function(x = 1, y = 1, **kwargs):。 + + + +lambda表达式 +用于生成函数。 +使用方式：lambda x, y: x + y +示例如下： +from mindspore import ms_function + +@ms_function() +def test(x, y): + number_add = lambda x, y: x + y + return number_add(x, y) + +ret = test(1, 5) +print('ret:{}'.format(ret)) + + +结果如下： +ret: 6 + + + + + +列表生成式和生成器表达式 +支持列表生成式（List Comprehension）和生成器表达式（Generator Expression）。 + +列表生成式 +用于生成列表。由于编译器会自动把List类型转换成Tuple类型，经过编译后最终输出类型为Tuple。 +使用方式：参考Python语法说明。 +示例如下： +from mindspore import ms_function + +@ms_function() +def test(x, y): + l = [x * x for x in range(1, 11) if x % 2 == 0] + return l + +ret = test(1, 5) +print('ret:{}'.format(ret)) + + +结果如下： +ret:(4, 16, 36, 64, 100) + + +限制： +不支持多层嵌套迭代器的使用方式。 +限制用法示例如下（使用了两层迭代器）： +l = [y for x in ((1, 2), (3, 4), (5, 6)) for y in x] + + +会提示错误： +TypeError: The `generators` supports one `comprehension` in ListComp/GeneratorExp, but got 2 comprehensions. + + + + +生成器表达式 +用于生成列表，与列表生成式动作完全一致，最终的输出类型同样是Tuple。此表达式即刻产生List值，与Python解释器中列表生成式的动作有所差异。 +使用方式：同列表生成式。 +示例如下： +from mindspore import ms_function + +@ms_function() +def test(x, y): + l = (x * x for x in range(1, 11) if x % 2 == 0) + return l + +ret = test(1, 5) +print('ret:{}'.format(ret)) + + +结果如下： +ret:(4, 16, 36, 64, 100) + + +使用限制同列表生成式。 + + +",静态图语法支持,mindspore、mindspore、算子、数据类型、语句、网络、数据、迭代 +静态图语法支持§函数,https://www.mindspore.cn/docs/zh-CN/r1.7/note/static_graph_syntax_support.html," + +Python内置函数 +当前支持的Python内置函数包括：len、isinstance、partial、map、range、enumerate、super、pow和filter。 + +len +功能：求序列的长度。 +调用：len(sequence) +入参：sequence – Tuple、List、Dictionary或者Tensor。 +返回值：序列的长度，类型为int。当入参是Tensor时，返回的是Tensor第0维的长度。 +示例如下： +from mindspore import ms_function, Tensor +import numpy as np + +z = Tensor(np.ones((6, 4, 5))) + +@ms_function() +def test(): + x = (2, 3, 4) + y = [2, 3, 4] + d = {""a"": 2, ""b"": 3} + x_len = len(x) + y_len = len(y) + d_len = len(d) + z_len = len(z) + return x_len, y_len, d_len, z_len + +x_len, y_len, d_len, z_len = test() +print('x_len:{}'.format(x_len)) +print('y_len:{}'.format(y_len)) +print('d_len:{}'.format(d_len)) +print('z_len:{}'.format(z_len)) + + +结果如下： +x_len:3 +y_len:3 +d_len:2 +z_len:6 + + + + +isinstance +功能：判断对象是否为类的实例。区别于算子Isinstance，该算子的第二个入参是MindSpore的dtype模块下定义的类型。 +调用：isinstance(obj, type) +入参： + +obj – MindSpore支持类型的一个实例。 +type – bool、int、float、str、list、tuple、dict、Tensor、Parameter，或者是一个只包含这些类型的tuple。 + +返回值：obj为type的实例，返回True，否则返回False。 +示例如下： +from mindspore import ms_function, Tensor +import numpy as np + +z = Tensor(np.ones((6, 4, 5))) + +@ms_function() +def test(): + x = (2, 3, 4) + y = [2, 3, 4] + x_is_tuple = isinstance(x, tuple) + y_is_list = isinstance(y, list) + z_is_tensor = isinstance(z, Tensor) + return x_is_tuple, y_is_list, z_is_tensor + +x_is_tuple, y_is_list, z_is_tensor = test() +print('x_is_tuple:{}'.format(x_is_tuple)) +print('y_is_list:{}'.format(y_is_list)) +print('z_is_tensor:{}'.format(z_is_tensor)) + + +结果如下： +x_is_tuple:True +y_is_list:True +z_is_tensor:True + + + + +partial +功能：偏函数，固定函数入参。 +调用：partial(func, arg, ...) +入参： + +func – 函数。 +arg – 一个或多个要固定的参数，支持位置参数和键值对传参。 + +返回值：返回某些入参固定了值的函数。 +示例如下： +from mindspore import ms_function, ops + +def add(x, y): + return x + y + +@ms_function() +def test(): + add_ = ops.partial(add, x=2) + m = add_(y=3) + n = add_(y=5) + return m, n + +m, n = test() +print('m:{}'.format(m)) +print('n:{}'.format(n)) + + +结果如下： +m:5 +n:7 + + + + +map +功能：根据提供的函数对一个或者多个序列做映射，由映射的结果生成一个新的序列。 +如果多个序列中的元素个数不一致，则生成的新序列与最短的那个长度相同。 +调用：map(func, sequence, ...) +入参： + +func – 函数。 +sequence – 一个或多个序列（Tuple或者List）。 + +返回值：返回一个Tuple。 +示例如下： +from mindspore import ms_function + +def add(x, y): + return x + y + +@ms_function() +def test(): + elements_a = (1, 2, 3) + elements_b = (4, 5, 6) + ret = map(add, elements_a, elements_b) + return ret + +ret = test() +print('ret:{}'.format(ret)) + + +结果如下： +ret: (5, 7, 9) + + + + +zip +功能：将多个序列中对应位置的元素打包成一个个元组，然后由这些元组组成一个新序列， +如果各个序列中的元素个数不一致，则生成的新序列与最短的那个长度相同。 +调用：zip(sequence, ...) +入参：sequence – 一个或多个序列(Tuple或List)`。 +返回值：返回一个Tuple。 +示例如下： +from mindspore import ms_function + +@ms_function() +def test(): + elements_a = (1, 2, 3) + elements_b = (4, 5, 6) + ret = zip(elements_a, elements_b) + return ret + +ret = test() +print('ret:{}'.format(ret)) + + +结果如下： +ret:((1, 4), (2, 5), (3, 6)) + + + + +range +功能：根据起始值、结束值和步长创建一个Tuple。 +调用： + +range(start, stop, step) +range(start, stop) +range(stop) + +入参： + +start – 计数起始值，类型为int，默认为0。 +stop – 计数结束值，但不包括在内，类型为int。 +step – 步长，类型为int，默认为1。 + +返回值：返回一个Tuple。 +示例如下： +from mindspore import ms_function + +@ms_function() +def test(): + x = range(0, 6, 2) + y = range(0, 5) + z = range(3) + return x, y, z + +x, y, z = test() +print('x:{}'.format(x)) +print('y:{}'.format(y)) +print('z:{}'.format(z)) + + +结果如下： +x:(0, 2, 4) +y:(0, 1, 2, 3, 4) +z:(0, 1, 2) + + + + +enumerate +功能：生成一个序列的索引序列，索引序列包含数据和对应下标。 +调用： + +enumerate(sequence, start) +enumerate(sequence) + +入参： + +sequence – 一个序列（Tuple、List、Tensor）。 +start – 下标起始位置，类型为int，默认为0。 + +返回值：返回一个Tuple。 +示例如下： +from mindspore import ms_function, Tensor +import numpy as np + +y = Tensor(np.array([[1, 2], [3, 4], [5, 6]])) + +@ms_function() +def test(): + x = (100, 200, 300, 400) + m = enumerate(x, 3) + n = enumerate(y) + return m, n + +m, n = test() +print('m:{}'.format(m)) +print('n:{}'.format(n)) + + +结果如下： +m:((3, 100), (4, 200), (5, 300), (6, 400)) +n:((0, Tensor(shape=[2], dtype=Int64, value= [1, 2])), (1, Tensor(shape=[2], dtype=Int64, value= [3, 4])), (2, Tensor(shape=[2], dtype=Int64, value= [5, 6]))) + + + + +super +功能：用于调用父类(超类)的一个方法，一般在super之后调用父类的方法。 +调用： + +super().xxx() +super(type, self).xxx() + +入参： + +type – 类。 +self – 对象。 + +返回值：返回父类的方法。 +示例如下： +from mindspore import nn + +class FatherNet(nn.Cell): + def __init__(self, x): + super(FatherNet, self).__init__(x) + self.x = x + + def construct(self, x, y): + return self.x * x + + def test_father(self, x): + return self.x + x + +class SingleSubNet(FatherNet): + def __init__(self, x, z): + super(SingleSubNet, self).__init__(x) + self.z = z + + def construct(self, x, y): + ret_father_construct = super().construct(x, y) + ret_father_test = super(SingleSubNet, self).test_father(x) + return ret_father_construct, ret_father_test + + + + +pow +功能：求幂。 +调用：pow(x, y) +入参： + +x – 底数， Number或Tensor。 +y – 幂指数， Number或Tensor。 + +返回值：返回x的y次幂，Number或Tensor。 +示例如下： +from mindspore import ms_function, Tensor +import numpy as np + +x = Tensor(np.array([1, 2, 3])) +y = Tensor(np.array([1, 2, 3])) + +@ms_function() +def test(x, y): + return pow(x, y) + +ret = test(x, y) + +print('ret:{}'.format(ret)) + + +结果如下： +ret:[ 1 4 27] + + + + +print +功能：用于打印。 +调用：print(arg, ...) +入参：arg – 要打印的信息(int 、float、bool、String或Tensor)。 +当打印的数据是int，float或者bool时，会将其包成一个0-D的tensor打印出来。 +返回值：无返回值。 +示例如下： +from mindspore import ms_function, Tensor, dtype +import numpy as np + +x = Tensor(np.array([1, 2, 3]), dtype.int32) +y = Tensor(3, dtype.int32) + +@ms_function() +def test(x, y): + print(x) + print(y) + return x, y + +ret = test(x, y) + + +结果如下： +Tensor(shape=[3], dtype=Int32, value= [1 2 3]) +3 + + + + +filter +功能：根据提供的函数对一个序列的元素做判断，每个元素依次作为参数传入函数中，将返回结果不为0或False的元素组成新的序列。 +调用：filter(func, sequence) +入参： + +func – 函数。 +sequence – 序列（Tuple或List）。 + +返回值：返回一个Tuple。 +示例如下： +from mindspore import ms_function + +def is_odd(x): + if x % 2: + return True + return False + +@ms_function() +def test(): + elements = (1, 2, 3, 4, 5) + ret = filter(is_odd, elements) + return ret + +ret = test() +print('ret:{}'.format(ret)) + + +结果如下： +ret:(1, 3, 5) + + + + + +函数参数 + +参数默认值：目前不支持默认值设为Tensor类型数据，支持int、float、bool、None、str、tuple、list、dict类型数据。 +可变参数：支持带可变参数网络的推理和训练。 +键值对参数：目前不支持带键值对参数的函数求反向。 +可变键值对参数：目前不支持带可变键值对的函数求反向。 + + +",静态图语法支持,mindspore、mindspore、算子、内置函数、网络、数据 +静态图语法支持§网络定义,https://www.mindspore.cn/docs/zh-CN/r1.7/note/static_graph_syntax_support.html," + +网络入参 +整网（最外层网络）入参仅支持bool、int、float、Tensor、None、mstype.number(mstype.bool_、mstype.int、mstype.float、mstype.uint)，以及只包含这些类型对象的list或者tuple，和value值是这些类型的Dictionary。 +在对整网入参求梯度的时候，会忽略非Tensor的入参，只计算Tensor入参的梯度。例如整网入参(x, y, z)中，x和z是Tensor，y是非Tensor时，在对整网入参求梯度的时候，只会计算x和z的梯度，返回(grad_x, grad_z)。 +如果网络里要使用其他类型，可在初始化网络的时候，传入该类型对象，作为网络属性保存起来，然后在construct里使用。 +内层调用的网络入参无此限制。 +示例如下： +from mindspore import nn, ops, Tensor +import numpy as np + +class Net(nn.Cell): + def __init__(self, flag): + super(Net, self).__init__() + self.flag = flag + + def construct(self, x, y, z): + if self.flag == ""ok"": + return x + y + z + return x - y - z + +class GradNet(nn.Cell): + def __init__(self, net): + super(GradNet, self).__init__() + self.grad_all = ops.GradOperation(get_all=True) + self.forward_net = net + + def construct(self, x, y, z): + return self.grad_all(self.forward_net)(x, y, z) + +flag = ""ok"" +input_x = Tensor(np.ones((2, 3)).astype(np.float32)) +input_y = 2 +input_z = Tensor(np.ones((2, 3)).astype(np.float32) * 2) + +net = Net(flag) +grad_net = GradNet(net) +ret = grad_net(input_x, input_y, input_z) + +print('ret:{}'.format(ret)) + + +结果如下： +ret:(Tensor(shape=[2, 3], dtype=Float32, value= +[[ 1.00000000e+00, 1.00000000e+00, 1.00000000e+00], + [ 1.00000000e+00, 1.00000000e+00, 1.00000000e+00]]), Tensor(shape=[2, 3], dtype=Float32, value= +[[ 1.00000000e+00, 1.00000000e+00, 1.00000000e+00], + [ 1.00000000e+00, 1.00000000e+00, 1.00000000e+00]])) + + +上面定义的Net网络里，在初始化时传入一个string flag，作为网络的属性保存起来，然后在construct里使用self.flag这个属性。 +整网入参x和z是Tensor，y是int数，grad_net在对整网入参(x, y, z)求梯度时，会自动忽略y的梯度，只计算x和z的梯度，ret = (grad_x, grad_z)。 + + +网络实例类型 + +带@ms_function装饰器的普通Python函数。 +继承自nn.Cell的Cell子类。 + + + +网络构造组件 + + + +类别 +内容 + + + + +Cell实例 +mindspore/nn/*、自定义Cell。 + + +Cell实例的成员函数 +Cell的construct中可以调用其他类成员函数。 + + +dataclass实例 +使用@dataclass装饰的类。 + + +Primitive算子 +mindspore/ops/operations/* + + +Composite算子 +mindspore/ops/composite/* + + +constexpr生成算子 +使用@constexpr生成的值计算算子。 + + +函数 +自定义Python函数、前文中列举的系统函数。 + + + + + +网络使用约束 + +不允许修改网络的非Parameter类型数据成员。 +示例如下： +from mindspore import nn, Tensor, Parameter +import numpy as np + +class Net(nn.Cell): + def __init__(self): + super(Net, self).__init__() + self.x = 2 + self.par = Parameter(Tensor(np.ones((2, 3, 4))), name=""par"") + + def construct(self, x, y): + self.par[0] = y + self.x = x + return x + y + +net = Net() +net(1, 2) + + +上面所定义的网络里，self.x不是一个Parameter，不允许被修改，而self.par是一个Parameter，可以被修改。 +结果报错如下： +TypeError: 'self.x' should be initialized as a 'Parameter' type in the '__init__' function + + + +当construct函数里，使用未定义的类成员时，不会像Python解释器那样抛出AttributeError，而是作为None处理。 +示例如下： +from mindspore import nn + +class Net(nn.Cell): + def __init__(self): + super(Net, self).__init__() + + def construct(self, x): + return x + self.y + +net = Net() +net(1) + + +上面所定义的网络里，construct里使用了并未定义的类成员self.y，此时会将self.y作为None处理。 +结果报错如下： +RuntimeError: mindspore/ccsrc/frontend/operator/composite/multitype_funcgraph.cc:161 GenerateFromTypes] The 'add' operation does not support the type [Int64, kMetaTypeNone] + + + + + +",静态图语法支持,mindspore、GradOperation、mindspore、算子、Runtime、网络、ast、数据、graph、ib、npu +tensor索引支持§tensor索引支持,https://www.mindspore.cn/docs/zh-CN/r1.7/note/index_support.html," + +Tensor 支持单层与多层索引取值，赋值以及增强赋值，支持动态图(PyNative)以及静态图(Graph)模式。 + +",Tensor索引支持,PyNative、Graph +tensor索引支持§索引取值,https://www.mindspore.cn/docs/zh-CN/r1.7/note/index_support.html," +索引值支持int、bool、None、ellipsis、slice、Tensor、List、Tuple。 + +int索引取值 +支持单层和多层int索引取值，单层int索引取值：tensor_x[int_index]，多层int索引取值：tensor_x[int_index0][int_index1]...。 +int索引取值操作的是第0维，索引值小于第0维长度，在取出第0维对应位置数据后，会消除第0维。 +例如，如果对一个shape为(3, 4, 5)的tensor进行单层int索引取值，取得结果的shape是(4, 5)。 +多层索引取值可以理解为，后一层索引取值在前一层索引取值结果上再进行int索引取值。 +示例如下： +from mindspore import Tensor +import mindspore.numpy as np +tensor_x = Tensor(np.arange(2 * 3 * 2).reshape((2, 3, 2))) +data_single = tensor_x[0] +data_multi = tensor_x[0][1] + + +结果如下： +data_single: Tensor(shape=[3, 2], dtype=Int64, value=[[0, 1], [2, 3], [4, 5]]) +data_multi: Tensor(shape=[2], dtype=Int64, value=[2, 3]) + + + +bool索引取值 +支持单层和多层bool索引取值，单层bool索引取值：tensor_x[True]，多层bool索引取值：tensor_x[True][True]...。 +bool索引取值操作的是第0维，在取出所有数据后，会在axis=0轴上扩展一维，对应True/False，该维长度分别为1/0。False将会在shape中引入0，因此暂只支持True。 +例如，对一个shape为(3, 4, 5)的tensor进行单层True索引取值，取得结果的shape是(1, 3, 4, 5)。 +多层索引取值可以理解为，后一层索引取值在前一层索引取值结果上再进行bool索引取值。 +示例如下： +tensor_x = Tensor(np.arange(2 * 3 ).reshape((2, 3))) +data_single = tensor_x[True] +data_multi = tensor_x[True][True] + + +结果如下： +data_single: Tensor(shape=[1, 2, 3], dtype=Int64, value=[[[0, 1, 2], [3, 4, 5]]]) +data_multi: Tensor(shape=[1, 1, 2, 3], dtype=Int64, value=[[[[0, 1, 2], [3, 4, 5]]]]) + + + +None索引取值 +None索引取值和True索引取值一致，可参考True索引取值，这里不再赘述。 + +ellipsis索引取值 +支持单层和多层ellipsis索引取值，单层ellipsis索引取值：tensor_x[...]，多层ellipsis索引取值：tensor_x[...][...]...。 +ellipsis索引取值操作在所有维度上取出所有数据。一般多作为Tuple索引的组成元素，Tuple索引将于下面介绍。 +例如，对一个shape为(3, 4, 5)的tensor进行ellipsis索引取值，取得结果的shape依然是(3, 4, 5)。 +示例如下： +tensor_x = Tensor(np.arange(2 * 3 ).reshape((2, 3))) +data_single = tensor_x[...] +data_multi = tensor_x[...][...] + + +结果如下： +data_single: Tensor(shape=[2, 3], dtype=Int64, value=[[0, 1, 2], [3, 4, 5]]) +data_multi: Tensor(shape=[2, 3], dtype=Int64, value=[[0, 1, 2], [3, 4, 5]]) + + + +slice索引取值 +支持单层和多层slice索引取值，单层slice索引取值：tensor_x[slice_index]，多层slice索引取值：tensor_x[slice_index0][slice_index1]...。 +slice索引取值操作的是第0维，取出第0维所切到位置的元素，slice不会降维，即使切到长度为1，区别于int索引取值。 +例如，tensor_x[0:1:1] != tensor_x[0]，因为shape_former = (1,) + shape_latter。 +多层索引取值可以理解为，后一层索引取值在前一层索引取值结果上再进行slice索引取值。 +slice有start、stop和step组成。start默认值为0，stop默认值为该维长度，step默认值为1。 +例如，tensor_x[:] == tensor_x[0:length:1]。 +示例如下： +tensor_x = Tensor(np.arange(4 * 2 * 2).reshape((4, 2, 2))) +data_single = tensor_x[1:4:2] +data_multi = tensor_x[1:4:2][1:] + + +结果如下： +data_single: Tensor(shape=[2, 2, 2], dtype=Int64, value=[[[4, 5], [6, 7]], [[12, 13], [14, 15]]]) +data_multi: Tensor(shape=[1, 2, 2], dtype=Int64, value=[[[12, 13], [14, 15]]]) + + + +Tensor索引取值 +支持单层和多层Tensor索引取值，单层Tensor索引取值：tensor_x[tensor_index]，多层Tensor索引取值：tensor_x[tensor_index0][tensor_index1]...。 +Tensor索引取值操作的是第0维，取出第0维对应位置的元素。 +索引Tensor数据类型必须是int型，可以是(int8, int16, int32, int64)，值必须为非负数，且小于第0维长度。 +Tensor索引取值得到结果的data_shape = tensor_index.shape + tensor_x.shape[1:]。 +例如，对一个shape为(6, 4, 5)的tensor通过shape为(2, 3)的tensor进行索引取值，取得结果的shape为(2, 3, 4, 5)。 +多层索引取值可以理解为，后一层索引取值在前一层索引取值结果上再进行Tensor索引取值。 +示例如下： +tensor_x = Tensor(np.arange(4 * 2 * 3).reshape((4, 2, 3))) +tensor_index0 = Tensor(np.array([[1, 2], [0, 3]]), mstype.int32) +tensor_index1 = Tensor(np.array([[0, 0]]), mstype.int32) +data_single = tensor_x[tensor_index0] +data_multi = tensor_x[tensor_index0][tensor_index1] + + +结果如下： +data_single: Tensor(shape=[2, 2, 2, 3], dtype=Int64, value=[[[[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16 ,17]]], [[[0, 1, 2], [3, 4, 5]], [[18, 19, 20], [21, 22, 23]]]]) +data_multi: Tensor(shape=[1, 2, 2, 2, 3], dtype=Int64, value=[[[[[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16 ,17]]], [[[0, 1, 2], [3, 4, 5]], [[18, 19, 20], [21, 22, 23]]]]])) + + + +List索引取值 +支持单层和多层List索引取值，单层List索引取值：tensor_x[list_index]，多层List索引取值：tensor_x[list_index0][list_index1]...。 +List索引取值操作的是第0维，取出第0维对应位置的元素。 +索引List数据类型必须是int、bool或两者混合。若数据类型为int，则取值在[-dimension_shape, dimension_shape-1]之间；若数据类型为bool， 则限制bool个数为对应维度长度，筛选对应维度上值为True的元素；若值为前两者混合，则bool类型的True/False将转为int类型的1/0。 +List索引取值得到结果的data_shape = list_index.shape + tensor_x.shape[1:]。 +例如，对一个shape为(6, 4, 5)的tensor通过shape为(3,)的tensor进行索引取值，取得结果的shape为(3, 4, 5)。 +多层索引取值可以理解为，后一层索引取值在前一层索引取值结果上再进行List索引取值。 +示例如下： +tensor_x = Tensor(np.arange(4 * 2 * 3).reshape((4, 2, 3))) +list_index0 = [1, 2, 0] +list_index1 = [True, False, True] +data_single = tensor_x[list_index0] +data_multi = tensor_x[list_index0][list_index1] + + +结果如下： +data_single: Tensor(shape=[3, 2, 3], dtype=Int64, value=[[[6, 7, 8], [9, 10, 11]], [[12, 13, 14], [15, 16, 17]], [[0, 1, 2], [3, 4, 5]]]) +data_multi: Tensor(shape=[2, 2, 3], dtype=Int64, value=[[[6, 7, 8], [9, 10, 11]], [[0, 1, 2], [3, 4, 5]]]) + + + +Tuple索引取值 +索引Tuple的数据类型可以为int、bool、None、slice、ellipsis、Tensor、List、Tuple。支持单层和多层Tuple索引取值，单层Tuple索引取值：tensor_x[tuple_index]，多层Tuple索引取值：tensor_x[tuple_index0][tuple_index1]...。Tuple中包含的List与Tuple包含元素规则与单独的List规则相同，其他元素规则与单独元素也相同。 +索引Tuple中元素按照最终索引Broadcast规则，分为Basic Index、Advanced Index两类。Basic Index包含slice、ellipsis与None三种类型，Advanced Index包含int、bool、Tensor、List、Tuple等五种类型。索引过程中，所有的Advanced Index将会做Broadcast，若Advaned Index连续，最终broadcast shape将插入在第一个Advanced Index位置；若不连续，则broadcast shape插入在0位置。 +索引里除None扩展对应维度，bool扩展对应维度后与Advanced Index做Broadcast。除ellipsis、bool、None外每个元素操作对应位置维度，即Tuple中第0个元素操作第0维，第1个元素操作第1维，以此类推。每个元素的索引规则与该元素类型索引取值规则一致。 +Tuple索引里最多只有一个ellipsis，ellipsis前半部分索引元素从前往后对应Tensor第0维往后，后半部分索引元素从后往前对应Tensor最后一维往前，其他未指定的维度，代表全取。 +元素里包含的Tensor数据类型必须是int型，可以是(int8, int16, int32, int64)，值必须为非负数，且小于第0维长度。 +例如，tensor_x[0:3, 1, tensor_index] == tensor_x[(0:3, 1, tensor_index)]，因为0:3, 1, tensor_index就是一个Tuple。 +多层索引取值可以理解为，后一层索引取值在前一层索引取值结果上再进行Tuple索引取值。 +示例如下： +tensor_x = Tensor(np.arange(2 * 3 * 4).reshape((2, 3, 4))) +tensor_index = Tensor(np.array([[1, 2, 1], [0, 3, 2]]), mstype.int32) +data = tensor_x[1, 0:1, tensor_index] + + +结果如下： +data: Tensor(shape=[2, 3, 1], dtype=Int64, value=[[[13], [14], [13]], [[12], [15], [14]]]) + + + + +",Tensor索引支持,mindspore、mindspore、数据类型、ast、数据 +tensor索引支持§索引赋值,https://www.mindspore.cn/docs/zh-CN/r1.7/note/index_support.html," +对于形如: tensor_x[index] = value， index的类型支持int、bool、ellipsis、slice、None、Tensor、List、Tuple。 +value的类型支持Number、Tuple、List和Tensor。被赋的值会首先被转换为张量，数据类型与原张量(tensor_x)相符。 +当value为Number时，可以理解为将tensor_x[index]索引对应元素都更新为Number。 +当value为数组，即只包含Number的Tuple、List或Tensor时，value.shape需要可以与tensor_x[index].shape做广播，将value广播到tensor_x[index].shape后，更新tensor_x[index]对应的值。 +当value为Tuple或List时，若value中元素包含Number，Tuple，List 和 Tensor等多种类型，该Tuple 和 List 目前只支持1维。 +当value为Tuple或List，且存在Tensor时，非Tensor的元素会首先被转换为Tensor，然后这些Tensor在axis=0轴上打包之后成为一个新的赋值Tensor，这时按照value为Tensor的规则进行赋值。所有Tensor的数据类型必须保持一致。 +索引赋值可以理解为对索引到的位置元素按照一定规则进行赋值，所有索引赋值都不会改变原Tensor的shape。 + +当索引中有多个元素指向原张量的同一个位置时，该值的更新受底层算子限制，可能出现随机的情况。因此暂不支持索引中重复对张量中一个位置的值反复更新。详情请见:TensorScatterUpdate 算子介绍 +当前只支持单层索引(tensor_x[index] = value)， 多层索引(tensor_x[index1][index2]... = value)暂不支持。 + + +int索引赋值 +支持单层int索引赋值：tensor_x[int_index] = u。 +示例如下： +import mindspore.numpy as np +tensor_x = np.arange(2 * 3).reshape((2, 3)).astype(np.float32) +tensor_y = np.arange(2 *3).reshape((2, 3)).astype(np.float32) +tensor_z = np.arange(2* 3).reshape((2, 3)).astype(np.float32) +tensor_x[1] = 88.0 +tensor_y[1]= np.array([66, 88, 99]).astype(np.float32) +tensor_z[1] = (66, np.array(88).astype(np.int64), 99) + + +结果如下： +tensor_x: Tensor(shape=[2, 3], dtype=Float32, value=[[0.0, 1.0, 2.0], [88.0, 88.0, 88.0]]) +tensor_y: Tensor(shape=[2, 3], dtype=Float32, value=[[0.0, 1.0, 2.0], [66.0, 88.0, 99.0]]) +tensor_z: Tensor(shape=[2, 3], dtype=Float32, value=[[0.0, 1.0, 2.0], [66.0, 88.0, 99.0]]) + + + +bool索引赋值 +支持单层bool索引赋值：tensor_x[bool_index] = u。 +示例如下： +import mindspore.numpy as np +tensor_x = np.arange(2 * 3).reshape((2, 3)).astype(np.float32) +tensor_y = np.arange(2 * 3).reshape((2, 3)).astype(np.float32) +tensor_z = np.arange(2 * 3).reshape((2, 3)).astype(np.float32) +tensor_x[True] = 88.0 +tensor_y[True]= np.array([66, 88, 99]).astype(np.float32) +tensor_z[True] = (66, 88, 99) + + +结果如下： +tensor_x: Tensor(shape=[2, 3], dtype=Float32, value=[[88.0, 88.0, 88.0], [88.0, 88.0, 88.0]]) +tensor_y: Tensor(shape=[2, 3], dtype=Float32, value=[[66.0, 88.0, 99.0], [66.0, 88.0, 99.0]]) +tensor_z: Tensor(shape=[2, 3], dtype=Float32, value=[[66.0, 88.0, 99.0], [66.0, 88.0, 99.0]]) + + + +ellipsis索引赋值 +支持单层ellipsis索引赋值，单层ellipsis索引赋值：tensor_x[...] = u。 +示例如下： +import mindspore.numpy as np +tensor_x = np.arange(2 * 3).reshape((2, 3)).astype(np.float32) +tensor_y = np.arange(2 * 3).reshape((2, 3)).astype(np.float32) +tensor_z = np.arange(2 * 3).reshape((2, 3)).astype(np.float32) +tensor_x[...] = 88.0 +tensor_y[...] = np.array([[22, 44, 55], [22, 44, 55]]) +tensor_z[...] = ([11, 22, 33], [44, 55, 66]) + + +结果如下： +tensor_x: Tensor(shape=[2, 3], dtype=Float32, value=[[88.0, 88.0, 88.0], [88.0, 88.0, 88.0]]) +tensor_y: Tensor(shape=[2, 3], dtype=Float32, value=[[22.0, 44.0, 55.0], [22.0, 44.0, 55.0]]) +tensor_z: Tensor(shape=[2, 3], dtype=Float32, value=[[11., 22., 33.], [44., 55., 66.]]) + + + +slice索引赋值 +支持单层slice索引赋值：tensor_x[slice_index] = u。 +示例如下： +import mindspore.numpy as np +tensor_x = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_y = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_z = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_k = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_x[0:1] = 88.0 +tensor_y[0:2] = 88.0 +tensor_z[0:2] = np.array([[11, 12, 13], [11, 12, 13]]).astype(np.float32) +tensor_k[0:2] = ([11, 12, 13], (14, 15, 16)) + + +结果如下： +tensor_x: Tensor(shape=[3, 3], dtype=Float32, value=[[88.0, 88.0, 88.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]) +tensor_y: Tensor(shape=[3, 3], dtype=Float32, value=[[88.0, 88.0, 88.0], [88.0, 88.0, 88.0], [6.0, 7.0, 8.0]]) +tensor_z: Tensor(shape=[3, 3], dtype=Float32, value=[[11.0, 12.0, 13.0], [11.0, 12.0, 13.0], [6.0, 7.0, 8.0]]) +tensor_k: Tensor(shape=[3, 3], dtype=Float32, value=[[11.0, 12.0, 13.0], [14.0, 15.0, 16.0], [6.0, 7.0, 8.0]]) + + + +None索引赋值 +支持单层None索引赋值：tensor_x[none_index] = u。 +示例如下： +import mindspore.numpy as np +tensor_x = np.arange(2 * 3).reshape((2, 3)).astype(np.float32) +tensor_y = np.arange(2 * 3).reshape((2, 3)).astype(np.float32) +tensor_z = np.arange(2 * 3).reshape((2, 3)).astype(np.float32) +tensor_x[None] = 88.0 +tensor_y[None]= np.array([66, 88, 99]).astype(np.float32) +tensor_z[None] = (66, 88, 99) + + +结果如下： +tensor_x: Tensor(shape=[2, 3], dtype=Float32, value=[[88.0, 88.0, 88.0], [88.0, 88.0, 88.0]]) +tensor_y: Tensor(shape=[2, 3], dtype=Float32, value=[[66.0, 88.0, 99.0], [66.0, 88.0, 99.0]]) +tensor_z: Tensor(shape=[2, 3], dtype=Float32, value=[[66.0, 88.0, 99.0], [66.0, 88.0, 99.0]]) + + + +Tensor索引赋值 +支持单层Tensor索引赋值，即tensor_x[tensor_index] = u。 +当前不支持索引Tensor为bool类型，只能为mstype.int*型。 +示例如下： +import mindspore.numpy as np +tensor_x = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_y = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_z = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_index = np.array([[2, 0, 2], [0, 2, 0], [0, 2, 0]], np.int32) +tensor_x[tensor_index] = 88.0 +tensor_y[tensor_index] = np.array([11.0, 12.0, 13.0]).astype(np.float32) +tensor_z[tensor_index] = [11, 12, 13] + + +结果如下： +tensor_x: Tensor(shape=[3, 3], dtype=Float32, value=[[88.0, 88.0, 88.0], [3.0, 4.0, 5.0], [88.0, 88.0, 88.0]]) +tensor_y: Tensor(shape=[3, 3], dtype=Float32, value=[[11.0, 12.0, 13.0], [3.0, 4.0, 5.0], [11.0, 12.0, 13.0]]) +tensor_z: Tensor(shape=[3, 3], dtype=Float32, value=[[11.0, 12.0, 13.0], [3.0, 4.0, 5.0], [11.0, 12.0, 13.0]]) + + + +List索引赋值 +支持单层List索引赋值：tensor_x[list_index] = u。 +List索引赋值和List索引取值对索引的支持一致。 +示例如下： +import mindspore.numpy as np +tensor_x = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_y = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_index = np.array([[0, 1], [1, 0]]).astype(np.int32) +tensor_x[[0,1]] = 88.0 +tensor_y[[True, False, False]] = np.array([11, 12, 13]).astype(np.float32) + + +结果如下： +tensor_x: Tensor(shape=[3, 3], dtype=Float32, value=[[88.0, 88.0, 88.0], [88.0, 88.0, 88.0], [6.0, 7.0, 8.0]]) +tensor_y: Tensor(shape=[3, 3], dtype=Float32, value=[[11.0, 12.0, 13.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]]) + + + +Tuple索引赋值 +支持单层Tuple索引赋值：tensor_x[tuple_index] = u。 +Tuple索引赋值和Tuple索引取值对索引的支持一致，但不支持Tuple中包含None。 +示例如下： +import mindspore.numpy as np +tensor_x = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_y = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_z = np.arange(3 * 3).reshape((3, 3)).astype(np.float32) +tensor_index = np.array([0, 1]).astype(np.int32) +tensor_x[1, 1:3] = 88.0 +tensor_y[1:3, tensor_index] = 88.0 +tensor_z[1:3, tensor_index] = np.array([11, 12]).astype(np.float32) + + +结果如下： +tensor_x: Tensor(shape=[3, 3], dtype=Float32, value=[[0.0, 1.0, 2.0], [3.0, 88.0, 88.0], [6.0, 7.0, 8.0]]) +tensor_y: Tensor(shape=[3, 3], dtype=Float32, value=[[0.0, 1.0, 2.0], [88.0, 88.0, 5.0], [88.0, 88.0, 8.0]]) +tensor_z: Tensor(shape=[3, 3], dtype=Float32, value=[[0.0, 1.0, 2.0], [11.0, 12.0, 5.0], [11.0, 12.0, 8.0]]) + + + + +",Tensor索引支持,mindspore、mindspore、算子、数据类型、ast、数据 +tensor索引支持§索引增强赋值,https://www.mindspore.cn/docs/zh-CN/r1.7/note/index_support.html," +增强索引赋值，支持+=、-=、*=、/=、%=、**=、//=七种类型，index与value的规则约束与索引赋值相同。索引值支持int、bool、ellipsis、slice、None、Tensor、List、Tuple八种类型，赋值支持Number、Tensor、Tuple、List四种类型。 +索引增强赋值可以理解为对索引到的位置元素按照一定规则进行取值，取值所得再与value进行操作符运算，最终将运算结果进行赋值，所有索引增强赋值都不会改变原Tensor的shape。 + +当索引中有多个元素指向原张量的同一个位置时，该值的更新受底层算子限制，可能出现随机的情况。因此暂不支持索引中重复对张量中一个位置的值反复更新。详情请见:TensorScatterUpdate 算子介绍 +目前索引中包含 True、False 和 None的情况暂不支持. + + +规则与约束 +与索引赋值相比，增加了取值与运算的过程。取值过程中index的约束规则与索引取值中index相同，支持int、bool、Tensor、Slice、Ellipsis、None、List与Tuple。上述几种类型的数据中所包含int值，需在[-dim_size, dim_size-1]闭合区间内。 +运算过程中value的约束规则与索引赋值中value的约束规则相同，value类型需为(Number、Tensor、List、Tuple)之一，且value类型不是Number时， value的形状需要可以广播到tensor_x[index]的形状。 +示例如下： +tensor_x = Tensor(np.arange(3 * 4).reshape(3, 4).astype(np.float32)) +tensor_y = Tensor(np.arange(3 * 4).reshape(3, 4).astype(np.float32)) +tensor_x[[0, 1], 1:3] += 2 +tensor_y[[1], ...] -= [4, 3, 2, 1] + + +结果如下： +tensor_x: Tensor(shape=[3, 4], dtype=Float32, value=[[0.0, 3.0, 4.0, 3.0], [4.0, 7.0, 8.0, 7.0], [8.0, 9.0, 10.0, 11.0]]) +tensor_y: Tensor(shape=[3, 4], dtype=Float32, value=[[0.0, 1.0, 2.0, 3.0], [0.0, 2.0, 4.0, 6.0], [8.0, 9.0, 10.0, 11.0]]) + + + + +",Tensor索引支持,算子、ast、数据 diff --git a/Design_Migration_Grammar_API_dataset/Migration_Guide_dataset/html_migration_data_generate.py b/Design_Migration_Grammar_API_dataset/Migration_Guide_dataset/html_migration_data_generate.py new file mode 100644 index 0000000..efbc885 --- /dev/null +++ b/Design_Migration_Grammar_API_dataset/Migration_Guide_dataset/html_migration_data_generate.py @@ -0,0 +1,153 @@ +import requests +import csv +from bs4 import BeautifulSoup +import re + +#定义寻找特征字符位置的函数 +def find_en(st, text): + position = [] + n = 0 + for m in range(0, 1000): + pos = body.find(st, n, len(text)) + n = pos + 1 + position.append(pos) + if position[m] == -1: + break + return position + +#定义修正中英文冒号的函数，将中文冒号的QA插入 +def correct(datalist1, datalist2): + if len(datalist1) != 1: + for m in range(0, len(datalist1)-1): + for n in range(0, len(datalist2)-1): + if datalist2[n] > datalist1[m]: + datalist2.insert(n, datalist1[m]) + break + +#去除可能出现在A中的小标题 +def delete(list1): + for m in range(0, len(list1)): + l = list1[m].find('\n\n\n\n') + if l != -1: + list1[m] = list1[m][0:l + 1] + +if __name__ == "__main__": + #定义列表和特征字符 + #url_ipynb = ['https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/training_visual_design.html'] + url_html = ['https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/preparation.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/script_analysis.html', \ + 'https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/migrate_3rd_scripts_mindconverter.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/migration_script.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/training_process_comparision.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/typical_api_comparision.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/optim.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/use_third_party_op.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/neural_network_debug.html', 'https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_problem_preliminary_location.html', 'https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_optimization.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/performance_optimization.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/inference.html', \ + 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/sample_code.html', 'https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/faq.html'] + + process = ['概述', '准备工作', '网络脚本分析', '使用MindConverter迁移模型定义脚本', '迁移脚本', '基本执行流程横向对比', '典型算子或接口区别介绍', '优化器迁移指南', '基于自定义算子接口调用第三方算子库', \ + '网络调试', '精度问题初步定位指南', '精度问题详细定位和调优指南', '性能调试', '推理执行', '网络迁移调试实例', '常见问题'] + + tag = ['白皮书', 'MindSpore', '全场景', '自动微分', 'GradOperation', 'MindSpore', 'Parameter Server', \ + '并行', '优化器', 'Host&Device', '分布式', '算子', '接口', '数据集', '集合通信', '同步模式', '损失函数', '控制流', \ + '自由变量', '闭包', 'MindRecord', 'Pipeline', 'Adaptor', 'Optimizer', 'Runtime', 'Operators', 'Callback', \ + 'MindSpore AKG', 'Auto-Tiling', 'Auto-Mapping', 'Davinci', '样例脚本', 'GPU', 'CPU', 'CuBLAS库', 'Linux', 'Ascend', \ + '模型推理', 'MindInsight', 'plugin_name', 'MindArmour', 'AI Fuzzer', 'MINDIR', '缩略语', \ + '数据类型', '原型', '运算符', '语句', '内置函数', '网络', \ + 'PyNative', 'MindConverter', '评估', 'TensorFlow', 'Pytorch', 'ONNX', 'PB', 'API', 'Model', 'SGD', 'loss', 'metric', 'ARM', 'AST', \ + 'TensorBoard', 'Dataloader', 'GeneratorDataset', ' GradOperation', 'TrainOneStepCell', '反向传播', '求导', 'weight decay', 'LR', '学习率', \ + 'Aten', '调试', 'MindOptimizer', '精度', 'checklist', '数据', 'loss scale', '超参', '计算图', '精度', '可视化', '模型结构', \ + '优化', '迭代', 'ModelZoo', 'MindSpore Serving', '脚本', '单机', 'profiling', 'MindData', '框架', '性能', 'Dataset', 'macOS', 'SDK版本', 'SciPy',\ + 'whl包', 'protobuf', 'Ubuntu', 'Windows', 'WSL', 'Conda', 'Serving', 'gmp', 'cuda', 'JupyterLab', 'eval', 'NLP', 'HCLL', 'ModelArts', 'Graph', \ + 'C++', 'AIPP', 'OpenMPI', 'NCLL', 'RDMA', 'IB', 'RoCE', 'taichi', 'Caffe', 'NPU', 'Embedding', 'Parameter Server', 'JIT Fallback'] + tag_change = [] + Dataset = [] + #转义tag中的特殊符号 + for i in tag: + tag_change.append(re.escape(i)) + #十一个语料库大循环 + for numbers in range(0, len(process)): + #获取网页文本 + req = requests.get(url=url_html[numbers]) + req.encoding = 'utf-8' + html = req.text + bs = BeautifulSoup(html, "html.parser")#html.parser是解析器 + All_title = bs.find_all("div", attrs={"class": "section"})#所有标题 + + #定义二级标题及其内容 + pre_title_2 = [] + pre_title_1 = [] + title = [] + content = [] + #获取所有二级标题 + for one_title in All_title: + h_1 = one_title.find('h1') + h_2 = one_title.find('h2') + if h_1 != None: + pre_title_1.append(process[numbers].lower())# 一级标题名字 + if h_1 == None and h_2 != None: + title_2 = h_2.get_text()#二级标题名字 + + pre_title_2.append(title_2) + #提取一级标题和二级标题之间的内容 + result = bs.select("#" + pre_title_1[0]) + body = result[0].get_text() + title_1_location = find_en("¶", body) + # 有二级标题 如："二阶优化器THOR介绍" or "训练可视总体设计" + if len(pre_title_2) > 0: + title_2_location = find_en(pre_title_2[0], body) + body_1 = body[title_1_location[0] + 1 : title_2_location[0]] + # 判断一级标题到二级标题间有无内容 + if len(body_1) > 20: + title.append(pre_title_1[0] + "§" + pre_title_1[0]) + content.append(body_1) + # 没有二级标题 如："全场景统一" or "术语" + else: + body_1 = body[title_1_location[0] + 1: ] + title.append(pre_title_1[0] + "§" + pre_title_1[0]) + content.append(body_1) + + #提取二级标题及其内容 + for title_2 in pre_title_2: + title_mis = title_2.rstrip('¶') + # 标题有特殊符号需要替换 + flag_1 = "&" in title_mis + flag_2 = " " in title_mis + if flag_1 == True: + title_mis = title_mis.replace("&", "") + if flag_2 == True: + title_mis = title_mis.replace(" ", "-") + title_mis = title_mis.lower() + result = bs.select("#" + title_mis) + body = result[0].get_text() + title_2_location = find_en(title_2, body) + body_1 = body[title_2_location[0] + len(title_2):] + body_1 = body_1.replace('¶', '') + title_2 = title_2.rstrip('¶') + title.append(pre_title_1[0] + "§" + title_2) + content.append(body_1) + + # 匹配tag + tag1 = [] + tag2 = [] + for m in range(0, len(title)): + str8 = title[m] + content[m] + for i in tag_change: + t = re.search(i, str8, flags=re.IGNORECASE) + if t != None: + tag2.append(t.group(0)) + tag1.append(tag2) + tag2 = [] + # 将tag列表合并为字符串 + FinalTag = [] + for m in range(0, len(title)): + ft_str = '、'.join(tag1[m]) + FinalTag.append(ft_str) + + # 将各个二级标题元素合并，用于写入csv文件 + for n in range(0, len(title)): + Dataset.append([title[n], url_html[numbers], content[n], process[numbers], FinalTag[n]]) + # 插入csv + headers = ('title', 'link', 'content', 'process', 'tag') # + with open('html_migration_dataset.csv', 'w', encoding='utf-8', newline='') as f: + write = csv.writer(f) # 创建writer对象 + write.writerow(headers) + for n in range(len(Dataset)): + write.writerow(Dataset[n]) diff --git a/Design_Migration_Grammar_API_dataset/Migration_Guide_dataset/html_migration_dataset.csv b/Design_Migration_Grammar_API_dataset/Migration_Guide_dataset/html_migration_dataset.csv new file mode 100644 index 0000000..50fb452 --- /dev/null +++ b/Design_Migration_Grammar_API_dataset/Migration_Guide_dataset/html_migration_dataset.csv @@ -0,0 +1,4814 @@ +title,link,content,process,tag +概述§概述,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html," + +本迁移指导包含从其他机器学习框架将神经网络迁移到MindSpore的完整步骤。 +迁移流程的准备工作从必须的环境配置开始，然后分析网络脚本所包含的算子。MindSpore脚本开发会从数据处理代码开始，使用MindConverter进行网络构建得到迁移后的网络脚本，最后迁移推理执行脚本。构建完成后的优化过程包含缺失算子的开发与调试、网络性能与精度调优。迁移指导附迁移流程常见问题的解决方法和网络迁移完整样例。每章会提供具体样例供参考。具体迁移流程见下图： + + +",概述,MindSpore、MindSpore、算子、网络、MindConverter、调试、精度、数据、精度、优化、脚本、框架、性能 +概述§准备工作,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html," +网络迁移首先需要安装最新版本的MindSpore，本章会详细描述安装过程与知识准备。知识准备包括对MindSpore组件ModelZoo和Hub的基本介绍，包含用途、场景与使用方法。此外还有云上训练的相关教程：使用ModelArts适配脚本，在OBS上传数据集，然后进行线上训练。 +",概述,MindSpore、MindSpore、数据集、网络、Model、数据、ModelZoo、脚本、ModelArts +概述§网络脚本分析,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html," +使用MindSpore运行网络脚本之前，必须对原框架的脚本进行分析。这一章首先会介绍在MindSpore框架下评估算子的方法，常见方法包括查询MindSpore与PyTorch/TensorFlow算子映射表等。需要分析的另一部分为语法评估与框架功能，包括静态图语法支持。 +",概述,MindSpore、MindSpore、算子、网络、评估、TensorFlow、PyTorch、脚本、框架 +概述§网络脚本开发,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html," +在网络脚本分析完成后就可以使用MindSpore对新网络进行开发了。这章从网络输入层的数据处理功能开始，重点介绍网络脚本构建流程：使用MindConverter或手写映射脚本，还可以借助PyTorch/TensorFlow自带的可视化工具构图。流程包含开发的最佳实践方法和常用自验项目，并列出了常见问题处理方法。 +",概述,MindSpore、MindSpore、网络、MindConverter、TensorFlow、PyTorch、数据、可视化、脚本 +概述§算子开发&调试,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html," +部分网络在迁移到MindSpore框架时会存在不支持的算子，除了向MindSpore开发者社区反馈之外，用户可以选择开发自定义MindSpore算子。本章包括进行算子开发的教程与示例，还有常见的调试技巧。 +",概述,MindSpore、MindSpore、算子、网络、调试、框架 +概述§网络调试,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html," +在网络脚本开发完成并补齐算子后，需要对模型进行调试保证输出结果正确。这章介绍了常用的网络调试思路：单Step与多轮迭代调试。常用的调试方法包括使用PyNative模式比对子网输出结果，MindSpore也支持自定义调试信息。最后会提供常见问题的处理方法。 +",概述,MindSpore、MindSpore、算子、网络、PyNative、调试、迭代、脚本 +概述§精度&性能调优,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html," +在网络脚本调试完成并可以顺利输出结果之后，我们需要对模型进行调试达到预期性能。MindSpore为开发者提供了Profiler性能调试工具，在算子性能、迭代性能、数据处理性能等方面提供了易用、丰富的调试功能，帮助用户快速定位、解决性能问题。调试教程分为Ascend平台与GPU平台调优，并提供了三个使用Profiler工具的例子。 +",概述,MindSpore、MindSpore、算子、GPU、Ascend、网络、调试、精度、数据、精度、迭代、脚本、性能 +概述§推理执行,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html," +MindSpore可以基于训练好的模型，在不同的硬件平台上执行推理任务，还可以基于MindSpore Serving部署在线推理服务。基于模型的推理可以通过训练参数文件或者网络模型文件进行推理，基于MindSpore Serving的在线推理可以通过gRPC或者RESTful等接口访问推理服务。 +",概述,MindSpore、MindSpore、接口、网络、MindSpore Serving、Serving +概述§网络迁移调试实例,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html," +本章包含了一个完整的网络迁移样例，使用ResNet50为例子，从对标网络的分析与复现开始，详细说明脚本开发与精度调试调优等步骤，最后列出了迁移过程中的常见问题与相应优化方法，如多机同步问题、框架性能问题等等。 +",概述,网络、调试、精度、精度、优化、脚本、框架、性能 +概述§常见问题,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/overview.html," +我们会在这里列出整个网络迁移过程的常见问题与相应解决方法。 +",概述,网络 +准备工作§概述,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/preparation.html," +在进行网络开发或网络迁移工作之前，首先需要安装MindSpore，并掌握机器学习的相关知识。用户可以选择购买《深度学习与MindSpore实践》一书来了解相关知识，通过访问MindSpore官网了解MindSpore的用法。 +",准备工作,MindSpore、MindSpore、网络 +准备工作§安装MindSpore,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/preparation.html," +参考如下表格确定系统的发行版本、架构（X86或Arm）及Python版本。 + + + + + + + +系统 +查询内容 +查询命令 + + + +Linux +系统发行版本 +cat /proc/version + +Linux +系统架构 +uname -m + +Linux +Python版本 +python3 + + + +根据自己使用的操作系统及计算硬件，选择对应的MindSpore版本，通过Pip、Conda、Docker或源码编译等方式安装MindSpore，推荐访问MindSpore安装页面，并参考该网站指导完成安装。 +",准备工作,MindSpore、MindSpore、Linux、Arm、Conda +准备工作§MindSpore验证,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/preparation.html," +安装完成MindSpore后可以运行以下命令（以MindSpore r1.6版本为例），测试MindSpore是否安装完成。 + +[1]: + + +import mindspore + +mindspore.run_check() + + + + + + + + +MindSpore version: 1.6.0 +The result of multiplication calculation is correct, MindSpore has been installed successfully! + + +",准备工作,MindSpore、MindSpore +准备工作§知识准备,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/preparation.html," + +MindSpore编程指南 +用户可以通过参考MindSpore教程了解如何使用MindSpore进行训练、调试、调优、推理；也可以通过参考MindSpore编程指南了解MindSpore的基本组成和常用编程方法；也可以通过参考MindSpore Python API详细了解MindSpore各接口的相关信息，以便于用户能够更好地使用。 + + +ModelZoo和Hub +ModelZoo是MindSpore与社区共同提供的深度优化的模型集市，向开发者提供了深度优化的模型，以便于生态中的小伙伴可以方便地基于ModelZoo中的模型进行个性化开发。当前已经覆盖了机器视觉、自然语言处理、语音、推荐系统等多个领域的主流模型。 +mindspore Hub是存放MindSpore官方或者第三方开发者提供的预训练模型的平台。它向应用开发者提供了简单易用的模型加载和微调API，使得用户可以基于预训练模型进行推理或者微调，并部署到自己的应用中。用户也可以将自己训练好的模型按照指定的步骤发布模型到MindSpore Hub中，供其他用户下载和使用。 + + +云上训练 +ModelArts是华为云提供的面向AI开发者的一站式开发平台，集成了昇腾AI处理器资源池，用户可以在该平台下体验MindSpore。相关文档可参考AI开发平台ModelArts。 + +",准备工作,MindSpore、MindSpore、接口、API、Model、调试、优化、ModelZoo、ModelArts +网络脚本分析§算子评估,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/script_analysis.html," + +MindSpore算子设计 +使用MindSpore框架搭建神经网络流程与其他框架（TensorFlow/PyTorch）类似，但支持的算子存在差异，需要在进行网络迁移（例如由TensorFlow迁移至MindSpore Ascend平台）时找出MindSpore框架缺失的算子。 +MindSpore API由各种Python/C++ API算子组成，可以大致分为： + +数据框架算子 +包括张量、基本数据类型、训练梯度、优化器算子，如mindspore.int32、mindspore.nn.Cell等。 + +数据预处理算子 +包括图片读取、数据类型转化算子，如mindspore.dataset.MnistDataset等。 + +网络结构算子 +包括网络构建中使用到的卷积、归一化算子，如mindspore.nn.Conv2d、mindspore.nn.Dense等。 +网络结构算子表层为ME算子，即用户调用的算子API（例如mindspore.nn.Softmax），ME算子底层调用TBE算子（C/C++）实现。 +统计缺失ME算子时，需要找出源码脚本中所有算子（含数据框架类、数据预处理、网络结构算子）在MindSpore框架的对应算子（例如tf.nn.relu对应MindSpore算子为mindspore.nn.ReLU）。如果MindSpore中没有对应算子，则计入缺失。 + + + + +查询算子映射表 +在代码库找到网络结构及实现训练功能的Python文件（名称一般为train.py model.py等等），在脚本文件中查找所有相关算子（含数据框架类、数据预处理、网络结构算子），并与MindSpore算子API对比，查找mindspore.nn或者mindspore.ops下算子的平台支持情况。 +若该网页均未能找到对应的ME算子，则可继续在MindSpore API列表中搜索算子名称。 +若源码为PyTorch脚本，则可以直接查询MindSpore与PyTorch的算子映射找到对应的MindSpore算子。其他框架算子的映射可以参考算子命名与功能描述。注意，针对相同功能的算子，MindSpore的命名可能与其他框架不同，同名算子参数与功能也可能与其他框架有区别，均以官方描述为准。 + + +缺失算子处理策略 + +考虑用其他算子替换：需要分析算子实现公式，审视是否可以用现有MindSpore算子叠加达到预期目标。 +考虑使用自定义算子实现：参考Custom算子的使用指南。 +考虑通过自定义算子方式使用其他已有第三方算子库实现：参考基于自定义算子接口调用第三方算子库。 +考虑临时规避方案：比如某个loss不支持，可以替换为同类已支持的loss算子。 +在MindSpore社区提交建议开发缺失算子。 + + +",网络脚本分析,MindSpore、MindSpore、优化器、算子、接口、Ascend、数据类型、网络、评估、TensorFlow、PyTorch、API、model、loss、数据、优化、脚本、框架、dataset、C++ +网络脚本分析§语法评估,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/script_analysis.html," +MindSpore提供GRAPH_MODE和PYNATIVE_MODE两种模式。 +PyNative模式下模型进行推理的行为与一般Python代码无异。 +而在使用GRAPH_MODE时，或使用PYNATIVE_MODE进行训练时，通常会出现语法限制。在这两种情况下，需要对Python代码进行图编译操作，而这一步操作中MindSpore目前还未能支持完整的Python语法全集，所以construct函数的编写会存在部分限制。具体限制内容可以参考MindSpore静态图语法。 + +常见限制原则 +相较于详细的语法说明，常见的限制可以归结为以下几点： + +构图时不要调用其他Python库，例如numpy、scipy，相关的处理应该前移到__init__阶段。 +构图时不要使用自定义类型，而应该使用MindSpore提供的数据类型和Python基础类型，可以使用基于这些类型的tuple/list组合。 +构图时不要对数据进行多线程或多进程处理。 + + + +常见处理策略 + +使用MindSpore内部提供的算子替换其他Python库的功能。常量的处理可以前移到__init__阶段。 +使用基础类型进行组合，可以考虑增加函数参数量。函数入参数没有限制，并且可以使用不定长输入。 +避免网络中出现多线程处理。 + + +",网络脚本分析,MindSpore、MindSpore、算子、数据类型、网络、PYNATIVE、评估、数据、脚本、scipy、GRAPH +使用mindconverter迁移模型定义脚本§工具概述,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/migrate_3rd_scripts_mindconverter.html," +MindConverter是一款模型迁移工具，可将PyTorch(ONNX)或Tensorflow(PB)模型快速迁移到MindSpore框架下使用。模型文件（ONNX/PB）包含网络模型结构（network）与权重信息（weights），迁移后将生成MindSpore框架下的模型定义脚本（model.py）与权重文件（ckpt）。 + +此外，本工具支持通过在PyTorch网络脚本中增加API(pytorch2mindspore)的方式，将PyTorch网络模型迁移到MindSpore框架下。 +",使用MindConverter迁移模型定义脚本,MindSpore、MindSpore、网络、mindconverter、Tensorflow、PyTorch、ONNX、PB、API、model、模型结构、脚本、框架 +使用mindconverter迁移模型定义脚本§快速开始,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/migrate_3rd_scripts_mindconverter.html," +安装MindConverter请参考工具安装，安装完成后可获得命令行和API如下： + +使用命令行 +mindconverter --model_file /path/to/model_file --shape SHAPE --input_nodes INPUTS --output_nodes OUTPUTS + + + +--model_file指定模型文件路径，模型文件支持onnx或pb格式。 +--shape指定模型输入shape信息，多输入场景以空格分隔。 +--input_nodes指定模型输入节点名称，多输入场景以空格分隔。 +--output_nodes指定模型输出节点名称，多输出场景以空格分隔。 +转换结果默认输出到$PWD/output。 + +注意事项： + +模型文件为onnx格式，如果模型输入shape是静态数值，只需要指定--model_file即可完成转换；否则需要指定--shape和--input_nodes才可完成转换；--output_nodes可省略。模型输入shape判断请参考常见问题。 +模型文件为pb格式，无特殊场景。 + +更多CLI参数请参考命令行参数说明。 + + +使用API +在PyTorch网络脚本中添加如下代码。 +from mindconverter import pytorch2mindspore +pytorch2mindspore(model, dummy_inputs) + + +API使用方法请参考MindConvrter API描述。 + +",使用MindConverter迁移模型定义脚本,mindspore、mindspore、网络、mindconverter、PyTorch、onnx、pb、API、model、脚本、npu +使用mindconverter迁移模型定义脚本§工具安装,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/migrate_3rd_scripts_mindconverter.html," + +环境依赖 +使用MindConverter前需要安装以下依赖包，建议在x86环境下安装。ARM环境请参考常见问题。 + +使用命令行 +# 安装配套版本的MindSpore（以r1.2版本为例） +pip install mindspore~=1.2.0 + +# 安装onnx相关的依赖包 +pip install onnx~=1.8.0 +pip install onnxoptimizer~=0.1.2 +pip install onnxruntime~=1.5.2 + +# 如果使用 Tensorflow PB 文件转换，则需安装tf2onnx +pip install tf2onnx~=1.7.1 + + + + +使用API +# 安装配套版本的MindSpore（以r1.6版本为例） +pip install mindspore~=1.6.0 + +# 安装Torch (建议使用Torch官方的LTS版本1.8.2) +pip install torch==1.8.2+cpu -f https://download.pytorch.org/whl/lts/1.8/torch_lts.html + + + + + +安装方式 +可以采用pip或源码编译方式进行安装。 + +pip安装 +安装PyPI上的版本: +pip install mindconverter + + +安装自定义版本: +pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/{version}/MindInsight/any/mindconverter-{version}-py3-none-any.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple + + + + +在联网状态下，安装whl包时会自动下载MindConverter安装包的依赖项（依赖项详情参见requirements.txt），其余情况需自行安装。 +{version}表示MindConverter版本号，例如下载1.6.0版本MindConverter时，{version}应写为1.6.0。 + + + + +源码编译安装 +从代码仓下载源码 +git clone https://gitee.com/mindspore/mindinsight.git -b r1.7 + + +编译安装MindConverter，可选择以下任意一种安装方式： + +在源码根目录下执行如下命令。 +cd mindinsight/ecosystem_tools/mindconverter +pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple +python setup.py install + + + +构建whl包进行安装。 +进入源码的根目录，先执行build目录下的MindConverter编译脚本，再执行命令安装output目录下生成的whl包。 +cd mindinsight +bash build/build.sh mindconverter +pip install output/mindverter-{version}-py3-none-any.whl -i https://pypi.tuna.tsinghua.edu.cn/simple + + + + + + +",使用MindConverter迁移模型定义脚本,MindSpore、MindSpore、optimizer、runtime、cpu、MindInsight、mindconverter、Tensorflow、pytorch、onnx、PB、API、ARM、脚本、whl包 +使用mindconverter迁移模型定义脚本§迁移方案,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/migrate_3rd_scripts_mindconverter.html," +一个网络模型工程，通常包含以下四个主要组成部分，各部分的迁移指引如下： + +模型定义（model.py） + +使用MindConverter工具转换模型结构。 +手工调整可读性（可选）。 +转换后的模型内嵌到原框架工程，验证转换等价性，参考常见问题。 + + +数据处理（dataset.py） + +内置数据集可查询接口映射辅助转换。 +自定义数据集与相关数据处理，可参考转换模板。 + + +模型训练（train.py） + +损失函数（loss_fn），可查询接口映射或自定义实现。 +优化器（optimizer），可查询接口映射或自定义实现。 +模型训练的代码比较灵活，代码组织风格与MindSpore图模式差异较大，建议自行实现，参考转换模板。 + + +模型推理（eval.py） + +度量指标（metric），可查询接口映射或自定义实现。 +模型推理的代码比较灵活，代码组织风格与MindSpore图模式差异较大，建议自行实现，参考转换模板。 + + + +",使用MindConverter迁移模型定义脚本,MindSpore、MindSpore、优化器、接口、数据集、损失函数、optimizer、模型推理、网络、mindconverter、model、loss、metric、数据、模型结构、优化、脚本、框架、dataset、eval +使用mindconverter迁移模型定义脚本§实践步骤,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/migrate_3rd_scripts_mindconverter.html," + +第0步：导出模型文件 +以PyTorch框架为例导出ONNX模型文件（Tensorflow框架请参考常见问题），需要Pytorch算子支持相应的ONNX算子，详情参考Pytorch与ONNX的算子列表，操作步骤如下： + +下载网络模型工程的源码、权重文件、数据集。 +分析模型定义代码，整改forward函数的入参列表，确保入参均为Tensor类型，参考常见问题。 +从模型推理的代码中，识别模型对象（model）与输入的shape信息，导出ONNX文件。 +import torch + +# 根据实际情况替换以下类路径 +from customized.path.to.pytorch.model import PyTorchNetwork + +model = PyTorchNetwork() +param_dict = torch.load('/path/to/weights.pth') +model.load_state_dict(param_dict) + +input_shape = (1, 3, 224, 224) +input_tensor = torch.randn(*input_shape, dtype=torch.float32) +torch.onnx.export(model, input_tensor, '/path/to/model.onnx', opset_version=11) + + + +验证ONNX模型与原脚本精度是否一致。 +import onnxruntime +import numpy as np + +session = onnxruntime.InferenceSession('/path/to/model.onnx') +input_node = session.get_inputs()[0] +output = session.run(None, {input_node.name: np.load('/path/to/input.npy')}) +assert np.allclose(output, np.load('/path/to/output.npy')) + + + + + + +第1步：转换模型定义 +执行MindConverter CLI命令，生成MindSpore模型文件（model.py）、权重信息（ckpt）、转换报告与权重映射表。 +mindconverter --model_file /path/to/model.onnx + + +如果需要从.onnx文件中获取模型输入节点shape、输入节点名称、输出节点名称，推荐使用Netron工具加载ONNX模型文件，获取上述信息。 +模型文件（model.py）与权重信息（ckpt）可用于验证模型迁移的等价性，也可用于导出MindIR格式文件。 +import mindspore +import numpy as np + +# 根据实际情况替换以下类路径 +from customized.path.to.mindspore.model import MindSporeNetwork + +network = MindSporeNetwork() +param_dict = mindspore.load_checkpoint('network.ckpt') +mindspore.load_param_into_net(network, param_dict) + +input_data = np.load('/path/to/input.npy') +output_benchmark = np.load('/path/to/output.npy') + +# 验证迁移等价性 +output_data = network(mindspore.Tensor(input_data)) +assert np.allclose(output_data.asnumpy(), output_benchmark) + +# 导出MindIR文件 +mindspore.export(network, mindspore.Tensor(input_data)), file_name='your_network_name', file_format='MINDIR') + + +注意事项： + +由于模型转换工具以推理模式加载ONNX文件，转换后会导致网络中Dropout算子丢失，需要用户手动补齐。 +模型转换工具本质上为算子驱动，对于MindConverter未维护的ONNX算子与MindSpore算子映射，将会出现相应的算子无法转换的问题，对于该类算子，用户可手动修改，或基于MindConverter实现映射关系，向MindInsight仓库贡献。 +在使用基于计算图的迁移时，MindConverter会根据--shape参数将模型输入的批次大小（batch size）、句子长度（sequence length）、图片尺寸（image shape）等尺寸相关参数固定下来，用户需要保证基于MindSpore重训练、推理时输入shape与转换时一致；若需要调整输入尺寸，请重新指定--shape进行转换，或修改转换后脚本中涉及张量尺寸变更操作相应的操作数。 +脚本文件和权重文件输出于同一个目录下，转换报告和权重映射表输出于同一个目录下。 +模型文件的安全性与一致性请用户自行保证。 + + + +第2步：转换数据处理 +内置数据集可直接查询接口映射，自定义数据集需要自行实现，更多转换方案可参考数据处理。 +PyTorch源码如下： +from torch.utils.data import Dataset, DataLoader +from torchvision import transforms + +class CustomDataset(Dataset): + def __init__(self, *args, **kwargs): + self.records = [...] + self.labels = [...] + # 定义数据增强 + self.transform = transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), + ]) + def __len__(self): + return len(self.labels) + def __getitem__(self, idx): + # 执行数据增强 + data = self.transform(self.records[idx]) + return data, self.labels[idx] + +dataset = CustomDataset(*args, **kwargs) +data_loader = DataLoader(dataset, batch_size=BATCH_SIZE) + + +对应MindSpore代码如下： +from mindspore.dataset import GeneratorDataset +from mindspore.dataset import py_transforms as transforms + +class CustomGenerator: + def __init__(self, *args, **kwargs): + self.records = [...] + self.labels = [...] + # 定义数据增强 + self.transform = transforms.Compose([ + transforms.ToTensor(), + transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)), + ]) + def __len__(self): + return len(self.labels) + def __getitem__(self, idx): + # 执行数据增强 + data = self.transform(self.records[idx]) + return data, self.labels[idx] + +generator = CustomGenerator(*args, **kwargs) +dataset = GeneratorDataset(generator, column_names=['data', 'label']).batch(BATCH_SIZE) + + + + +第3步：转换模型训练 +损失函数（loss_fn）可查询接口映射或自定义实现，更多转换方案可参考损失函数。 +优化器（optimizer）可查询接口映射或自定义实现，更多转换方案可参考优化器。 +模型训练的代码比较灵活，代码组织风格与MindSpore图模式差异较大，建议自行实现，更多转换方案可参考网络构建。 +PyTorch源码如下： +import torch + +# 根据实际情况替换以下类路径 +from customized.path.to.pytorch.model import PyTorchNetwork + +# 创建网络模型实例 +network = PyTorchNetwork() + +# 定义优化器与学习率 +optimizer = torch.optim.SGD(network.parameters(), lr=LEARNING_RATE) +scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=DECAY_RATE) + +# 执行模型训练 +for i in range(EPOCH_SIZE): + for data, label in data_loader: + optimizer.zero_grad() + output = network(data) + loss = loss_fn(output, label) + loss.backward() + optimizer.step() + scheduler.step() + + +对应MindSpore代码（Low-Level API）如下： +from mindspore import nn + +# 根据实际情况替换以下类路径 +from customized.path.to.mindspore.model import MindSporeNetwork + +# 创建网络模型实例 +network = MindSporeNetwork() + +# 定义学习率与优化器 +scheduler = nn.ExponentialDecayLR(LEARNING_RATE, decay_rate=DECAY_RATE, decay_steps=1) +optimizer = nn.SGD(params=network.trainable_params(), learning_rate=scheduler) + +# 执行模型训练 +net_with_loss = nn.WithLossCell(network, loss_fn) +train_network = nn.TrainOneStepCell(net_with_loss, optimizer) +train_network.set_train() +data_iterator = dataset.create_tuple_iterator(num_epochs=EPOCH_SIZE) +for i in range(EPOCH_SIZE): + for data, label in data_iterator: + loss = train_network(data, label) + + +对应MindSpore代码（High-Level API）如下： +from mindspore import nn +from mindspore import Model + +# 根据实际情况替换以下类路径 +from customized.path.to.mindspore.model import MindSporeNetwork + +# 创建网络模型实例 +network = MindSporeNetwork() + +# 定义学习率与优化器 +scheduler = nn.ExponentialDecayLR(LEARNING_RATE, decay_rate=DECAY_RATE, decay_steps=1) +optimizer = nn.SGD(params=network.trainable_params(), learning_rate=scheduler) + +# 执行模型训练 +model = Model(network, loss_fn=loss_fn, optimizer=optimizer) +model.train(EPOCH_SIZE, dataset) + + + + +第4步：转换模型推理 +度量指标（metric），可查询接口映射或自定义实现。 +模型推理的代码比较灵活，代码组织风格与MindSpore图模式差异较大，建议自行实现，更多转换方案可参考模型推理。 +PyTorch源码如下： +import torch + +# 根据实际情况替换以下类路径 +from customized.path.to.pytorch.model import PyTorchNetwork + +network = PyTorchNetwork() +param_dict = torch.load('/path/to/weights.path') +network.load_state_dict(param_dict) + +for data, label in data_loader: + output = network(data) + loss = loss_fn(output, label) + accuracy = metric_fn(output, label) + print(accuracy) + + +对应MindSpore代码（Low-Level API）如下： +import mindspore + +# 根据实际情况替换以下类路径 +from customized.path.to.mindspore.model import MindSporeNetwork + +network = MindSporeNetwork() +param_dict = mindspore.load_checkpoint('/path/to/weights.ckpt') +mindspore.load_param_into_net(network, param_dict) + +data_iterator = dataset.create_tuple_iterator() +for data, label in data_iterator: + output = network(data) + loss = loss_fn(output, label) + accuracy = metric_fn(output, label) + print(accuracy) + + +对应MindSpore代码（High-Level API）如下： +import mindspore +from mindspore import Model + +# 根据实际情况替换以下类路径 +from customized.path.to.mindspore.model import MindSporeNetwork + +network = MindSporeNetwork() +param_dict = mindspore.load_checkpoint('/path/to/weights.ckpt') +mindspore.load_param_into_net(network, param_dict) + +model = Model(network, loss_fn=loss_fn, metrics={'accuracy'}) +accuracy = model.eval(dataset) + + + +",使用MindConverter迁移模型定义脚本,MindSpore、MindSpore、优化器、算子、接口、数据集、损失函数、optimizer、runtime、模型推理、MindInsight、MindIR、网络、mindconverter、Tensorflow、PyTorch、ONNX、API、model、SGD、loss、metric、DataLoader、GeneratorDataset、TrainOneStepCell、lr、学习率、精度、数据、计算图、精度、优化、脚本、框架、Dataset、eval、npu +使用mindconverter迁移模型定义脚本§命令行参数说明,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/migrate_3rd_scripts_mindconverter.html," +usage: mindconverter [-h] [--version] + [--model_file MODEL_FILE] [--shape SHAPE [SHAPE ...]] + [--input_nodes INPUT_NODES [INPUT_NODES ...]] + [--output_nodes OUTPUT_NODES [OUTPUT_NODES ...]] + [--output OUTPUT] [--report REPORT] + + +参数含义如下： + + + +参数名 +必填 +功能描述 +类型 +默认值 +取值示例 + + + + +-h, --help +否 +显示帮助信息 +- +- +- + + +--version +否 +显示版本信息 +- +- +- + + +--model_file +是 +指定模型文件路径 +String +- +/path/to/model.onnx + + +--shape +是 +指定模型输入shape信息，多输入场景以空格分隔 +String +- +1,3,224,224 + + +--input_nodes +是 +指定模型输入节点名称，多输入场景以空格分隔 +String +- +input_1:0 + + +--output_nodes +是 +指定模型输出节点名称，多输出场景以空格分隔 +String +- +output_1:0 output_2:0 + + +--output +否 +指定转换生成文件的保存目录 +String +$PWD +/path/to/output/dir + + + +",使用MindConverter迁移模型定义脚本,mindconverter、onnx、model、脚本、npu +使用mindconverter迁移模型定义脚本§模型支持列表,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/migrate_3rd_scripts_mindconverter.html," +MindConverter已支持转换的模型列表，请参考链接。 +",使用MindConverter迁移模型定义脚本,mindconverter、脚本 +使用mindconverter迁移模型定义脚本§错误码速查表,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/migrate_3rd_scripts_mindconverter.html," +MindConverter错误码定义，请参考链接。 +",使用MindConverter迁移模型定义脚本,mindconverter、脚本 +使用mindconverter迁移模型定义脚本§常见问题,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/migrate_3rd_scripts_mindconverter.html," + +ARM环境安装依赖组件 +ARM环境下使用模型迁移工具，需要源码编译安装protobuf/onnx/onnxoptimizer，编译过程可能涉及其他系统组件，现编译报错需要人工排查，因此建议切换到x86环境中使用模型迁移工具。 + +源码编译安装protobuf（参考 ONNX）与cpp后端。 +# 编译安装 protobuf +git clone https://github.com/protocolbuffers/protobuf.git +cd protobuf +git checkout v3.16.0 +git submodule update --init --recursive +mkdir build_source +cd build_source +cmake ../cmake -Dprotobuf_BUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX=/usr/local/protobuf -DCMAKE_INSTALL_SYSCONFDIR=/etc -DCMAKE_POSITION_INDEPENDENT_CODE=ON -Dprotobuf_BUILD_TESTS=OFF -DCMAKE_BUILD_TYPE=Release +make -j$(nproc) +make install + +# 安装cpp后端 +cd ../python +python setup.py install --cpp_implementation + + + +设置protobuf环境变量。 +export PROTOBUF_PATH=/usr/local/protobuf +export PATH=$PROTOBUF_PATH/bin:$PATH +export PKG_CONFIG_PATH=$PROTOBUF_PATH/lib/pkgconfig +export LD_LIBRARY_PATH=$PROTOBUF_PATH/lib:$LD_LIBRARY_PATH +export LIBRARY_PATH=$PROTOBUF_PATH/lib:$LIBRARY_PATH +export PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION=cpp + + + +验证protobuf的cpp后端。 +from google.protobuf.internal import api_implementation +print(api_implementation.Type()) + + + +安装protobuf后，需要通过源码编译方式，重新安装onnx，以保证onnx基于静态库编译的protobuf运行，详情参考 安装指引。 +git clone https://github.com/onnx/onnx.git +cd onnx +git submodule update --init --recursive +# prefer lite proto +set CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON +pip install -e . + + + +源码编译安装onnxoptimizer，详情参考 安装指引。 +git clone --recursive https://github.com/onnx/optimizer onnxoptimizer +cd onnxoptimizer +pip3 install -e . + + + +安装onnxruntime。 +pip install onnxruntime~=1.5.2 + + + + + + +判断模型输入shape的形式 +使用Netron工具加载ONNX模型文件，点击最上面的一个节点，观察侧栏中INPUTS里每一个输入的type，如果type是一个具体数值，如int64[1,9]，那么当前输入为静态；否则为动态，如int64[batch,sequence]。 + + +TensorFlow模型导出 +Tensorflow模型导出PB文件，进而映射成ONNX算子，需要Tensorflow算子支持相应的ONNX算子，详情参考Tensorflow与ONNX的算子列表。使用Keras构建模型的用户，可尝试如下方法进行导出： +TensorFlow 1.x版本 +import tensorflow as tf +from tensorflow.python.framework import graph_io +from tensorflow.python.keras.applications.inception_v3 import InceptionV3 + +model = InceptionV3() +INPUT_NODES = [ipt.op.name for ipt in model.inputs] +OUTPUT_NODES = [opt.op.name for opt in model.outputs] + +tf.keras.backend.set_learning_phase(0) +session = tf.keras.backend.get_session() +with session.graph.as_default(): + graph_inf = tf.graph_util.remove_training_nodes(session.graph.as_graph_def()) + graph_frozen = tf.graph_util.convert_variables_to_constants(session, graph_inf, OUTPUT_NODES) + graph_io.write_graph(graph_frozen, logdir=""/path/to/output/dir"", name=""model.pb"", as_text=False) + +print(f""Input nodes name: {INPUT_NODES}, output nodes name: {OUTPUT_NODES}"") + + +TensorFlow 2.x版本 +import tensorflow as tf +from tensorflow.python.framework.convert_to_constants import convert_variables_to_constants_v2 +from tensorflow.keras.applications import InceptionV3 + +model = InceptionV3() +spec = tf.TensorSpec(model.inputs[0].shape, model.inputs[0].dtype) +full_model = tf.function(lambda x: model(x)).get_concrete_function(spec) +frozen_func = convert_variables_to_constants_v2(full_model) +frozen_func.graph.as_graph_def() +tf.io.write_graph(frozen_func.graph, logdir=""/path/to/output/dir"", name=""model.pb"", as_text=False) + + +TensorFlow不作为MindConverter明确声明的依赖库，若想使用基于图结构的模型转换工具，需要手动安装TensorFlow。 + + +整改forward参数列表 +某些模型的forward参数列表中，包含非Tensor类型的入参，示例如下： +class Model(nn.Cell): + def __init__(self, *args, **kwargs): + self.op = Operator() + self.loss_fn = LossFunction() + def forward(self, data, label): + output = self.op(data) + loss = self.loss_fn(output, label) + return output, loss + + +其中 label 不是Tensor类型的入参，需要进行整改： +class Model(nn.Cell): + def __init__(self, *args, **kwargs): + self.op = Operator() + def forward(self, data): + output = self.op(data) + return output + + + + +MindSpore模型内嵌到原框架 +将MindSpore的模型内嵌到PyTorch脚本中，结合权重信息，验证转换的等价性。 +import mindspore +import torch +from torch.utils.data import DataLoader + +# 根据实际情况替换以下类路径 +from customized.path.to.mindspore.model import MindSporeNetwork + +network = MindSporeNetwork() +param_dict = mindspore.load_checkpoint('network.ckpt') +mindspore.load_param_into_net(network, param_dict) + +data_loader = DataLoader(dataset, batch_size=BATCH_SIZE) +for data, label in data_loader: + ms_data = mindspore.Tensor(data.numpy()) + ms_output = network(ms_data) + output = torch.Tensor(ms_output.asnumpy()) + loss = loss_fn(output, label) + accuracy = metric_fn(output, label) + print(accuracy) + + + + +转换报告与权重映射表 +对于未成功转换的算子，转换报告记录未转换的代码行与算子信息，同时在代码中标识该节点输入/输出的shape（分别表示为input_shape与output_shape），便于用户手动修改。以Reshape算子为例，将生成如下代码： +class Classifier(nn.Cell): + def __init__(self): + super(Classifier, self).__init__() + self.reshape = onnx.Reshape(input_shape=(1, 1280, 1, 1), output_shape=(1, 1280)) + + def construct(self, x): + # Suppose input of `reshape` is x. + reshape_output = self.reshape(x) + # skip codes ... + + +通过input_shape、output_shape参数，用户可以便捷地完成算子替换，替换结果如下： +from mindspore import ops + +class Classifier(nn.Cell): + def __init__(self): + super(Classifier, self).__init__() + self.reshape = ops.Reshape(input_shape=(1, 1280, 1, 1), output_shape=(1, 1280)) + + def construct(self, x): + # Suppose input of `reshape` is x. + reshape_output = self.reshape(x, (1, 1280)) + # skip codes ... + + +权重映射表保存算子在MindSpore中的权重信息（converted_weight）和在原始框架中的权重信息（source_weight），示例如下： +{ + ""resnet50"": [ + { + ""converted_weight"": { + ""name"": ""conv2d_0.weight"", + ""shape"": [64, 3, 7, 7], + ""data_type"": ""Float32"" + }, + ""source_weight"": { + ""name"": ""conv1.weight"", + ""shape"": [64, 3, 7, 7], + ""data_type"": ""float32"" + } + } + ] +} + + + + +基于AST转换脚本 +MindConverter支持基于AST的方案进行PyTorch脚本迁移，通过对原脚本的抽象语法树进行解析、编辑，将其替换为MindSpore的抽象语法树，再利用抽象语法树生成代码。 + +抽象语法树语法树解析操作受原脚本用户编码风格影响，可能导致同一模型的不同脚本最终的转换率存在一定差异，因此AST方案已调整为DEPRECATED状态，将在r2.0版本移除。 + +假设原PyTorch脚本路径为/path/to/model.py，用户希望将脚本输出至/path/to/output/dir，转换命令如下： +mindconverter --in_file /path/to/model.py --output /path/to/output/dir + + +转换报告中，对于未转换的代码行形式为如下，其中x, y指明的是原PyTorch脚本中代码的行、列号。对于未成功转换的算子，可参考MindSporeAPI映射查询功能手动对代码进行迁移。对于工具无法迁移的算子，会保留原脚本中的代码。 +line x:y: [UnConvert] 'operator' didn't convert. ... + + +以下转换报告示例中，对于部分未成功转换的算子，转换报告提供修改建议：如line 157:23，将torch.nn.AdaptiveAvgPool2d替换为mindspore.ops.ReduceMean。 + [Start Convert] + [Insert] 'from mindspore import ops' is inserted to the converted file. + line 1:0: [Convert] 'import torch' is converted to 'import mindspore'. + ... + line 157:23: [UnConvert] 'nn.AdaptiveAvgPool2d' didn't convert. Maybe could convert to mindspore.ops.ReduceMean. + ... + [Convert Over] + + +AST方案不支持以下场景： + +部分类和方法目前无法转换。 + +使用torch.Tensor的shape，ndim和dtype成员 +torch.nn.AdaptiveXXXPoolXd和torch.nn.functional.adaptive_XXX_poolXd() +torch.nn.functional.Dropout +torch.unsqueeze()和torch.Tensor.unsqueeze() +torch.chunk()和torch.Tensor.chunk() + + +继承的父类是nn.Module的子类。 +# 代码片段摘自torchvision.models.mobilenet +from torch import nn + +class ConvBNReLU(nn.Sequential): + def __init__(self, in_planes, out_planes, kernel_size=3, stride=1, groups=1): + padding = (kernel_size - 1) // 2 + super(ConvBNReLU, self).__init__( + nn.Conv2d(in_planes, out_planes, kernel_size, stride, padding, groups=groups, bias=False), + nn.BatchNorm2d(out_planes), + nn.ReLU6(inplace=True) + ) + + + + + +",使用MindConverter迁移模型定义脚本,MindSpore、MindSpore、算子、optimizer、runtime、mindconverter、TensorFlow、PyTorch、onnx、PB、api、model、loss、metric、ARM、AST、DataLoader、脚本、框架、dataset、protobuf、graph、IB、NPU +迁移脚本§概述,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/migration_script.html," +本文档主要介绍，怎样将网络脚本从TensorFlow或PyTorch框架迁移至MindSpore。 +",迁移脚本,MindSpore、MindSpore、网络、TensorFlow、PyTorch、脚本、框架 +迁移脚本§TensorFlow脚本迁移MindSpore,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/migration_script.html," +通过读TensorBoard图，进行脚本迁移。 + +以TensorFlow实现的PoseNet为例，演示如何利用TensorBoard读图，编写MindSpore代码，将TensorFlow模型迁移到MindSpore上。 + +此处提到的PoseNet代码为基于Python2的代码，需要对Python3做一些语法更改才能在Python3上运行，具体修改内容不予赘述。 + + +改写代码，利用tf.summary接口，保存TensorBoard需要的log，并启动TensorBoard。 +打开的TensorBoard如图所示，图例仅供参考，可能因log生成方式的差异，TensorBoard展示的图也有所差异。 + + +找到3个输入的Placeholder，通过看图并阅读代码得知，第二、第三个输入都只在计算loss时使用。 + + + +至此，我们可以初步划分出，构造网络模型三步： +第一步，在网络的三个输入中，第一个输入将在backbone中计算出六个输出； +第二步，上一步结果与第二、第三个输入在loss子网中计算loss； +第三步，利用TrainOneStepCell自动微分构造反向网络；利用TensorFlow工程中提供的Adam优化器及属性，写出对应的MindSpore优化器来更新参数，网络脚本骨干可写作： +import mindspore +from mindspore import nn +from mindspore.nn import TrainOneStepCell +from mindspore.nn import Adam + +# combine backbone and loss +class PoseNetLossCell(nn.Cell): + def __init__(self, backbone, loss): + super(PoseNetLossCell, self).__init__() + self.pose_net = backbone + self.loss = loss + def construct(self, input_1, input_2, input_3): + p1_x, p1_q, p2_x, p2_q, p3_x, p3_q = self.poss_net(input_1) + loss = self.loss(p1_x, p1_q, p2_x, p2_q, p3_x, p3_q, input_2, input_3) + return loss + +# define backbone +class PoseNet(nn.Cell): + def __init__(self): + super(PoseNet, self).__init__() + def construct(self, input_1): + """"""do something with input_1, output num 6"""""" + return p1_x, p1_q, p2_x, p2_q, p3_x, p3_q + +# define loss +class PoseNetLoss(nn.Cell): + def __init__(self): + super(PoseNetLoss, self).__init__() + + def construct(self, p1_x, p1_q, p2_x, p2_q, p3_x, p3_q, poses_x, poses_q): + """"""do something to calc loss"""""" + return loss + +# define network +backbone = PoseNet() +loss = PoseNetLoss() +net_with_loss = PoseNetLossCell(backbone, loss) +opt = Adam(net_with_loss.trainable_params(), learning_rate=0.001, beta1=0.9, beta2=0.999, eps=1e-08, use_locking=False) +net_with_grad = TrainOneStepCell(net_with_loss, opt) + + + + + +接下来，我们来具体实现backbone中的计算逻辑。 +第一个输入首先经过了一个名为conv1的子图，通过看图可得，其中计算逻辑为： + +输入->Conv2D->BiasAdd->ReLU，虽然图上看起来，BiasAdd后的算子名虽然为conv1，但其实际执行的是ReLU。 + +这样一来，第一个子图conv1，可以定义如下，具体参数，与原工程中的参数对齐： +class Conv1(nn.Cell): + def __init__(self): + super(Conv1, self).__init__() + self.conv = Conv2d() + self.relu = ReLU() + def construct(self, x): + x = self.conv(x) + x = self.relu(x) + return x + + +通过观察TensorBoard图和代码，我们不难发现，原TensorFlow工程中定义的conv这一类型的子网，可以复写为MindSpore的子网，减少重复代码。 +TensorFlow工程conv子网定义： +def conv(self, + input, + k_h, + k_w, + c_o, + s_h, + s_w, + name, + relu=True, + padding=DEFAULT_PADDING, + group=1, + biased=True): + # Verify that the padding is acceptable + self.validate_padding(padding) + # Get the number of channels in the input + c_i = input.get_shape()[-1] + # Verify that the grouping parameter is valid + assert c_i % group == 0 + assert c_o % group == 0 + # Convolution for a given input and kernel + convolve = lambda i, k: tf.nn.conv2d(i, k, [1, s_h, s_w, 1], padding=padding) + with tf.variable_scope(name) as scope: + kernel = self.make_var('weights', shape=[k_h, k_w, c_i / group, c_o]) + if group == 1: + # This is the common-case. Convolve the input without any further complications. + output = convolve(input, kernel) + else: + # Split the input into groups and then convolve each of them independently + input_groups = tf.split(3, group, input) + kernel_groups = tf.split(3, group, kernel) + output_groups = [convolve(i, k) for i, k in zip(input_groups, kernel_groups)] + # Concatenate the groups + output = tf.concat(3, output_groups) + # Add the biases + if biased: + biases = self.make_var('biases', [c_o]) + output = tf.nn.bias_add(output, biases) + if relu: + # ReLU non-linearity + output = tf.nn.relu(output, name=scope.name) + return output + + +则对应MindSpore子网定义如下： +from mindspore import nn +from mindspore.nn import Conv2d, ReLU + +class ConvReLU(nn.Cell): + def __init__(self, channel_in, kernel_size, channel_out, strides): + super(ConvReLU, self).__init__() + self.conv = Conv2d(channel_in, channel_out, kernel_size, strides, has_bias=True) + self.relu = ReLU() + + def construct(self, x): + x = self.conv(x) + x = self.relu(x) + return x + + +那么，对照着TensorBoard中的数据流向与算子属性，backbone计算逻辑可编写如下： +from mindspore.nn import MaxPool2d +import mindspore.ops as ops + + +class LRN(nn.Cell): + def __init__(self, radius, alpha, beta, bias=1.0): + super(LRN, self).__init__() + self.lrn = ops.LRN(radius, bias, alpha, beta) + def construct(self, x): + return self.lrn(x) + + +class PoseNet(nn.Cell): + def __init__(self): + super(PoseNet, self).__init__() + self.conv1 = ConvReLU(3, 7, 64, 2) + self.pool1 = MaxPool2d(3, 2, pad_mode=""SAME"") + self.norm1 = LRN(2, 2e-05, 0.75) + self.reduction2 = ConvReLU(64, 1, 64, 1) + self.conv2 = ConvReLU(64, 3, 192, 1) + self.norm2 = LRN(2, 2e-05, 0.75) + self.pool2 = MaxPool2d(3, 2, pad_mode=""SAME"") + self.icp1_reduction1 = ConvReLU(192, 1, 96, 1) + self.icp1_out1 = ConvReLU(96, 3, 128, 1) + self.icp1_reduction2 = ConvReLU(192, 1, 16, 1) + self.icp1_out2 = ConvReLU(16, 5, 32, 1) + self.icp1_pool = MaxPool2d(3, 1, pad_mode=""SAME"") + self.icp1_out3 = ConvReLU(192, 5, 32, 1) + self.icp1_out0 = ConvReLU(192, 1, 64, 1) + self.concat = ops.Concat(axis=1) + self.icp2_reduction1 = ConvReLU(256, 1, 128, 1) + self.icp2_out1 = ConvReLU(128, 3, 192, 1) + self.icp2_reduction2 = ConvReLU(256, 1, 32, 1) + self.icp2_out2 = ConvReLU(32, 5, 96, 1) + self.icp2_pool = MaxPool2d(3, 1, pad_mode=""SAME"") + self.icp2_out3 = ConvReLU(256, 1, 64, 1) + self.icp2_out0 = ConvReLU(256, 1, 128, 1) + self.icp3_in = MaxPool2d(3, 2, pad_mode=""SAME"") + self.icp3_reduction1 = ConvReLU(480, 1, 96, 1) + self.icp3_out1 = ConvReLU(96, 3, 208, 1) + self.icp3_reduction2 = ConvReLU(480, 1, 16, 1) + self.icp3_out2 = ConvReLU(16, 5, 48, 1) + self.icp3_pool = MaxPool2d(3, 1, pad_mode=""SAME"") + self.icp3_out3 = ConvReLU(480, 1, 64, 1) + self.icp3_out0 = ConvReLU(480, 1, 192, 1) + """"""etc"""""" + """"""..."""""" + + def construct(self, input_1): + """"""do something with input_1, output num 6"""""" + x = self.conv1(input_1) + x = self.pool1(x) + x = self.norm1(x) + x = self.reduction2(x) + x = self.conv2(x) + x = self.norm2(x) + x = self.pool2(x) + pool2 = x + + x = self.icp1_reduction1(x) + x = self.icp1_out1(x) + icp1_out1 = x + + icp1_reduction2 = self.icp1_reduction2(pool2) + icp1_out2 = self.icp1_out2(icp1_reduction2) + + icp1_pool = self.icp1_pool(pool2) + icp1_out3 = self.icp1_out3(icp1_pool) + + icp1_out0 = self.icp1_out0(pool2) + + icp2_in = self.concat((icp1_out0, icp1_out1, icp1_out2, icp1_out3)) + """"""etc"""""" + """"""..."""""" + + return p1_x, p1_q, p2_x, p2_q, p3_x, p3_q + + +相应的，loss计算逻辑可编写如下： +class PoseNetLoss(nn.Cell): + def __init__(self): + super(PoseNetLoss, self).__init__() + self.sub = ops.Sub() + self.square = ops.Square() + self.reduce_sum = ops.ReduceSum() + self.sqrt = ops.Sqrt() + + def construct(self, p1_x, p1_q, p2_x, p2_q, p3_x, p3_q, poses_x, poses_q): + """"""do something to calc loss"""""" + l1_x = self.sqrt(self.reduce_sum(self.square(self.sub(p1_x, poses_x)))) * 0.3 + l1_q = self.sqrt(self.reduce_sum(self.square(self.sub(p1_q, poses_q)))) * 150 + l2_x = self.sqrt(self.reduce_sum(self.square(self.sub(p2_x, poses_x)))) * 0.3 + l2_q = self.sqrt(self.reduce_sum(self.square(self.sub(p2_q, poses_q)))) * 150 + l3_x = self.sqrt(self.reduce_sum(self.square(self.sub(p3_x, poses_x)))) * 1 + l3_q = self.sqrt(self.reduce_sum(self.square(self.sub(p3_q, poses_q)))) * 500 + return l1_x + l1_q + l2_x + l2_q + l3_x + l3_q + + +最终，你的训练脚本应该类似如下所示： +if __name__ == ""__main__"": + backbone = PoseNet() + loss = PoseNetLoss() + net_with_loss = PoseNetLossCell(backbone, loss) + opt = Adam(net_with_loss.trainable_params(), learning_rate=0.001, beta1=0.9, beta2=0.999, eps=1e-08, use_locking=False) + net_with_grad = TrainOneStepCell(net_with_loss, opt) + """"""dataset define"""""" + model = Model(net_with_grad) + model.train(epoch_size, dataset) + + +这样，就基本完成了模型脚本从TensorFlow到MindSpore的迁移，接下来就是利用丰富的MindSpore工具和计算策略，对精度进行调优，在此不予详述。 + + +",迁移脚本,MindSpore、自动微分、MindSpore、优化器、算子、接口、网络、TensorFlow、model、loss、TensorBoard、TrainOneStepCell、LR、aten、精度、数据、精度、优化、脚本、dataset、npu +迁移脚本§PyTorch脚本迁移MindSpore,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/migration_script.html," +通过读PyTorch脚本，直接进行迁移。 + +PyTorch子网模块通常继承torch.nn.Module，MindSpore通常继承mindspore.nn.Cell；PyTorch子网模块正向计算逻辑需要重写forward方法，MindSpore子网模块正向计算逻辑需要重写construct方法。 +以常见的Bottleneck类在MindSpore下的迁移为例。 +PyTorch工程代码 +# defined in PyTorch +class Bottleneck(nn.Module): + def __init__(self, inplanes, planes, stride=1, mode='NORM', k=1, dilation=1): + super(Bottleneck, self).__init__() + self.mode = mode + self.relu = nn.ReLU(inplace=True) + self.k = k + + btnk_ch = planes // 4 + self.bn1 = nn.BatchNorm2d(inplanes) + self.conv1 = nn.Conv2d(inplanes, btnk_ch, kernel_size=1, bias=False) + + self.bn2 = nn.BatchNorm2d(btnk_ch) + self.conv2 = nn.Conv2d(btnk_ch, btnk_ch, kernel_size=3, stride=stride, padding=dilation, + dilation=dilation, bias=False) + + self.bn3 = nn.BatchNorm2d(btnk_ch) + self.conv3 = nn.Conv2d(btnk_ch, planes, kernel_size=1, bias=False) + + if mode == 'UP': + self.shortcut = None + elif inplanes != planes or stride > 1: + self.shortcut = nn.Sequential( + nn.BatchNorm2d(inplanes), + self.relu, + nn.Conv2d(inplanes, planes, kernel_size=1, stride=stride, bias=False) + ) + else: + self.shortcut = None + + def _pre_act_forward(self, x): + residual = x + + out = self.bn1(x) + out = self.relu(out) + out = self.conv1(out) + + out = self.bn2(out) + out = self.relu(out) + out = self.conv2(out) + + out = self.bn3(out) + out = self.relu(out) + out = self.conv3(out) + + if self.mode == 'UP': + residual = self.squeeze_idt(x) + elif self.shortcut is not None: + residual = self.shortcut(residual) + + out += residual + + return out + + def squeeze_idt(self, idt): + n, c, h, w = idt.size() + return idt.view(n, c // self.k, self.k, h, w).sum(2) + + def forward(self, x): + out = self._pre_act_forward(x) + return out + + + +根据PyTorch和MindSpore对卷积参数定义的区别，可以翻译成如下定义： +from mindspore import nn +import mindspore.ops as ops + +# defined in MindSpore +class Bottleneck(nn.Cell): + def __init__(self, inplanes, planes, stride=1, k=1, dilation=1): + super(Bottleneck, self).__init__() + self.mode = mode + self.relu = nn.ReLU() + self.k = k + + btnk_ch = planes // 4 + self.bn1 = nn.BatchNorm2d(num_features=inplanes, momentum=0.9) + self.conv1 = nn.Conv2d(in_channels=inplanes, out_channels=btnk_ch, kernel_size=1, pad_mode='pad', has_bias=False) + + self.bn2 = nn.BatchNorm2d(num_features=btnk_ch, momentum=0.9) + self.conv2 = nn.Conv2d(in_channels=btnk_ch, out_channels=btnk_ch, kernel_size=3, stride=stride, pad_mode='pad', padding=dilation, dilation=dilation, has_bias=False) + + self.bn3 = nn.BatchNorm2d(num_features=btnk_ch, momentum=0.9) + self.conv3 = nn.Conv2d(in_channels=btnk_ch, out_channels=planes, kernel_size=1, pad_mode='pad', has_bias=False) + + self.shape = ops.Shape() + self.reshape = ops.Reshape() + self.reduce_sum = ops.ReduceSum() + + if mode == 'UP': + self.shortcut = None + elif inplanes != planes or stride > 1: + self.shortcut = nn.SequentialCell([ + nn.BatchNorm2d(num_features=inplanes, momentum=0.9), + nn.ReLU(), + nn.Conv2d(in_channels=inplanes, out_channels=planes, kernel_size=1, stride=stride, pad_mode='pad', has_bias=False) + ]) + else: + self.shortcut = None + + def _pre_act_forward(self, x): + residual = x + + out = self.bn1(x) + out = self.relu(out) + out = self.conv1(out) + + out = self.bn2(out) + out = self.relu(out) + out = self.conv2(out) + + out = self.bn3(out) + out = self.relu(out) + out = self.conv3(out) + + if self.shortcut is not None: + residual = self.shortcut(residual) + + out += residual + return out + + def construct(self, x): + out = self._pre_act_forward(x) + return out + + + +PyTorch的反向传播通常使用loss.backward()实现，参数更新通过optimizer.step()实现，在MindSpore中，这些不需要用户显式调用执行，可以交给TrainOneStepCell类进行反向传播和梯度更新。最后，训练脚本结构应如下所示： +# define dataset +dataset = ... + +# define backbone and loss +backbone = Net() +loss = NetLoss() + +# combine backbone and loss +net_with_loss = WithLossCell(backbone, loss) + +# define optimizer +opt = ... + +# combine forward and backward +net_with_grad = TrainOneStepCell(net_with_loss, opt) + +# define model and train +model = Model(net_with_grad) +model.train(epoch_size, dataset) + + + + +PyTorch和mindspore在一些基础API的定义上比较相似，比如mindspore.nn.SequentialCell和torch.nn.Sequential，另外，一些算子API可能不尽相同，此处列举一些常见的API对照，更多信息可以参考MindSpore官网的MindSpore与PyTorch对照表。 + + + +PyTorch +MindSpore + + + + +tensor.view() +mindspore.ops.operations.Reshape()(tensor) + + +tensor.size() +mindspore.ops.operations.Shape()(tensor) + + +tensor.sum(axis) +mindspore.ops.operations.ReduceSum()(tensor, axis) + + +torch.nn.Upsample[mode: nearest] +mindspore.ops.operations.ResizeNearestNeighbor + + +torch.nn.Upsample[mode: bilinear] +mindspore.ops.operations.ResizeBilinear + + +torch.nn.Linear +mindspore.nn.Dense + + +torch.nn.PixelShuffle +mindspore.ops.operations.DepthToSpace + + + +值得注意的是，尽管torch.nn.MaxPool2d和mindspore.nn.MaxPool2d在接口定义上较为相似，但在Ascend上的训练过程中，MindSpore实际调用了MaxPoolWithArgMax算子，该算子与TensorFlow的同名算子功能相同，在迁移过程中MaxPool层后的输出MindSpore与PyTorch不一致是正常现象，理论上不影响最终训练结果。 +",迁移脚本,MindSpore、MindSpore、算子、接口、optimizer、Ascend、TensorFlow、PyTorch、API、model、loss、TrainOneStepCell、反向传播、脚本、dataset +基本执行流程横向对比§总体流程,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/training_process_comparision.html," +MindSpore 的模型训练和推理的总体执行流程，基本与主流的 AI 框架（如 TensorFlow 和 PyTorch）类似，主要分为以下几个步骤： + +构建数据集对象 +定义正向网络结构 +定义 Loss +定义优化器 +迭代数据集对象，执行正向传播，输出 Loss +执行反向传播计算梯度 +优化器更新参数 + +以下是典型的 MindSpore、PyTorch 和 TensorFlow 的训练代码： + +MindSpore +from src.dataset import create_dataset +from src.lenet import LeNet +from mindspore import context, Model +from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor +from mindspore.nn import Accuracy + +# set context, including device type, device number... +context.set_context(mode=context.GRAPH_MODE, device_target=config.device_target) +# 1. define dataset object +ds_train = create_dataset(data_path, batch_size) +# 2. define forward network +network = LeNet(num_classes) +# 3. define loss +net_loss = SoftmaxCrossEntropyWithLogits() +# 4. define optimizer +net_opt = Momentum(network.trainable_params(), lr, momentum) +# define callbacks +config_ck = CheckpointConfig(save_checkpoint_steps) +ckpt_cb = ModelCheckpoint(prefix=""lenet"", config=config_ck) +loss_cb = LossMonitor() + +# define model +model = Model(network, net_loss, net_opt, metrics={""Accuracy"": Accuracy()}) +# 5-7. start training +model.train(epoch_size, ds_train, callbacks=[loss_cb, ckpoint_cb ]) + + +代码来源： ModelZoo/LeNet5 + +PyTorch +import torch +import torchvision +from model import LeNet +# 1. define dataset object and DataLoader +train_set = torchvision.datasets.CIFAR10(root='./data', train=True) +train_loader = torch.utils.data.DataLoader(train_set, batch_size) +# 2. define forward network +net = LeNet() +# 3. define loss +net_loss = torch.nn.CrossEntropyLoss() +# 4. define optimizer +net_opt = torch.optim.Adam(net.parameters(), lr) +for epoch in range(n): + for step, data in enumerate(train_loader, start=0): + inputs, labels = data + optimizer.zero_grad() + # 5. forward propagation and output loss + outputs = net(inputs) + loss = net_loss(outputs, labels) + # 6. backward propagation + loss.backward() + # 7. update parameters + net_opt.step() + print('Epoch {}, Loss: {}' % (epoch + 1, step + 1, loss,)) +print('Finished Training') +save_path = './Lenet.pth' +torch.save(net.state_dict(), path) + + + +TensorFlow +import tensorflow as tf +from model import LeNet +mnist = tf.keras.datasets.mnist +(x_train, y_train), (x_test, y_test) = mnist.load_data() +# 1. define dataset +train_ds = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32) +# 2. define forward network +model = LeNet() +# 3. define loss +net_loss = tf.keras.losses.SparseCategoricalCrossentropy() +# 4. define optimizer +net_opt = tf.keras.optimizers.Adam() + +@tf.function +def train_step(images, labels): + with tf.GradientTape() as tape: + # 5. forward execution and output loss + predictions = model(images) + loss = net_loss(labels, predictions) + # 6. backward propagation + gradients = tape.gradient(loss, model.trainable_variables) + # 7. update parameters + net_opt.apply_gradients(zip(gradients, model.trainable_variables)) + return loss + +for epoch in range(EPOCHS): + loss = 0 + for images, labels in train_ds: + loss = train_step(images, labels) + print('Epoch {}, Loss: {}'.format(epoch + 1, loss)) + + + + + +可以看到，MindSpore、PyTorch 和 TensorFlow 在步骤 1-4 的执行流程上几乎一致，API 也很相似，开发者在做网络迁移时可以很容易进行脚本适配。但在步骤 5-7 上，三者却有一定的差异，主要是因为 MindSpore、TensorFlow 和 PyTorch 实现自动微分的逻辑不同。下面我们就对其中的几点差异做详细说明。 +",基本执行流程横向对比,MindSpore、自动微分、MindSpore、优化器、数据集、optimizer、callback、网络、TensorFlow、PyTorch、API、Model、Loss、metric、DataLoader、反向传播、lr、数据、优化、迭代、ModelZoo、脚本、框架、dataset、GRAPH、npu +基本执行流程横向对比§构建数据集,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/training_process_comparision.html," +在构造自定义数据集时，MindSpore 和 PyTorch 有很多相似的 API，构造自定义 Dataset 对象的基本流程如下： + +首先创建一个类，在该类中定义 __init__ 、 __getitem__ 、 __len__ 三个方法。 +import numpy as np +class MyDataset(): + """"""Self Defined dataset."""""" + def __init__(self, n): + self.data = [] + self.label = [] + for _ in range(n): + data.append(np.zeros((3, 4, 5)) + label.append(np.ones((1)) + def __len__(self): + return len(self.data) + def __getitem__(self, idx): + data = self.data[idx] + label = self.label[idx] + return data, label + + +这里的 __len__ 和 __getitem__ 在 MindSpore 和 PyTorch 中都具有相同的意义， __len__ 表示数据集的总大小，__getitem__ 通过传入的 idx 获取相应索引的数据。虽然 MyDataset 类可以帮助我们在给定索引的情况下获取数据，但实际训练的过程中，我们还需要更加复杂的功能，例如：按照某种自定义顺序索引数据、将不同索引的数据组合成一个 batch、为分布式训练做数据切分等。为了实现这些复杂的功能，MindSpore 提供了一个更高层的 API mindspore.dataset.GeneratorDataset （对应到 PyTorch 上为 torch.utils.data.DataLoader ）。 + +使用 GeneratorDataset 封装 MyDataset，提供更多数据预处理操作。 +my_dataset = MyDataset(100) +# corresponding to torch.utils.data.DataLoader(my_dataset) +dataset = mindspore.dataset.GeneratorDataset(my_dataset) + + + + +可以发现，无论是 MindSpore 的 GeneratorDataset 还是 PyTorch 的 DataLoader，都提供了很多参数，我们将其中常用的参数进行对比： + + + +GeneratorDataset +DataLoader +参数意义 + + + + +source  +dataset +数据集对象 + + +column_names +/ +数据输入每一列的名字 + + +column_types  +/ +数据输入每一列的类型 + + +num_samples  +/ +实际加载的数据数量 + + +num_parallel_workers  +num_workers +并行处理数据的子进程数量 + + +shuffle  +/ +是否对数据序列进行 shuffle + + +sampler  +sampler +定义索引生成函数 + + +num_shards  +/ +数据集的均分数量（分布式运算涉及） + + +shard_id  +/ +数据集的均分后的序号（分布式运算涉及） + + +/ +batch_size +批大小 + + +/ +batch_sampler +批索引生成函数 + + +/ +collate_fn +组成批数据的映射函数 + + +/ +drop_last +是否丢弃无法 batch 的数据 + + + +column_name、column_names 是 MindSpore 增加的参数项，主要是为更好的描述数据列。num_samples 是限制实际读取的数据量，当数据集很大时可以只加载部分数据。 +在 PyTorch 中，数据 shffule 和分布式数据分发的操作主要由对应的 sampler 实现，MindSpore 沿用了这一设计，但考虑到这两个操作使用频率较高，MindSpore 直接在 GeneratorDataSet 类中增加新参数 shuffle 和 num_shards、shard_id 来实现这两个功能。 +对于 PyTorch 中额外的四个参数 batch_size、batch_sampler、collate_fn 和 drop_last，考虑到它们均与批处理有关，MindSpore 将这四个参数全部移动到了成员函数 batch 中，这种设计使得参数分组更加清晰。 +需要注意的是，MindSpore 的 GeneratorDataset 和 PyTorch 的 Dataloader 并不是同一个概念。GenerateDataset 加载数据集后生成最基本的数据流，输出为单个样本数据，我们还可以继续使用 MindData 提供的接口进行其他预处理的数据增强操作，例如 map、batch、shuffle、repeat 等。而 Dataloader 通常是数据处理的最终出口，输出 batch size 个样本，然后直接送入网络。 + +迭代 Dataset + + +PyTorch +for step, (data, label) in enumerate(dataloader): + output = net(data) + loss = loss_fn(output, label) + + + +MindSpore +# method 1: create a tuple iterator +for columns in dataset.create_dict_iterator(): + # type of columns is dict + data = columns['data'] + label = columns['label'] + ... + +# method 2: create a dict iterator +for columns in dataset.create_tuple_iterator(): + # type of columns is tuple + data = columns[0] + label = columns[1] + ... + + + + +MindSpore 和 PyTorch 的数据集迭代过程基本相同，而 MindSpore 可以以 dict 和 tuple 两种形式输出数据。 +需要注意的是，MindSpore 中的 GeneratorDataset 类除了用于迭代输出数据，它也为 MindSpore 特有的数据下沉模式做了适配，使得基于 NPU Ascend910 设备训练时，NPU 无需与 Host 交互便可获取训练数据。 +",基本执行流程横向对比,MindSpore、MindSpore、并行、分布式、接口、数据集、Ascend、网络、PyTorch、API、loss、ast、DataLoader、GeneratorDataset、数据、迭代、MindData、Dataset、NPU +基本执行流程横向对比§反向传播,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/training_process_comparision.html," +MindSpore 和 PyTorch 都提供了自动微分功能，让我们在定义了正向网络后，可以通过简单的接口调用实现自动反向传播以及梯度更新。但需要注意的是，MindSpore 和 PyTorch 构建反向图的逻辑是不同的，这个差异也会带来 API 设计上的不同。 + +反向传播原理 + +PyTorch 的自动微分 +我们知道 PyTorch 是基于计算路径追踪的自动微分，当我们定义一个网络结构后， 并不会建立反向图，而是在执行正向图的过程中，Variable 或 Parameter 记录每一个正向计算对应的反向函数，并生成一个动态计算图，用于后续的梯度计算。当在最终的输出处调用 backward 时，就会从根节点到叶节点应用链式法则计算梯度。PyTorch 的动态计算图所存储的节点实际是 Function 函数对象，每当对 Tensor 执行一步运算后，就会产生一个 Function 对象，它记录了反向传播中必要的信息。反向传播过程中，autograd 引擎会按照逆序，通过 Function 的 backward 依次计算梯度。 这一点我们可以通过 Tensor 的隐藏属性查看。 +例如，运行以下代码： +import torch +from torch.autograd import Variable +x = Variable(torch.ones(2, 2), requires_grad=True) +x = x * 2 +x = x - 1 +x.backward(x) + + +此时我们查看 x 的属性，可以发现它已记录了整个反向传播过程所需要的信息： + +上图中的 grad_fn 记录了 x 反向传播所需要的函数，而由于 x 是经过多次正向计算得到的，因此 grad_fn 不只记录了一条反向函数。 + +MindSpore 的自动微分 +在图模式下，MindSpore 的自动微分是基于图结构的微分，和 PyTorch 不同，它不会在正向计算过程中记录任何信息，仅仅执行正常的计算流程（在PyNative模式下和 PyTorch 类似）。那么问题来了，如果整个正向计算都结束了，MindSpore 也没有记录任何信息，那它是如何知道反向传播怎么执行的呢？ +MindSpore 在做自动微分时，需要传入正向图结构，自动微分的过程就是通过对正向图的分析从而得到反向传播信息，自动微分的结果与正向计算中具体的数值无关，仅和正向图结构有关。通过对正向图的自动微分，我们得到了反向传播过程，而这个反向传播过程其实也是通过一个图结构来表达，也就是反向图。将反向图添加到用户定义的正向图之后，组成一个最终的计算图。不过后添加的反向图和其中的反向算子我们并不感知，也无法手动添加，只能通过 MindSpore 为我们提供的接口自动添加，这样做也避免了我们在反向构图时引入错误。 +最终，我们看似仅执行了正向图，其实图结构里既包含了正向算子，又包含了 MindSpore 为我们添加的反向算子，也就是说，MindSpore 在我们定义的正向图后面又新加了一个看不见的 Cell，这个 Cell 里都是根据正向图推导出来的反向算子。 +而这个帮助我们构建反向图的接口就是 GradOperation ： +class GradNetWrtX(nn.Cell): + def __init__(self, net): + super(GradNetWrtX, self).__init__() + self.net = net + self.grad_op = GradOperation() + def construct(self, x, y): + gradient_function = self.grad_op(self.net) + return gradient_function(x, y) + + + + +查看文档介绍我们可以发现，GradOperation 并不是一个算子，它的输入输出并不是 Tensor，而是 Cell，也就是我们定义的正向图和自动微分得到的反向图。为什么输入是一个图结构呢？因为构建反向图并不需要知道具体的输入数据是什么，只要知道正向图的结构就行了，有了正向图就可以推算出反向图结构，之后我们可以把正向图+反向图当成一个新的计算图来对待，这个新的计算图就像是一个函数，对于你输入的任何一组数据，它不仅能计算出正向的输出，还能计算出所有权重的梯度，由于图结构是固定的，并不保存中间变量，所以这个图结构可以被反复调用。 +同理，之后我们再给网络加上优化器结构时，优化器也会加上优化器相关的算子，也就是再给这个计算图加点我们不感知的优化器算子，最终，计算图就构建完成。 +在 MindSpore 中，大部分操作都会最终转换成真实的算子操作，最终加入到计算图中，因此，我们实际执行的计算图中算子的数量远多于我们最开始定义的计算图中算子的数量。 + + +TrainOneStepCell +当我们定义的网络结构比较简单，只需要基本的反向传播流程，且无需对梯度做额外操作时，直接使用 MindSpore 封装的高级接口 mindspore.Model 即可，代码如下： +# define forward network +network = LeNet(num_classes) +# define loss +net_loss = SoftmaxCrossEntropyWithLogits() +# define optimizer +net_opt = Momentum(network.trainable_params(), lr, momentum) + +# define model +model = Model(network, net_loss, net_opt) + + +使用 Model 封装后，网络会自动添加反向、优化器相关算子。但有时网络结构复杂，有多个输入输出，或者在求梯度后，还需要对梯度进行额外的操作（例如梯度裁剪、使用 Loss Scale 等），此时我们需要自行掌控反向流程，为此，MindSpore 提供了 nn.TrainOneStepCell 模板，nn.TrainOneStepCell 的功能是添加反向算子和优化器算子，当需要自定义反向结构时，我们可以基于该模板重写反向流程（Model 实际也是调用 TrainOneStepCell 完成自动微分）。 +nn.TrainOneStepCell 继承了 nn.Cell，所以它构建反向网络结构的逻辑和我们构建正向网络的保持一致。这里我们对 nn.TrainOneStepCell 的源码进行分析： +class TrainOneStepCell(Cell): + r"""""" + Network training package class. + + Wraps the network with an optimizer. The resulting Cell is trained with input '\*inputs'. + The backward graph will be created in the construct function to update the parameter. Different + parallel modes are available for training. + + Args: + network (Cell): The training network. The network only supports single output. + optimizer (Union[Cell]): Optimizer for updating the weights. + sens (numbers.Number): The scaling number to be filled as the input of backpropagation. Default value is 1.0. + + Inputs: + - **(\*inputs)** (Tuple(Tensor)) - Tuple of input tensors with shape :math:`(N, \ldots)`. + + Outputs: + Tensor, a tensor means the loss value, the shape of which is usually :math:`()`. + + Raises: + TypeError: If `sens` is not a number. + + Supported Platforms: + ``Ascend`` ``GPU`` ``CPU`` + + Examples: + >>> net = Net() + >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits() + >>> optim = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9) + >>> #1) Using the WithLossCell existing provide + >>> loss_net = nn.WithLossCell(net, loss_fn) + >>> train_net = nn.TrainOneStepCell(loss_net, optim) + >>> + >>> #2) Using user-defined WithLossCell + >>> class MyWithLossCell(Cell): + ... def __init__(self, backbone, loss_fn): + ... super(MyWithLossCell, self).__init__(auto_prefix=False) + ... self._backbone = backbone + ... self._loss_fn = loss_fn + ... + ... def construct(self, x, y, label): + ... out = self._backbone(x, y) + ... return self._loss_fn(out, label) + ... + ... @property + ... def backbone_network(self): + ... return self._backbone + ... + >>> loss_net = MyWithLossCell(net, loss_fn) + >>> train_net = nn.TrainOneStepCell(loss_net, optim) + """""" + + def __init__(self, network, optimizer, sens=1.0): + super(TrainOneStepCell, self).__init__(auto_prefix=False) + self.network = network + # set require_grad=True for Parameters in network + self.network.set_grad() + self.optimizer = optimizer + self.weights = self.optimizer.parameters + self.grad = C.GradOperation(get_by_list=True, sens_param=True) + # set init value for back propagation + self.sens = sens + # reduce_flag, used in distributed training + self.reducer_flag = False + self.grad_reducer = F.identity + self.parallel_mode = _get_parallel_mode() + self.reducer_flag = self.parallel_mode in (ParallelMode.DATA_PARALLEL, ParallelMode.HYBRID_PARALLEL) + if self.reducer_flag: + self.mean = _get_gradients_mean() + # number of devices + self.degree = _get_device_num() + self.grad_reducer = DistributedGradReducer(self.weights, self.mean, self.degree) + + def construct(self, *inputs): + # get the loss of forward + loss = self.network(*inputs) + # set init value for backward propagation + sens = F.fill(loss.dtype, loss.shape, self.sens) + # perform backward propagation + grads = self.grad(self.network, self.weights)(*inputs, sens) + grads = self.grad_reducer(grads) + loss = F.depend(loss, self.optimizer(grads)) + return loss + + +如果理解了刚才介绍的 MindSpore 反向传播原理，就会很容易理解 TrainOneStepCell 的每一步在做什么，其实就是一个基于计算图求导的过程。 +这里需要特别解释最后几个语句： + +sens 表示初始梯度，类似 PyTorch 中 loss.backward(sens) 的作用，为反向传播过程设置一个初始梯度。 +DistributedGradReducer 是负责一个分布式梯度计算的 Cell （相当于又是一个计算图），在多卡训练时，它会将所有卡的梯度先求和，然后除以卡的数量（ self.degree ），最终得到全局平均的梯度。 + +... +grads = self.grad(self.network, self.weights)(*inputs, sens) +grads = self.grad_reducer(grads) +loss = F.depend(loss, self.optimizer(grads)) +... + + +除了 TrainOneStepCell，对于混合精度场景，MindSpore 还提供了带有 Loss Scale 的 TrainOneStepWithLossScale，原理其实是一样的，感兴趣的读者可以阅读混合精度的原理以及查看该方法的实现。 +当我们使用 TrainOneStepCell 添加反向网络结构后，仍可以使用 Model 类进行封装，但此时不需要再给 Model 传入 loss、优化器这两个参数了，因为传入的网络已经包含了正向+反向结构。最后，通过调用 model.train() ，开始正常的训练流程。 +参考链接： TrainOneStepCell 、 TrainOneStepWithLossScale + +",基本执行流程横向对比,MindSpore、自动微分、GradOperation、MindSpore、优化器、分布式、算子、接口、optimizer、GPU、CPU、Ascend、语句、网络、PyNative、PyTorch、API、Model、loss、 GradOperation、TrainOneStepCell、反向传播、求导、lr、精度、数据、Loss Scale、计算图、精度、优化、graph、ib、npu +典型算子或接口区别介绍§接口类,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/typical_api_comparision.html," + +torch.device +PyTorch 在构建模型时，通常会利用 torch.device 指定模型和数据绑定的设备，是在 CPU 还是 GPU 上，如果支持多 GPU，还可以指定具体的 GPU 序号。绑定相应的设备后，需要将模型和数据部署到对应设备，代码如下： +# bind to the GPU 0 if GPU is available, otherwise bind to CPU +device = torch.device(""cuda:0"" if torch.cuda.is_available() else ""cpu"") # 单 GPU 或者 CPU +# deploy model to specified hardware +model.to(device) +# deploy data to specified hardware +data.to(device) + +# distribute training on multiple GPUs +if torch.cuda.device_count() > 1: + model = nn.DataParallel(model, device_ids=[0,1,2]) +model.to(device) + +# set available device +os.environ['CUDA_VISIBLE_DEVICE']='1' +model.cuda() + + +而在 MindSpore 中，我们通过 context 中 的 device_target 参数 指定模型绑定的设备，device_id 指定设备的序号。与 PyTorch 不同的是，一旦设备设置成功，输入数据和模型会默认拷贝到指定的设备中执行，不需要也无法再改变数据和模型所运行的设备类型。代码如下： +from mindspore import context +context.set_context(device_target='Ascend', device_id=0) + +# define net +Model = .. +# define dataset +dataset = .. +# training, automatically deploy to Ascend according to device_target +Model.train(1, dataset) + + +此外，网络运行后返回的 Tensor 默认均拷贝到 CPU 设备，可以直接对该 Tensor 进行访问和修改，包括转成 numpy 格式，无需像 PyTorch 一样需要要先执行 tensor.cpu 再转换成 numpy 格式。 + + +nn.Module +使用 PyTorch 构建网络结构时，我们会用到 nn.Module 类，通常将网络中的元素定义在 __init__ 函数中并对其初始化，将网络的图结构表达定义在 forward 函数中，通过调用这些类的对象完成整个模型的构建和训练。nn.Module 不仅为我们提供了构建图接口，它还为我们提供了一些常用的 API ，来帮助我们执行更复杂逻辑。 +MindSpore 中的 nn.Cell 类发挥着和 PyTorch 中 nn.Module 相同的作用，都是用来构建图结构的模块，MindSpore 也同样提供了丰富的 API 供开发者使用，虽然名字不能一一对应，但 nn.Module 中常用的功能都可以在 nn.Cell 中找到映射。 +以几个常用方法为例： + + + +常用方法 +nn.Module +nn.Cell + + + + +获取子元素 +named_children +cells_and_names + + +添加子元素 +add_module +insert_child_to_cell + + +获取元素的参数 +parameters +get_parameters + + + + + +数据对象 +在 PyTorch 中，可以存储数据的对象总共有四种，分别时 Tensor、Variable、Parameter、Buffer。这四种对象的默认行为均不相同，当我们不需要求梯度时，通常使用 Tensor 和 Buffer 两类数据对象，当我们需要求梯度时，通常使用 Variable 和 Parameter 两类对象。PyTorch 在设计这四种数据对象时，功能上存在冗余（Variable 后续会被废弃也说明了这一点）。 +MindSpore 优化了数据对象的设计逻辑，仅保留了两种数据对象：Tensor 和 Parameter，其中 Tensor 对象仅参与运算，并不需要对其进行梯度求导和参数更新，而 Parameter 数据对象和 PyTorch 的 Parameter 意义相同，会根据其属性 requires_grad 来决定是否对其进行梯度求导和 参数更新。 在网络迁移时，只要是在 PyTorch 中未进行参数更新的数据对象，均可在 MindSpore 中声明为 Tensor。 + + +梯度求导 +梯度求导涉及的算子和接口差异主要是由 MindSpore 和 PyTorch 自动微分原理不同引起的。 + +torch.no_grad +在 PyTorch 中，默认情况下，执行正向计算时会记录反向传播所需的信息，在推理阶段或无需反向传播网络中，这一操作是冗余的，会额外耗时，因此，PyTorch 提供了 torch.no_grad 来取消该过程。 +而 MindSpore 只有在调用 GradOperation 才会根据正向图结构来构建反向图，正向执行时不会记录任何信息，所以 MindSpore 并不需要该接口，也可以理解为 MindSpore 的正向计算均在 torch.no_grad 情况下进行的。 + + +retain_graph +由于 PyTorch 是基于函数式的自动微分，所以默认每次执行完反向传播后都会自动清除记录的信息，从而进行下一次迭代。这就会导致当我们想再次利用这些反向图和梯度信息时，由于已被删除而获取失败。因此，PyTorch 提供了 backward(retain_graph=True) 来主动保留这些信息。 +而 MindSpore 则不需要这个功能，MindSpore 是基于计算图的自动微分，反向图信息在调用 GradOperation 后便永久的记录在计算图中，只要再次调用计算图就可以获取梯度信息。 + + +高阶导数 +基于计算图的自动微分还有一个好处，我们可以很方便的实现高阶求导。第一次对正向图执行 GradOperation 操作后，我们可以得到一阶导，此时计算图被更新为正向图+一阶导的反向图结构，但我们再次对更新后的计算图执行 GradOperation 后，我们就可以得到二阶导，以此类推，通过基于计算图的自动微分，我们很容易求得一个网络的高阶导数。 + + +",典型算子或接口区别介绍,MindSpore、自动微分、GradOperation、MindSpore、算子、接口、GPU、CPU、Ascend、网络、PyTorch、API、model、 GradOperation、反向传播、求导、数据、计算图、优化、迭代、dataset、cuda、graph、ib +典型算子或接口区别介绍§算子类,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/typical_api_comparision.html," +MindSpore 的大部分算子 API 和 TensorFlow 相近，但也有一部分算子的默认行为与 PyTorch 或 TensorFlow 存在差异。开发者在做网络脚本迁移时，如果未注意到这些差异，直接使用默认行为，很容易出现与原迁移网络不一致的情况，影响网络训练，我们建议开发者在迁移网络时不仅对齐使用的算子，也要对齐算子的属性。这里我们总结了几个常见的差异算子。 + +参数意义不同 + +nn.Dropout +Dropout 常用于防止训练过拟合，有一个重要的 概率值 参数，该参数在 MindSpore 中的意义与 PyTorch 和 TensorFlow 中的意义完全相反。 +在 MindSpore 中，概率值对应 Dropout 算子的属性 keep_prob，是指输入被保留的概率，1-keep_prob是指输入被置 0 的概率。 +在 PyTorch 和 TensorFlow 中，概率值分别对应 Dropout 算子的属性 p和 rate，是指输入被置 0 的概率，与 MindSpore.nn.Dropout 中的 keep_prob 意义相反。 +更多信息请参考链接： MindSpore Dropout 、 PyTorch Dropout 、 TensorFlow Dropout + + +nn.BatchNorm2d +BatchNorm 是 CV 领域比较特殊的正则化方法，它在训练和推理的过程中有着不同计算流程，通常由算子属性控制。MindSpore 和 PyTorch 的 BatchNorm 在这一点上使用了两种不同的参数组。 + +差异一 +torch.nn.BatchNorm2d 在不同参数下的状态 + + + + + +training +track_running_stats +状态 + + + + +True +True +期望中训练的状态，running_mean 和 running_var 会跟踪整个训练过程中 batch 的统计特性，而每组输入数据用当前 batch 的 mean 和 var 统计特性做归一化，然后再更新 running_mean 和 running_var。 + + +True +False +每组输入数据会根据当前 batch 的统计特性做归一化，但不会有 running_mean 和 running_var 参数了。 + + +False +Ture +期望中推理的状态，BN 使用 running_mean 和 running_var 做归一化，并且不会对其进行更新。 + + +False +False +效果同第二点，只不过处于推理状态，不会学习 weight 和 bias 两个参数。一般不采用该状态。 + + + +mindspore.nn.BatchNorm2d 在不同参数下的状态 + + + +use_batch_statistics +状态 + + + + +True +期望中训练的状态，moving_mean 和 moving_var 会跟踪整个训练过程中 batch 的统计特性，而每组输入数据用当前 batch 的 mean 和 var 统计特性做归一化，然后再更新 moving_mean 和 moving_var。 + + +Fasle +期望中推理的状态，BN 使用 moving_mean 和 moving_var 做归一化，并且不会对其进行更新。 + + +None +自动设置 use_batch_statistics。如果是训练，use_batch_statistics=True，如果是推理，use_batch_statistics=False。 + + + +通过比较可以发现，mindspore.nn.BatchNorm2d 相比 torch.nn.BatchNorm2d，少了两种冗余的状态，仅保留了最常用的训练和推理两种状态。 + +差异二 +BatchNorm系列算子 的 momentum 参数在 MindSpore 和 PyTorch 表示的意义相反，关系为： +\(momentum_{pytorch} = 1 - momentum_{mindspore}\) +参考链接：mindspore.nn.BatchNorm2d，torch.nn.BatchNorm2d + + + + + +算子行为不同 + +ops.Transpose +在做轴变换时，PyTorch 常用到两种算子 - Tensor.permute 和 torch.transpose，而 MindSpore 和 TensorFlow 仅提供了 transpose 算子。需要注意的是，Tensor.permute 包含了 torch.transpose 的功能，torch.transpose 仅支持同时交换两个轴，而 Tensor.permute 可以同时变换多个轴。 +# pytorch 代码 +import numpy as np +import torch +from torch import Tensor +data = np.empty((1, 2, 3, 4)).astype(np.float32) +ret1 = torch.transpose(Tensor(data), dim0=0, dim1=3) +ret1.shape # (4, 2, 3, 1) +ret2 = Tensor(data).permute((3, 2, 1, 0)) +ret2.shape # (4, 3, 2, 1) + + +MindSpore 和 TensorFlow 的 transpose算子功能相同， 虽然名字叫 transpose，但实际可以做多个轴的同时变换，等价于 Tensor.permute。因此，MindSpore 也不再单独提供类似 torch.tranpose 的算子。 +# mindspore 代码 +import mindspore as ms +import numpy as np +from mindspore import Tensor, ops +ms.context.set_context(device_target=""Ascend"") +data = np.empty((1, 2, 3, 4)).astype(np.float32) +ret = ops.Transpose()(Tensor(data), (3, 2, 1, 0)) +ret.shape # (4, 3, 2, 1) + + +更多信息请参考链接：MindSpore Transpose 、 PyTorch Transpose 、PyTorch Permute 、 TensforFlow Transpose + + +Conv 和 Pooling +对于类似卷积和池化的算子，我们知道算子的输出特征图大小依赖输入特征图、步长、kernel_size 和 padding 等变量。 +如果 pad_mode 设置为 valid，则输出特征图高和宽的计算公式分别为： + +如果 pad_mode（对应 PyTorch 中的属性为 padding，与属性 pad_mode 含义并不相同） 设置为 same 时，有时需要对输入特征图进行自动的 padding 操作，当padding 的元素为偶数时，padding 的元素会均匀分布在特征图的上下左右，此时 MindSpore、PyTorch 和 TensorFlow 中该类算子行为一致。 +但当 padding 的元素为奇数时，PyTorch 会优先填充在输入特征图的左侧和上侧： + +而 MindSpore 和 TensorFlow 则优先填充在特征图的右侧和下侧： + +举例说明： +# mindspore example +import numpy as np +import mindspore as ms +from mindspore import Tensor, ops +ms.context.set_context(device_target=""Ascend"") +data = np.arange(9).reshape(1,1,3,3).astype(np.float32) +# data +# [[[[0. 1. 2.] +# [3. 4. 5.] +# [6. 7. 8.]]]] +op = ops.MaxPool(kernel_size=2, strides=2, pad_mode='same') +op(Tensor(data)) +# [[[[4. 5.] +#    [7. 8.]]]] + + +在做 MindSpore 模型迁移时，如果模型加载了 PyTorch 的预训练模型，而之后又在 MindSpore 进行 finetune，则该差异可能会导致精度下降，对于 padding 策略为 same 的卷积，开发者需要特别注意。 +如果想和 PyTorch 行为保持一致，可以先使用 ops.Pad 算子手动 pad 元素，然后使用 pad_mode=""valid"" 的卷积和池化操作。 +import numpy as np +import mindspore as ms +from mindspore import Tensor, ops +ms.context.set_context(device_target=""Ascend"") +data = np.arange(9).reshape(1, 1, 3, 3).astype(np.float32) +# only padding on top left of feature map +pad = ops.Pad(((0, 0), (0, 0), (1, 0), (1, 0))) +data = pad(Tensor(data)) +ops.MaxPool(kernel_size=2, strides=2, pad_mode='same')(data) +# [[[[0. 2.] +# [6. 8.]]]] + + + + + +默认权重初始化不同 +我们知道权重初始化对网络的训练十分重要，通过我们会选择一个适合的分布来初始化权重。但还有一个部分算子会隐式的声明权重，在不同的框架中，即使这些算子功能一致，但如果隐式声明的权重初始化方式分布不同，也会对训练过程产生影响，甚至无法收敛。 +常见隐式声明权重的算子：Conv、Dense(Linear)、Embedding、LSTM 等，其中区别较大的是 Conv 类和 Dense 两种算子。 + +Conv2d + +mindspore.nn.Conv2d的weight为：\(\mathcal{N}(0, 1)\)，bias为：zeros。 +torch.nn.Conv2d的weight为：\(\mathcal{U} (-\sqrt{k},\sqrt{k} )\)，bias为：\(\mathcal{U} (-\sqrt{k},\sqrt{k} )\)。 +tf.keras.Layers.Conv2D的weight为：glorot_uniform，bias为：zeros。 + +其中，\(k=\frac{groups}{c_{in}*\prod_{i}^{}{kernel\_size[i]}}\) + +Dense(Linear) + +mindspore.nn.Linear的weight为：\(\mathcal{N}(0, 1)\)，bias为：zeros。 +torch.nn.Dense的weight为：\(\mathcal{U}(-\sqrt{k},\sqrt{k})\)，bias为：\(\mathcal{U}(-\sqrt{k},\sqrt{k} )\)。 +tf.keras.Layers.Dense的weight为：glorot_uniform，bias为：zeros。 + +其中，\(k=\frac{groups}{in\_features}\) + + +对于没有正则化的网络，如没有 BatchNorm 算子的 GAN 网络，梯度很容易爆炸或者消失，权重初始化就显得十分重要，各位开发者应注意权重初始化带来的影响。 + +",典型算子或接口区别介绍,MindSpore、MindSpore、算子、接口、Ascend、网络、TensorFlow、PyTorch、API、ast、精度、数据、精度、脚本、框架、Embedding +优化器迁移指南§概述,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/optim.html," +优化器在模型训练过程中，用于计算和更新网络参数，本文对比MindSpore和PyTorch的在这一部分的实现方式差异，分别从基本用法、基类入参设置及支持的方法、自定义优化器、API映射四部分展开。 +",优化器迁移指南,MindSpore、MindSpore、优化器、网络、PyTorch、API、优化 +优化器迁移指南§基本用法,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/optim.html," +MindSpore：使用优化器时，通常需要预先定义网络、损失函数和优化器： +from mindspore import context, Tensor, ParameterTuple +from mindspore import nn, Model, ops +import numpy as np +from mindspore import dtype as mstype + +class Net(nn.Cell): + def __init__(self): + super(Net, self).__init__() + self.conv = nn.Conv2d(3, 64, 3) + self.bn = nn.BatchNorm2d(64) + def construct(self, x): + x = self.conv(x) + x = self.bn(x) + return x + +net = Net() +loss = nn.MSELoss() +optimizer = nn.SGD(params=net.trainable_params(), learning_rate=0.01) + + +在MindSpore中，定义好网络、损失函数、优化器后，一般在以下三种场景下使用： + +MindSpore封装了Model高阶API来方便用户定义和训练网络，在定义Model时指定优化器； +# 使用Model接口 +model = Model(net, loss_fn=loss, optimizer=optimizer, metrics={""accuracy""}) + + + +MindSpore提供了TrainOneStepCell接口，通过传入优化器和一个WithLossCell的实例，自定义训练网络； +# 使用TrainOneStepCell自定义网络 +loss_net = nn.WithLossCell(net, loss) # 包含损失函数的Cell +train_net = nn.TrainOneStepCell(loss_net, optimizer) +train_dataset = [(Tensor(np.random.rand(1, 3, 64, 32), mstype.float32), Tensor(np.random.rand(1, 64, 64, 32), mstype.float32))] +for i in range(5): + for image, label in train_dataset: + train_net.set_train() + res = train_net(image, label) # 执行网络的单步训练 + + + +在PyNative模式下，实现单步执行优化器。 +# pynative模式下，单步实现GradOperation求梯度，并执行优化器 +context.set_context(mode=context.PYNATIVE_MODE, device_target=""GPU"") + +class GradWrap(nn.Cell): + """""" GradWrap definition """""" + def __init__(self, network): + super(GradWrap, self).__init__(auto_prefix=False) + self.network = network + self.weights = ParameterTuple(filter(lambda x: x.requires_grad, network.get_parameters())) + + def construct(self, x, label): + weights = self.weights + return ops.GradOperation(get_by_list=True)(self.network, weights)(x, label) + + loss_net = nn.WithLossCell(net, loss) + train_network = GradWrap(loss_net) + + output = net(image) + loss_output = loss(output, label) + grads = train_network(image, label) + success = optimizer(grads) + + + + +PyTorch：PyTorch为Tensor建立了grad属性和backward方法，tensor.grad是通过tensor.backward方法（本质是torch.autograd.backward）计算的，且在计算中进行梯度值累加，因此一般在调用tensor.backward方法前，需要手动将grad属性清零。MindSpore没有为Tensor和grad建立直接联系，在使用时不需要手动清零。 +在下面的代码中，初始化了一个优化器实例，每次循环调用zero_grad清零梯度，backward更新梯度，step更新网络参数，返回损失值。 +import torch +from torch import optim, nn +import numpy as np + +class Net(nn.Module): + def __init__(self): + super(Net, self).__init__() + self.conv = nn.Conv2d(3, 64, 3) + self.bn = nn.BatchNorm2d(64) + self.relu = nn.ReLU() + def forward(self, x): + x = self.conv(x) + x = self.bn(x) + x = self.relu(x) + return x + +model = Net() +optimizer = optim.SGD(model.parameters(), lr=0.01) +loss_fn = nn.MSELoss() +train_dataset = [(torch.tensor(np.random.rand(1, 3, 64, 32).astype(np.float32)), torch.tensor(np.random.rand(1, 64, 62, 30).astype(np.float32)))] + +for epoch in range(5): + for image, label in train_dataset: + optimizer.zero_grad() + output = model(image) + loss = loss_fn(output, label) + loss.backward() + optimizer.step() + + +",优化器迁移指南,MindSpore、GradOperation、MindSpore、优化器、接口、损失函数、optimizer、GPU、网络、PyNative、PyTorch、API、Model、SGD、loss、metric、ast、TrainOneStepCell、lr、优化、dataset +优化器迁移指南§基类入参设置及支持的方法,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/optim.html," + +基类入参 +MindSpore： +optimizer(learning_rate, parameters, weight_decay=0.0, loss_scale=1.0) + + +PyTorch： +optimizer(params, defaults) + + + +网络中需要被训练的参数 +MindSpore和PyTorch的优化器都需要传入网络中需要被训练的参数，且参数的设置同时都支持默认接口和用户自定义设置两种方式。 + +默认接口： +MindSpore的parameter包含了网络中所有的参数，通过require_grad属性来区分是否需要训练和优化。trainable_params方法返回一个filter的list，筛选了网络中require_grad属性为True的parameter。 +from mindspore import nn +optim_sgd = nn.SGD(net.trainable_params()) + + +PyTorch的state包含了网络中所有的参数，其中需要被优化的是parameter，不需要优化的是buffer（例如：BatchNorm中的running_mean和running_var ）。parameters方法返回需要被优化参数的generator。 +from torch import nn, optim +optim_sgd = optim.SGD(params=model.parameters(), lr=0.01) + + + +用户自定义： +MindSpore和PyTorch都支持用户自定义传入需要优化的参数，例如，对非卷积参数进行训练和优化。代码样例如下： +from mindspore import nn + +net = Net() +all_params = net.get_parameters() +non_conv_params = list(filter(lambda x: ""conv"" not in x.name, all_params)) +optim_sgd = nn.SGD(params=non_conv_params) + + +from torch import optim + +net = Net() +all_params = model.named_parameters() +target_params = [] +for name, params in all_params: + if ""conv"" in name: + target_params.append(params) +optim_sgd = optim.SGD(params=target_params, lr=0.01) + + + + + + +学习率 +使用固定学习率时，用法相同，传入固定值即可；使用动态学习率时，MindSpore和PyTorch都支持动态学习率调整策略，实现方式略有不同。 + +MindSpore：动态学习率有两种实现方式，预生成列表mindspore.nn.dynamic_lr和计算图格式mindspore.nn.learning_rate_schedule，且动态学习率实例作为优化器的参数输入。以预生成学习率列表的piecewise_constant_lr为例： +from mindspore import nn + +milestone = [2, 5, 10] +learning_rates = [0.1, 0.05, 0.01] +lr = nn.dynamic_lr.piecewise_constant_lr(milestone, learning_rates) +print(lr) + + +out: [0.1, 0.1, 0.05, 0.05, 0.05, 0.01, 0.01, 0.01, 0.01, 0.01] + + + +PyTorch：优化器作为lr_scheduler的输入，调用step方法对学习率进行更新。 +from torch import optim + +model = Net() +optimizer = optim.SGD(model.parameters(), 0.1) +scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.9) + +for epoch in range(5): + for input, target in train_dataset: + optimizer.zero_grad() + output = model(input) + loss = loss_fn(output, target) + loss.backward() + optimizer.step() + scheduler.step() + print(scheduler.get_last_lr()) + +# out: +# [0.09000000000000001] +# [0.08100000000000002] +# [0.07290000000000002] +# [0.06561000000000002] +# [0.05904900000000002] + + + + +调整策略映射表 + + + +mindspore.nn.dynamic_lr +mindspore.nn.learning_rate_schedule +torch.optim.lr_scheduler + + + + +piecewise_constant_lr：分段不变 +/ +StepLR: 每隔step_size个epoch，学习率乘gamma；MultiStepLR: epoch为milestones的时候学习率乘️gamma + + +exponential_decay_lr：指数衰减 +ExponentialDecayLR：指数衰减 +ExponentialLR: 指数衰减，lr = lr * (学习率乘gamma^epoch) + + +natural_exp_decay_lr：自然指数衰减 +NaturalExpDecayLR：自然指数衰减 +/ + + +inverse_decay_lr：反时间衰减 +InverseDecayLR：反时间衰减 +/ + + +cosine_decay_lr：余弦衰减 +CosineDecayLR：余弦衰减 +CosineAnnealingLR: 余弦衰减 + + +polynomial_decay_lr：多项式衰减 +PolynomialDecayLR：多项式衰减 +/ + + +/ +/ +CosineAnnealingWarmRestarts：周期变化余弦衰减 + + +/ +/ +CyclicLR/OneCycleLR：三角循环 + + +/ +/ +ReduceLROnPlateau：自适应调整 + + +/ +/ +LambdaLR：传入Lambda函数，自定义调整 + + +/ +/ +MultiplicativeLR：乘上lr_lambda中设置的数值 + + + + + +weight decay +用法相同。一般情况下，weight_decay取值范围为[0, 1)，实现对需要优化的参数使用权重衰减的策略，以避免模型过拟合问题；weight_decay的默认值为0.0，此时不使用权重衰减策略。 + + +参数分组 +MindSpore和PyTorch都支持参数分组且使用方法相似，在使用时都是给优化器传入一个字典的列表，每个字典对应一个参数组，其中key为参数名，value为对应的设置值。不同点是，MindSpore只支持对“lr”，“weight_decay”，“grad_centralizaiton”实现分组，pytoch支持对所有参数进行分组。此外，PyTorch还支持add_param_group方法，对参数组进行添加和管理。 + +MindSpore和PyTorch各自有部分优化器不支持参数分组，请参考具体优化器的实现。 + +MindSpore参数分组用法请参考超参分组；PyTorch参数分组用法参考下述样例： +from torch import optim + +net = Net() +all_params = net.parameters() +conv_params = [] +non_conv_params = [] +# 根据自己的筛选规则 将所有网络参数进行分组 +for pname, p in model.named_parameters(): + if ('conv' in pname): + conv_params += [p] + else: + non_conv_params += [p] + +print(len(conv_params), len(non_conv_params)) +# 构建不同学习参数的优化器 +optimizer = torch.optim.SGD([ + {'params': conv_params, 'lr': 0.02}, + {'params': non_conv_params, 'weight_decay': 0.5}], + lr=0.01, momentum=0.9) + +# out: 2 2 + + + + +混合精度 +MindSpore中的混合精度场景下，如果使用FixedLossScaleManager进行溢出检测，且drop_overflow_update为False时，优化器需设置loss_scale的值，且loss_scale值与FixedLossScaleManager的相同，详细使用方法可以参考优化器的混合精度配置。PyTorch的混合精度设置不作为优化器入参。 + + + +基类支持的方法 + +获取LR +torch.optim.lr_scheduler.get_last_lr()：根据参数组返回对应的最新学习率数值的列表。 +mindspore中没有直接可以按照组别获取对应学习率的功能，但提供了以下方法辅助使用： + +mindspore.nn.optimizer.get_lr()：获取当前step的学习率，可以在自定义优化器时，在construct方法中使用。 +mindspore.nn.optimizer.get_lr_parameter(params)：获取指定参数组的参数学习率列表，如果是固定学习率，返回一个标量Parameter的列表；如果是计算图格式的动态学习率，返回一个Cell的列表；如果是列表格式的动态学习率，返回shape为(n,)的Parameter的列表（其中n是动态学习率列表的长度）。 + + + +获取优化器的状态 +torch.optimizer.param_groups：获取优化器相关配置参数的状态，返回数据格式为字典的列表，key为参数名，value为参数值。以SGD为例，字典的key为key为’params’、 ‘lr’、’momentum’、’dampening’、’weight_decay’、 ‘nesterov’等。 +torch.optimizer.state_dict：获取optimizer的状态，返回一个key为“state”、“param_groups”，value为对应数值的字典。 +MindSpore暂无对应功能。 + + +",优化器迁移指南,MindSpore、MindSpore、优化器、接口、optimizer、网络、PyTorch、model、sgd、loss、arm、ast、weight decay、lr、学习率、精度、数据、超参、计算图、精度、优化、dataset、npu +优化器迁移指南§自定义优化器,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/optim.html," +MindSpore和PyTorch都支持用户基于python基本语法及相关算子自定义优化器。在PyTorch中，通过重写__init__和step方法，用户可以根据需求自定义优化器，具体用法可以参考这篇教程。MindSpore也支持类似用法，以Momentum为例，使用基础的小算子构建： +from mindspore import Parameter, ops, nn + +class MomentumOpt(nn.Optimizer): + def __init__(self, params, learning_rate, momentum, weight_decay=0.0, loss_scale=1.0, use_nesterov=False): + super(MomentumOpt, self).__init__(learning_rate, params, weight_decay, loss_scale) + self.momentum = Parameter(Tensor(momentum, mstype.float32), name=""momentum"") + self.moments = self.parameters.clone(prefix=""moments"", init=""zeros"") + self.assign = ops.Assign() + def construct(self, gradients): + params = self.parameters + moments = self.moments + success = None + for param, mom, grad in zip(params, moments, gradients): + # 小算子表达 + update = self.momentum * param + mom + self.learning_rate * grad + success = self.assign(param, update) + return success + + +MindSpore的ops模块也提供了ApplyMomentum的高阶算子，使用方式可参考： +from mindspore import Parameter, ops, nn + +class MomentumOpt(nn.Optimizer): + def __init__(self, params, learning_rate, momentum, weight_decay=0.0, loss_scale=1.0, use_nesterov=False): + super(MomentumOpt, self).__init__(learning_rate, params, weight_decay, loss_scale) + self.moments = self.parameters.clone(prefix=""moments"", init=""zeros"") + self.opt = ops.ApplyMomentum(use_nesterov=use_nesterov) + def construct(self, gradients): + params = self.parameters + moments = self.moments + success = None + for param, mom, grad in zip(params, moments, gradients): + # 大算子表达 + success = self.opt(param, mom, self.learning_rate, grad, self.momentum) + return success + + +",优化器迁移指南,MindSpore、MindSpore、优化器、算子、Optimizer、PyTorch、loss、优化 +优化器迁移指南§API映射,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/optim.html," +MindSpore和PyTorch的API对应关系和差异可以参考API映射，其余暂时没有对应关系的接口目前情况如下： +# PyTorch +torch.optim.ASGD +torch.optim.LBFGS + + +# mindspore +mindspore.nn.ProximalAadagrad +mindspore.nn.AdamOffload +mindspore.nn.FTRL +mindspore.nn.Lamb +mindspore.nn.thor + + +",优化器迁移指南,MindSpore、MindSpore、优化器、接口、PyTorch、API、SGD、优化 +基于自定义算子接口调用第三方算子库§概述,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/use_third_party_op.html," +当开发网络遇到内置算子不足以满足需求时，你可以利用MindSpore的Python API中的Custom原语方便快捷地进行不同类型自定义算子的定义和使用。 +网络开发者可以根据需要选用不同的自定义算子开发方式。详情请参考Custom算子的使用指南。 +其中，自定义算子有一种开发方式aot方式有其特殊的使用方式。aot方式可以通过加载预编译的so来调用相应的cpp/cuda函数。因此，当第三方库提供了cpp/cuda函数API时，可以尝试将其函数接口在so中调用，以下以PyTorch的Aten库为例进行介绍。 +",基于自定义算子接口调用第三方算子库,MindSpore、MindSpore、算子、接口、网络、PyTorch、API、Aten、cuda +基于自定义算子接口调用第三方算子库§PyTorch Aten算子对接,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/use_third_party_op.html," +当迁移一张使用PyTorch Aten算子的网络遇到内置算子不足的情况时，我们可以利用Custom算子的aot开发方式调用PyTorch Aten的算子进行快速验证。 +PyTorch提供了一种方式可以支持引入PyTorch的头文件，从而使用其相关的数据结构编写cpp/cuda代码，并编译成so。参考：https://pytorch.org/docs/stable/_modules/torch/utils/cpp_extension.html#CppExtension。 +将两种方式结合使用，自定义算子可以调用PyTorch Aten算子，使用方式如下: + +1. 下载工程文件 +工程文件可以通过这里下载。 +使用以下命令解压压缩包，得到文件夹test_custom_pytorch。 +tar xvf test_custom_pytorch.tar + + +文件夹中包含以下几个文件： +test_custom_pytorch +├── env.sh # set PyTorch/lib into LD_LIBRARY_PATH +├── leaky_relu.cpp # an example of use Aten CPU operator +├── leaky_relu.cu # an example of use Aten GPU operator +├── ms_ext.cpp # convert Tensors between MindSpore and PyTorch +├── ms_ext.h # convert API +├── README.md +├── run_cpu.sh # a script to run cpu case +├── run_gpu.sh # a script to run gpu case +├── setup.py # a script to compile cpp/cu into so +├── test_cpu_op_in_gpu_device.py # a test file to run Aten CPU operator on GPU device +├── test_cpu_op.py # a test file to run Aten CPU operator on CPU device +└── test_gpu_op.py # a test file to run Aten GPU operator on GPU device + + +使用PyTorch Aten算子主要关注env.sh、setup.py、leaky_relu.cpp/cu、test_*.py即可。 +其中，env.sh用于设置环境变量，setup.py用于编译so，leaky_relu.cpp/cu用于参考编写调用PyTorch Aten算子的源码，test_*.py用于参考调用Custom算子。 + + +2. 编写调用PyTorch Aten算子的源码文件 +参考leaky_relu.cpp/cu，编写调用PyTorch Aten算子的源码文件。 +由于aot类型的自定义算子采用AOT编译方式，要求网络开发者基于特定接口，手写算子实现函数对应的源码文件，并提前将源码文件编译为动态链接库，然后在网络运行时框架会自动调用执行动态链接库中的函数。在算子实现的开发语言方面，GPU平台支持CUDA，CPU平台支持C和C++。源码文件中的算子实现函数的接口规范如下： +extern ""C"" int func_name(int nparam, void **params, int *ndims, int64_t **shapes, const char **dtypes, void *stream, void *extra); + + +如果是调用cpu算子，以leaky_relu.cpp为例，该文件提供AOT需要的函数LeakyRelu，里面调用了PyTorch Aten的函数torch::leaky_relu_out： +#include +#include // 头文件引用部分 +#include ""ms_ext.h"" + +extern ""C"" int LeakyRelu( + int nparam, + void** params, + int* ndims, + int64_t** shapes, + const char** dtypes, + void* stream, + void* extra) { + auto tensors = get_torch_tensors(nparam, params, ndims, shapes, dtypes, c10::kCPU); + auto at_input = tensors[0]; + auto at_output = tensors[1]; + torch::leaky_relu_out(at_output, at_input); + // 如果使用不带输出的版本，代码如下： + // torch::Tensor output = torch::leaky_relu(at_input); + // at_output.copy_(output); + return 0; +} + + +如果是调用gpu算子，以leaky_relu.cu为例： +#include +#include // 头文件引用部分 +#include ""ms_ext.h"" + +extern ""C"" int LeakyRelu( + int nparam, + void** params, + int* ndims, + int64_t** shapes, + const char** dtypes, + void* stream, + void* extra) { + cudaStream_t custream = static_cast(stream); + cudaStreamSynchronize(custream); + auto tensors = get_torch_tensors(nparam, params, ndims, shapes, dtypes, c10::kCUDA); + auto at_input = tensors[0]; + auto at_output = tensors[1]; + torch::leaky_relu_out(at_output, at_input); + return 0; +} + + +其中，PyTorch Aten提供了带输出的算子函数版本和不带输出的算子函数版本，带输出的算子函数有_out后缀，PyTorch Aten提供了300+常用算子的api。 +当调用torch::*_out时，不需要output拷贝。当调用不带_out后缀的版本，需要调用APItorch.Tensor.copy_进行结果拷贝。 +想查看支持调用PyTorch Aten的哪些函数，CPU版本参考PyTorch安装路径下的：python*/site-packages/torch/include/ATen/CPUFunctions_inl.h ，相应的GPU版本参考python*/site-packages/torch/include/ATen/CUDAFunctions_inl.h。 +以上用例中使用了ms_ext.h提供的api，这里稍作介绍: +// 将 MindSpore kernel 的 inputs/outputs 转换为 PyTorch Aten 的 Tensor +std::vector get_torch_tensors(int nparam, void** params, int* ndims, int64_t** shapes, const char** dtypes, c10::Device device) ; + + + + +3. 使用编译脚本setup.py生成so +setup.py使用PyTorch Aten提供的cppextension将上述c++/cuda源码编译成so文件。 +执行前需要确保已经安装PyTorch。 +pip install torch + + +并将PyTorch的lib加入LD_LIBRARY_PATH。 +export LD_LIBRARY_PATH=$(python3 -c 'import torch, os; print(os.path.dirname(torch.__file__))')/lib:$LD_LIBRARY_PATH + + +执行： +cpu: python setup.py leaky_relu.cpp leaky_relu_cpu.so +gpu: python setup.py leaky_relu.cu leaky_relu_gpu.so + + +将得到我们需要的 so 文件。 + + +4. 使用自定义算子 +以CPU为例，使用Custom算子调用上述PyTorch Aten算子，代码见test_cpu_op.py： +import numpy as np +from mindspore import context, Tensor +from mindspore.nn import Cell +import mindspore.ops as ops + +context.set_context(device_target=""CPU"") + +def LeakyRelu(): + return ops.Custom(""./leaky_relu_cpu.so:LeakyRelu"", out_shape=lambda x : x, out_dtype=lambda x : x, func_type=""aot"") + +class Net(Cell): + def __init__(self): + super(Net, self).__init__() + self.leaky_relu = LeakyRelu() + + def construct(self, x): + return self.leaky_relu(x) + +if __name__ == ""__main__"": + x0 = np.array([[0.0, -0.1], [-0.2, 1.0]]).astype(np.float32) + net = Net() + output = net(Tensor(x0)) + print(output) + + +执行： +python test_cpu_op.py + + +结果： +[[ 0. -0.001] + [-0.002 1. ]] + + +注意： +若使用的是PyTorch Aten GPU算子，device_target需设置为""GPU"". +context.set_context(device_target=""GPU"") +op = ops.Custom(""./leaky_relu_gpu.so:LeakyRelu"", out_shape=lambda x : x, out_dtype=lambda x : x, func_type=""aot"") + + +若使用的是PyTorch Aten CPU算子，而device_target是""GPU""，需要增加设置如下： +context.set_context(device_target=""GPU"") +op = ops.Custom(""./leaky_relu_cpu.so:LeakyRelu"", out_shape=lambda x : x, out_dtype=lambda x : x, func_type=""aot"") +op.add_prim_attr(""primitive_target"", ""CPU"") + + + + +使用cppextension编译so需满足该工具需要的编译器版本，检查gcc/clang/nvcc是否存在。 +使用cppextension编译so会在脚本路径生成一个build的文件夹，里面存放了so，脚本会将so拷贝到build外，但是cppextension如果发现build里已经有so会跳过编译，因此如果是新编译的so要记得清空build下的so。 +以上测试基于PyTorch 1.9.1版本，cuda使用11.1，python3.7，下载链接：https://download.pytorch.org/whl/cu111/torch-1.9.1%2Bcu111-cp37-cp37m-linux_x86_64.whl，PyTorch Aten支持的cuda版本需和本地的cuda版本一致，其他版本是否支持需用户自行探索。 + + + +",基于自定义算子接口调用第三方算子库,MindSpore、MindSpore、算子、接口、GPU、CPU、linux、网络、PyTorch、API、aSt、Aten、数据、脚本、框架、cuda、C++、ib、npu +网络调试§网络调试,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/neural_network_debug.html," + +本章将介绍网络调试的基本思路、常用工具，以及一些常见问题处理。 + +",网络调试,网络、调试 +网络调试§网络调试的基本流程,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/neural_network_debug.html," +网络调试的过程主要分为以下几个步骤： + +网络流程调试成功，网络执行整体不报错，正确输出loss值，且正常完成参数更新。 +一般情况下，使用model.train接口完整执行一个step并且不报错，即正常执行并完成了参数更新；如果需要精确确认，可以通过mindspore.train.callback.CheckpointConfig中的参数save_checkpoint_steps=1保存连续两个step的Checkpoint文件，或者使用save_checkpoint接口直接保存Checkpoint文件，然后通过以下代码打印Checkpoint文件中的权重值，查看两个step的权重是否发生改变，并完成更新。 +import mindspore +import numpy as np +ckpt = mindspore.load_checkpoint(ckpt_path) +for param in ckpt: + value = ckpt[param].data.asnumpy() + print(value) + + + +网络多轮迭代执行输出loss值，且loss值具有基本的收敛趋势。 +网络精度调试，超参调优。 + +",网络调试,mindspore、mindspore、接口、callback、网络、model、loss、调试、精度、超参、精度、迭代 +网络调试§网络调试中的常用方法,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/neural_network_debug.html," + +流程调试 +本节内容介绍脚本开发基本完成后，网络流程调试过程中可能出现的问题和解决方法。 + +用PyNative模式进行流程调试 +在脚本开发和网络流程调试中，我们推荐使用PyNative模式进行调试。PyNative模式支持执行单算子、普通函数和网络，以及单独求梯度的操作。在PyNative模式下，可以方便地设置断点，获取网络执行的中间结果，也可以通过pdb的方式对网络进行调试。 +在默认情况下，MindSpore处于Graph模式，可以通过context.set_context(mode=context.PYNATIVE_MODE)设置为PyNative模式，相关示例可参考使用PyNative模式调试。 + + +获取更多报错信息 +在网络流程调试过程中，如果需要获取更多的报错信息，可通过以下方式获得： + +在PyNative模式下可使用pdb进行调试，利用pdb打印相关堆栈和上下文信息帮助问题定位。 +使用Print算子打印更多上下文信息，具体示例可参考Print算子功能介绍。 +调整日志级别获取更多报错信息，MindSpore可通过环境变量方便地调整日志级别，具体可参考日志相关的环境变量和配置。 + + + +常见错误 +在网络流程调试中，常见的错误有以下几类： + +算子执行报错 +网络流程调试过程中，常出现shape不匹配、dtype不支持等算子执行报错，此时应根据报错信息检查是否正确使用算子，以及算子输入数据的shape是否与预期相符，并进行相应修改。 +相关算子支持和API介绍可参考算子支持列表和算子Python API。 + +相同脚本，在PyNative模式下能跑通，但Graph模式下报错 +MindSpore的Graph模式下，construct函数中的代码由MindSpore框架进行解析，有一些Python语法还未支持，因此导致报错。此时应当根据报错信息按照MindSpore的语法说明修改相关代码。 + +分布式并行训练脚本配置错误 +分布式并行训练脚本及环境配置可参考分布式并行训练教程。 + + + + + +loss值对比检查 +在具有对标脚本的情况下，可对比对标脚本跑出的loss值与MindSpore脚本跑出的loss值，以验证整体网络结构和算子精度的正确性。 + +主要步骤 + +保证输入相同 +需保证两个网络中输入相同，使得在相同的网络结构下，网络输出相同。可使用以下几种方式保证输入相同： + +使用numpy自行构造输入数据，保证网络输入相同，MindSpore支持Tensor和numpy的自由转换。构造输入数据可以参考以下脚本： +input = Tensor(np.random.randint(0, 10, size=(3, 5, 10)).astype(np.float32)) + + + +使用相同数据集进行计算，MindSpore支持使用TFRecord数据集，可使用mindspore.dataset.TFRecordDataset接口读取。 + + +去除网络中随机性因素的影响 +去除网络中的随机性影响，主要方法有设置相同的随机性种子，关掉数据shuffle，修改代码去除dropout、initializer等网络中具有随机性的算子的影响等。 + +保证相关超参数的设置相同 +需保证网络中的超参数设置相同，以保证相同的输入，算子的输出相同。 + +运行网络，比较输出的loss值，一般loss值误差在1‰左右，因为算子本身存在一定精度误差，随着step数增大，误差会有一定累加。 + + + +相关问题定位 +如果loss值误差较大，可使用以下几种方式进行问题定位： + +检查输入、超参设置是否相同，以及是否完全去除了随机性影响。 +同一脚本多次重跑，loss值相差较大，则说明没有完全去除网络中的随机性影响。 + +整体判断。 +如果第一轮loss值就出现较大误差，则说明网络的前向计算就存在问题。 +如果第一轮loss值在误差范围内，第二轮开始loss值出现较大误差，则说明网络的前向计算应该没有问题，反向梯度和权重更新计算可能存在问题。 + +有了整体的判断之后，由粗到细进行输入输出数值的精度对比。 +首先，对各个子网从输入开始逐层对比输入输出值，确定初始出现问题的子网。 +然后，对比子网中的网络结构以及算子的输入输出，找到出现问题的网络结构或算子，进行修改。 +如果在此过程中发现了算子精度存在问题，可在MindSpore代码托管平台上提issue，相关人员将对问题进行跟踪处理。 + +MindSpore提供了丰富的工具获取网络中间数据，可根据实际情况选用。 + +数据Dump功能 +使用Print算子打印相关信息 +使用可视化组件MindInsight + + + + + + +精度调试工具 + +自定义调试信息 + +Callback功能 +MindSpore已提供ModelCheckpoint、LossMonitor、SummaryCollector等Callback类用于保存模型参数、监控loss值、保存训练过程信息等功能，用户也可自定义Callback函数用于实现在每个epoch和step的开始和结束运行相关功能，具体示例可参考自定义Callback。 + +MindSpore metrics功能 +当训练结束后，可以使用metrics评估训练结果的好坏。MindSpore提供了多种metrics评估指标，如：accuracy、loss、precision、recall、F1等。 + +自定义训练 +自定义学习率 +MindSpore提供了一些常见的动态学习率实现以及一些常见的具有自适应学习率调整功能的优化器，可参考API文档中的Dynamic Learning Rate和Optimizer Functions。 +同时，用户可实现自定义的动态学习率，以WarmUpLR为例： +class WarmUpLR(LearningRateSchedule): + def __init__(self, learning_rate, warmup_steps): + super(WarmUpLR, self).__init__() + ## check the input + if not isinstance(learning_rate, float): + raise TypeError(""learning_rate must be float."") + validator.check_non_negative_float(learning_rate, ""learning_rate"", self.cls_name) + validator.check_positive_int(warmup_steps, 'warmup_steps', self.cls_name) + ## define the operators + self.warmup_steps = warmup_steps + self.learning_rate = learning_rate + self.min = ops.Minimum() + self.cast = ops.Cast() + + def construct(self, global_step): + ## calculate the lr + warmup_percent = self.cast(self.min(global_step, self.warmup_steps), mstype.float32)/ self.warmup_steps + return self.learning_rate * warmup_percent + + + + + + +使用MindOptimizer进行超参调优 +MindSpore提供了MindOptimizer工具帮助用户进行更便捷的超参调优，详细示例和使用方法可参考使用MindOptimizer进行超参调优。 + + +loss值异常定位 +对loss值为INF、NAN，或者loss值不收敛的情况，可从以下几种情况进行排查： + +检查loss_scale溢出。 +在混合精度使用loss_scale的场景下，出现loss值为INF、NAN的情况，可能是scale值过大造成的，如果为动态loss_scale，则会自动调整scale值；如果为静态loss_scale，则需要减小scale值。 +如果scale=1的情况下依旧存在loss值为INF、NAN的情况，则网络中应该有算子出现溢出，需要进行进一步定位。 + +造成loss值异常的原因可能由输入数据异常、算子溢出、梯度消失、梯度爆炸等原因造成。 +排查算子溢出、梯度为0、权重异常、梯度消失和梯度爆炸等网络中间值情况，推荐使用MindInsight调试器设置相应检测点进行检测和调试，这种方式可较为全面地进行问题定位，可调试性也比较强。 +下面介绍几种简单的初步排查方法： + +观察权重值是否出现梯度爆炸的情况，也可通过加载保存的Checkpoint文件，打印权重值进行初步判断，打印权重值可参考以下代码： +import mindspore +import numpy as np +ckpt = mindspore.load_checkpoint(ckpt_path) +for param in ckpt: + value = ckpt[param].data.asnumpy() + print(value) + + + +查看是否出现梯度为0的情况，也可以通过对比不同step保存的Checkpoint文件的权重值是否发生变化，进行初步判断，Checkpoint文件的权重值对比可参考以下代码： +import mindspore +import numpy as np +ckpt1 = mindspore.load_checkpoint(ckpt1_path) +ckpt2 = mindspore.load_checkpoint(ckpt2_path) +sum = 0 +same = 0 +for param1,param2 in zip(ckpt1,ckpt2): + sum = sum + 1 + value1 = ckpt[param1].data.asnumpy() + value2 = ckpt[param2].data.asnumpy() + if value1 == value2: + print('same value: ', param1, value1) + same = same + 1 +print('All params num: ', sum) +print('same params num: ', same) + + + +查看权重值中是否出现NAN、INF异常数据，也可通过加载Checkpoint文件进行简单判断，一般来说，权重值中出现NAN、INF，则梯度计算中也出现了NAN、INF，可能有溢出情况发生，相关代码可参考： +import mindspore +import numpy as np +ckpt = mindspore.load_checkpoint(ckpt_path) +for param in ckpt: + value = ckpt[param].data.asnumpy() + if np.isnan(value): + print('NAN value:', value) + if np.isinf(value): + print('INF value:', value) + + + + + + + + +",网络调试,MindSpore、MindSpore、并行、优化器、分布式、算子、接口、数据集、Optimizer、operators、Callback、MindInsight、网络、PyNative、评估、API、Model、loss、metric、arm、ast、LR、学习率、调试、MindOptimizer、精度、数据、超参、精度、可视化、优化、脚本、框架、dataset、Graph、npu +精度问题初步定位指南§精度问题初步定位指南,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_problem_preliminary_location.html," + +本指南旨在为算法开发者提供一个简明扼要的精度问题初步定位指导。完整的精度问题定位和调优方法，请参考精度问题详细定位和调优指南。 +本指南适用于训练脚本能够运行到训练结束并输出每个迭代的loss值的情况。若训练中途出现中断训练的报错，则应该首先根据错误提示解决这些报错。 +本指南假设读者有能力独立完成深度学习训练脚本的编写，对深度学习、MindSpore有基础的了解。 +我们提供两种常见的问题初步定位方法：基于checklist的精度问题初步定位和基于现象对比的精度问题初步定位。实际操作时，一般使用一种方法即可，推荐优先使用基于checklist的精度问题初步定位方法。如果有标杆脚本（指开发MindSpore脚本时参考的脚本），可以考虑基于现象对比的精度问题初步定位方法。 + +",精度问题初步定位指南,MindSpore、MindSpore、loss、精度、checklist、精度、迭代、脚本 +精度问题初步定位指南§基于问题checklist的精度问题初步定位,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_problem_preliminary_location.html," +当出现精度问题时，您可以参考以下checklist进行检查。若通过checklist发现了可疑的问题，则您应参考精度问题详细定位和调优指南尝试修复这些可疑问题。若checklist使用完毕后，未发现可疑问题，则您应尝试其它精度问题定位和调优手段，或者参考精度问题详细定位和调优指南。如果您怀疑精度问题和MindSpore框架相关，请在向我们求助前确认不存在checklist上列出的问题，求助方法请见本文末尾。 + +checklist使用说明 +建议您将下列checklist全文拷贝到word中，逐项检查，在word中填写检查结论并保存。对于比较复杂的问题，建议您在检查结论后粘贴相关的截图和代码，这些信息可以在您向我们求助时帮助我们更好地判断您的问题。 +关于“检查方案”列：您可以根据实际情况选择等效或者效力更强的其它检查方案。 +关于“检查结论”列：请根据实际情况从“发现问题”、“无问题”、“不涉及”三个选项中选择填写。 + + +常见数据集问题 + +ds.01 数据集中缺失值过多 +检查方法： +缺失值常常以NaN，+/-Inf等形式存在，不同的数据集中使用的缺失值符号也不尽相同。检查缺失值时，首先明确每个字段使用何种方式表示缺失值，然后使用计数器对每个字段中的缺失值个数进行计数，以此来掌握数据集中缺失值的情况。 +若数据中存在未处理的缺失值，则此项的检查结果为“发现问题”，需要采取合适的手段处理（处理手段请参考 精度问题详细定位和调优指南） +检查结论： +请填写 + + +ds.02 数据的标签错误 +检查方法： +采用抽样的方法对数据标签是否正确进行检查。无标签的场景（例如无监督学习）无需进行本检查。 +若标签不多，建议基于所有的标签对训练数据进行无放回的层次抽样，确保每个标签至少有一个样本入选，然后对入选的样本进行检查。合理选择抽取概率，使得样本量在50个左右。 +若标签较多，建议先对标签进行抽样，随机选择20个标签。然后基于所选择的标签对训练数据进行无放回的层次抽样，确保每个标签至少有一个样本入选。合理选择抽取概率，使得样本量在50个左右。 +获取完样本后，应采用合适可视化方式检查数据标签是否正确。例如，图像数据可以使用matplotlib绘制出图片后检查，文本数据则可以直接打印到屏幕上进行检查。 +检查结论： +请填写 + + +ds.03 数据集每个类别的样本数目不均衡或部分类别训练样本不足 +检查方法： +使用计数器对每个类别的样本数目进行计数，然后通过标准差和柱状图等方式判断样本数目是否均衡。一般来说，有监督深度学习算法在每类5000个标注样本的情况下将达到可以接受的精度，当数据集中有1000万个以上的已标注样本时，模型的表现将会超过人类。 +检查结论： +请填写 + + +ds.04 训练环境上的数据集同标准数据集不同 +检查方法： +建议确认训练环境中拷贝下来的数据集同源数据集一致，特别是在并行训练中，建议确认每台机器上都正确地存储了数据集。使用知名数据集时，应确认训练环境中使用的数据集同知名数据集一致。检查步骤如下： + +获取参考训练与实际环境训练的数据集文件列表，确保两个文件列表一致。训练环境中的文件列表应基于真实训练过程记录，例如在训练脚本中创建数据集时记录数据集文件列表。 +基于文件列表获取参考数据集文件与实际环境数据集文件的MD5校验码，确保两组校验码一致。 + +检查结论： +请填写 + + + +常见数据处理算法问题 + +dp.01 未对数据进行归一化或标准化 +检查方法： +检查数据处理代码，确认数据处理代码中进行了必要的归一化或标准化调用。归一化或标准化是指将数据映射到同一尺度，常见的操作方法包括Resize、Rescale、Normalize等。 +例子： +以ModelZoo的resnet50模型为例，可见其在数据处理代码中进行了归一化，因此检查结果为“无问题”。 + trans += [ + C.Resize((224, 224)), + C.Rescale(1.0 / 255.0, 0.0), + C.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]), + C.HWC2CHW() + ] + + +检查结论： +请填写 + + +dp.02 推理时数据处理方式有误 +检查方法： +检查训练脚本的数据处理代码和推理脚本的数据处理代码，两者的处理逻辑一般要保持一致。需要说明的是，一些用于数据增强的随机操作（如随机旋转，随机裁切等）一般只应用在训练集，推理时无需进行随机操作。 +例子： +以ModelZoo的resnet50模型为例（cifar10数据集），其训练脚本和推理脚本复用一个数据处理函数，通过do_train参数区分训练模式和推理模式。检查代码可以发现，do_train仅影响两个随机数据处理算子，在训练模式时使用，在推理模式下不使用，其余处理逻辑相同。因此检查结果为“无问题”。 + if do_train: + trans += [ + C.RandomCrop((32, 32), (4, 4, 4, 4)), + C.RandomHorizontalFlip(prob=0.5) + ] + + +检查结论： +请填写 + + +dp.03 训练时没有对数据集进行混洗 +检查方法： +检查训练脚本的数据处理代码中是否使能了混洗（shuffle）功能。通过混洗，可以打乱数据顺序，有助于避免过拟合。如果未进行混洗，或者混洗不充分，会导致总是以相同的数据顺序更新模型，严重限制了梯度优化方向的可选择性，导致收敛点的选择空间变少，容易过拟合。混洗功能的常见使能方式有如下几种，使用任意一种方式来使能混洗功能均可： + +创建数据集时，指定shuffle参数为True。例如 mindspore.dataset.Cifar10Dataset中的shuffle参数。 +在数据处理的过程中，使用shuffle方法，例如mindspore.dataset.Cifar10Dataset.shuffle。 +如果使用了Sampler，还可以使能Sampler提供的shuffle功能。例如mindspore.dataset.PKSampler中的shuffle参数。 + +例子： +以ModelZoo中的resnet50为例（cifar10数据集），其在创建数据集时shuffle参数指定为True，因此检查结果为“无问题”。 + if device_num == 1: + data_set = ds.Cifar10Dataset(dataset_path, num_parallel_workers=8, shuffle=True) + else: + data_set = ds.Cifar10Dataset(dataset_path, num_parallel_workers=8, shuffle=True, + num_shards=device_num, shard_id=rank_id) + + +检查结论： +请填写 + + +dp.04 涉及到数据补齐时，补齐方式错误 +检查方法： +检查数据补齐（padding）的位置、方式、值是否同设计一致。数据补齐是指通过填充假数据，使得数据的大小、形状满足训练要求。 +检查结论： +请填写 + + +dp.05 并行训练时多节点分片方式错误 +检查方法： +多节点数据预处理流程可能存在基于文件名、文件个数等进行分片的模式。该模式下由于文件读取接口在不同节点上对文件名排序的不同，会导致分片差异较大甚至文件重复分片到不同节点等不期望的结果。 +检查结论： +请填写 + + + +常见超参问题 + +hp.01 学习率过大或过小 +检查方法： +通过一个简单的实验可以初步确定学习率的范围。具体来讲，选定一个足够大的学习率范围（例如从0到0.5），设置训练运行几个epoch（例如10个），在训练运行过程中，逐迭代地线性（或指数）增大学习率，就可以得到一个准确率和学习率的关系曲线，如图。关注曲线中准确率开始上升和不再上升的部分所对应的学习率，可以将准确率开始上升时的学习率当做学习率的下限，将准确率不再上升时的学习率当做学习率的上限，在上下限之间的学习率都可以认为是合理的。 + +图1 学习率与准确率的关系 此曲线通过8个epoch的训练得到 图片引用自(Smith, 2017) +检查结论： +请填写 + + +hp.02 epoch数目过大或过小 +检查方法： +一个epoch是指使用训练集的全部数据将模型训练一次的过程。epoch数目指上面的过程进行了几次。通过训练过程中的训练集loss曲线和测试集loss曲线可以帮助判断合理的epoch数目。一般来说，随着训练进行，训练集上的loss不断减小，而验证集上的loss先下降，后缓慢增加，应选择验证集loss最小时的epoch作为训练的最佳epoch数。 + +*图2 epoch和loss的关系 图中蓝色曲线为训练集上的loss曲线 绿色曲线为验证集上的loss曲线 * +检查结论： +请填写 + + +hp.03 batch size过大 +检查方法： +过大的batch size将会降低准确度。一般来讲，32是一个比较安全的值，64、128、256 也都值得尝试。建议先在较小的batch size和数据集上进行训练，得到准确度的基线。在大batch size的训练中关注准确率的变化情况，如果距离基线较远，说明batch size可能较大（也可能是学习率和batch size不匹配，一般在增大batch size时应同步增大learning rate，使batch size和learning rate的比例保持恒定）。 +检查结论： +请填写 + + + +常见API使用问题 + +api.01 使用API时未注意到MindSpore API和其它框架API的差异 +检查方法： +MindSpore API同其它框架的API存在一定差异。有标杆脚本的情况下，要特别注意: + +MindSpore脚本的参数初始化方式是否同标杆脚本相同 +MindSpore中部分API的参数默认值，参数含义同其它框架不同 + +此处我们列举一些比较重要的差异供大家检查： + +MindSpore的Conv2d算子，默认没有bias（has_bias=False），而PyTorch的Conv2d算子，默认有bias。Conv2d算子的weight默认使用 Normal(0.0, 0.01)，这一初始化方式和PyTorch（Uniform）、TensorFlow（Uniform）均不同。与PyTorch的差异对比。 +MindSpore的DropOut算子，参数含义为保留的概率（keep_prob），而PyTorch的DropOut算子，参数含义为丢弃的概率。 +MindSpore的BatchNorm2d中的动量默认值和PyTorch不同。PyTorch默认是0.1，MindSpore中默认值是0.9。与PyTorch的差异对比。 + +较完整的API差异列表请参考 https://www.mindspore.cn/docs/zh-CN/r1.7/note/api_mapping/pytorch_api_mapping.html。 +例子： +以ModelZoo中的resnet50为例（cifar10数据集），结合API差异列表可知，此脚本中使用了如下可能存在差异的API：mindspore.nn.Conv2d，mindspore.nn.BatchNorm2d。 +逐个确认可知，脚本中使用Conv2d时，显式指定了weight_init方式。脚本中使用BatchNorm2d时，显式指定了momentum参数。这些参数的值和设计相符，因此可以判定“无问题”。 +检查结论： +请填写 + + +api.02 使用API时未根据训练/推理场景对应设置模式 +检查方法： +训练脚本中，未使用model.train API进行训练时需要进行本检查。 +评估脚本中，未使用model.eval API进行评估时需要进行本检查。 +推理脚本中，未使用model.predict API进行推理时需要进行本检查。 +根据是否为训练场景，在调用模型时提前设置cell.set_train()。若为训练场景，应该先调用 cell.set_train(True)，其它场景，则应该先调用cell.set_train(False)。 +备注： +对于mindspore.nn名称空间下的BatchNorm系列算子，建议您保持参数use_batch_statistics为默认值None。当use_batch_statistics为默认值None时，BatchNorm算子会根据cell.set_train()所给定的模式决定每个迭代中是否更新moving mean和moving variance参数：在cell.set_train()所给定的模式为True时更新上述两个参数，在cell.set_train()所给定的模式为False时不对上述两个参数进行更新。若设置了use_batch_statistics=True，即使设置了cell.set_train(False)以表示当前处于非训练场景，BatchNorm算子仍然会更新moving mean和moving variance参数。 +例子： +以ModelZoo中的resnet50为例（cifar10数据集），其在train.py和eval.py中分别使用的model.train和model.eval API进行训练和推理，在infer.py中，其在推理前显式调用net.set_train（False），因此检查结果为“无问题”。 +检查结论： +请填写 + + + +常见计算图结构问题 +为了检查计算图结构问题，请读者首先参考收集Summary数据，将计算图保存到summary文件中，然后使用MindInsight可视化查看计算图。 +检查结论： +请填写 + +cg.01 权重共享错误 +检查方法： +权重共享错误，是指应该共享的权重未共享，或者不应该共享的权重共享了。在MindInsight计算图页面对感兴趣的权重进行抽检，选中权重节点，根据权重节点的输出节点可以判断权重是否被共享，观察输出节点的名称，可以得知输出节点大致对应的代码。节点名称以Default开头的，一般为正向图中的节点，需要重点关注。节点名称以Gradients开头或者含有optimizer的，一般为反向图或者优化器相关的节点，检查时可以忽略。例如，要检查Conv2d的权重，可以在计算图页面右上角的搜索框中键入conv2d，然后选择任意感兴趣的conv2d节点，接着找到该节点的输入权重节点，即可对该权重节点进行检查。 +检查结论： +请填写 + + +cg.02 权重冻结错误 +检查方法： +对照代码检查权重的冻结情况是否同设计一致。有两种方法可以冻结权重，这两种方法在代码中都具有明显的特征。 +方法一：设置Parameter的requires_grad参数为False。 +方法二：使用stop_gradient阻止梯度继续向后传播，阻止所有会影响权重的梯度后，该权重的更新也就事实上被阻止了。 +检查结论： +请填写 + + +cg.03 节点连接错误 +检查方法： +在MindInsight计算图页面自顶向下地对重要的模型元素进行检查，确保这些元素体现在了计算图中。例如，检查LeNet5是否存在节点连接错误时，可以逐层展开MindInsight计算图页面显示的计算图，确认conv、relu、fc等重要元素存在于计算图中，并且连接正确。Gradients命名空间下的计算图为MindSpore自动微分生成，检查时可以忽略。 +检查结论： +请填写 + + +cg.04 loss函数有误 +检查方法： +使用MindSpore内置loss函数时，应检查使用的loss函数种类是否同设计相符。使用自定义loss函数时，应检查loss函数的代码实现是否和设计相符，必要时可以手动实现一个numpy版本，使用相同输入对比MindSpore版本的loss函数和numpy版本的loss函数输出是否一致。 +检查结论： +请填写 + + + +常见权重初始化问题 + +wi.01 权重初始值全部为0 +检查方法： +检查脚本中的权重（不含优化器中的状态）初始化方式（包括显式指定的权重初始值和部分mindspore.nn命名空间下API中默认初始化的权重），是否有将权重初始化为全零的情况。需要注意的是，部分参数，例如bias，初始化为全0是正确的。 +检查结论： +请填写 + + +wi.02 加载的预训练模型不正确 +检查方法： +加载预训练模型/骨干模型时，要确保加载了正确的权重。当使用resnet等骨干模型时，要注意加载同设计相符，匹配使用场景的预训练模型。有标杆脚本时，要确保加载的预训练模型和标杆脚本能使用的预训练模型有相同的权重值。 +检查结论： +请填写 + + + +常见混合精度和溢出问题 +当您在Ascend后端上运行脚本时，或者使用了混合精度功能时，建议您参考本节中的检查项进行检查，以确认是否存在混合精度及溢出问题。 + +mp.01 训练中存在溢出问题 +检查方法： +当使用混合精度训练，或者是使用Ascend AI处理器训练时，建议检查是否存在溢出问题。 +使用GPU时，通过调试器中的“检查张量溢出”监测点可以进行溢出检查。 +发现溢出问题后，应首先找到并分析第一个出现溢出的节点（对于Ascend的溢出数据，可以按文件名中的时间戳，找时间戳最小的一个；对于GPU上的溢出，只要找执行序中最靠前的一个），结合算子的输入输出数据确定溢出原因。 +出现溢出问题后常见的解决措施如下： + +使能动态loss scale功能，或者是合理设置静态loss scale的值，请参考LossScale。需要注意的是，直接将GPU场景中的静态loss scale用于Ascend上的训练时，可能会导致不期望的频繁溢出，影响收敛。loss scale使能后，可能需要多次实验以调整loss scale的初始值init_loss_scale、调整比例scale_factor、调整窗口scale_window等参数，直到训练中浮点溢出非常少，请参考DynamicLossScaleManager以了解这些参数的含义。 +溢出问题对精度有关键影响且无法规避的，将相应的算子调整为FP32算子（调整后可能对性能有较大影响）。 + +检查结论： +请填写 + + +mp.02 混合精度训练时，未正确设置loss scale +检查方法： +在使用混合精度时，一般应确认使能了DynamicLossScaleManager或FixedLossScaleManager，推荐优先使用DynamicLossScaleManager。可以先使用DynamicLossScaleManager或FixedLossScaleManager的默认参数值进行训练，若产生溢出的迭代过多，影响最终精度时，应根据主要的溢出现象，针对性调整loss_scale的值。当主要溢出现象为梯度上溢时，应减小loss_scale的值（可以尝试将原loss_scale值除以2）；当主要溢出现象为梯度下溢时，应增大loss_scale的值（可以尝试将原loss_scale值乘以2）。对于Ascend AI处理器上的训练，其在大部分情况下为混合精度训练。由于Ascend AI处理器计算特性与GPU混合精度计算特性存在差异，LossScaleManager超参也可能需要根据训练情况调整为与GPU上不同的值以保证精度。 +检查结论： +请填写 + + +mp.03 loss scale和梯度裁剪的应用顺序不正确 +检查方法： +梯度裁剪（gradient clip）是指当梯度大于某个阈值时，强制调整梯度使其变小的技术。梯度裁剪对RNN网络中的梯度爆炸问题有较好的效果。如果同时使用了loss scale和梯度裁剪，需要进行本检查。请对照代码检查确认梯度裁剪的应用对象是除以loss scale后得到的原始梯度值。 +检查结论： +请填写 + + +mp.04 计算梯度惩罚时，没有先将梯度恢复为无loss scale的梯度 +检查方法： +梯度惩罚是指将梯度添加到代价函数中，约束梯度长度的技术。如果同时使用了loss scale和梯度惩罚（gradient penalty），需要进行本检查。检查确认计算梯度惩罚项时，输入的梯度为无loss scale的梯度。例如，可以先将代用loss scale的梯度除以loss scale，再用来计算梯度惩罚项。 +检查结论： +请填写 + + +",精度问题初步定位指南,MindSpore、自动微分、MindSpore、并行、优化器、算子、接口、数据集、optimizer、GPU、Ascend、MindInsight、网络、评估、TensorFlow、PyTorch、API、Model、loss、学习率、调试、精度、checklist、数据、loss scale、超参、计算图、精度、可视化、优化、迭代、ModelZoo、脚本、框架、性能、dataset、eval、ib +精度问题初步定位指南§基于现象对比的精度问题初步定位,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_problem_preliminary_location.html," +在脚本、超参、数据集未修改的情况下，若版本升级后在新版本上多次运行完全相同的脚本均存在明显的精度劣化（相较于旧版本），请向我们求助并提供相关信息。 +有其它框架下的标杆脚本时，可以通过对比MindSpore脚本和标杆脚本的现象来初步定位精度问题。标杆脚本是指，开发MindSpore脚本时镜像参考的脚本，也即，MindSpore脚本中的绝大多数细节由标杆脚本决定。迁移场景中，被迁移的脚本一般是标杆脚本。 +本方法操作步骤如下： + +固定MindSpore脚本随机性 +见固定随机性以复现脚本运行结果。 + + +复现精度问题 +固定随机性后，应首先检查精度问题是否复现。 +若问题不再复现，说明精度问题和固定随机性时所作的操作有关，依照不固定网络、不固定数据集、不固定初始化权重、不固定超参、不固定全局随机数种子的顺序尝试，可以确定哪个操作导致问题不在复现，从而判断问题原因，并针对性优化训练脚本。 +若问题在随机step偶现、或是在确定step偶现、或是在随机step必现。结合上面步骤中loss曲线在多次运行时一致的检查结果，应再次检查确认是否所有随机因素都固定了。 +若问题在确定迭代必现，为方便后续现象对比和问题定位，可以尝试将问题提前到第一个或第二个step出现。具体来讲，假设问题在第D个迭代出现，则应设法保存第D-1个迭代的checkpoint，记为checkpoint（D-1），并设置数据集skip对应的数据，然后加载checkpoint（D-1）运行训练，此时问题应在第二个迭代出现（初始迭代记为第一个迭代）。 + + +同标杆脚本对比 +同标杆脚本对比，是对定位精度问题具有极大帮助的一步。这一步中，需要将MindSpore脚本和标杆脚本进行全面彻底的对比，一个目的是检查MindSpore脚本中是否存在错误，另一个目的是固定标杆脚本的随机性，以便同MindSpore脚本对比loss曲线。 +建议采用模拟执行，逐行对比的方式做检查。想象以相同的参数分别执行训练脚本，执行时确认MindSpore脚本和标杆脚本的逻辑一致，运行参数含义匹配，确认的范围一般局限在开发者自己编写的代码即可（深度学习框架本身的代码可以不打开）。在这个执行过程中，着重关注以下部分： + +确认标杆脚本中各种全局随机数种子已固定。 +对比超参是否一致，并固定标杆脚本中的超参。 +对比数据集和数据处理是否一致，并固定标杆脚本中的数据处理方法和数据顺序。 +对比网络结构是否一致，并删除网络中带有随机性的算子。 +对比权重初始化是否一致。建议MindSpore脚本和标杆脚本加载具有相同值的checkpoint文件。网络结构一致的情况下，一般通过简单的权重名称替换即可将一个框架的checkpoint文件转换为另一个框架的checkpoint文件。 +强烈建议在标杆脚本中使能混合精度。若标杆脚本使能混合精度后出现精度问题，则需要优化算法以使算法能够正常在混合精度下收敛。 + +在对比的过程中，除了要对比脚本中写出来的参数，还要注意未写在脚本中的参数默认值。例如，MindSpore的Conv2d算子，默认has_bias为False，使用Normal(0.0, 0.01)进行权重初始化，而PyTorch的Conv2d算子，默认has_bias为True，初始化方式也不同。MindSpore与PyTorch的详细API差异请见 https://www.mindspore.cn/docs/zh-CN/r1.7/note/api_mapping/pytorch_api_mapping.html。 +执行完上述对比和固定流程后，一般会发现若干MindSpore脚本中的不一致，修复这些不一致后，往往精度问题就解决了。若不一致之处都修复了，问题仍然存在，可以使用相同的数据集和参数分别运行MindSpore脚本和标杆脚本，对比两者的loss： + +若第一个迭代的loss不同，说明两个脚本可能还存在不一致，或者是未固定的随机性。 +若第一个迭代的loss相同，第二个迭代的loss不同，说明在第一个迭代的反向计算或权重更新，或是在第二个迭代的正向计算中出现了不一致。需要您检查MindSpore脚本和标杆脚本的优化器、输入数据等是否一致。如果检查确认MindSpore脚本和标杆脚本一致，随机性都已固定，请收集相关信息向我们求助 。 + +若第一个和第二个迭代的loss值均相同，则可以更进一步对比整条loss曲线。如果整条loss曲线基本一致，则说明标杆脚本大概率也存在精度问题，如果整条loss曲线出现了分叉，则分叉的位置是定位精度问题的关键。 +需要特别说明的是，由于Ascend上部分算子没有FP32实现，在同Ascend上的MindSpore对比时，标杆脚本也应使能混合精度 ，以确定开启混合精度情况下的精度上限。 + +",精度问题初步定位指南,MindSpore、MindSpore、优化器、算子、数据集、Ascend、网络、PyTorch、API、loss、精度、数据、超参、精度、优化、迭代、脚本、框架 +精度问题初步定位指南§求助方式,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_problem_preliminary_location.html," +参考上面两种初步定位方法的任意一种进行操作。若未发现可疑点，一般说明脚本不存在明显的问题，此时请参考精度调优建议进行调优。若使用基于现象对比的定位方法发现了疑点，请依据定位方法中的提示判断是需要自行定位的问题还是向MindSpore求助。若使用checklist发现了疑点或问题，请参考精度问题详细定位和调优指南进行详细定位。 +当您遇到精度问题，要向MindSpore求助时，提供相关材料将有助于我们更好地判断和解决您的问题。建议您提供的材料包括但不限于： + +若您使用了checklist，则建议您将checklist的检查结果添加到附件中。 +若您使用了基于现象对比的初步定位方法，则建议您将现象截图（包括MindSpore脚本和标杆脚本），固定完随机性后的MindSpore脚本和标杆脚本，以及复现问题所需的最小数据集和运行环境说明（例如MindSpore版本、在GPU还是Ascend上执行）等添加到附件中。 +始终建议您将能够复现问题的可运行脚本、最小数据集、运行环境说明（例如MindSpore版本、在GPU还是Ascend上执行）等添加到附件中。 + +求助链接：https://gitee.com/mindspore/mindspore/issues/new +",精度问题初步定位指南,MindSpore、MindSpore、数据集、GPU、Ascend、精度、checklist、数据、精度、脚本 +精度问题初步定位指南§参考文献,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_problem_preliminary_location.html," +Smith, L. N. (2017). Cyclical learning rates for training neural networks. Proceedings - 2017 IEEE Winter Conference on Applications of Computer Vision, WACV 2017, 464–472. https://doi.org/10.1109/WACV.2017.58 +",精度问题初步定位指南,精度、精度、roce +精度问题详细定位和调优指南§精度问题详细定位和调优指南,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_optimization.html," + +模型训练的最终结果是为了得到一个精度达标的模型，而在AI训练过程中有时会遇到loss（模型损失值）无法下降，或者发散，metrics（模型度量指标）达不到预期等，造成无法得到一个理想精度的模型，这时候需要去进行分析训练过程中出现了什么样的问题，针对性地采用包括调整数据、调整超参、重构模型结构等方法，去解决模型精度调优过程中遇到的各种问题。 +本文介绍MindSpore团队总结的精度调优的方法，及解决精度调优过程中问题的分析思路，并且将MindSpore中用于精度调优的工具做分类介绍。 + +",精度问题详细定位和调优指南,MindSpore、MindSpore、loss、metric、精度、数据、超参、精度、模型结构 +精度问题详细定位和调优指南§常见精度问题分析,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_optimization.html," +在精度调优实践中，发现异常现象是比较容易的。但是，如果我们对异常现象不够敏感、不会解释，还是会同问题根因失之交臂。下面对常见精度问题进行了解释，能够提高你对异常现象的敏感度，帮你更快定位精度问题。 + +精度问题的常见现象和原因 +模型精度问题和一般的软件问题不同，定位周期一般也更长。在通常的程序中，程序输出和预期不符意味着存在bug（编码错误）。但是对一个深度学习模型来说，模型精度达不到预期，有着更复杂的原因和更多的可能性。由于模型精度要经过长时间的训练才能看到最终结果，定位精度问题通常会花费更长的时间。 + +常见现象 +精度问题的直接现象一般体现在loss（模型损失值）和metrics（模型度量指标）上。loss现象一般表现为： + +loss跑飞，出现NAN，+/- INF，极大值。 +loss不收敛、收敛慢。 +loss为0等。 + +模型metrics一般表现为模型的accuracy、precision等metric达不到预期。 +精度问题的直接现象较容易观察，借助MindInsight等可视化工具，还可以在梯度、权重、激活值等张量上观察到更多现象。常见现象如： + +梯度消失。 +梯度爆炸。 +权重不更新。 +权重变化过小。 +权重变化过大。 +激活值饱和等。 + + + +常见原因 +对精度问题的原因分析，可以简单分为超参问题、模型结构问题、数据问题、算法设计问题等类别： + +超参问题 +超参是模型和数据之间的润滑剂，超参的选择直接影响了模型对数据拟合效果的优劣。超参方面常见的问题如下： + +学习率设置不合理（过大、过小）。 +学习率可以说是模型训练中最重要的超参了。学习率过大，会导致loss震荡，不能收敛到预期值。学习率过小，会导致loss收敛慢。应根据理论和经验合理选择学习率策略。 + +loss_scale参数不合理。 +权重初始化参数不合理等。 +epoch过大或过小。 +epoch数目直接影响模型是欠拟合还是过拟合。epoch过小，模型未训练到最优解就停止了训练，容易欠拟合；epoch过大，模型训练时间过长，容易在训练集上过拟合，在测试集上达不到最优的效果。应根据训练过程中验证集上模型效果的变化情况，合理选择epoch数目。 + +batch size过大。 +batch size过大时，模型可能不能收敛到较优的极小值上，从而降低模型的泛化能力。 + + + +数据问题 + +数据集问题 +数据集的质量决定了算法效果的上限，如果数据质量差，再好的算法也难以得到很好的效果。常见数据集问题如下： + +数据集中缺失值过多。 +数据集中存在缺失值、异常值，会导致模型学习到错误的数据关系。一般来说，应该从训练集中删除存在缺失值或异常值的数据，或者设置合理的默认值。数据标签错误是异常值的一种特殊情况，但是这种情况对训练的破坏性较大，应通过抽查输入模型的数据等方式提前识别这类问题。 + +每个类别中的样本数目不均衡。 +数据集中每个类别的样本数目不均衡，是指数据集中每个类别中的样本数目有较大差距。例如，图像分类数据集（训练集）中，大部分类别都有1000个样本，但是“猫”这一类别只有100个样本，就可以认为出现了样本数目不均衡的情况。样本数目不均衡会导致模型在样本数目少的类别上预测效果差。如果出现了样本数目不均衡，应该酌情增加样本量小的类别的样本。一般来说，有监督深度学习算法在每类5000个标注样本的情况下将达到可以接受的性能，当数据集中有1000万个以上的已标注样本时，模型的表现将会超过人类。 + +数据集中存在异常值。 +训练样本不足。 +训练样本不足是指相对于模型容量，训练集中的样本数量太少。训练样本不足会导致训练不稳定，且容易出现过拟合。如果模型的参数量同训练样本数量不成比例，应该考虑增加训练样本或者降低模型复杂度。 + +数据的标签错误。 + + +数据处理问题 +常见数据处理问题如下： + +数据处理参数不正确。 +未对数据进行归一化或标准化。 +未对数据进行归一化或标准化，是指输入模型的数据，各个维度不在一个尺度上。一般来说，模型要求各个维度的数据在-1到1之间，均值为0。如果某两个维度的尺度存在数量级的差异，可能会影响模型的训练效果，此时需要对数据进行归一化或标准化。 + +数据处理方式和训练集不一致。 +数据处理方式和训练集不一致是指在使用模型进行推理时，处理方式和训练集不一致。例如对图片的缩放、裁切、归一化参数和训练集不同，会导致推理时的数据分布和训练时的数据分布产生差异，可能会降低模型的推理精度。 + +一些数据增强操作（如随机旋转，随机裁切等）一般只应用在训练集，推理时无需进行数据增强。 + + +没有对数据集进行shuffle。 +没有对数据集进行shuffle，是指训练时未对数据集进行混洗。未进行shuffle，或者混洗不充分，会导致总是以相同的数据顺序更新模型，严重限制了梯度优化方向的可选择性，导致收敛点的选择空间变少，容易过拟合。 + + + + + +算法问题 + +API使用问题 +常见API使用问题如下： + +使用API没有遵循MindSpore约束。 +使用API未遵循MindSpore约束，是指使用的API和真实应用的场景不匹配。例如，在除数中可能含有零的场景，应该考虑使用DivNoNan而非Div以避免产生除零问题。又例如，MindSpore中，DropOut第一个参数为保留的概率，和其它框架正好相反（其它框架为丢掉的概率），使用时需要注意。 + +构图时未遵循MindSpore construct约束。 +构图未遵循mindspore construct约束，是指图模式下的网络未遵循MindSpore静态图语法支持中声明的约束。例如，MindSpore目前不支持对带键值对参数的函数求反向。完整约束请见静态图语法支持。 + + + +计算图结构问题 +计算图结构是模型计算的载体，计算图结构错误一般是实现算法时代码写错了。计算图结构方面常见的问题有： + +算子使用错误（使用的算子不适用于目标场景）。 +权重共享错误（共享了不应共享的权重）。 +权重共享错误，是指应该共享的权重未共享，或者不应该共享的权重共享了。通过MindInsight计算图可视，可以检查这一类问题。 + +节点连接错误（应该连接到计算图中的block未连接）。 +节点连接错误，是指计算图中各block的连接和设计不一致。如果发现节点连接错误，应该仔细检查脚本是否编写出错。 + +节点模式不正确。 +节点模式不正确，是指节点所处的训练/推理模式和实际情况不一致。请参考使用API时根据训练/推理场景对应设置模式以合理设置节点模式。 + +权重冻结错误（冻结了不应冻结的权重）。 +权重冻结错误，是指应该冻结的权重未冻结，或者不应该冻结的权重冻结了。在MindSpore中，冻结权重可以通过控制传入优化器的params参数来实现。未传入优化器的Parameter将不会被更新。可以通过检查脚本，或者查看MindInsight中的参数分布图确认权重冻结情况。 + +loss函数有误。 +loss函数有误，是指loss函数算法实现错误，或者未选择合理的loss函数。例如，BCELoss和BCEWithLogitsLoss是不同的，应根据是否需要sigmoid函数合理选择。 + +优化器算法错误（如果自行实现了优化器）等。 + + +权重初始化问题 +权重初始值是模型训练的起点，不合理的初始值将会影响模型训练的速度和效果。权重初始化方面常见问题如下： + +权重初始值全部为0。 +权重初始值全为0，是指初始化后，权重值为0。这一般会导致权重更新问题，应使用随机值初始化权重。 + +分布式场景不同节点的权重初始值不同。 +分布式场景不同节点的权重初始值不同，是指初始化后，不同节点上的同名权重初始值不同。正常来说，MindSpore会对梯度做全局AllReduce操作。确保每个step结尾，权重更新量是相同的，从而保证每个step中，各个节点上的权重一致。如果初始化时各节点的权重不同，就会导致不同节点的权重在接下来的训练中处于不同的状态，会直接影响模型精度。分布式场景应通过固定相同的随机数种子等方式，确保权重的初始值一致。 + + + + + +相同现象存在多个可能原因导致精度问题定位难 +以loss不收敛为例（下图），任何可能导致激活值饱和、梯度消失、权重更新不正确的问题都可能导致loss不收敛。例如错误地冻结了部分权重，使用的激活函数和数据不匹配（使用relu激活函数，输入值全部小于0），学习率过小等原因都是loss不收敛的可能原因。 + +图1：相同现象存在多个可能原因导致精度问题定位难 + + + + +精度问题checklist + + + +常见数据集问题 +常见超参问题 +常见计算图结构问题 +常见数据处理算法问题 +常见API使用问题 +常见权重初始化问题 + + + + +数据集中缺失值过多 +学习率设置不合理（过大、过小） +权重共享错误 +未对数据进行归一化或标准化 +使用API没有遵循MindSpore约束 +权重初始值全部为0 + + +每个类别中的样本数目不均衡 +loss_scale参数不合理 +权重冻结错误 +数据处理方式和训练集不一致 +构图时未遵循MindSpore construct约束 +分布式场景不同节点的权重初始值不同 + + +数据集中存在异常值 +权重初始化参数不合理 +节点连接错误 +没有对数据集进行shuffle + + + + +训练样本不足 +epoch过大或过小 +节点模式不正确 +数据处理参数不合理 + + + + +数据的标签错误 +batch size过大 +loss函数有误 + + + + + + + +算子使用错误 + + + + + + + +优化器算法错误 + + + + + + + + + +常用的精度调试调优思路 +遇到精度问题时，常用调试调优思路如下： + +检查代码和超参。 +代码是精度问题的重要源头，检查代码重在对脚本和代码做检查，力争在源头发现问题；模型结构体现了MindSpore对代码的理解。 + +检查模型结构。 +检查模型结构重在检查MindSpore的理解和算法工程师的设计是否一致。 + +检查输入数据。 +检查loss曲线。 +有的问题要到动态的训练过程中才会发现，检查输入数据和loss曲线正是将代码和动态训练现象结合进行检查。 + +检查精度是否达到预期。 +检查精度是否达到预期则是对整体精度调优过程重新审视，并考虑调整超参、解释模型、优化算法等调优手段。 + + +检查模型结构和超参重在检查模型的静态特征；检查输入数据和loss曲线则是将静态特征和动态训练现象结合检查；检查精度是否达到预期则是对整体精度调优过程重新审视，并考虑调整超参、解释模型、优化算法等调优手段。此外，熟悉模型和工具也很重要，为了帮助用户高效实施上述的精度调优思路，MindInsight提供了配套的能力，如下图。 + +图2 精度问题定位思路及MindInsight对应能力 +下面将分别介绍这些思路。 + +精度调优准备 + +回顾算法设计，全面熟悉模型。 +精度调优前，要先对算法设计做回顾，确保算法设计明确。如果参考论文实现模型，则应回顾论文中的全部设计细节和超参选择情况；如果参考其它框架脚本实现模型，则应确保有一个唯一的、精度能够达标的标杆脚本；如果是新开发的算法，也应将重要的设计细节和超参选择明确出来。这些信息是后面检查脚本步骤的重要依据。 +精度调优前，还要全面熟悉模型。只有熟悉了模型，才能准确理解MindInsight提供的信息，判断是否存在问题，查找问题源头。因此，花时间理解模型算法和结构、理解模型中算子的作用和参数的含义、理解模型所用优化器的特性等模型要素是很重要的。动手分析精度问题细节前，建议先带着问题加深对这些模型要素的了解。 + +熟悉MindInsight工具。 +定位精度问题时，建议使用MindInsight的Summary训练信息收集功能，在脚本中加入SummaryCollector。如下训练代码片段所示，初始化SummaryCollector并加入到model.train的callbacks参数中： +# Init a SummaryCollector callback instance, and use it in model.train or model.eval +summary_collector = SummaryCollector(summary_dir='./summary_dir', collect_freq=1) + +# Note: dataset_sink_mode should be set to False, else you should modify collect freq in SummaryCollector +model.train(epoch=1, train_dataset=ds_train, callbacks=[summary_collector], dataset_sink_mode=False) + +ds_eval = create_dataset('./dataset_path') +model.eval(ds_eval, callbacks=[summary_collector]) + + + +dataset_path为用户本地的训练数据集路径。 + +使用训练看板可视化功能查看训练过程数据： + +图3 训练看板 +需要在线调试模型时，参考使用调试器功能。 + + + + +检查代码和超参 +代码是精度问题的重要源头，超参问题、模型结构问题、数据问题、算法设计和实现问题会体现在脚本中，对脚本做检查是定位精度问题很有效率的手段。检查代码主要依赖代码走读，建议使用小黄鸭调试法：在代码走读的过程中，耐心地向没有经验的“小黄鸭”解释每一行代码的作用，从而激发灵感，发现代码问题。检查脚本时，要注意检查脚本实现（包括数据处理、模型结构、loss函数、优化器等实现）同设计是否一致，如果参考了其它脚本，要重点检查脚本实现同其它脚本是否一致，所有不一致的地方都应该有充分合理的理由，否则就应修改。 +检查脚本时，也要关注超参的情况，超参问题主要体现为超参取值不合理，例如 + +学习率设置不合理； +loss_scale参数不合理； +权重初始化参数不合理等。 + +MindInsight可以辅助用户对超参做检查，大多数情况下，SummaryCollector会自动记录常见超参，您可以通过MindInsight的训练参数详情功能和溯源分析功能查看超参。结合MindInsight模型溯源分析模块和脚本中的代码，可以确认超参的取值，识别明显不合理的超参。如果有标杆脚本，建议同标杆脚本一一比对超参取值，如果有默认参数值，则默认值也应一并比对，以避免不同框架的参数默认值不同导致精度下降或者训练错误。 + +图4 通过MindInsight训练参数详情查看模型超参 + + +检查模型结构 +在模型结构方面，常见的问题有： + +算子使用错误（使用的算子不适用于目标场景，如应该使用浮点除，错误地使用了整数除）。 +权重共享错误（共享了不应共享的权重）。 +权重冻结错误（冻结了不应冻结的权重）。 +节点连接错误（应该连接到计算图中的block未连接）。 +loss函数错误。 +优化器算法错误（如果自行实现了优化器）等。 + +建议通过检查模型代码的方式对模型结构进行检查。此外，MindInsight也可以辅助用户对模型结构进行检查。大多数情况下，SummaryCollector会自动记录计算图，通过MindInsight，用户可以方便地对计算图进行查看。 + +图5 通过MindInsight训练看板中的计算图模块查看模型结构 +模型脚本运行后，建议使用MindInsight计算图可视模块查看模型结构，加深对计算图的理解，确认模型结构符合预期。若有标杆脚本，还可以同标杆脚本对照查看计算图，检查当前脚本和标杆脚本的计算图是否存在重要的差异。 +考虑到模型结构一般都很复杂，期望在这一步就能发现所有的模型结构问题是不现实的。只要通过可视化的模型结构加深对计算图的理解，发现明显的结构问题即可。后面的步骤中，发现了更明确的精度问题现象后，我们还会回到这一步重新检查确认。 + +MindInsight支持查看SummaryCollector记录的计算图和MindSpore context的save_graphs参数导出的pb文件计算图。请参考我们教程中的计算图可视化部分了解更多信息。 +脚本迁移工具可以将PyTorch、TensorFlow框架下编写的模型转换为MindSpore脚本，请访问教程使用工具迁移模型定义脚本以了解更多信息。 + + + +检查输入数据 +通过检查输入模型的数据，可以结合脚本判断数据处理流水线和数据集是否存在问题。输入数据的常见问题有： + +数据缺失值过多； +每个类别中的样本数目不均衡； +数据中存在异常值； +数据标签错误； +训练样本不足； +未对数据进行标准化，输入模型的数据不在正确的范围内； +finetune和pretrain的数据处理方式不同； +训练阶段和推理阶段的数据处理方式不同； +数据处理参数不正确等。 + +MindInsight可以辅助用户对输入数据、数据处理流水线进行检查。大多数情况下，SummaryCollector会自动记录输入模型的数据（数据处理后的数据）和数据处理流水线参数。输入模型的数据会展示在“数据抽样”模块，数据处理流水线参数会展示在“数据图”模块和“数据溯源”模块。 +通过MindInsight的数据抽样模块，可以检查输入模型的（数据处理流水线处理后的）数据。若数据明显不符合预期（例如数据被裁剪的范围过大，数据旋转的角度过大等），可以判断输入数据出现了一定的问题。 +通过MindInsight的数据图和数据溯源模块，可以检查数据处理流水线的数据处理过程和具体参数取值，从而发现不合理的数据处理方法。 + +图6 通过MindInsight训练看板中的数据抽样模块查看输入模型的数据 + +图7 通过MindInsight训练看板中的数据图查看数据处理流水线 +如果有标杆脚本，还可以同标杆脚本对照，检查数据处理流水线输出的数据是否和当前脚本的数据相同。例如，将数据处理流水线输出的数据保存为npy文件，然后使用numpy.allclose方法对标杆脚本和当前脚本的数据进行对比。如果发现不同，则数据处理阶段可能存在精度问题。 +若数据处理流水线未发现问题，可以手动检查数据集是否存在分类不均衡、标签匹配错误、缺失值过多、训练样本不足等问题。 + + +检查loss曲线 +很多精度问题会在网络训练过程中发现，常见的问题或现象有： + +权重初始化不合理（例如初始值为0，初始值范围不合理等）； +权重中存在过大、过小值； +权重变化过大； +权重冻结不正确； +权重共享不正确； +激活值饱和或过弱（例如Sigmoid的输出接近1，Relu的输出全为0）； +梯度爆炸、消失； +训练epoch不足； +算子计算结果存在NAN、INF等。 + +上述这些问题或现象，有的可以通过loss表现出来，有的则难以观察。MindInsight提供了针对性的功能，可以观察上述现象、自动检查问题，帮助您更快定位问题根因。例如： + +MindInsight的参数分布图模块可以展示模型权重随训练过程的变化趋势； +MindInsight的张量可视模块可以展示张量的具体取值，对不同张量进行对比； +MindInsight调试器内置了种类丰富，功能强大的检查能力，可以检查权重问题（例如权重不更新、权重更新过大、权重值过大/过小）、梯度问题（例如梯度消失、梯度爆炸）、激活值问题（例如激活值饱和或过弱）、张量全为0、NAN/INF等问题。 + + +图8 通过MindInsight训练看板中的标量可视模块查看loss曲线 +大多数情况下，SummaryCollector会自动记录模型的loss曲线，可以通过MindInsight的标量可视模块查看。loss曲线能够反映网络训练的动态趋势，通过观察loss曲线，可以得到模型是否收敛、是否过拟合等信息。 + +图9 通过MindInsight参数分布图可以查看训练过程中的权重变化情况 +大多数情况下，SummaryCollector会自动记录模型参数变化情况（默认记录5个参数），可以通过MindInsight的参数分布图模块查看。如果想要记录更多参数的参数分布图，请参考SummaryCollector的histogram_regular参数，或参考HistogramSummary算子。 + +图10 通过MindInsight训练看板中的张量可视模块查看特定张量的具体取值 +张量不会被自动记录，如果想要通过MindInsight查看张量的具体取值，请使用TensorSummary算子。 +下面结合loss曲线的常见现象介绍使用MindInsight进行精度问题定位的思路。 + +loss跑飞。 +loss跑飞是指loss中出现了NAN、+/-INF或者特别大的值。loss跑飞一般意味着算法设计或实现存在问题。定位思路如下： + +回顾脚本、模型结构和数据： +1）检查超参是否有不合理的特别大/特别小的取值； +2）检查模型结构是否实现正确，特别是检查loss函数是否实现正确； +3）检查输入数据中是否有缺失值、是否有特别大/特别小的取值。 + +观察训练看板中的参数分布图，检查参数更新是否有明显的异常。若发现参数更新异常，可以结合调试器定位参数更新异常的原因。 +使用调试器模块对训练现场进行检查。 +1）若loss值出现NAN、+/-INF，可使用“检查张量溢出”条件添加全局监测点，定位首先出现NAN、+/-INF的算子节点，检查算子的输入数据是否会导致计算异常（例如除零）。若是算子输入数据的问题，则可以针对性地加入小数值epsilon避免计算异常。 +2）若loss值出现特别大的值，可使用“检查过大张量”条件添加全局监测点，定位首先出现大值的算子节点，检查算子的输入数据是否会导致计算异常。若输入数据本身存在异常，则可以继续向上追踪产生该输入数据的算子，直到定位出具体原因。 +3）若怀疑参数更新、梯度等方面存在异常，可使用“检查权重变化过大”、“检查梯度消失”、“检查梯度过大”等条件设置监测点，定位到异常的权重或梯度，然后结合张量检查视图，逐层向上对可疑的正向算子、反向算子、优化器算子等进行检查。 + + + +loss收敛慢。 +loss收敛慢是指loss震荡、收敛速度慢，经过很长时间才能达到预期值，或者最终也无法收敛到预期值。相较于loss跑飞，loss收敛慢的数值特征不明显，更难定位。定位思路如下： + +回顾脚本、模型结构和数据： +1）检查超参是否有不合理的特别大/特别小的取值，特别是检查学习率是否设置过小或过大，学习率设置过小会导致收敛速度慢，学习率设置过大会导致loss震荡、不下降； +2）检查模型结构是否实现正确，特别是检查loss函数、优化器是否实现正确； +3）检查输入数据的范围是否正常，特别是输入数据的值是否过小。 + +观察训练看板中的参数分布图，检查参数更新是否有明显的异常。若发现参数更新异常，可以结合调试器定位参数更新异常的原因。 +使用调试器模块对训练现场进程检查。 +1）可使用“检查权重变化过小”、“检查未变化权重”条件对可训练（未固定）的权重进行监测，检查权重是否变化过小。若发现权重变化过小，可进一步检查学习率取值是否过小、优化器算法是否正确实现、梯度是否消失，并做针对性的修复。 +2）可使用“检查梯度消失”条件对梯度进行监测，检查是否存在梯度消失的现象。若发现梯度消失，可进一步向上检查导致梯度消失的原因。例如，可以通过“检查激活值范围”条件检查是否出现了激活值饱和、Relu输出为0等问题。 + +其它loss现象。 +若训练集上loss为0，一般说明模型出现了过拟合，请尝试增大训练集大小。 + + + + + + +检查精度是否达到预期 +MindInsight可以为用户记录每次训练的精度结果。在model.train和model.eval中使用同一个SummaryCollector实例时，会自动记录模型评估（metrics）信息。训练结束后，可以通过MindInsight的模型溯源模块检查训练结果精度是否达标。 + +图11 通过MindInsight溯源分析功能查看模型评估信息 + +检查训练集上的精度。 +若训练集上模型的loss值、metric值未达到预期，可以参考以下思路进行定位和优化： + +回顾代码、模型结构、输入数据和loss曲线， +1）检查脚本，检查超参是否有不合理的值 +2）检查模型结构是否实现正确 +3）检查输入数据是否正确 +4）检查loss曲线的收敛结果和收敛趋势是否存在异常 + +尝试使用MindInsight溯源分析功能优化超参。溯源分析页面会对超参的重要性进行分析，用户应优先考虑调整重要性高的超参，从散点图中可以观察出超参和优化目标的关系，从而针对性地调整超参取值。 + +图12 通过MindInsight溯源分析查看参数重要性 + +图13 通过MindInsight溯源分析以散点图形式查看参数和优化目标的关系 + +尝试使用MindInsight调参器优化超参。请注意，调参器通过执行多次完整训练的方式进行超参搜索，消耗的时间为网络一次训练用时的若干倍，如果网络一次训练耗时较长，则超参搜索将需要很长的时间。 +尝试使用MindInsight模型解释功能优化模型和数据集。模型解释功能可以通过显著图可视化展示对分类结果最重要的区域，还可以通过评分体系提示应该对哪类标签进行优化。 +尝试下文介绍的常用调优建议。 + + +检查验证集上的精度。 +若训练集精度和验证集精度都未达到预期，则应首先参考上一节检查训练集精度。若训练集精度已达到预期，但是验证集精度未达到预期，大概率是模型出现了过拟合，处理思路如下： + +检查验证集评估脚本的评估逻辑有无错误。特别是数据处理方式是否与训练集一致，推理算法有无错误，是否加载了正确的模型checkpoint。 +增加数据量。包括增加样本量，进行数据增强和扰动等。 +正则化。常见的技术如参数范数惩罚（例如向目标函数中添加一个正则项），参数共享（强迫模型的两个组件共享相同的参数值），提前中止训练等。 +适当降低模型的规模。例如减少卷积层数等。 + + +检查测试集上的精度. +若验证集和测试集精度都未达到预期，则应首先参考上一节检查验证集精度。若验证集精度已达到预期，但是测试集精度未达到预期，考虑到测试集的数据是模型从未见过的新数据，原因一般是测试集的数据分布和训练集的数据分布不一致。处理思路如下： + +检查测试集评估脚本的评估逻辑有无错误。特别是数据处理方式是否与训练集一致，推理算法有无错误，是否加载了正确的模型CheckPoint。 +检查测试集中的数据质量，例如数据的分布范围是否明显同训练集不同，数据是否存在大量的噪声、缺失值或异常值。 + + + + + +",精度问题详细定位和调优指南,MindSpore、MindSpore、优化器、分布式、算子、数据集、callback、MindInsight、网络、评估、TensorFlow、PyTorch、pb、API、model、loss、metric、lR、学习率、调试、精度、checklist、数据、超参、计算图、精度、可视化、模型结构、优化、脚本、框架、性能、dataset、eval、graph +精度问题详细定位和调优指南§常用调优建议,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_optimization.html," +本节提供了数据、算法、超参等领域的常用精度调优建议。当精度距离标杆脚本差距较小（例如只差几个百分点时）时，根据场景的不同，您可以尝试不同的优化建议。 +在有标杆脚本的场景，例如模型迁移或者论文复现场景，您应该参照本指南前面的章节排查MindSpore脚本中是否存在问题。若已参照上述指南排查完毕，未发现问题，则您应优先考虑优化超参。 +在没有标杆脚本的场景，例如新算法研发时，请逐条参考以下调优建议。 + +数据优化 + +确保各个分类中的样本数目相近 +当数据集中各分类的样本数目不均衡时，需要进行调整以使每个分类对训练有程度相近的影响。可以考虑以下方法： +基于数据重采样的方法： + +对样本数较少的类过采样 +对样本数目较多的类欠采样 +混用上面两种方案。 + +通过上述重采样，使得训练过程中每个类出现的样本数相对均衡。需要注意的是，过采样有过拟合的风险(Cao et al., 2019)。 +基于代价的方法： + +loss函数不变，根据每个类中的样本数目重新设置loss权重，其中，权重为每一类别样本数的平方根的倒数。 +在loss函数中直接反映类不均衡的情况，迫使样本数较小的类同决策边界间的范围扩大。 + + + +获取更多数据 +让模型效果更好的最直接方法就是获取更多数据，训练集越大，模型效果一般越好。 + + +归一化数据 +归一化数据是指将数据映射到同一尺度，常见的操作方法包括Resize、Rescale、Normalize等。按照激活函数的值域上下界来归一化数据通常可以取得不错的效果。例如，当使用sigmoid激活函数时，建议将输入归一化到0到1之间；当使用tanh激活函数时，推荐将输入数据归一化到-1到1之间。 +此外，可以系统性地尝试不同的数据归一化方法，包括把数据归一化到0-1、归一化到-1到1之间，或者是将数据标准化到均值为0，方差为1的分布上。然后针对每种数据归一化方法评估模型的表现。 + + +对数据做变换以使数据服从均匀分布 +对于数值类型的数据，可以考虑对数据进行转换以调整数据的分布。例如某列数据是指数分布，可以通过一个log变换将该列数据变换为均匀分布。 + + + +算法优化 + +参考领域中的已有工作 +如果所要实现的算法已经有很多相关的研究工作，不妨参考一下相关的论文，并把论文中使用的各种方法记录下来，根据经验尝试各种可能的组合。例如，你可能在训练GAN网络时发现精度差几个百分点难以达标，此时你可以多参考一些研究工作，尝试它们使用的技巧，例如更改loss函数（例如WGAN，WGAN-GP等），修改训练方法（例如将每个step内Generator和Discriminator各训练1次改为各训练3次）等。 + + +优化模型中每一层的大小 +在设计模型时，可以在一开始将每一层的尺寸（例如卷积层的输入输出大小）设计为相同的。有研究证明，将所有层的尺寸设置为相同的，其模型表现一般不会差于正金字塔（层的尺寸逐层增大）或者倒金字塔（层的尺寸逐层减小）的模型结构。 +推荐将第一个隐层的大小大于输入尺寸。相较于第一个隐层的大小小于输入大小的情况，第一个隐层的大小大于输入大小时模型的表现更好。 + + +模型层数的选择和优化 +层数更多的模型有更大的机会来对数据中的抽象特征进行表达和重组，提供更强的表征能力，但是也更容易过拟合。层数较少的模型则容易出现欠拟合。 + + +权重初始值的选择和优化 +权重初始值对训练效果的影响较大，在MindSpore的模型交付实践中， 常常有因为权重初始值引起的精度差异。在有标杆脚本时，应该确保MindSpore脚本的权重初始化方式和标杆脚本的权重初始化方式一致。特别要小心未指定权重初始化方式的场景，此时使用的是各个框架的默认初始化方式，而MindSpore、PyTorch、TensorFlow等框架的默认权重初始化方式常常不同。 +常见的权重初始化方式包括： + +随机初始化 +Xavier初始化(Glorot & Bengio, 2010) +Kaiming初始化(He et al., 2015) 等 + +其中，Xavier初始化适用于使用tanh作为激活函数的网络而不适用于使用ReLU作为激活函数的网络，Kaiming初始化适合于使用ReLU作为激活函数的网络。不推荐使用常数初始化、全零初始化（bias除外），因为权重初始化为统一的常数（例如0/1）时，所有神经元学到的特征相同（梯度相同），进而导致模型表现较差。不推荐使用过大或过小的权重初始值。当权重初始值过小时，模型的收敛可能会很慢，在比较深的网络可能完全不能收敛。这是由于过小的权重容易导致激活值太小，梯度消失。当权重初始值过大时，模型可能完全无法收敛，这是由于较大的权重容易导致梯度爆炸，扰乱参数更新的方向。 +在Batch Normalization提出前，权重初始值的均值和方差是需要着重考虑的因素。简单来说，模型输出的大小和权重的乘积（以及激活函数的输出范围）相关，当权重值过小时，模型输出的大小也会变得很小，当权重值过大时，模型输出的大小也会变得很大，Xavier和Kaiming初始化都是基于稳定权重方差和激活函数输出范围的目的推到得到的。当网络中使用Batch Normalization时，一定程度上能减缓对权重初始值的依赖，但仍然建议使用前述推荐的权重初始化方式。 +如果不确定使用哪种权重初始化方式，可以固定其它因素，对多种权重初始化方式进行对比。 + + +激活函数的选择和优化 +对于卷积神经网络（Convolutional Neural Network, CNN）等大部分网络，ReLU激活函数通常是一个不错的选择。如果ReLU效果不是很好，可以尝试Leaky ReLU或Maxout等变种。对于循环神经网络（Recurrent Neural Network，RNN），tanh函数也是一个不错的选择。除非您是这方面的专家，有明确的动机或者理论分析的支撑，通常不建议自行尝试学术界尚未证明效果的激活函数。 +在深度不是特别深的CNN中，激活函数的影响一般不会太大。 + + +优化器的选择和优化 +优化器对模型精度和收敛速度（收敛所需的参数更新次数）都会有影响。通常Adam优化器是一个不错的选择。带有动量的优化器有助于提升大batch size下的训练速度。 +在选择优化器时，一方面要注意优化器之间有功能上的包含关系(Choi et al., 2019)。例如RMSProp优化器功能包含了Momentum优化器的功能。这是因为，令RMSProp中的decay参数取1，epsilon参数取0，则RMSProp即等效于动量为momentum/learning_rate的Momentum优化器。Adam优化器同样也包含了Momentum优化器的功能。MindSpore的Momentum优化器和SGD优化器的功能是类似的。另一方面也要注意，功能更强大的优化器，一般有更多参数，要花费更长时间才能找到合适的超参。 + + +早停法 +一旦验证集上的表现下降时，就应该停止训练以免过拟合，也即早停法。 + + + +超参优化 +狭义上讲，超参是指在训练开始前即手工确定好的变量。广义上讲，上文讨论过的模型设计选择也可以认为是超参，例如网络层数设计，激活函数选择等。需要说明的是，训练得到的结果不能算作超参，例如训练后得到的权重数据就不是超参。本节主要讲狭义超参的优化，下文中如没有特殊说明，指的都是狭义超参。 +进行超参优化时要注意：没有通用的最佳超参。选择最优超参没有一劳永逸的方法，既需要经验，也需要不断试错。 + +学习率的选择和优化 +学习率是控制如何使用损失函数的梯度调整网络权重的超参数。学习率的取值对模型能否收敛，模型收敛的速度有重要影响。相较于固定学习率，在训练过程中循环变化学习率总体来说是有益于模型收敛的。循环变化学习率的最大值和最小值可以这样确定(Smith, 2017)：选定一个足够大的学习率范围（例如从0到5），设置训练运行几个epoch（例如10个），在训练运行过程中，逐迭代地线性（或指数）增大学习率，就可以得到一个准确率和学习率的关系曲线，如下图。关注曲线中准确率开始上升和不再上升的的部分所对应的学习率，可以将准确率开始上升时的学习率当做学习率的下限，将准确率不再上升时的学习率当做学习率的上限，在上下限之间的学习率都可以认为是合理的。此外，在Neural Networks: Tricks of the Trade这本书中提供了一个经验法则：最优学习率一般为可以使网络收敛的最大学习率的二分之一。另一个经验法则是，0.01的学习率通常适用于大多数网络 。当然这些经验法则是否正确就需要各位读者自行判断了。 + +图14 学习率与准确率的关系 此曲线通过8个epoch的训练得到 图片引用自(Smith, 2017) +以上文所述的合理学习率为起点，每个网络的最优值都需要根据具体情况（网络类型、batch size、优化器、其他相关超参等）实验和调整。 + + +batch size的选择和优化 +batch size是指一次训练，也即一次前向传播、反向传播、权重更新过程所使用的样本数目。batch size越大，就越有潜力达到快的训练速度，但是batch size不能无限增大。一方面，batch size越大，所需要的硬件内存就越多，硬件内存为可能的最大batch size设置了上界。另一方面，当batch size过大时，模型的泛化能力将下降(Keskar et al., 2016)。batch size较小时，可以起到正则化的效果，有助于减少过拟合(Masters & Luschi, 2018)，但是不能充分发挥硬件的运算能力。 +基于上面的描述，需要较快的训练速度和正则化效果之间进行权衡。一般来讲，32是一个比较好的默认值(Bengio, 2012)，64、128、256 也都值得尝试。batch size 学习率之间存在相互影响，将在下一节阐述。 + + +学习率和batch size的联合优化 +一旦在某个batch size下找到最优的学习率后，后续调整batch size时，应该同步调整学习率，使得batch size和学习率的比值保持固定，这被成为linear scaling rule。基于郎之万动力学，学习率和batch size在满足linear scaling rule时可以得到相等的动力学演化时间(Xie et al., 2020)。在做出一些假设后，当学习率同batch size的比值固定时，只需要训练相同的epoch数，训练效果应该是一样的。并行场景下利用这一点同步增大batch size和学习率能够有效缩短训练时间。但是需要注意的是，batch size及学习率过大时，会破坏一些假设，例如中心极限定理成立要求batch size远小于训练数据集大小，连续时间近似成立要求学习率足够小等。当这些假设被破坏时，linear scaling rule也就不成立了，此时需要适当降低batch size或学习率。 + + +动量值的选择和优化 +当使用带有动量的优化器（例如Momentum）时，动量和学习率一般应朝相反的方向调整，不同动量下的最佳学习率不同。当使用循环学习率时，同样推荐按照相反的方向循环变化动量值 ，也即，当学习率从大到小变化时，动量应从小到大变化。当学习率固定时，动量值也应保持固定。 + + +权重衰减参数的选择和优化 +权重衰减（weight decay）是指在在模型训练过程中对目标代价函数增加一个L2参数范数惩罚，权重衰减参数控制这一惩罚项的系数，请参考SGD优化器的weight_decay参数。实验证明，权重衰减参数最好在训练过程中保持恒定。0.001/0.0001/0.00001都是常见的取值。当数据集较小、模型深度较浅时，推荐使用大一些的参数值，当数据集较大、模型深度较深时，推荐使用小一些的参数值。这可能是因为，较大的数据集本身便提供了某种程度的正则化，从而降低了需要权重衰减提供的正则化。 + + + +多卡训练调优建议 + +同时调整global batch size和学习率 +global batch size是指多卡训练时的全局batch size。以单机4卡数据并行训练为例，若每一路数据并行的batch size为32，则global batch size为4*32=128。多卡训练时，应使global batch size和学习率的比值保持固定，若global batch size增大为原来的4倍，一般学习率也应增大为原来的4倍。细节请见上文“学习率和batch size的联合优化”。 + + +确保数据并行的权重初始值在每各路间一致 +多路（多卡）数据并行时，结果的正确性依赖于各路（各卡）的权重初始值一致。请通过加载相同的checkpoint，或者提前固定随机种子等方法确保权重初始值一致。固定随机种子的操作方法请参考固定随机性文档。 + + + +精度调优相关参考文献 +Bengio, Y. (2012). Practical Recommendations for Gradient-Based Training of Deep Architectures. +Cao, K., Wei, C., Gaidon, A., Arechiga, N., & Ma, T. (2019). Learning Imbalanced Datasets with Label-Distribution-Aware Margin Loss. Advances in Neural Information Processing Systems, 32. https://arxiv.org/abs/1906.07413v2 +Choi, D., Shallue, C. J., Nado, Z., Lee, J., Maddison, C. J., & Dahl, G. E. (2019). On Empirical Comparisons of Optimizers for Deep Learning. https://www.tensorflow.org/ +Glorot, X., & Bengio, Y. (2010). Understanding the difficulty of training deep feedforward neural networks. Journal of Machine Learning Research, 9, 249–256. +He, K., Zhang, X., Ren, S., & Sun, J. (2015). Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. Proceedings of the IEEE International Conference on Computer Vision, 2015 Inter, 1026–1034. https://doi.org/10.1109/ICCV.2015.123 +Keskar, N. S., Mudigere, D., Nocedal, J., Smelyanskiy, M., & Tang, P. T. P. (2016). On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima. 5th International Conference on Learning Representations, ICLR 2017 - Conference Track Proceedings, 1–16. http://arxiv.org/abs/1609.04836 +Masters, D., & Luschi, C. (2018). Revisiting small batch training for deep neural networks. ArXiv, 1–18. +Montavon, G., Orr, G. B., & Müller, K.-R. (Eds.). (2012). Neural Networks: Tricks of the Trade. 7700. https://doi.org/10.1007/978-3-642-35289-8 +Nwankpa, C., Ijomah, W., Gachagan, A., & Marshall, S. (2018). Activation Functions: Comparison of trends in Practice and Research for Deep Learning. http://arxiv.org/abs/1811.03378 +Smith, L. N. (2017). Cyclical learning rates for training neural networks. Proceedings - 2017 IEEE Winter Conference on Applications of Computer Vision, WACV 2017, 464–472. https://doi.org/10.1109/WACV.2017.58 +Xie, Z., Sato, I., & Sugiyama, M. (2020). A Diffusion Theory For Deep Learning Dynamics: Stochastic Gradient Descent Exponentially Favors Flat Minima. https://arxiv.org/abs/2002.03495v14 + +",精度问题详细定位和调优指南,MindSpore、MindSpore、并行、优化器、数据集、损失函数、Optimizer、网络、评估、TensorFlow、PyTorch、SGD、loss、ast、反向传播、weight decay、LR、学习率、精度、数据、超参、精度、模型结构、优化、迭代、脚本、单机、框架、Dataset、ib、roce +精度问题详细定位和调优指南§参考文档,https://www.mindspore.cn/mindinsight/docs/zh-CN/r1.7/accuracy_optimization.html," + +可视化调试调优工具 +训练过程中进行可视化数据采集时，可参考资料收集Summary数据。 +训练过程中进行可视化数据分析时，可参考资料训练看板和溯源和对比看板。 + + +数据问题处理 +对数据进行标准化、归一化、通道转换等操作，在图片数据处理上，增加随机视野图片，随机旋转度图片等，另外数据混洗、batch和数据倍增等操作，可参考数据处理、数据增强和自动数据增强。 + +如何将数据增强增强操作应用到自定义数据集中，可以参考mindspore.dataset.GeneratorDataset.map算子。 + + + +超参问题处理 +AI训练中的超参包含全局学习率，epoch和batch等，如果需要在不同的超参下，训练过程进行可视化时，可参考资料：可视化的超参调优；如果需要设置动态学习率超参时，可参考资料：学习率的优化算法。 + + +模型结构问题处理 +一般的处理模型结构问题，需要用到的操作有：模型结构的重构，选择合适的优化器或者损失函数等。 +需要重构模型结构时，可参考资料：Cell构建及其子类。 +选择合适的损失函数，可参考资料：损失函数算子支持列表。 +选择合适的优化器时，可参考资料：优化器算子支持列表。 + +",精度问题详细定位和调优指南,mindspore、mindspore、优化器、算子、数据集、损失函数、GeneratorDataset、学习率、调试、精度、数据、超参、精度、可视化、模型结构、优化、dataset +性能调试§性能调试,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/performance_optimization.html," + +Profiler为MindSpore提供了性能调优能力，针对算子性能、数据处理性能等提供了易用、丰富的调试功能，帮助用户快速定位、解决性能问题。 +本章将介绍性能调优的常见方法及案例，以及一些常见问题的处理。 + +",性能调试,MindSpore、MindSpore、算子、调试、数据、性能 +性能调试§快速入门,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/performance_optimization.html," +Profiler的功能介绍及使用说明请参见教程： +性能调试（Ascend） +性能调试（GPU） +集群性能调试 +本节将通过三个典型案例介绍Profiler工具的常见使用方式。 + +案例一：迭代间隙过长 +在MindSpore ModelZoo中运行ResNet50单卡训练脚本，batch size设置为32，发现单step时间约为90ms，性能较差。 +通过MindInsight性能分析页面观察到迭代轨迹中的迭代间隙过长，这通常说明数据是性能瓶颈点。 + +图1： 迭代轨迹中的迭代间隙过长 +查看数据准备详情页面中的迭代间隙标签页，我们观察到，数据队列在前期有较多的数据，后期数据的个数变为0，原因是前期在图编译阶段已经开始了数据集的加载和增强，队列中随即缓存了多条数据； +而后期正常训练开始后，队列中的数据被消费的速度要快于被生产的速度，因此数据队列逐渐变为空，说明此时数据变成了瓶颈。观察主机队列也是同样的情况。综合分析，正常训练过程中， +数据处理为性能瓶颈点。 因此，需要进入数据准备详情页面中的数据处理标签页来查看具体问题。 + +图2：数据准备详情页面——迭代间隙 +通过观察数据处理标签页的算子间队列关系，我们发现，Queue_3及其之后的队列使用率较低，即MapOp_3作为生产者生产数据的速度较慢，因此可以判定MapOp_3的性能还有优化空间，尝试对该算子进行性能优化。 + +图3：数据准备详情页面——数据处理 +针对数据处理算子的性能优化，可以参考优化数据处理页面。 +查看ResNet50网络中数据处理的代码部分，发现map算子的num_parallel_workers参数没有设置，默认为1，代码如下： +if do_train: + trans = [ + C.RandomCropDecodeResize(image_size, scale=(0.08, 1.0), ratio=(0.75, 1.333)), + C.RandomHorizontalFlip(prob=0.5), + C.Normalize(mean=mean, std=std), + C.HWC2CHW() + ] +else: + trans = [ + C.Decode(), + C.Resize(256), + C.CenterCrop(image_size), + C.Normalize(mean=mean, std=std), + C.HWC2CHW() + ] + +data_set = data_set.map(operations=trans, input_columns=""image"") + + +将num_parallel_workers参数调整为12后，再次运行训练脚本，优化参考代码如下： +data_set = data_set.map(operations=trans, input_columns=""image"", num_parallel_workers=12) + + +通过MindInsight性能分析页面观察迭代轨迹，可以看到迭代间隙时长由72.8ms缩短到0.25ms，单step时长由90ms缩短到18.07ms。 + +图4：迭代轨迹中迭代间隙缩短 + + +案例二：前向运行时间长 +在MindSpore ModelZoo中运行VGG16模型的推理脚本，发现单step时间约为113.79ms，性能较差。 +通过MindInsight性能分析页面观察到迭代轨迹中的前向运行时间很长。在单卡训练或推理过程中，前向耗时长通常考虑是否有算子的耗时时长可以优化。 + +图5：迭代轨迹中，前向运行时间过长 +打开算子耗时统计详情页面，在算子详情页面中发现MatMul算子耗时占比较高。 + +图6：通过算子耗时详情页面寻找可优化算子 +对于算子耗时优化，在float16和float32格式精度无明显差别的前提下，通常可使用计算量更小的float16格式來提高性能，参考使能混合精度页面。 +优化参考代码如下： +from mindspore import context +... +network = vgg16(config.num_classes, config, phase=""test"") +network.add_flags_recursive(fp16=True) + + +在设置float16格式后，再次运行推理脚本，通过MindInsight性能分析页面观察迭代轨迹，可以看到前向运行时长由82.45ms缩短到16.89ms，单step耗时大大缩短。如下图所示： + +图7：迭代轨迹中前向耗时缩短 + + +案例三： 优化迭代拖尾 +在MindSpore ModelZoo中运行ResNet50 8卡训练脚本，batch size设置为32，单step时间为23.6ms，期望能继续提高单step时间。 +通过MindInsight性能分析页面观察迭代轨迹，发现迭代间隙与前反向已经没有多少优化的空间，考虑迭代拖尾是否可以优化。 + +图8：迭代轨迹中迭代拖尾耗时情况 +迭代拖尾时间包含AllReduce梯度同步、参数更新等操作。正常情况下，AllReduce梯度同步会等所有反向算子执行结束，也就是对所有权重都计算出梯度后再一次性同步所有机器的梯度， +而使用AllReduce切分，我们可以在计算出一部分权重的梯度后，立刻进行这部分权重的梯度同步，这样梯度同步和剩余算子的梯度计算可以并行执行，也就隐藏了这部分AllReduce梯度同步的时间。 +切分策略通常是手动尝试，寻找一个最优的方案（支持切分大于两段）。以ResNet50网络为例，该网络共有160个权重，[85, 160]表示第0至85个权重计算完梯度后立刻进行梯度同步，第86至160个权重计算完后再进行梯度同步，这里共切分两段，因此需要进行两次梯度同步。优化参考代码如下： +from mindspore import context +from resnet50_imagenet2012_config.yaml import config +... + +if config.net_name == ""resnet50"" or config.net_name == ""se-resnet50"": + # AllReduce split + context.set_auto_parallel_context(all_reduce_fusion_config=[85, 160]) +else: + # Another split stratety + context.set_auto_parallel_context(all_reduce_fusion_config=[180, 313]) +init() + + +对AllReduce进行切分后，再次运行ResNet50 8P脚本，通过MindInsight性能分析页面观察迭代轨迹，迭代拖尾时间由6.15ms缩短到4.20ms。如下图所示： + +图9：迭代拖尾耗时变短 + +",性能调试,MindSpore、MindSpore、并行、算子、数据集、GPU、Ascend、MindInsight、网络、Model、lR、调试、精度、数据、精度、优化、迭代、ModelZoo、脚本、性能、npu +性能调试§常见问题,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/performance_optimization.html," + +启动失败 +如您遇到启动失败的报错，请排查是否遇到了以下情况： + +系统内存已无可用空间或剩余可用空间过小。 +MindSpore版本和昇腾AI处理器配套软件包版本不匹配。 + + +",性能调试,MindSpore、MindSpore、调试、性能 +推理执行§推理执行,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/inference.html," + +MindSpore可以基于训练好的模型，在不同的硬件平台上执行推理任务，还可以基于MindSpore Serving部署在线推理服务。 + +",推理执行,MindSpore、MindSpore、MindSpore Serving、Serving +推理执行§基于模型推理服务,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/inference.html," + +总览 +MindSpore支持保存为CheckPoint格式的训练参数文件和MindIR、AIR、ONNX格式的网络模型文件。 +参考执行推理，不仅可以直接通过mindspore.model.predict接口执行本机推理，还可以通过mindspore.export导出MindIR、AIR、ONNX格式的网络模型文件，以便于跨平台执行推理。 +使用MindIR格式的模型文件消除了不同后端模型的差异，可以用于执行跨硬件平台推理，支持部署到云端Serving和端侧Lite平台。 + + +不同硬件平台执行推理 + +Ascend硬件平台参考Ascend 910 AI处理器上推理和Ascend 310 AI处理器上推理。 +GPU/CPU硬件平台参考GPU/CPU上推理。 +Lite端侧推理的相关应用参考端侧推理。 + + +Ascend硬件平台推理的接口使用问题参考C++接口使用类解决。 + + +",推理执行,MindSpore、MindSpore、接口、GPU、CPU、Ascend、模型推理、MindIR、网络、ONNX、model、Serving、C++ +推理执行§基于MindSpore Serving部署在线推理服务,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/inference.html," +MindSpore Serving是一个轻量级、高性能的服务模块，旨在帮助MindSpore开发者在生产环境中高效部署在线推理服务。当用户使用MindSpore完成模型训练后，导出MindSpore模型，即可使用MindSpore Serving创建该模型的推理服务。参考以下几个样例进行部署： + +基于MindSpore Serving部署推理服务。 +基于gRPC接口访问MindSpore Serving服务。 +基于RESTful接口访问MindSpore Serving服务。 +通过配置模型提供Servable。 +基于MindSpore Serving部署分布式推理服务。 + + +MindSpore Serving部署在线推理服务的问题可以参考MindSpore Serving类解决。 + +",推理执行,MindSpore、MindSpore、分布式、接口、MindSpore Serving、性能、Serving +网络迁移调试实例§网络迁移调试实例,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/sample_code.html," + +本章将结合用例来介绍网络迁移的基本步骤、常用工具、定位问题的思路及解决方法。 +这里以经典网络 ResNet50 为例，结合代码来详细介绍网络迁移方法。 + +",网络迁移调试实例,网络、调试 +网络迁移调试实例§对标网络分析与复现,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/sample_code.html," + +确定迁移目标 +网络迁移的第一步是确定迁移目标，即先找到一个合适的、可达成的标准，通常一个深度神经网络的交付目标包括以下四个部分： + +网络实现：这是迁移目标中最基本的部分，有时同一个神经网络有不同的版本、同一个版本有不同的实现方式或者在相同的神经网络下使用不同的超参，这些差别会对最终的收敛精度和性能造成一定影响。通常，我们以神经网络作者本身的实现为准，也可以参考不同框架（例如TensorFlow、PyTorch等）的官方实现或其他主流开源工具箱（例如 MMDetection）。 +数据集：相同的神经网络和参数，在不同的数据集上往往差别很大，因此我们需要确认迁移网络所使用的数据集。一些数据集的数据内容会频繁更新，确定数据集时需要注意数据集的版本、训练数据和测试数据划分比例等问题。 +收敛精度：不同的框架、不同的GPU型号、是否为分布式训练等因素会对精度有所影响，在确定迁移目标时需要分析清楚对标的框架、硬件等信息。 +训练性能：和收敛精度相同，训练性能主要受网络脚本、框架性能、GPU硬件本身和是否为分布式训练等因素影响。 + + +ResNet50 迁移示例 +ResNet50 是 CV 中经典的深度神经网络，有较多开发者关注和复现，而 PyTorch 的语法和 MindSpore 较为相似，因此，我们选择 PyTorch 作为对标框架。 +PyTorch 官方实现脚本可参考 torchvision model 或者 英伟达 PyTorch 实现脚本，其中包括了主流 ResNet 系列网络的实现（ResNet18、ResNet34、ResNet50、ResNet101、ResNet152）。ResNet50 所使用的数据集为 ImageNet2012，收敛精度可参考 PyTorch Hub。 +开发者可以基于 PyTorch 的 ResNet50 脚本直接在对标的硬件环境下运行，然后计算出性能数据，也可以参考同硬件环境下的官方数据。例如，当我们对标 Nvidia DGX-1 32GB(8x V100 32GB) 硬件时，可参考 Nvidia 官方发布的 ResNet50 性能数据。 + + + +复现迁移目标 +网络迁移目标确定完成后，接下来要做的就是复现指标。复现标杆数据对后续精度和性能调优十分重要，当我们在 MindSpore 开发的网络和对标脚本有精度/性能差距时，很多时候都是以标杆数据作为基准，一步一步地分析迁移脚本和对标脚本的差别，如果对标脚本无法复现指标，那我们以此为基准开发的 MindSpore 脚本就很难达到迁移目标。复现迁移指标时，不仅要复现训练阶段，推理阶段也同样重要。 +需要注意的是，对于部分网络，使用相同的硬件环境和脚本，最终达到的收敛精度和性能也可能与原作者提出的结果有细微差别，这属于正常的波动范围，我们在迁移网络时要把这种波动考虑在内。 + + +复现单Step结果 +复现单 Step 结果主要是为了接下来的脚本开发和网络调优。对于复杂的神经网络，完整的训练需要耗时几天甚至几个月，如果仅以最终的训练精度和结果做参考，会极大地降低开发效率。因此，我们需要提前复现单 Step 的运行结果，即获取只执行第一个 Step 后网络的状态（该状态是经历了数据预处理、权重初始化、正向计算、loss 计算、反向梯度计算和优化器更新之后的结果，覆盖了网络训练的全部环节），并以此为对照展开后续的开发工作。 + +",网络迁移调试实例,MindSpore、MindSpore、优化器、分布式、数据集、GPU、网络、TensorFlow、PyTorch、model、loss、调试、精度、数据、超参、精度、优化、脚本、框架、性能 +网络迁移调试实例§脚本开发,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/sample_code.html," + +脚本开发前分析 +在开始真正的开发脚本前，需要进行对标脚本分析。脚本分析的目的是识别出 MindSpore 与对标框架相比缺失的算子或功能。具体方法可以参考脚本评估教程。 +MindSpore 已支持绝大多数常用 功能 和 算子。MindSpore 既支持动态图（PyNative）模式，又支持静态图（Graph）模式，动态图模式灵活、易于调试，因此动态图模式主要用于网络调试，静态图模式性能好，主要用于整网训练，在分析缺失算子和功能时，要分别分析这两种模式。 +如果发现有缺失的算子和功能，首先可考虑基于当前算子或功能来组合出缺失的算子和功能，对于主流的 CV 和 NLP 类网络，新的缺失算子一般都可以通过组合已有算子的方式来解决。 +组合的算子可以通过 Cell 的方式实现，在 MindSpore 中，nn类算子 就是通过这种方式实现的。例如下面的 ReduceSumExp 算子，它是由已有的Exp、ReduceSum、Log小算子组合而成： +class ReduceLogSumExp(Cell): + def __init__(self, axis, keep_dims=False): + super(ReduceLogSumExp, self).__init__() + validator.check_value_type('axis', axis, [int, list, tuple], self.cls_name) + validator.check_value_type('keep_dims', keep_dims, [bool], self.cls_name) + self.axis = axis + self.exp = ops.Exp() + self.sum = ops.ReduceSum(keep_dims) + self.log = ops.Log() + + def construct(self, x): + exp = self.exp(x) + sumexp = self.sum(exp, self.axis) + logsumexp = self.log(sumexp) + return logsumexp + + +如果缺失的功能和算子无法规避，或者组合算子性能较差，严重影响网络的训练和推理，可联系 MindSpore社区 反馈，我们会有专门的工作人员为您解决。 + +ResNet50 迁移示例 +以下为 ResNet 系列网络结构： + +PyTorch 实现的 ResNet50 脚本参考 torchvision model。 +我们可以基于算子和功能两个方面分析： + +算子分析 + + + + +PyTorch 使用算子 +MindSpore 对应算子 +是否支持该算子所需功能 + + + + +nn.Conv2D +nn.Conv2d +是 + + +nn.BatchNorm2D +nn.BatchNom2d +是 + + +nn.ReLU +nn.ReLU +是 + + +nn.MaxPool2D +nn.MaxPool2d +是 + + +nn.AdaptiveAvgPool2D +无 +不支持 + + +nn.Linear +nn.Dense +是 + + +torch.flatten +nn.Flatten +是 + + + +注：对于 PyTorch 脚本，MindSpore 提供了 PyTorch 算子映射，可直接查询该算子是否支持。 + +功能分析 + + + + +Pytorch 使用功能 +MindSpore 对应功能 + + + + +nn.init.kaiming_normal_ +initializer(init='HeNormal') + + +nn.init.constant_ +initializer(init='Constant') + + +nn.Sequential +nn.SequentialCell + + +nn.Module +nn.Cell + + +nn.distibuted +context.set_auto_parallel_context + + +torch.optim.SGD +nn.optim.SGD or nn.optim.Momentum + + + +（由于MindSpore 和 PyTorch 在接口设计上不完全一致，这里仅列出关键功能的比对） +经过算子和功能分析，我们发现，相比 PyTorch，MindSpore 功能上没有缺失，但算子上缺失 nn.AdaptiveAvgPool ，这时我们需要更一步的分析，该缺失算子是否有可替代方案。在 ResNet50 网络中，输入的图片 shape 是固定的，统一为 N,3,224,224，其中 N 为 batch size，3 为通道的数量，224 和 224 分别为图片的宽和高，网络中改变图片大小的算子有 Conv2d 和 Maxpool2d，这两个算子对shape 的影响是固定的，因此，nn.AdaptiveAvgPool2D 的输入和输出 shape 是可以提前确定的，只要我们计算出 nn.AdaptiveAvgPool2D 的输入和输出 shape，就可以通过 nn.AvgPool 或 nn.ReduceMean 来实现，所以该算子的缺失是可替代的，并不影响网络的训练。 + + + +数据预处理 +要理解一个神经网络的实现，首先要清楚网络的输入数据，因此，数据预处理是脚本开发的第一个环节。MindSpore 设计了一个专门进行数据处理的模块 - MindData，使用 MindData 进行数据预处理主要包括以下几个步骤： + +传入数据路径，读取数据文件。 +解析数据。 +数据处理（如常见数据切分、shuffle、数据增强等操作）。 +数据分发（以 batch_size 为单位分发数据，分布式训练涉及多机分发）。 + +在读取和解析数据过程中，MindSpore 提供了一种更友好的数据格式 - MindRecord。用户可以将常规格式的数据集转换为 MindSpore数据格式，即 MindRecord，从而方便地加载到 MindSpore 中进行训练。同时，MindSpore 在部分场景做了性能优化，使用 MindRecord 数据格式可以获得更好的性能。 +数据处理通常是数据准备中最耗时的阶段，大部分对数据的操作都被包含在这一步骤里，例如 CV 类网络中的Resize、Rescale、Crop 等操作。MindSpore 提供了一套常用的数据处理集成接口，用户可以不用自己实现而直接调用这些接口，这些集成接口不仅可以提升用户的易用性，还可以提升数据预处理的性能，减少训练过程中数据准备的耗时。具体可以参考数据预处理教程。 +在数据分发环节，MindData 提供了极为简洁的 API，可以通过直接调用 batch、repeat 等操作完成数据的 batch 组合、重复等操作。 +当完成以上4个步骤后，我们理论上使用 MindSpore 脚本和对标脚本处理数据集后，可以得到完全相同的数据（如果有引入随机情况的操作需要去除）。 + +ResNet50 迁移示例 +ResNet50 网络使用的是 ImageNet2012 数据集，其数据预处理的 PyTorch 代码如下： +# sample execution (requires torchvision) +from PIL import Image +from torchvision import transforms +input_image = Image.open(filename) +preprocess = transforms.Compose([ + transforms.Resize(256), + transforms.CenterCrop(224), + transforms.ToTensor(), + transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), +]) +input_tensor = preprocess(input_image) +input_batch = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model + + +通过观察以上代码，我们发现 ResNet50 的数据预处理主要做了 Resize、CenterCrop、Normalize 操作，在 MindSpore 中实现这些操作有两种方式，一是使用 MindSpore 的数据处理模块 MindData 来调用已封装好的数据预处理接口，二是通过 自定义数据集 进行加载。这里更建议开发者选择第一种方式，这样不仅可以减少重复代码的开发，减少错误的引入，还可以得到更好的数据处理性能。更多关于MindData数据处理的介绍，可参考 数据处理。 +以下是基于 MindData 开发的数据处理函数： +import os +from mindspore import dtype as mstype +import mindspore.dataset as ds +import mindspore.dataset.vision.c_transforms as C +import mindspore.dataset.transforms.c_transforms as C2 + + +def create_dataset(dataset_path, batch_size=32, rank_size=1, rank_id=0, do_train=True): + """""" + create a train or eval imagenet2012 dataset for resnet50 + + Args: + dataset_path(string): the path of dataset. + batch_size(int): the batch size of dataset. Default: 32 + rank_size(int): total num of devices for training. Default: 1, + greater than 1 in distributed training + rank_id(int): logical sequence in all devices. Default: 1, + can be greater than i in distributed training + + Returns: + dataset + """""" + data_set = ds.ImageFolderDataset(dataset_path, num_parallel_workers=8, shuffle=do_train, + num_shards=rank_size, shard_id=rank_id) + + mean = [0.485 * 255, 0.456 * 255, 0.406 * 255] + std = [0.229 * 255, 0.224 * 255, 0.225 * 255] + + # define map operations + trans = [ + C.Decode(), + C.Resize(256), + C.CenterCrop(224), + C.Normalize(mean=mean, std=std), + C.HWC2CHW() + ] + + type_cast_op = C2.TypeCast(mstype.int32) + + data_set = data_set.map(operations=trans, input_columns=""image"", num_parallel_workers=8) + data_set = data_set.map(operations=type_cast_op, input_columns=""label"", num_parallel_workers=8) + + # apply batch operations + data_set = data_set.batch(batch_size, drop_remainder=do_train) + + return data_set + + +在以上代码中我们可以发现，针对常用的经典数据集（如 ImageNet2012），MindData 也为我们提供了 ImageFolderDataset 接口直接读取原始数据，省去了手写代码读取文件的工作量。需要注意的是，单机训练和多机分布式训练时 MindData 创建数据集的参数是不一样的，分布式训练需要额外指定 num_shard 和 shard_id 两个参数。 + + + +子网开发 +通常子网开发包含两个部分：训练子网和 loss 子网，其中训练子网可根据网络的复杂程度决定是否继续划分。直接开发一个大型的神经网络脚本可能会让我们无从下手，因此，我们可以将网络中不同模块或子模块作为一个个子网抽离出来单独开发，这样可以保证各个子网并行开发，互相不受干扰。子网开发完成后，还可以固定子网输入和权重，与对标脚本的子网代码形成对比，作为后续网络开发的测试用例。 +在精度调优阶段，我们常常会遇到精度不达标的情况，这时我们会重新审视已开发的脚本并逐行排查。而使用子网方式开发脚本并形成测试用例可以高效地帮助我们排除怀疑点，从几十个算子里寻找可疑点，要比从成百上千个算子中找可疑点轻松得多，尤其是在很多时候，同一个子网会被重复调用多次，当我们以子网为单位排查时，可以减少很多工作量。 + +ResNet50 迁移示例 +分析 ResNet50 网络代码，主要可以分成以下几个子网： + +conv1x1、conv3x3：定义了不同 kernel_size 的卷积。 +BasicBlock：ResNet 系列网络中 ResNet18 和 ResNet34 的最小子网，由 Conv、BN、ReLU 和 残差组成。 +BottleNeck：ResNet 系列网络中 ResNet50、ResNet101 和 ResNet152 的最小子网，相比 BasicBlock 多了一层 Conv、BN 和 ReLU的结构，下采样的卷积位置也做了改变。 +ResNet：封装了 BasiclBlock、BottleNeck 和 Layer 结构的网络，传入不同的参数即可构造不同的ResNet系列网络。在该结构中，也使用了一些 PyTorch 自定义的初始化功能。 + +基于以上子网划分，我们结合 MindSpore 语法，重新完成上述开发。 +权重初始化可参考 MindSpore 已定义的权重初始化方法： +重新开发 conv3x3 和 conv1x1 +import mindspore.nn as nn + +def _conv3x3(in_channel, out_channel, stride=1): + return nn.Conv2d(in_channel, out_channel, kernel_size=3, stride=stride, + padding=0, pad_mode='same') + +def _conv1x1(in_channel, out_channel, stride=1): + return nn.Conv2d(in_channel, out_channel, kernel_size=1, stride=stride, + padding=0, pad_mode='same') + + +重新开发 BasicBlock 和 BottleNeck： +class ResidualBlockBase(nn.Cell): + def __init__(self, + in_channel, + out_channel, + stride=1): + super(ResidualBlockBase, self).__init__() + self.conv1 = _conv3x3(in_channel, out_channel, stride=stride) + self.bn1d = _bn(out_channel) + self.conv2 = _conv3x3(out_channel, out_channel, stride=1) + self.bn2d = _bn(out_channel) + self.relu = nn.ReLU() + + self.down_sample = False + if stride != 1 or in_channel != out_channel: + self.down_sample = True + + self.down_sample_layer = None + if self.down_sample: + self.down_sample_layer = nn.SequentialCell([_conv1x1(in_channel, out_channel, stride), + _bn(out_channel)]) + + def construct(self, x): + identity = x + + out = self.conv1(x) + out = self.bn1d(out) + out = self.relu(out) + + out = self.conv2(out) + out = self.bn2d(out) + + if self.down_sample: + identity = self.down_sample_layer(identity) + + out = out + identity + out = self.relu(out) + + return out + + +class ResidualBlock(nn.Cell): + expansion = 4 + + def __init__(self, + in_channel, + out_channel, + stride=1): + super(ResidualBlock, self).__init__() + self.stride = stride + channel = out_channel // self.expansion + self.conv1 = _conv1x1(in_channel, channel, stride=1) + self.bn1 = _bn(channel) + if self.stride != 1: + self.e2 = nn.SequentialCell([_conv3x3(channel, channel, stride=1), _bn(channel), + nn.ReLU(), nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='same')]) + else: + self.conv2 = _conv3x3(channel, channel, stride=stride) + self.bn2 = _bn(channel) + + self.conv3 = _conv1x1(channel, out_channel, stride=1) + self.bn3 = _bn_last(out_channel) + self.relu = nn.ReLU() + self.down_sample = False + if stride != 1 or in_channel != out_channel: + self.down_sample = True + self.down_sample_layer = None + if self.down_sample: + self.down_sample_layer = nn.SequentialCell([_conv1x1(in_channel, out_channel, stride), _bn(out_channel)]) + def construct(self, x): + identity = x + out = self.conv1(x) + out = self.bn1(out) + out = self.relu(out) + if self.stride != 1: + out = self.e2(out) + else: + out = self.conv2(out) + out = self.bn2(out) + out = self.relu(out) + out = self.conv3(out) + out = self.bn3(out) + if self.down_sample: + identity = self.down_sample_layer(identity) + + out = out + identity + out = self.relu(out) + return out + + +重新开发 ResNet 系列整网： +class ResNet(nn.Cell): + """""" + ResNet architecture. + + Args: + block (Cell): Block for network. + layer_nums (list): Numbers of block in different layers. + in_channels (list): Input channel in each layer. + out_channels (list): Output channel in each layer. + strides (list): Stride size in each layer. + num_classes (int): The number of classes that the training images are belonging to. + + Returns: + Tensor, output tensor. + + Examples: + >>> ResNet(ResidualBlock, + >>> [3, 4, 6, 3], + >>> [64, 256, 512, 1024], + >>> [256, 512, 1024, 2048], + >>> [1, 2, 2, 2], + >>> 10) + """""" + + def __init__(self, + block, + layer_nums, + in_channels, + out_channels, + strides, + num_classes): + super(ResNet, self).__init__() + + if not len(layer_nums) == len(in_channels) == len(out_channels) == 4: + raise ValueError(""the length of layer_num, in_channels, out_channels list must be 4!"") + self.conv1 = _conv7x7(3, 64, stride=2) + self.bn1 = _bn(64) + self.relu = ops.ReLU() + + self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode=""same"") + + self.layer1 = self._make_layer(block, + layer_nums[0], + in_channel=in_channels[0], + out_channel=out_channels[0], + stride=strides[0]) + self.layer2 = self._make_layer(block, + layer_nums[1], + in_channel=in_channels[1], + out_channel=out_channels[1], + stride=strides[1]) + self.layer3 = self._make_layer(block, + layer_nums[2], + in_channel=in_channels[2], + out_channel=out_channels[2], + stride=strides[2]) + self.layer4 = self._make_layer(block, + layer_nums[3], + in_channel=in_channels[3], + out_channel=out_channels[3], + stride=strides[3]) + + self.mean = ops.ReduceMean(keep_dims=True) + self.flatten = nn.Flatten() + self.end_point = _fc(out_channels[3], num_classes) + + def _make_layer(self, block, layer_num, in_channel, out_channel, stride): + """""" + Make stage network of ResNet. + + Args: + block (Cell): Resnet block. + layer_num (int): Layer number. + in_channel (int): Input channel. + out_channel (int): Output channel. + stride (int): Stride size for the first convolutional layer. + Returns: + SequentialCell, the output layer. + + Examples: + >>> _make_layer(ResidualBlock, 3, 128, 256, 2) + """""" + layers = [] + + resnet_block = block(in_channel, out_channel, stride=stride) + layers.append(resnet_block) + for _ in range(1, layer_num): + resnet_block = block(out_channel, out_channel, stride=1) + layers.append(resnet_block) + return nn.SequentialCell(layers) + + def construct(self, x): + x = self.conv1(x) + x = self.bn1(x) + x = self.relu(x) + c1 = self.maxpool(x) + + c2 = self.layer1(c1) + c3 = self.layer2(c2) + c4 = self.layer3(c3) + c5 = self.layer4(c4) + + out = self.mean(c5, (2, 3)) + out = self.flatten(out) + out = self.end_point(out) + + return out + + +传入 ResNet50 层数信息，构造 ResNet50 整网： +def resnet50(class_num=10): + """""" + Get ResNet50 neural network. + + Args: + class_num (int): Class number. + + Returns: + Cell, cell instance of ResNet50 neural network. + + Examples: + >>> net = resnet50(10) + """""" + return ResNet(ResidualBlock, + [3, 4, 6, 3], + [64, 256, 512, 1024], + [256, 512, 1024, 2048], + [1, 2, 2, 2], + class_num) + + +经过以上步骤，基于 MindSpore 的 ResNet50 整网结构和各子网结构已经开发完成，接下来就是开发其他模块。 + + + +其他模块 +其他模块通常包括：反向构造、梯度裁剪、优化器、学习率生成等，这些模块要么本身结构单一，要么依赖已开发完成的子网结果才能和对标脚本形成对比。相比子网开发，这些模块的脚本开发难度更小一些。 + +ResNet50 迁移示例 +关于其他训练配置，可以参考 英伟达训练 ResNet50 的配置信息，ResNet50 的训练主要涉及以下几项： + +使用了 SGD + Momentum 优化器 +使用了 WeightDecay 功能（但 BatchNorm 的 gamma 和 bias 没有使用） +使用了 cosine LR schedule +使用了 Label Smoothing + +实现带 Momentum 的 SGD 优化器，除 BN 的 gamma 和 bias 外，其他权重应用 WeightDecay ： +# define opt +decayed_params = [] +no_decayed_params = [] +for param in net.trainable_params(): + if 'beta' not in param.name and 'gamma' not in param.name and 'bias' not in param.name: + decayed_params.append(param) + else: + no_decayed_params.append(param) + +group_params = [{'params': decayed_params, 'weight_decay': weight_decay}, + {'params': no_decayed_params}, + {'order_params': net.trainable_params()}] +opt = Momentum(group_params, lr, momentum) + + +实现 cosine LR schedule，可以参考 MindSpore Cosine Decay LR +定义 Loss 函数和实现 Label Smoothing： +import mindspore.nn as nn +from mindspore import Tensor +from mindspore import dtype as mstype +from mindspore.nn import LossBase +import mindspore.ops as ops + +# define cross entropy loss +class CrossEntropySmooth(LossBase): + """"""CrossEntropy"""""" + def __init__(self, sparse=True, reduction='mean', smooth_factor=0., num_classes=1000): + super(CrossEntropySmooth, self).__init__() + self.onehot = ops.OneHot() + self.sparse = sparse + self.on_value = Tensor(1.0 - smooth_factor, mstype.float32) + self.off_value = Tensor(1.0 * smooth_factor / (num_classes - 1), mstype.float32) + self.ce = nn.SoftmaxCrossEntropyWithLogits(reduction=reduction) + + def construct(self, logit, label): + if self.sparse: + label = self.onehot(label, ops.shape(logit)[1], self.on_value, self.off_value) + loss = self.ce(logit, label) + return loss + +# define loss with label smooth +label_smooth_factor = 0.1 +loss = CrossEntropySmooth(sparse=True, reduction=""mean"",smooth_factor=label_smooth_factor, num_classes=1000) + + + + + +超参对比 +当各子网已经打通，最后一步要做的是和对标脚本对齐超参，保证网络结构一致。需要注意的是，在不同的框架上，同一套超参可能有不同的精度表现，在迁移网络时不一定要严格按照对标脚本的超参进行设置，可在不改变网络结构的情况下进行微调。 + +ResNet50 迁移示例 +在 ResNet50 的训练中，主要涉及以下超参： + +momentum =0.875 +batch_size = 256 +learning rate = 0.256 +learing rate schedule = cosine +weight_decay = 1/32768 +label_smooth = 0.1 +epoch size = 90 + + + +",网络迁移调试实例,MindSpore、MindSpore、并行、优化器、分布式、算子、接口、数据集、MindRecord、网络、PyNative、评估、PyTorch、API、model、SGD、loss、ast、LR、学习率、调试、精度、数据、超参、精度、优化、脚本、单机、MindData、框架、性能、dataset、eval、NLP、Graph、ib、roce、npu +网络迁移调试实例§流程打通,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/sample_code.html," +经过以上步骤后，我们已经开发完了网络迁移的必备脚本，接下来就是打通单机训练、分布式训练、推理流程。 + +单机训练 + +ResNet50 迁移示例 +为了更好的阅读代码，建议按照以下结构组织脚本： +. +├── scripts +│   ├── run_distribute_train.sh # 启动Ascend分布式训练（8卡） +│   ├── run_eval.sh # 启动Ascend评估 +│   └── run_standalone_train.sh # 启动Ascend单机训练（单卡） +├── src +│   ├── config.py # 配置文件 +│   ├── cross_entropy_smooth.py # 损失定义 +│   ├── dataset.py # 数据预处理 +│   └── resnet.py # 网络结构 +├── eval.py # 推理流程 +└── train.py # 训练流程 + +2 directories, 9 files + + +其中 train.py 定义如下： +""""""train resnet."""""" +import os +import argparse +import ast +from mindspore import context, set_seed, Model +from mindspore.nn import Momentum +from mindspore.context import ParallelMode +from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor +from mindspore.communication import init +from mindspore.common import initializer +import mindspore.nn as nn + +from src.config import config +from src.dataset import create_dataset +from src.resnet import resnet50 +from src.cross_entropy_smooth import CrossEntropySmooth + +set_seed(1) + +parser = argparse.ArgumentParser(description='Image classification') +parser.add_argument('--run_distribute', type=ast.literal_eval, default=False, help='Run distribute') +parser.add_argument('--dataset_path', type=str, default=None, help='Dataset path') +args_opt = parser.parse_args() + + +if __name__ == '__main__': + device_id = int(os.getenv('DEVICE_ID', '0')) + rank_size = int(os.getenv('RANK_SIZE', '1')) + rank_id = int(os.getenv('RANK_ID', '0')) + + # init context + context.set_context(mode=context.GRAPH_MODE, device_target='Ascend', device_id=device_id) + if rank_size > 1: + context.set_auto_parallel_context(device_num=rank_size, parallel_mode=ParallelMode.DATA_PARALLEL, + gradients_mean=True) + context.set_auto_parallel_context(all_reduce_fusion_config=[85, 160]) + init() + + # create dataset + dataset = create_dataset(args_opt.dataset_path, config.batch_size, rank_size, rank_id) + step_size = dataset.get_dataset_size() + + # define net + net = resnet50(class_num=config.class_num) + + # init weight + for _, cell in net.cells_and_names(): + if isinstance(cell, nn.Conv2d): + cell.weight.set_data(initializer.initializer(initializer.XavierUniform(), + cell.weight.shape, + cell.weight.dtype)) + if isinstance(cell, nn.Dense): + cell.weight.set_data(initializer.initializer(initializer.TruncatedNormal(), + cell.weight.shape, + cell.weight.dtype)) + + lr = nn.dynamic_lr.cosine_decay_lr(config.lr_end, config.lr, config.epoch_size * step_size, + step_size, config.warmup) + + # define opt + decayed_params = [] + no_decayed_params = [] + for param in net.trainable_params(): + if 'beta' not in param.name and 'gamma' not in param.name and 'bias' not in param.name: + decayed_params.append(param) + else: + no_decayed_params.append(param) + + group_params = [{'params': decayed_params, 'weight_decay': config.weight_decay}, + {'params': no_decayed_params}, + {'order_params': net.trainable_params()}] + opt = Momentum(group_params, lr, config.momentum) + # define loss + loss = CrossEntropySmooth(sparse=True, reduction=""mean"", smooth_factor=config.label_smooth_factor, + num_classes=config.class_num) + # define model + model = Model(net, loss_fn=loss, optimizer=opt, metrics={'acc'}) + + # define callbacks + time_cb = TimeMonitor(data_size=step_size) + loss_cb = LossMonitor() + cb = [time_cb, loss_cb] + if config.save_checkpoint: + #config_ck = CheckpointConfig(save_checkpoint_steps=config.save_checkpoint_epochs * step_size, + config_ck = CheckpointConfig(save_checkpoint_steps=5, + keep_checkpoint_max=config.keep_checkpoint_max) + ckpt_cb = ModelCheckpoint(prefix=""resnet"", directory=config.save_checkpoint_path, config=config_ck) + cb += [ckpt_cb] + + model.train(config.epoch_size, dataset, callbacks=cb, sink_size=step_size, dataset_sink_mode=False) + + +注意：关于目录中其他文件的代码，可以参考 MindSpore ModelZoo 的 ResNet50 实现（该脚本融合了其他 ResNet 系列网络及ResNet-SE 网络，具体实现可能和对标脚本有差异）。 + + + +分布式训练 +分布式训练相比单机训练对网络结构没有影响，可以通过调用 MindSpore 提供的分布式训练接口改造单机脚本即可完成分布式训练，具体可参考 分布式训练教程。 + +ResNet50 迁移示例 +对单机训练脚本添加以下接口： +import os +from mindspore import context +from mindspore.communication import init + +device_id = int(os.getenv('DEVICE_ID', '0')) +rank_size = int(os.getenv('RANK_SIZE', '1')) +rank_id = int(os.getenv('RANK_ID', '0')) + +# init context +context.set_context(mode=context.GRAPH_MODE, device_target='Ascend', device_id=device_id) +if rank_size > 1: + context.set_auto_parallel_context(device_num=rank_size, parallel_mode=ParallelMode.DATA_PARALLEL, + gradients_mean=True) + context.set_auto_parallel_context(all_reduce_fusion_config=[85, 160]) + # init distribute training + init() + + +修改 create_dataset 接口，使数据加载时对数据进行 shard 操作以支持分布式训练： +import os +import mindspore.dataset as ds + +device_id = int(os.getenv('DEVICE_ID', '0')) +rank_size = int(os.getenv('RANK_SIZE', '1')) +rank_id = int(os.getenv('RANK_ID', '0')) + +# rank_size is greater than 1 for distributed training +dataset = create_dataset(args_opt.dataset_path, config.batch_size, rank_size, rank_id) +# ... + + + + + +推理 +推理流程与训练相比有以下不同： + +无需定义优化器 +无需进行权重初始化 +网络定义后需要加载已训练好的 CheckPoint +定义计算推理精度的 metric + + +ResNet50 迁移示例 +修改后的推理脚本： +""""""train resnet."""""" +import os +import argparse +from mindspore import context, set_seed, Model +from mindspore.nn import SoftmaxCrossEntropyWithLogits +from mindspore import load_checkpoint, load_param_into_net + +from src.config import config +from src.dataset import create_dataset +from src.resnet import resnet50 +from src.cross_entropy_smooth import CrossEntropySmooth + +parser = argparse.ArgumentParser(description='Image classification') +parser.add_argument('--checkpoint_path', type=str, default=None, help='Checkpoint file path') +parser.add_argument('--dataset_path', type=str, default=None, help='Dataset path') +args_opt = parser.parse_args() + +set_seed(1) + + + +if __name__ == '__main__': + device_id = int(os.getenv('DEVICE_ID', '0')) + # init context + context.set_context(mode=context.GRAPH_MODE, device_target='Ascend', device_id=device_id) + + # create dataset + dataset = create_dataset(args_opt.dataset_path, config.batch_size, do_train=False) + step_size = dataset.get_dataset_size() + + # define net + net = resnet50(class_num=config.class_num) + + # load checkpoint + param_dict = load_checkpoint(args_opt.checkpoint_path) + load_param_into_net(net, param_dict) + net.set_train(False) + + # define loss, model + loss = CrossEntropySmooth(sparse=True, reduction='mean', smooth_factor=config.label_smooth_factor, + num_classes=config.class_num) + + # define model + model = Model(net, loss_fn=loss, metrics={'top_1_accuracy', 'top_5_accuracy'}) + + # eval model + res = model.eval(dataset) + print(""result:"", res, ""ckpt="", args_opt.checkpoint_path) + + + + + +问题定位 +在流程打通中可能会遇到一些中断训练的问题，可以参考 网络训练调试教程 定位和解决。 + + +完整示例 +完整示例请参考链接：https://gitee.com/mindspore/docs/tree/r1.7/docs/sample_code/migration_sample + +",网络迁移调试实例,mindspore、mindspore、优化器、分布式、接口、optimizer、callback、Ascend、网络、评估、Model、Loss、metric、arm、ast、lr、调试、精度、数据、精度、优化、ModelZoo、脚本、单机、dataset、eval、GRAPH、ib +网络迁移调试实例§精度调优,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/sample_code.html," +在打通流程后，就可以通过训练和推理两个步骤获得网络训练的精度。通常情况下，我们很难一次就复现对标脚本的精度，需要通过精度调优来逐渐提高精度，精度调优相比性能调优不够直观，效率低，工作量大。 +",网络迁移调试实例,网络、调试、精度、精度、脚本、性能 +网络迁移调试实例§性能调优,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/sample_code.html," +通常我们所指的性能调优是在固定数据集、网络规模和硬件数量的情况下提高训练性能，而通过改变数据集大小、网络规模、硬件数量来提高性能是显然的，不在本文的讨论范围内。 +除非性能问题已严重阻碍了精度调试，否则性能调优一定要放在精度达标以后进行，这其中主要有两个原因：一是在定位精度问题时很多修改会影响性能，使得已经调优过的性能再次未达标，可能浪费工作量；二是性能调优时有可能引入新的精度问题，如果没有已经达标的精度作为看护，后面再定位这次引入的精度问题难度会极大的增加。 + +分析Profiling数据 +分析Profiling数据是性能调优阶段必不可少的步骤，MindSpore 的性能和精度调优工具 MindInsight 提供了丰富的性能和精度调优方法，对于性能调优，最重要的信息就是Profiling数据。Profiling可以收集整网训练过程中端到端的详细性能数据，包含数据准备和迭代轨迹。在迭代轨迹中，你可以看到每个算子的起始运行时间、结束运行时间、调用次数和调用顺序等非常详细的信息，这对我们性能调优非常有帮助。生成Profiling数据的方式如下： +from mindspore.profiler import Profiler +from mindspore import Model, nn, context + +# init context +context.set_context(mode=context.GRAPH_MODE, device_target='Ascend', device_id=int(os.environ[""DEVICE_ID""])) + +# init profiler, profiling data will be stored under folder ./data by default +profiler = Profiler() + +# ... + +# start training +Model.train() + +# end training, parse profiling data to readable text +profiler.analyse() + + +关于Profiling更详细的使用方法，可以参考 Profiling 性能分析方法。 +获取到 Profiling 数据后，我们需要分析出性能瓶颈的阶段和算子，然后对其进行优化，分析的过程可以参考 性能调优指导。 + + +常见问题及相应优化方法 + +MindData 性能问题 +单Step性能抖动、数据队列一段时间内持续为空的情况都是由于数据预处理部分性能较差，使得数据处理速度跟不上单Step迭代速度导致，这两个现象通常成对出现。 +当数据处理速度较慢时，队列从最开始的满队列情况逐渐消耗为空队列，训练进程会开始等待空队列填入数据，一旦有新的数据填入，网络才会继续进行单Step训练。由于数据处理没有队列作为缓冲，数据处理的性能抖动直接体现在单Step的性能上，因此还会造成单Step性能抖动。 +关于MindData的性能问题，可以参考 MindInsight 组件的 数据准备性能分析，其给出了MindData 性能的常见问题及解决方法。 + + +多机同步性能问题 +当进行分布式训练时，在一个Step的训练过程中，完成前向传播和梯度计算后，各个机器开始进行AllReduce梯度同步，AllReduce同步时间主要受权重数量、机器数量影响，对于越复杂、机器规模越大的网络，其 AllReduce 梯度更新时间也越久，此时我们可以进行AllReduce 切分来优化这部分耗时。 +正常情况下，AllReduce 梯度同步会等所有反向算子执行结束，也就是对所有权重都计算出梯度后再一次性同步所有机器的梯度，而使用AllReduce切分后，我们可以在计算出一部分权重的梯度后，就立刻进行这部分权重的梯度同步，这样梯度同步和剩余算子的梯度计算可以并行执行，也就隐藏了这部分 AllReduce 梯度同步时间。切分策略通常是手动尝试，寻找一个最优的方案（支持切分大于两段）。 +以 ResNet50网络 为例，该网络共有 160 个 权重， [85, 160] 表示第 0 至 85个权重计算完梯度后立刻进行梯度同步，第 86 至 160 个 权重计算完后再进行梯度同步，这里共切分两段，因此需要进行两次梯度同步。代码实现如下： +device_id = int(os.getenv('DEVICE_ID', '0')) +rank_size = int(os.getenv('RANK_SIZE', '1')) +rank_id = int(os.getenv('RANK_ID', '0')) + +# init context +context.set_context(mode=context.GRAPH_MODE, device_target='Ascend', device_id=device_id) +if rank_size > 1: + context.set_auto_parallel_context(device_num=rank_size, parallel_mode=ParallelMode.DATA_PARALLEL, + gradients_mean=True) + context.set_auto_parallel_context(all_reduce_fusion_config=[85, 160]) + init() + + + + +算子性能问题 +单算子耗时久、对于同一种算子在不同shape或者不同 datatype 下性能差异较大的情况主要是由算子性能问题引起，通常有以下两个解决思路： + +使用计算量更小的数据类型。例如，同一个算子在 float16 和 float32 下精度无明显差别，可使用计算量更小的 float16 格式。 +使用算法相同的其他算子规避。 + +如果您发现有性能较差的算子时，建议联系 MindSpore社区 反馈，我们确认为性能问题后会及时优化。 + + +框架性能问题 +转换算子过多（TransData、Cast类算子）且耗时明显时，如果是我们手动加入的Cast算子，可分析其必要性，如果对精度没有影响，可去掉冗余的Cast、TransData算子。 +如果是MindSpore自动生成的转换算子过多，可能是MindSpore框架针对某些特殊情况没有充分优化，可联系 MindSpore社区 反馈。 + + +其他通用优化方法 + +使用自动混合精度 +混合精度训练方法是通过混合使用单精度和半精度数据格式来加速深度神经网络训练的过程，同时保持了单精度训练所能达到的网络精度。混合精度训练能够加速计算过程，同时减少内存使用和存取，并使得在特定的硬件上可以训练更大的模型或 batch size。 +具体可参考 混合精度教程。 + +使能图算融合 +图算融合是 MindSpore 特有的网络性能优化技术。它可以通过自动分析和优化现有网络计算图逻辑，并结合目标硬件能力，对计算图进行计算化简和替代、算子拆分和融合、算子特例化编译等优化，以提升设备计算资源利用率，实现对网络性能的整体优化。相比传统优化技术，图算融合具有多算子跨边界联合优化、与算子编译跨层协同、基于Polyhedral的算子即时编译等独特优势。另外，图算融合只需要用户打开对应配置后，整个优化过程即可自动完成，不需要网络开发人员进行其它额外感知，使得用户可以聚焦网络算法实现。 +图算融合的适用场景包括：对网络执行时间具有较高性能要求的场景；通过拼接基本算子实现自定义组合算子，并希望对这些基本算子进行自动融合，以提升自定义组合算子性能的场景。 +具体可参考 图算融合教程。 + + + + +",网络迁移调试实例,MindSpore、MindSpore、并行、分布式、算子、数据集、Ascend、MindInsight、数据类型、网络、Model、ast、lR、调试、精度、数据、计算图、精度、优化、迭代、Profiling、MindData、框架、性能、GRAPH +常见问题§常见问题,https://www.mindspore.cn/docs/zh-CN/r1.7/migration_guide/faq.html," + +从其他框架迁移到MindSpore框架的过程中，可能会遇到各种各样的问题，下面将迁移过程中的常见问题及其解决方法汇总如下： + +准备工作 +安装MindSpore常见问题处理 + +网络脚本分析 +算子映射及缺失算子处理策略 +常见语法限制及处理策略 + +网络脚本开发 +MindConverter工具常见问题处理 + +网络调试 +流程调试常见问题处理 +loss值对比检查常见问题处理 +loss值异常常见问题处理 + +性能调试 +性能调试常见问题及优化方法 +Profiler工具常见问题处理 + +执行推理 +端侧使用类常见问题处理 +推理常见问题处理 + + +",常见问题,网络、调试 diff --git a/Design_Migration_Grammar_API_dataset/readme.md b/Design_Migration_Grammar_API_dataset/readme.md new file mode 100644 index 0000000..19dd168 --- /dev/null +++ b/Design_Migration_Grammar_API_dataset/readme.md @@ -0,0 +1,29 @@ +# 基于官网设计、语法支持、迁移指南、API四个模块的数据集 + +## 概述 +如题所示，本项目是基于官网设计、语法支持、迁移指南、API四个模块整理的数据集，用于做问答机器人的语料库。采用python语言，直接从官网中读取模块的html文档，并对其各项属性进行划分所得到的格式为.csv的数据集。其headline一共分为如下部分：title，link，content，process和tag。 + +## 基本概念 +每个模块的一级标题不同，如语法支持模块的一级标题分别为：静态图语法支持、Tensor索引支持。二级标题是每个一级标题下的小标题，如分别为：概述、数据类型、原型、运算符、复合语句、函数。 + +## Title +Title为"一级标题§二级标题"，采用的是文本的格式，去掉了一些xml标签，本身这些标签对于问题的表述没有较大影响。 +当一级标题和二级标题之间有内容或者只有一级标题时，Title为"一级标题§一级标题" +## Link +Link为每个模块的一级标题的源网页地址链接。 + +## Content +Content为每个模块中二级标题包含的内容，与title一致，去掉了一些xml标签，同时以下几点需要注意：公式将转换成latex格式；表格从同一行左右两列变成上下两行的模式（一一对应），如语法支持模块的静态图语法支持-运算符中的表格（网址：https://www.mindspore.cn/docs/zh-CN/r1.7/note/static_graph_syntax_support.html；csv数据集:html_grammar_dataset.csv）；还去掉的部分名词自带的网页链接（多是用于展开介绍）以及图片（多是用于展示）。 + +## Process +每个模块的Process是其一级标题，如语法支持模块的process分别为：静态图语法支持、Tensor索引支持。其分类标准参照的是语料库的分类。 + +## Tag +Tag为官网设计、语法支持、迁移指南、API四个模块所涉及到的领域，没有具体的分类标准。暂时将tag设置为以下类别：'白皮书', 'MindSpore', '全场景', '自动微分', 'GradOperation', 'MindSpore', 'Parameter Server', '并行', '优化器', 'Host&Device', '分布式', '算子', '接口', '数据集', '集合通信', '同步模式', '损失函数', '控制流', '自由变量', '闭包', 'MindRecord', 'Pipeline', 'Adaptor', 'Optimizer', 'Runtime', 'Operators', 'Callback', 'MindSpore AKG', 'Auto-Tiling', 'Auto-Mapping', 'Davinci', '样例脚本', 'GPU', 'CPU', 'CuBLAS库', 'Linux', 'Ascend', '模型推理', 'MindInsight', 'plugin_name', 'MindArmour', 'AI Fuzzer', 'MINDIR', '缩略语','数据类型', '原型', '运算符', '语句', '内置函数', '网络', 'PyNative', 'MindConverter', '评估', 'TensorFlow', 'Pytorch', 'ONNX', 'PB', 'API', 'Model', 'SGD', 'loss', 'metric', 'ARM', 'AST', 'TensorBoard', 'Dataloader', 'GeneratorDataset', ' GradOperation', 'TrainOneStepCell', '反向传播', '求导', 'weight decay', 'LR', '学习率', 'Aten', '调试', 'MindOptimizer', '精度', 'checklist', '数据', 'loss scale', '超参', '计算图', '精度', '可视化', '模型结构', '优化', '迭代', 'ModelZoo', 'MindSpore Serving', '脚本', '单机', 'profiling', 'MindData', '框架', '性能', 'Dataset', 'macOS', 'SDK版本', 'SciPy', 'whl包', 'protobuf', 'Ubuntu', 'Windows', 'WSL', 'Conda', 'Serving', 'gmp', 'cuda', 'JupyterLab', 'eval', 'NLP', 'HCLL', 'ModelArts', 'Graph','C++', 'AIPP', 'OpenMPI', 'NCLL', 'RDMA', 'IB', 'RoCE', 'taichi', 'Caffe', 'NPU', 'Embedding', 'Parameter Server', 'JIT Fallback'。如果该问题不属于以上所有tag，则将其定义为’ ’，即空字符。 + +# Python源代码修改方法 +####（1）如要增加语料库，需要在url，process两个列表中添加元素，其中，url为语料库的网址链接，process为文章块的id。要注意的是，这三个列表需要对齐，否则会发生错误。 +####（2）如在原有语料库的基础上增加二级标题包含的内容，只需要重新运行该代码即可。 +####（3）如要增加或者删减tag，只需要在tag列表中进行相应的添加或删减。在进行tag查找的时候，是不区分大小写的，所以进行添加时，对于大小写没有要求，最终输出是按照原文本的大小写进行输出的。 +####（4）本代码可以将一级标题和二级标题中含有的特殊字符，如："::"、"_"、" "、"&"、"（"、"）"，转换成html解析器解析出的对应特殊字符，如："-"、""。如果一级标题和二级标题的特殊字符有变，需及时更改相关代码。 +####（5）html解析器解析的各级标题后都有特殊字符"¶"，代码中将其用以定位，更改代码时需注意。 \ No newline at end of file -- Gitee